src/xkbcomp/keycodes.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 "expr.h"
  29 #include "parseutils.h"
  30
  31 /*
  32  * The xkb_keycodes section
  33  * ========================
  34  *
  35  * This is the simplest section type, and is the first one to be
  36  * compiled. The purpose of this is mostly to map between the
  37  * hardware/evdev scancodes and xkb keycodes. Each key is given a name
  38  * of up to 4 letters, by which it can be referred to later, e.g. in the
  39  * symbols section.
  40  *
  41  * Minimum/Maximum keycode
  42  * -----------------------
  43  * Statements of the form:
  44  *      minimum = 8;
  45  *      maximum = 255;
  46  *
  47  * The file may explicitly declare the minimum and/or maximum keycode
  48  * contained therein (traditionally 8-255, inherited from old xfree86
  49  * keycodes). If these are stated explicitly, they are enforced. If
  50  * they are not stated, they are computed automatically.
  51  *
  52  * Keycode statements
  53  * ------------------
  54  * Statements of the form:
  55  *      <TLDE> = 49;
  56  *      <AE01> = 10;
  57  *
  58  * The above would let 49 and 10 be valid keycodes in the keymap, and
  59  * assign them the names TLDE and AE01 respectively. The format <WXYZ> is
  60  * always used to refer to a key by name.
  61  *
  62  * [ The naming convention <AE01> just denoted the position of the key
  63  * in the main alphanumric section of the keyboard, with the top left key
  64  * (usually "~") acting as origin. <AE01> is the key in the first row
  65  * second column (which is usually "1"). ]
  66  *
  67  * In the common case this just maps to the evdev scancodes from
  68  * /usr/include/linux/input.h, e.g. the following definitions:
  69  *      #define KEY_GRAVE            41
  70  *      #define KEY_1                2
  71  * Similar definitions appear in the xf86-input-keyboard driver. Note
  72  * that in all current keymaps there's a constant offset of 8 (for
  73  * historical reasons).
  74  *
  75  * If there's a conflict, like the same name given to different keycodes,
  76  * or same keycode given different names, it is resolved according to the
  77  * merge mode which applies to the definitions.
  78  *
  79  * The reason for the 4 characters limit is that the name is sometimes
  80  * converted to an unsigned long (in a direct mapping), instead of a char
  81  * array (see KeyNameToLong, LongToKeyName).
  82  *
  83  * Alias statements
  84  * ----------------
  85  * Statements of the form:
  86  *      alias <MENU> = <COMP>;
  87  *
  88  * Allows to refer to a previously defined key (here <COMP>) by another
  89  * name (here <MENU>). Conflicts are handled similarly.
  90  *
  91  * Indicator name statements
  92  * -------------------------
  93  * Statements of the form:
  94  *      indicator 1 = "Caps Lock";
  95  *      indicator 2 = "Num Lock";
  96  *      indicator 3 = "Scroll Lock";
  97  *
  98  * Assigns a name the indicator (i.e. keyboard LED) with the given index.
  99  * The amount of possible indicators is predetermined (XkbNumIndicators).
 100  * The indicator may be referred by this name later in the compat section
 101  * and by the user.
 102  *
 103  * Effect on the keymap
 104  * --------------------
 105  * After all of keycodes sections have been compiled, the following members
 106  * of struct xkb_keymap are finalized:
 107  *      xkb_keycode_t min_key_code;
 108  *      xkb_keycode_t max_key_code;
 109  *      darray(struct xkb_key_alias) key_aliases;
 110  *      const char *indicator_names[XkbNumIndicators];
 111  *      char *keycodes_section_name;
 112  * Further, the array of keys:
 113  *      darray(struct xkb_key) keys;
 114  * had been resized to its final size (i.e. all of the xkb_key objects are
 115  * referable by their keycode). However the objects themselves do not
 116  * contain any useful information besides the key name at this point.
 117  */
 118
 119 typedef struct _AliasInfo {
 120     enum merge_mode merge;
 121     unsigned file_id;
 122     struct list entry;
 123
 124     unsigned long alias;
 125     unsigned long real;
 126 } AliasInfo;
 127
 128 typedef struct _IndicatorNameInfo {
 129     enum merge_mode merge;
 130     unsigned file_id;
 131     struct list entry;
 132
 133     xkb_led_index_t ndx;
 134     xkb_atom_t name;
 135     bool virtual;
 136 } IndicatorNameInfo;
 137
 138 typedef struct _KeyNamesInfo {
 139     char *name;     /* e.g. evdev+aliases(qwerty) */
 140     int errorCount;
 141     unsigned file_id;
 142     enum merge_mode merge;
 143     xkb_keycode_t computedMin; /* lowest keycode stored */
 144     xkb_keycode_t computedMax; /* highest keycode stored */
 145     xkb_keycode_t explicitMin;
 146     xkb_keycode_t explicitMax;
 147     darray(unsigned long) names;
 148     darray(unsigned int) files;
 149     struct list leds;
 150     struct list aliases;
 151
 152     struct xkb_keymap *keymap;
 153 } KeyNamesInfo;
 154
 155 static void
 156 ResizeKeyNameArrays(KeyNamesInfo *info, int newMax)
 157 {
 158     if (newMax < darray_size(info->names))
 159         return;
 160
 161     darray_resize0(info->names, newMax + 1);
 162     darray_resize0(info->files, newMax + 1);
 163 }
 164
 165 static void
 166 InitAliasInfo(AliasInfo *info, enum merge_mode merge, unsigned file_id,
 167               char alias[XkbKeyNameLength], char real[XkbKeyNameLength])
 168 {
 169     memset(info, 0, sizeof(*info));
 170     info->merge = merge;
 171     info->file_id = file_id;
 172     info->alias = KeyNameToLong(alias);
 173     info->real = KeyNameToLong(real);
 174 }
 175
 176 static void
 177 InitIndicatorNameInfo(IndicatorNameInfo * ii, KeyNamesInfo * info)
 178 {
 179     ii->merge = info->merge;
 180     ii->file_id = info->file_id;
 181     ii->ndx = 0;
 182     ii->name = XKB_ATOM_NONE;
 183     ii->virtual = false;
 184 }
 185
 186 static IndicatorNameInfo *
 187 NextIndicatorName(KeyNamesInfo * info)
 188 {
 189     IndicatorNameInfo *ii;
 190
 191     ii = malloc(sizeof(*ii));
 192     if (!ii)
 193         return NULL;
 194
 195     InitIndicatorNameInfo(ii, info);
 196     list_append(&ii->entry, &info->leds);
 197
 198     return ii;
 199 }
 200
 201 static IndicatorNameInfo *
 202 FindIndicatorByIndex(KeyNamesInfo * info, xkb_led_index_t ndx)
 203 {
 204     IndicatorNameInfo *old;
 205
 206     list_foreach(old, &info->leds, entry)
 207         if (old->ndx == ndx)
 208             return old;
 209
 210     return NULL;
 211 }
 212
 213 static IndicatorNameInfo *
 214 FindIndicatorByName(KeyNamesInfo * info, xkb_atom_t name)
 215 {
 216     IndicatorNameInfo *old;
 217
 218     list_foreach(old, &info->leds, entry)
 219         if (old->name == name)
 220             return old;
 221
 222     return NULL;
 223 }
 224
 225 static bool
 226 AddIndicatorName(KeyNamesInfo *info, enum merge_mode merge,
 227                  IndicatorNameInfo *new)
 228 {
 229     IndicatorNameInfo *old;
 230     bool replace;
 231     int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
 232
 233     replace = (merge == MERGE_REPLACE) || (merge == MERGE_OVERRIDE);
 234
 235     old = FindIndicatorByName(info, new->name);
 236     if (old) {
 237         if ((old->file_id == new->file_id && verbosity > 0) ||
 238             verbosity > 9) {
 239             if (old->ndx == new->ndx) {
 240                 if (old->virtual != new->virtual) {
 241                     if (replace)
 242                         old->virtual = new->virtual;
 243                     log_warn(info->keymap->ctx, "Multiple indicators named %s; "
 244                              "Using %s instead of %s\n",
 245                              xkb_atom_text(info->keymap->ctx, new->name),
 246                              (old->virtual ? "virtual" : "real"),
 247                              (old->virtual ? "real" : "virtual"));
 248                 }
 249                 else {
 250                     log_warn(info->keymap->ctx, "Multiple indicators named %s; "
 251                              "Identical definitions ignored\n",
 252                              xkb_atom_text(info->keymap->ctx, new->name));
 253                 }
 254                 return true;
 255             }
 256             else {
 257                 log_warn(info->keymap->ctx, "Multiple indicators named %s; "
 258                          "Using %d, ignoring %d\n",
 259                          xkb_atom_text(info->keymap->ctx, new->name),
 260                          (replace ? old->ndx : new->ndx),
 261                          (replace ? new->ndx : old->ndx));
 262             }
 263
 264             if (replace) {
 265                 list_del(&old->entry);
 266                 free(old);
 267             }
 268         }
 269     }
 270
 271     old = FindIndicatorByIndex(info, new->ndx);
 272     if (old) {
 273         if ((old->file_id == new->file_id && verbosity > 0) ||
 274             verbosity > 9) {
 275             if (old->name == new->name && old->virtual == new->virtual) {
 276                 log_warn(info->keymap->ctx,
 277                          "Multiple names for indicator %d; "
 278                          "Identical definitions ignored\n", new->ndx);
 279             } else {
 280                 const char *oldType, *newType;
 281                 xkb_atom_t using, ignoring;
 282                 if (old->virtual)
 283                     oldType = "virtual indicator";
 284                 else
 285                     oldType = "real indicator";
 286                 if (new->virtual)
 287                     newType = "virtual indicator";
 288                 else
 289                     newType = "real indicator";
 290                 if (replace) {
 291                     using = new->name;
 292                     ignoring = old->name;
 293                 }
 294                 else {
 295                     using = old->name;
 296                     ignoring = new->name;
 297                 }
 298                 log_warn(info->keymap->ctx,
 299                          "Multiple names for indicator %d; "
 300                          "Using %s %s, ignoring %s %s\n",
 301                          new->ndx,
 302                          oldType, xkb_atom_text(info->keymap->ctx, using),
 303                          newType, xkb_atom_text(info->keymap->ctx, ignoring));
 304             }
 305         }
 306         if (replace) {
 307             old->name = new->name;
 308             old->virtual = new->virtual;
 309         }
 310         return true;
 311     }
 312     old = new;
 313     new = NextIndicatorName(info);
 314     if (!new) {
 315         log_wsgo(info->keymap->ctx,
 316                  "Couldn't allocate name for indicator %d; Ignored\n",
 317                  old->ndx);
 318         return false;
 319     }
 320     new->name = old->name;
 321     new->ndx = old->ndx;
 322     new->virtual = old->virtual;
 323     return true;
 324 }
 325
 326 static void
 327 ClearKeyNamesInfo(KeyNamesInfo * info)
 328 {
 329     AliasInfo *alias, *next_alias;
 330     IndicatorNameInfo *ii, *next_ii;
 331
 332     free(info->name);
 333     info->name = NULL;
 334     info->merge = MERGE_DEFAULT;
 335     info->computedMax = info->explicitMax = info->explicitMin = 0;
 336     info->computedMin = XKB_KEYCODE_MAX;
 337     darray_free(info->names);
 338     darray_free(info->files);
 339     list_foreach_safe(ii, next_ii, &info->leds, entry)
 340         free(ii);
 341     list_init(&info->leds);
 342     list_foreach_safe(alias, next_alias, &info->aliases, entry)
 343         free(alias);
 344     list_init(&info->aliases);
 345 }
 346
 347 static void
 348 InitKeyNamesInfo(KeyNamesInfo *info, struct xkb_keymap *keymap,
 349                  unsigned file_id)
 350 {
 351     info->name = NULL;
 352     info->merge = MERGE_DEFAULT;
 353     list_init(&info->leds);
 354     list_init(&info->aliases);
 355     info->file_id = file_id;
 356     darray_init(info->names);
 357     darray_init(info->files);
 358     ClearKeyNamesInfo(info);
 359     info->errorCount = 0;
 360     info->keymap = keymap;
 361 }
 362
 363 static int
 364 FindKeyByLong(KeyNamesInfo * info, unsigned long name)
 365 {
 366     xkb_keycode_t i;
 367
 368     for (i = info->computedMin; i <= info->computedMax; i++)
 369         if (darray_item(info->names, i) == name)
 370             return i;
 371
 372     return 0;
 373 }
 374
 375 /**
 376  * Store the name of the key as a long in the info struct under the given
 377  * keycode. If the same keys is referred to twice, print a warning.
 378  * Note that the key's name is stored as a long, the keycode is the index.
 379  */
 380 static bool
 381 AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, unsigned long name,
 382            enum merge_mode merge, unsigned file_id, bool reportCollisions)
 383 {
 384     xkb_keycode_t old;
 385     int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
 386
 387     ResizeKeyNameArrays(info, kc);
 388
 389     if (kc < info->computedMin)
 390         info->computedMin = kc;
 391     if (kc > info->computedMax)
 392         info->computedMax = kc;
 393
 394     if (reportCollisions)
 395         reportCollisions = (verbosity > 7 ||
 396                             (verbosity > 0 &&
 397                              file_id == darray_item(info->files, kc)));
 398
 399     if (darray_item(info->names, kc) != 0) {
 400         const char *lname = LongKeyNameText(darray_item(info->names, kc));
 401         const char *kname = LongKeyNameText(name);
 402
 403         if (darray_item(info->names, kc) == name && reportCollisions) {
 404             log_warn(info->keymap->ctx,
 405                      "Multiple identical key name definitions; "
 406                      "Later occurences of \"%s = %d\" ignored\n", lname, kc);
 407             return true;
 408         }
 409
 410         if (merge == MERGE_AUGMENT) {
 411             if (reportCollisions)
 412                 log_warn(info->keymap->ctx,
 413                          "Multiple names for keycode %d; "
 414                          "Using %s, ignoring %s\n", kc, lname, kname);
 415             return true;
 416         }
 417         else {
 418             if (reportCollisions)
 419                 log_warn(info->keymap->ctx,
 420                          "Multiple names for keycode %d; "
 421                          "Using %s, ignoring %s\n", kc, kname, lname);
 422             darray_item(info->names, kc) = 0;
 423             darray_item(info->files, kc) = 0;
 424         }
 425     }
 426
 427     old = FindKeyByLong(info, name);
 428     if (old != 0 && old != kc) {
 429         const char *kname = LongKeyNameText(name);
 430
 431         if (merge == MERGE_OVERRIDE) {
 432             darray_item(info->names, old) = 0;
 433             darray_item(info->files, old) = 0;
 434             if (reportCollisions)
 435                 log_warn(info->keymap->ctx,
 436                          "Key name %s assigned to multiple keys; "
 437                          "Using %d, ignoring %d\n", kname, kc, old);
 438         }
 439         else {
 440             if (reportCollisions && verbosity > 3)
 441                 log_warn(info->keymap->ctx,
 442                          "Key name %s assigned to multiple keys; "
 443                          "Using %d, ignoring %d\n", kname, old, kc);
 444             return true;
 445         }
 446     }
 447
 448     darray_item(info->names, kc) = name;
 449     darray_item(info->files, kc) = file_id;
 450     return true;
 451 }
 452
 453 /***====================================================================***/
 454
 455 static int
 456 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge,
 457                unsigned file_id);
 458
 459 static bool
 460 MergeAliases(KeyNamesInfo *into, KeyNamesInfo *from, enum merge_mode merge)
 461 {
 462     AliasInfo *alias, *next;
 463     KeyAliasDef def;
 464
 465     if (list_empty(&from->aliases))
 466         return true;
 467
 468     if (list_empty(&into->aliases)) {
 469         list_replace(&from->aliases, &into->aliases);
 470         list_init(&from->aliases);
 471         return true;
 472     }
 473
 474     memset(&def, 0, sizeof(def));
 475
 476     list_foreach_safe(alias, next, &from->aliases, entry) {
 477         def.merge = (merge == MERGE_DEFAULT) ? alias->merge : merge;
 478         LongToKeyName(alias->alias, def.alias);
 479         LongToKeyName(alias->real, def.real);
 480
 481         if (!HandleAliasDef(into, &def, def.merge, alias->file_id))
 482             return false;
 483     }
 484
 485     return true;
 486 }
 487
 488 static void
 489 MergeIncludedKeycodes(KeyNamesInfo *into, KeyNamesInfo *from,
 490                       enum merge_mode merge)
 491 {
 492     xkb_keycode_t i;
 493     IndicatorNameInfo *led;
 494
 495     if (from->errorCount > 0) {
 496         into->errorCount += from->errorCount;
 497         return;
 498     }
 499
 500     if (into->name == NULL) {
 501         into->name = from->name;
 502         from->name = NULL;
 503     }
 504
 505     ResizeKeyNameArrays(into, from->computedMax);
 506
 507     for (i = from->computedMin; i <= from->computedMax; i++) {
 508         unsigned long name = darray_item(from->names, i);
 509         if (name == 0)
 510             continue;
 511
 512         if (!AddKeyName(into, i, name, merge, from->file_id, false))
 513             into->errorCount++;
 514     }
 515
 516     list_foreach(led, &from->leds, entry) {
 517         led->merge = (merge == MERGE_DEFAULT ? led->merge : merge);
 518         if (!AddIndicatorName(into, led->merge, led))
 519             into->errorCount++;
 520     }
 521
 522     if (!MergeAliases(into, from, merge))
 523         into->errorCount++;
 524
 525     if (from->explicitMin != 0)
 526         if (into->explicitMin == 0 || into->explicitMin > from->explicitMin)
 527             into->explicitMin = from->explicitMin;
 528
 529     if (from->explicitMax > 0)
 530         if (into->explicitMax == 0 || into->explicitMax < from->explicitMax)
 531             into->explicitMax = from->explicitMax;
 532 }
 533
 534 static void
 535 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge);
 536
 537 /**
 538  * Handle the given include statement (e.g. "include "evdev+aliases(qwerty)").
 539  *
 540  * @param info Struct to store the key info in.
 541  * @param stmt The include statement from the keymap file.
 542  */
 543 static bool
 544 HandleIncludeKeycodes(KeyNamesInfo *info, IncludeStmt *stmt)
 545 {
 546     enum merge_mode merge = MERGE_DEFAULT;
 547     XkbFile *rtrn;
 548     KeyNamesInfo included, next_incl;
 549
 550     /* XXX: What's that? */
 551     if (stmt->file && streq(stmt->file, "computed")) {
 552         info->keymap->flags |= AutoKeyNames;
 553         info->explicitMin = 0;
 554         info->explicitMax = XKB_KEYCODE_MAX;
 555         return (info->errorCount == 0);
 556     }
 557
 558     InitKeyNamesInfo(&included, info->keymap, info->file_id);
 559     if (stmt->stmt) {
 560         free(included.name);
 561         included.name = stmt->stmt;
 562         stmt->stmt = NULL;
 563     }
 564
 565     for (; stmt; stmt = stmt->next_incl) {
 566         if (!ProcessIncludeFile(info->keymap->ctx, stmt, FILE_TYPE_KEYCODES,
 567                                 &rtrn, &merge)) {
 568             info->errorCount += 10;
 569             ClearKeyNamesInfo(&included);
 570             return false;
 571         }
 572
 573         InitKeyNamesInfo(&next_incl, info->keymap, rtrn->id);
 574
 575         HandleKeycodesFile(&next_incl, rtrn, MERGE_OVERRIDE);
 576
 577         MergeIncludedKeycodes(&included, &next_incl, merge);
 578
 579         ClearKeyNamesInfo(&next_incl);
 580         FreeXKBFile(rtrn);
 581     }
 582
 583     MergeIncludedKeycodes(info, &included, merge);
 584     ClearKeyNamesInfo(&included);
 585
 586     return (info->errorCount == 0);
 587 }
 588
 589 /**
 590  * Parse the given statement and store the output in the info struct.
 591  * e.g. <ESC> = 9
 592  */
 593 static int
 594 HandleKeycodeDef(KeyNamesInfo *info, KeycodeDef *stmt, enum merge_mode merge)
 595 {
 596     if ((info->explicitMin != 0 && stmt->value < info->explicitMin) ||
 597         (info->explicitMax != 0 && stmt->value > info->explicitMax)) {
 598         log_err(info->keymap->ctx,
 599                 "Illegal keycode %lu for name %s; "
 600                 "Must be in the range %d-%d inclusive\n",
 601                 stmt->value, KeyNameText(stmt->name), info->explicitMin,
 602                 info->explicitMax ? info->explicitMax : XKB_KEYCODE_MAX);
 603         return 0;
 604     }
 605
 606     if (stmt->merge != MERGE_DEFAULT) {
 607         if (stmt->merge == MERGE_REPLACE)
 608             merge = MERGE_OVERRIDE;
 609         else
 610             merge = stmt->merge;
 611     }
 612
 613     return AddKeyName(info, stmt->value, KeyNameToLong(stmt->name), merge,
 614                       info->file_id, true);
 615 }
 616
 617 static void
 618 HandleAliasCollision(KeyNamesInfo *info, AliasInfo *old, AliasInfo *new)
 619 {
 620     int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
 621
 622     if (new->real == old->real) {
 623         if ((new->file_id == old->file_id && verbosity > 0) || verbosity > 9)
 624             log_warn(info->keymap->ctx,
 625                      "Alias of %s for %s declared more than once; "
 626                      "First definition ignored\n",
 627                      LongKeyNameText(new->alias), LongKeyNameText(new->real));
 628     }
 629     else {
 630         unsigned long use, ignore;
 631
 632         if (new->merge == MERGE_AUGMENT) {
 633             use = old->real;
 634             ignore = new->real;
 635         }
 636         else {
 637             use = new->real;
 638             ignore = old->real;
 639         }
 640
 641         if ((old->file_id == new->file_id && verbosity > 0) || verbosity > 9)
 642             log_warn(info->keymap->ctx,
 643                      "Multiple definitions for alias %s; "
 644                      "Using %s, ignoring %s\n",
 645                      LongKeyNameText(old->alias), LongKeyNameText(use),
 646                      LongKeyNameText(ignore));
 647
 648         if (use != old->real)
 649             old->real = use;
 650     }
 651
 652     old->file_id = new->file_id;
 653     old->merge = new->merge;
 654 }
 655
 656 static int
 657 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge,
 658                unsigned file_id)
 659 {
 660     AliasInfo *alias;
 661
 662     list_foreach(alias, &info->aliases, entry) {
 663         if (alias->alias == KeyNameToLong(def->alias)) {
 664             AliasInfo new;
 665             InitAliasInfo(&new, merge, file_id, def->alias, def->real);
 666             HandleAliasCollision(info, alias, &new);
 667             return true;
 668         }
 669     }
 670
 671     alias = calloc(1, sizeof(*alias));
 672     if (!alias) {
 673         log_wsgo(info->keymap->ctx, "Allocation failure in HandleAliasDef\n");
 674         return false;
 675     }
 676
 677     alias->file_id = file_id;
 678     alias->merge = merge;
 679     alias->alias = KeyNameToLong(def->alias);
 680     alias->real = KeyNameToLong(def->real);
 681     list_append(&alias->entry, &info->aliases);
 682
 683     return true;
 684 }
 685
 686 #define MIN_KEYCODE_DEF 0
 687 #define MAX_KEYCODE_DEF 1
 688
 689 /**
 690  * Handle the minimum/maximum statement of the xkb file.
 691  * Sets explicitMin/Max of the info struct.
 692  *
 693  * @return 1 on success, 0 otherwise.
 694  */
 695 static int
 696 HandleKeyNameVar(KeyNamesInfo *info, VarDef *stmt)
 697 {
 698     const char *elem, *field;
 699     xkb_keycode_t kc;
 700     ExprDef *arrayNdx;
 701     int which;
 702
 703     if (!ExprResolveLhs(info->keymap->ctx, stmt->name, &elem, &field,
 704                         &arrayNdx))
 705         return false;               /* internal error, already reported */
 706
 707     if (elem) {
 708         log_err(info->keymap->ctx,
 709                 "Unknown element %s encountered; "
 710                 "Default for field %s ignored\n", elem, field);
 711         return false;
 712     }
 713
 714     if (istreq(field, "minimum")) {
 715         which = MIN_KEYCODE_DEF;
 716     }
 717     else if (istreq(field, "maximum")) {
 718         which = MAX_KEYCODE_DEF;
 719     }
 720     else {
 721         log_err(info->keymap->ctx,
 722                 "Unknown field encountered; "
 723                 "Assigment to field %s ignored\n", field);
 724         return false;
 725     }
 726
 727     if (arrayNdx != NULL) {
 728         log_err(info->keymap->ctx,
 729                 "The %s setting is not an array; "
 730                 "Illegal array reference ignored\n", field);
 731         return false;
 732     }
 733
 734     if (!ExprResolveKeyCode(info->keymap->ctx, stmt->value, &kc)) {
 735         log_err(info->keymap->ctx,
 736                 "Illegal keycode encountered; "
 737                 "Assignment to field %s ignored\n", field);
 738         return false;
 739     }
 740
 741     if (kc > XKB_KEYCODE_MAX) {
 742         log_err(info->keymap->ctx,
 743                 "Illegal keycode %d (must be in the range %d-%d inclusive); "
 744                 "Value of \"%s\" not changed\n",
 745                 kc, 0, XKB_KEYCODE_MAX, field);
 746         return false;
 747     }
 748
 749     if (which == MIN_KEYCODE_DEF) {
 750         if (info->explicitMax > 0 && info->explicitMax < kc) {
 751             log_err(info->keymap->ctx,
 752                     "Minimum key code (%d) must be <= maximum key code (%d); "
 753                     "Minimum key code value not changed\n",
 754                     kc, info->explicitMax);
 755             return false;
 756         }
 757
 758         if (info->computedMax > 0 && info->computedMin < kc) {
 759             log_err(info->keymap->ctx,
 760                     "Minimum key code (%d) must be <= lowest defined key (%d); "
 761                     "Minimum key code value not changed\n",
 762                     kc, info->computedMin);
 763             return false;
 764         }
 765
 766         info->explicitMin = kc;
 767     }
 768     else if (which == MAX_KEYCODE_DEF) {
 769         if (info->explicitMin > 0 && info->explicitMin > kc) {
 770             log_err(info->keymap->ctx,
 771                     "Maximum code (%d) must be >= minimum key code (%d); "
 772                     "Maximum code value not changed\n",
 773                     kc, info->explicitMin);
 774             return false;
 775         }
 776
 777         if (info->computedMax > 0 && info->computedMax > kc) {
 778             log_err(info->keymap->ctx,
 779                     "Maximum code (%d) must be >= highest defined key (%d); "
 780                     "Maximum code value not changed\n",
 781                     kc, info->computedMax);
 782             return false;
 783         }
 784
 785         info->explicitMax = kc;
 786     }
 787
 788     return true;
 789 }
 790
 791 static int
 792 HandleIndicatorNameDef(KeyNamesInfo *info, IndicatorNameDef *def,
 793                        enum merge_mode merge)
 794 {
 795     IndicatorNameInfo ii;
 796     const char *str;
 797
 798     if (def->ndx < 1 || def->ndx > XkbNumIndicators) {
 799         info->errorCount++;
 800         log_err(info->keymap->ctx,
 801                 "Name specified for illegal indicator index %d\n; Ignored\n",
 802                 def->ndx);
 803         return false;
 804     }
 805
 806     InitIndicatorNameInfo(&ii, info);
 807
 808     if (!ExprResolveString(info->keymap->ctx, def->name, &str)) {
 809         char buf[20];
 810         snprintf(buf, sizeof(buf), "%d", def->ndx);
 811         info->errorCount++;
 812         return ReportBadType(info->keymap, "indicator", "name", buf,
 813                              "string");
 814     }
 815
 816     ii.ndx = (xkb_led_index_t) def->ndx;
 817     ii.name = xkb_atom_intern(info->keymap->ctx, str);
 818     ii.virtual = def->virtual;
 819
 820     return AddIndicatorName(info, merge, &ii);
 821 }
 822
 823 /**
 824  * Handle the xkb_keycodes section of a xkb file.
 825  * All information about parsed keys is stored in the info struct.
 826  *
 827  * Such a section may have include statements, in which case this function is
 828  * semi-recursive (it calls HandleIncludeKeycodes, which may call
 829  * HandleKeycodesFile again).
 830  *
 831  * @param info Struct to contain the fully parsed key information.
 832  * @param file The input file (parsed xkb_keycodes section)
 833  * @param merge Merge strategy (MERGE_OVERRIDE, etc.)
 834  */
 835 static void
 836 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge)
 837 {
 838     ParseCommon *stmt;
 839     bool ok;
 840
 841     free(info->name);
 842     info->name = strdup_safe(file->name);
 843
 844     for (stmt = file->defs; stmt; stmt = stmt->next) {
 845         switch (stmt->type) {
 846         case STMT_INCLUDE:    /* e.g. include "evdev+aliases(qwerty)" */
 847             ok = HandleIncludeKeycodes(info, (IncludeStmt *) stmt);
 848             break;
 849         case STMT_KEYCODE: /* e.g. <ESC> = 9; */
 850             ok = HandleKeycodeDef(info, (KeycodeDef *) stmt, merge);
 851             break;
 852         case STMT_ALIAS: /* e.g. alias <MENU> = <COMP>; */
 853             ok = HandleAliasDef(info, (KeyAliasDef *) stmt, merge,
 854                                 info->file_id);
 855             break;
 856         case STMT_VAR: /* e.g. minimum, maximum */
 857             ok = HandleKeyNameVar(info, (VarDef *) stmt);
 858             break;
 859         case STMT_INDICATOR_NAME: /* e.g. indicator 1 = "Caps Lock"; */
 860             ok = HandleIndicatorNameDef(info, (IndicatorNameDef *) stmt,
 861                                         merge);
 862             break;
 863         default:
 864             log_err(info->keymap->ctx,
 865                     "Keycode files may define key and indicator names only; "
 866                     "Ignoring %s\n", StmtTypeToString(stmt->type));
 867             ok = false;
 868             break;
 869         }
 870
 871         if (!ok)
 872             info->errorCount++;
 873
 874         if (info->errorCount > 10) {
 875             log_err(info->keymap->ctx, "Abandoning keycodes file \"%s\"\n",
 876                     file->topName);
 877             break;
 878         }
 879     }
 880 }
 881
 882 static int
 883 ApplyAliases(KeyNamesInfo *info)
 884 {
 885     int i;
 886     struct xkb_key *key;
 887     struct xkb_key_alias *old, *a;
 888     AliasInfo *alias, *next;
 889     int nNew = 0, nOld;
 890     struct xkb_keymap *keymap = info->keymap;
 891
 892     nOld = darray_size(keymap->key_aliases);
 893     old = &darray_item(keymap->key_aliases, 0);
 894
 895     list_foreach(alias, &info->aliases, entry) {
 896         key = FindNamedKey(keymap, alias->real, false,
 897                            CreateKeyNames(keymap), 0);
 898         if (!key) {
 899             log_lvl(info->keymap->ctx, 5,
 900                     "Attempt to alias %s to non-existent key %s; Ignored\n",
 901                     LongKeyNameText(alias->alias),
 902                     LongKeyNameText(alias->real));
 903             alias->alias = 0;
 904             continue;
 905         }
 906
 907         key = FindNamedKey(keymap, alias->alias, false, false, 0);
 908         if (key) {
 909             log_lvl(info->keymap->ctx, 5,
 910                     "Attempt to create alias with the name of a real key; "
 911                     "Alias \"%s = %s\" ignored\n",
 912                     LongKeyNameText(alias->alias),
 913                     LongKeyNameText(alias->real));
 914             alias->alias = 0;
 915             continue;
 916         }
 917
 918         nNew++;
 919
 920         if (!old)
 921             continue;
 922
 923         for (i = 0, a = old; i < nOld; i++, a++) {
 924             AliasInfo old_alias;
 925
 926             if (KeyNameToLong(a->alias) == alias->alias)
 927                 continue;
 928
 929             InitAliasInfo(&old_alias, MERGE_AUGMENT, 0, a->alias, a->real);
 930             HandleAliasCollision(info, &old_alias, alias);
 931             old_alias.real = KeyNameToLong(a->real);
 932             alias->alias = 0;
 933             nNew--;
 934             break;
 935         }
 936     }
 937
 938     if (nNew == 0)
 939         goto out;
 940
 941     darray_resize0(keymap->key_aliases, nOld + nNew);
 942
 943     a = &darray_item(keymap->key_aliases, nOld);
 944     list_foreach(alias, &info->aliases, entry) {
 945         if (alias->alias != 0) {
 946             LongToKeyName(alias->alias, a->alias);
 947             LongToKeyName(alias->real, a->real);
 948             a++;
 949         }
 950     }
 951
 952 out:
 953     list_foreach_safe(alias, next, &info->aliases, entry)
 954         free(alias);
 955     list_init(&info->aliases);
 956     return true;
 957 }
 958
 959 /**
 960  * Compile the xkb_keycodes section, parse it's output, return the results.
 961  *
 962  * @param file The parsed XKB file (may have include statements requiring
 963  * further parsing)
 964  * @param result The effective keycodes, as gathered from the file.
 965  * @param merge Merge strategy.
 966  *
 967  * @return true on success, false otherwise.
 968  */
 969 bool
 970 CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
 971                 enum merge_mode merge)
 972 {
 973     xkb_keycode_t kc;
 974     KeyNamesInfo info; /* contains all the info after parsing */
 975     IndicatorNameInfo *ii;
 976
 977     InitKeyNamesInfo(&info, keymap, file->id);
 978
 979     HandleKeycodesFile(&info, file, merge);
 980
 981     /* all the keys are now stored in info */
 982
 983     if (info.errorCount != 0)
 984         goto err_info;
 985
 986     if (info.explicitMin > 0) /* if "minimum" statement was present */
 987         keymap->min_key_code = info.explicitMin;
 988     else
 989         keymap->min_key_code = info.computedMin;
 990
 991     if (info.explicitMax > 0) /* if "maximum" statement was present */
 992         keymap->max_key_code = info.explicitMax;
 993     else
 994         keymap->max_key_code = info.computedMax;
 995
 996     darray_resize0(keymap->keys, keymap->max_key_code + 1);
 997     for (kc = info.computedMin; kc <= info.computedMax; kc++)
 998         LongToKeyName(darray_item(info.names, kc),
 999                       XkbKey(keymap, kc)->name);
1000
1001     keymap->keycodes_section_name = strdup_safe(info.name);
1002
1003     list_foreach(ii, &info.leds, entry)
1004         keymap->indicator_names[ii->ndx - 1] =
1005             xkb_atom_text(keymap->ctx, ii->name);
1006
1007     ApplyAliases(&info);
1008
1009     ClearKeyNamesInfo(&info);
1010     return true;
1011
1012 err_info:
1013     ClearKeyNamesInfo(&info);
1014     return false;
1015 }