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 "config.h"
  28
  29 #include "xkbcomp-priv.h"
  30 #include "text.h"
  31 #include "expr.h"
  32 #include "include.h"
  33
  34 typedef struct {
  35     enum merge_mode merge;
  36
  37     xkb_atom_t alias;
  38     xkb_atom_t real;
  39 } AliasInfo;
  40
  41 typedef struct {
  42     enum merge_mode merge;
  43
  44     xkb_atom_t name;
  45 } LedNameInfo;
  46
  47 typedef struct {
  48     char *name;
  49     int errorCount;
  50
  51     xkb_keycode_t min_key_code;
  52     xkb_keycode_t max_key_code;
  53     darray(xkb_atom_t) key_names;
  54     LedNameInfo led_names[XKB_MAX_LEDS];
  55     unsigned int num_led_names;
  56     darray(AliasInfo) aliases;
  57
  58     struct xkb_context *ctx;
  59 } KeyNamesInfo;
  60
  61 /***====================================================================***/
  62
  63 static void
  64 InitAliasInfo(AliasInfo *info, enum merge_mode merge,
  65               xkb_atom_t alias, xkb_atom_t real)
  66 {
  67     memset(info, 0, sizeof(*info));
  68     info->merge = merge;
  69     info->alias = alias;
  70     info->real = real;
  71 }
  72
  73 static LedNameInfo *
  74 FindLedByName(KeyNamesInfo *info, xkb_atom_t name,
  75               xkb_led_index_t *idx_out)
  76 {
  77     for (xkb_led_index_t idx = 0; idx < info->num_led_names; idx++) {
  78         LedNameInfo *ledi = &info->led_names[idx];
  79         if (ledi->name == name) {
  80             *idx_out = idx;
  81             return ledi;
  82         }
  83     }
  84
  85     return NULL;
  86 }
  87
  88 static bool
  89 AddLedName(KeyNamesInfo *info, enum merge_mode merge, bool same_file,
  90            LedNameInfo *new, xkb_led_index_t new_idx)
  91 {
  92     xkb_led_index_t old_idx;
  93     LedNameInfo *old;
  94     const int verbosity = xkb_context_get_log_verbosity(info->ctx);
  95     const bool report = (same_file && verbosity > 0) || verbosity > 9;
  96     const bool replace = (merge == MERGE_REPLACE || merge == MERGE_OVERRIDE);
  97
  98     /* LED with the same name already exists. */
  99     old = FindLedByName(info, new->name, &old_idx);
 100     if (old) {
 101         if (old_idx == new_idx) {
 102             log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 103                      "Multiple indicators named \"%s\"; "
 104                      "Identical definitions ignored\n",
 105                      xkb_atom_text(info->ctx, new->name));
 106             return true;
 107         }
 108
 109         if (report) {
 110             xkb_led_index_t use = (replace ? new_idx + 1 : old_idx + 1);
 111             xkb_led_index_t ignore = (replace ? old_idx + 1 : new_idx + 1);
 112             log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 113                      "Multiple indicators named %s; Using %d, ignoring %d\n",
 114                      xkb_atom_text(info->ctx, new->name), use, ignore);
 115         }
 116
 117         if (replace)
 118             *old = *new;
 119
 120         return true;
 121     }
 122
 123     if (new_idx >= info->num_led_names)
 124         info->num_led_names = new_idx + 1;
 125
 126     /* LED with the same index already exists. */
 127     old = &info->led_names[new_idx];
 128     if (old->name != XKB_ATOM_NONE) {
 129         if (report) {
 130             const xkb_atom_t use = (replace ? new->name : old->name);
 131             const xkb_atom_t ignore = (replace ? old->name : new->name);
 132             log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 133                      "Multiple names for indicator %d; "
 134                      "Using %s, ignoring %s\n", new_idx + 1,
 135                      xkb_atom_text(info->ctx, use),
 136                      xkb_atom_text(info->ctx, ignore));
 137         }
 138
 139         if (replace)
 140             *old = *new;
 141
 142         return true;
 143     }
 144
 145     *old = *new;
 146     return true;
 147 }
 148
 149 static void
 150 ClearKeyNamesInfo(KeyNamesInfo *info)
 151 {
 152     free(info->name);
 153     darray_free(info->key_names);
 154     darray_free(info->aliases);
 155 }
 156
 157 static void
 158 InitKeyNamesInfo(KeyNamesInfo *info, struct xkb_context *ctx)
 159 {
 160     memset(info, 0, sizeof(*info));
 161     info->ctx = ctx;
 162     info->min_key_code = XKB_KEYCODE_INVALID;
 163 #if XKB_KEYCODE_INVALID < XKB_KEYCODE_MAX
 164 #error "Hey, you can't be changing stuff like that."
 165 #endif
 166 }
 167
 168 static xkb_keycode_t
 169 FindKeyByName(KeyNamesInfo *info, xkb_atom_t name)
 170 {
 171     xkb_keycode_t i;
 172
 173     for (i = info->min_key_code; i <= info->max_key_code; i++)
 174         if (darray_item(info->key_names, i) == name)
 175             return i;
 176
 177     return XKB_KEYCODE_INVALID;
 178 }
 179
 180 static bool
 181 AddKeyName(KeyNamesInfo *info, xkb_keycode_t kc, xkb_atom_t name,
 182            enum merge_mode merge, bool same_file, bool report)
 183 {
 184     xkb_atom_t old_name;
 185     xkb_keycode_t old_kc;
 186     const int verbosity = xkb_context_get_log_verbosity(info->ctx);
 187
 188     report = report && ((same_file && verbosity > 0) || verbosity > 7);
 189
 190     if (kc >= darray_size(info->key_names))
 191         darray_resize0(info->key_names, kc + 1);
 192
 193     info->min_key_code = MIN(info->min_key_code, kc);
 194     info->max_key_code = MAX(info->max_key_code, kc);
 195
 196     /* There's already a key with this keycode. */
 197     old_name = darray_item(info->key_names, kc);
 198     if (old_name != XKB_ATOM_NONE) {
 199         const char *lname = KeyNameText(info->ctx, old_name);
 200         const char *kname = KeyNameText(info->ctx, name);
 201
 202         if (old_name == name) {
 203             if (report)
 204                 log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 205                          "Multiple identical key name definitions; "
 206                          "Later occurrences of \"%s = %d\" ignored\n",
 207                          lname, kc);
 208             return true;
 209         }
 210         else if (merge == MERGE_AUGMENT) {
 211             if (report)
 212                 log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 213                          "Multiple names for keycode %d; "
 214                          "Using %s, ignoring %s\n", kc, lname, kname);
 215             return true;
 216         }
 217         else {
 218             if (report)
 219                 log_warn(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 220                          "Multiple names for keycode %d; "
 221                          "Using %s, ignoring %s\n", kc, kname, lname);
 222             darray_item(info->key_names, kc) = XKB_ATOM_NONE;
 223         }
 224     }
 225
 226     /* There's already a key with this name. */
 227     old_kc = FindKeyByName(info, name);
 228     if (old_kc != XKB_KEYCODE_INVALID && old_kc != kc) {
 229         const char *kname = KeyNameText(info->ctx, name);
 230
 231         if (merge == MERGE_OVERRIDE) {
 232             darray_item(info->key_names, old_kc) = XKB_ATOM_NONE;
 233             if (report)
 234                 log_warn(info->ctx,
 235                          XKB_WARNING_CONFLICTING_KEY_NAME,
 236                          "Key name %s assigned to multiple keys; "
 237                          "Using %d, ignoring %d\n", kname, kc, old_kc);
 238         }
 239         else {
 240             if (report)
 241                 log_vrb(info->ctx, 3,
 242                         XKB_WARNING_CONFLICTING_KEY_NAME,
 243                         "Key name %s assigned to multiple keys; "
 244                         "Using %d, ignoring %d\n", kname, old_kc, kc);
 245             return true;
 246         }
 247     }
 248
 249     darray_item(info->key_names, kc) = name;
 250     return true;
 251 }
 252
 253 /***====================================================================***/
 254
 255 static bool
 256 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge);
 257
 258 static void
 259 MergeIncludedKeycodes(KeyNamesInfo *into, KeyNamesInfo *from,
 260                       enum merge_mode merge)
 261 {
 262     if (from->errorCount > 0) {
 263         into->errorCount += from->errorCount;
 264         return;
 265     }
 266
 267     if (into->name == NULL) {
 268         into->name = from->name;
 269         from->name = NULL;
 270     }
 271
 272     /* Merge key names. */
 273     if (darray_empty(into->key_names)) {
 274         into->key_names = from->key_names;
 275         darray_init(from->key_names);
 276         into->min_key_code = from->min_key_code;
 277         into->max_key_code = from->max_key_code;
 278     }
 279     else {
 280         if (darray_size(into->key_names) < darray_size(from->key_names))
 281             darray_resize0(into->key_names, darray_size(from->key_names));
 282
 283         for (unsigned i = from->min_key_code; i <= from->max_key_code; i++) {
 284             xkb_atom_t name = darray_item(from->key_names, i);
 285             if (name == XKB_ATOM_NONE)
 286                 continue;
 287
 288             if (!AddKeyName(into, i, name, merge, true, false))
 289                 into->errorCount++;
 290         }
 291     }
 292
 293     /* Merge key aliases. */
 294     if (darray_empty(into->aliases)) {
 295         into->aliases = from->aliases;
 296         darray_init(from->aliases);
 297     }
 298     else {
 299         AliasInfo *alias;
 300
 301         darray_foreach(alias, from->aliases) {
 302             KeyAliasDef def;
 303
 304             def.merge = (merge == MERGE_DEFAULT ? alias->merge : merge);
 305             def.alias = alias->alias;
 306             def.real = alias->real;
 307
 308             if (!HandleAliasDef(into, &def, def.merge))
 309                 into->errorCount++;
 310         }
 311     }
 312
 313     /* Merge LED names. */
 314     if (into->num_led_names == 0) {
 315         memcpy(into->led_names, from->led_names,
 316                sizeof(*from->led_names) * from->num_led_names);
 317         into->num_led_names = from->num_led_names;
 318         from->num_led_names = 0;
 319     }
 320     else {
 321         for (xkb_led_index_t idx = 0; idx < from->num_led_names; idx++) {
 322             LedNameInfo *ledi = &from->led_names[idx];
 323
 324             if (ledi->name == XKB_ATOM_NONE)
 325                 continue;
 326
 327             ledi->merge = (merge == MERGE_DEFAULT ? ledi->merge : merge);
 328             if (!AddLedName(into, ledi->merge, false, ledi, idx))
 329                 into->errorCount++;
 330         }
 331     }
 332 }
 333
 334 static void
 335 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge);
 336
 337 static bool
 338 HandleIncludeKeycodes(KeyNamesInfo *info, IncludeStmt *include)
 339 {
 340     KeyNamesInfo included;
 341
 342     InitKeyNamesInfo(&included, info->ctx);
 343     included.name = include->stmt;
 344     include->stmt = NULL;
 345
 346     for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
 347         KeyNamesInfo next_incl;
 348         XkbFile *file;
 349
 350         file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_KEYCODES);
 351         if (!file) {
 352             info->errorCount += 10;
 353             ClearKeyNamesInfo(&included);
 354             return false;
 355         }
 356
 357         InitKeyNamesInfo(&next_incl, info->ctx);
 358
 359         HandleKeycodesFile(&next_incl, file, MERGE_OVERRIDE);
 360
 361         MergeIncludedKeycodes(&included, &next_incl, stmt->merge);
 362
 363         ClearKeyNamesInfo(&next_incl);
 364         FreeXkbFile(file);
 365     }
 366
 367     MergeIncludedKeycodes(info, &included, include->merge);
 368     ClearKeyNamesInfo(&included);
 369
 370     return (info->errorCount == 0);
 371 }
 372
 373 static bool
 374 HandleKeycodeDef(KeyNamesInfo *info, KeycodeDef *stmt, enum merge_mode merge)
 375 {
 376     if (stmt->merge != MERGE_DEFAULT) {
 377         if (stmt->merge == MERGE_REPLACE)
 378             merge = MERGE_OVERRIDE;
 379         else
 380             merge = stmt->merge;
 381     }
 382
 383     if (stmt->value < 0 || stmt->value > XKB_KEYCODE_MAX) {
 384         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 385                 "Illegal keycode %lld: must be between 0..%u; "
 386                 "Key ignored\n", (long long) stmt->value, XKB_KEYCODE_MAX);
 387         return false;
 388     }
 389
 390     return AddKeyName(info, (xkb_keycode_t) stmt->value,
 391                       stmt->name, merge, false, true);
 392 }
 393
 394 static bool
 395 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge)
 396 {
 397     AliasInfo *old, new;
 398
 399     darray_foreach(old, info->aliases) {
 400         if (old->alias == def->alias) {
 401             if (def->real == old->real) {
 402                 log_vrb(info->ctx, 1,
 403                         XKB_WARNING_CONFLICTING_KEY_NAME,
 404                         "Alias of %s for %s declared more than once; "
 405                         "First definition ignored\n",
 406                         KeyNameText(info->ctx, def->alias),
 407                         KeyNameText(info->ctx, def->real));
 408             }
 409             else {
 410                 xkb_atom_t use, ignore;
 411
 412                 use = (merge == MERGE_AUGMENT ? old->real : def->real);
 413                 ignore = (merge == MERGE_AUGMENT ? def->real : old->real);
 414
 415                 log_warn(info->ctx,
 416                          XKB_WARNING_CONFLICTING_KEY_NAME,
 417                          "Multiple definitions for alias %s; "
 418                          "Using %s, ignoring %s\n",
 419                          KeyNameText(info->ctx, old->alias),
 420                          KeyNameText(info->ctx, use),
 421                          KeyNameText(info->ctx, ignore));
 422
 423                 old->real = use;
 424             }
 425
 426             old->merge = merge;
 427             return true;
 428         }
 429     }
 430
 431     InitAliasInfo(&new, merge, def->alias, def->real);
 432     darray_append(info->aliases, new);
 433     return true;
 434 }
 435
 436 static bool
 437 HandleKeyNameVar(KeyNamesInfo *info, VarDef *stmt)
 438 {
 439     const char *elem, *field;
 440     ExprDef *arrayNdx;
 441
 442     if (!ExprResolveLhs(info->ctx, stmt->name, &elem, &field, &arrayNdx))
 443         return false;
 444
 445     if (elem) {
 446         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown element %s encountered; "
 447                 "Default for field %s ignored\n", elem, field);
 448         return false;
 449     }
 450
 451     if (!istreq(field, "minimum") && !istreq(field, "maximum")) {
 452         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown field encountered; "
 453                 "Assignment to field %s ignored\n", field);
 454         return false;
 455     }
 456
 457     /* We ignore explicit min/max statements, we always use computed. */
 458     return true;
 459 }
 460
 461 static bool
 462 HandleLedNameDef(KeyNamesInfo *info, LedNameDef *def,
 463                  enum merge_mode merge)
 464 {
 465     LedNameInfo ledi;
 466     xkb_atom_t name;
 467
 468     if (def->ndx < 1 || def->ndx > XKB_MAX_LEDS) {
 469         info->errorCount++;
 470         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 471                 "Illegal indicator index (%d) specified; must be between 1 .. %d; "
 472                 "Ignored\n", def->ndx, XKB_MAX_LEDS);
 473         return false;
 474     }
 475
 476     if (!ExprResolveString(info->ctx, def->name, &name)) {
 477         char buf[20];
 478         snprintf(buf, sizeof(buf), "%u", def->ndx);
 479         info->errorCount++;
 480         return ReportBadType(info->ctx, XKB_ERROR_WRONG_FIELD_TYPE,
 481                              "indicator", "name", buf, "string");
 482     }
 483
 484     ledi.merge = merge;
 485     ledi.name = name;
 486     return AddLedName(info, merge, true, &ledi, def->ndx - 1);
 487 }
 488
 489 static void
 490 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge)
 491 {
 492     bool ok;
 493
 494     free(info->name);
 495     info->name = strdup_safe(file->name);
 496
 497     for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
 498         switch (stmt->type) {
 499         case STMT_INCLUDE:
 500             ok = HandleIncludeKeycodes(info, (IncludeStmt *) stmt);
 501             break;
 502         case STMT_KEYCODE:
 503             ok = HandleKeycodeDef(info, (KeycodeDef *) stmt, merge);
 504             break;
 505         case STMT_ALIAS:
 506             ok = HandleAliasDef(info, (KeyAliasDef *) stmt, merge);
 507             break;
 508         case STMT_VAR:
 509             ok = HandleKeyNameVar(info, (VarDef *) stmt);
 510             break;
 511         case STMT_LED_NAME:
 512             ok = HandleLedNameDef(info, (LedNameDef *) stmt, merge);
 513             break;
 514         default:
 515             log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 516                     "Keycode files may define key and indicator names only; "
 517                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
 518             ok = false;
 519             break;
 520         }
 521
 522         if (!ok)
 523             info->errorCount++;
 524
 525         if (info->errorCount > 10) {
 526             log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 527                     "Abandoning keycodes file \"%s\"\n",
 528                     file->name);
 529             break;
 530         }
 531     }
 532 }
 533
 534 /***====================================================================***/
 535
 536 static bool
 537 CopyKeyNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 538 {
 539     struct xkb_key *keys;
 540     xkb_keycode_t min_key_code, max_key_code, kc;
 541
 542     min_key_code = info->min_key_code;
 543     max_key_code = info->max_key_code;
 544     /* If the keymap has no keys, let's just use the safest pair we know. */
 545     if (min_key_code == XKB_KEYCODE_INVALID) {
 546         min_key_code = 8;
 547         max_key_code = 255;
 548     }
 549
 550     keys = calloc(max_key_code + 1, sizeof(*keys));
 551     if (!keys)
 552         return false;
 553
 554     for (kc = min_key_code; kc <= max_key_code; kc++)
 555         keys[kc].keycode = kc;
 556
 557     for (kc = info->min_key_code; kc <= info->max_key_code; kc++)
 558         keys[kc].name = darray_item(info->key_names, kc);
 559
 560     keymap->min_key_code = min_key_code;
 561     keymap->max_key_code = max_key_code;
 562     keymap->keys = keys;
 563     return true;
 564 }
 565
 566 static bool
 567 CopyKeyAliasesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 568 {
 569     AliasInfo *alias;
 570     unsigned i, num_key_aliases;
 571     struct xkb_key_alias *key_aliases;
 572
 573     /*
 574      * Do some sanity checking on the aliases. We can't do it before
 575      * because keys and their aliases may be added out-of-order.
 576      */
 577     num_key_aliases = 0;
 578     darray_foreach(alias, info->aliases) {
 579         /* Check that ->real is a key. */
 580         if (!XkbKeyByName(keymap, alias->real, false)) {
 581             log_vrb(info->ctx, 5,
 582                     XKB_WARNING_UNDEFINED_KEYCODE,
 583                     "Attempt to alias %s to non-existent key %s; Ignored\n",
 584                     KeyNameText(info->ctx, alias->alias),
 585                     KeyNameText(info->ctx, alias->real));
 586             alias->real = XKB_ATOM_NONE;
 587             continue;
 588         }
 589
 590         /* Check that ->alias is not a key. */
 591         if (XkbKeyByName(keymap, alias->alias, false)) {
 592             log_vrb(info->ctx, 5,
 593                     XKB_WARNING_ILLEGAL_KEYCODE_ALIAS,
 594                     "Attempt to create alias with the name of a real key; "
 595                     "Alias \"%s = %s\" ignored\n",
 596                     KeyNameText(info->ctx, alias->alias),
 597                     KeyNameText(info->ctx, alias->real));
 598             alias->real = XKB_ATOM_NONE;
 599             continue;
 600         }
 601
 602         num_key_aliases++;
 603     }
 604
 605     /* Copy key aliases. */
 606     key_aliases = NULL;
 607     if (num_key_aliases > 0) {
 608         key_aliases = calloc(num_key_aliases, sizeof(*key_aliases));
 609         if (!key_aliases)
 610             return false;
 611
 612         i = 0;
 613         darray_foreach(alias, info->aliases) {
 614             if (alias->real != XKB_ATOM_NONE) {
 615                 key_aliases[i].alias = alias->alias;
 616                 key_aliases[i].real = alias->real;
 617                 i++;
 618             }
 619         }
 620     }
 621
 622     keymap->num_key_aliases = num_key_aliases;
 623     keymap->key_aliases = key_aliases;
 624     return true;
 625 }
 626
 627 static bool
 628 CopyLedNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 629 {
 630     keymap->num_leds = info->num_led_names;
 631     for (xkb_led_index_t idx = 0; idx < info->num_led_names; idx++) {
 632         LedNameInfo *ledi = &info->led_names[idx];
 633
 634         if (ledi->name == XKB_ATOM_NONE)
 635             continue;
 636
 637         keymap->leds[idx].name = ledi->name;
 638     }
 639
 640     return true;
 641 }
 642
 643 static bool
 644 CopyKeyNamesInfoToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 645 {
 646     /* This function trashes keymap on error, but that's OK. */
 647     if (!CopyKeyNamesToKeymap(keymap, info) ||
 648         !CopyKeyAliasesToKeymap(keymap, info) ||
 649         !CopyLedNamesToKeymap(keymap, info))
 650         return false;
 651
 652     keymap->keycodes_section_name = strdup_safe(info->name);
 653     XkbEscapeMapName(keymap->keycodes_section_name);
 654     return true;
 655 }
 656
 657 /***====================================================================***/
 658
 659 bool
 660 CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
 661                 enum merge_mode merge)
 662 {
 663     KeyNamesInfo info;
 664
 665     InitKeyNamesInfo(&info, keymap->ctx);
 666
 667     HandleKeycodesFile(&info, file, merge);
 668     if (info.errorCount != 0)
 669         goto err_info;
 670
 671     if (!CopyKeyNamesInfoToKeymap(keymap, &info))
 672         goto err_info;
 673
 674     ClearKeyNamesInfo(&info);
 675     return true;
 676
 677 err_info:
 678     ClearKeyNamesInfo(&info);
 679     return false;
 680 }