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     if (!include)
 343         return false;
 344
 345     InitKeyNamesInfo(&included, info->ctx);
 346     included.name = include->stmt;
 347     include->stmt = NULL;
 348
 349     for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
 350         KeyNamesInfo next_incl;
 351         XkbFile *file;
 352
 353         file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_KEYCODES);
 354         if (!file) {
 355             info->errorCount += 10;
 356             ClearKeyNamesInfo(&included);
 357             return false;
 358         }
 359
 360         InitKeyNamesInfo(&next_incl, info->ctx);
 361
 362         HandleKeycodesFile(&next_incl, file, MERGE_OVERRIDE);
 363
 364         MergeIncludedKeycodes(&included, &next_incl, stmt->merge);
 365
 366         ClearKeyNamesInfo(&next_incl);
 367         FreeXkbFile(file);
 368     }
 369
 370     MergeIncludedKeycodes(info, &included, include->merge);
 371     ClearKeyNamesInfo(&included);
 372
 373     return (info->errorCount == 0);
 374 }
 375
 376 static bool
 377 HandleKeycodeDef(KeyNamesInfo *info, KeycodeDef *stmt, enum merge_mode merge)
 378 {
 379     if (stmt->merge != MERGE_DEFAULT) {
 380         if (stmt->merge == MERGE_REPLACE)
 381             merge = MERGE_OVERRIDE;
 382         else
 383             merge = stmt->merge;
 384     }
 385
 386     if (stmt->value < 0 || stmt->value > XKB_KEYCODE_MAX) {
 387         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 388                 "Illegal keycode %lld: must be between 0..%u; "
 389                 "Key ignored\n", (long long) stmt->value, XKB_KEYCODE_MAX);
 390         return false;
 391     }
 392
 393     return AddKeyName(info, (xkb_keycode_t) stmt->value,
 394                       stmt->name, merge, false, true);
 395 }
 396
 397 static bool
 398 HandleAliasDef(KeyNamesInfo *info, KeyAliasDef *def, enum merge_mode merge)
 399 {
 400     AliasInfo *old, new;
 401
 402     darray_foreach(old, info->aliases) {
 403         if (old->alias == def->alias) {
 404             if (def->real == old->real) {
 405                 log_vrb(info->ctx, 1,
 406                         XKB_WARNING_CONFLICTING_KEY_NAME,
 407                         "Alias of %s for %s declared more than once; "
 408                         "First definition ignored\n",
 409                         KeyNameText(info->ctx, def->alias),
 410                         KeyNameText(info->ctx, def->real));
 411             }
 412             else {
 413                 xkb_atom_t use, ignore;
 414
 415                 use = (merge == MERGE_AUGMENT ? old->real : def->real);
 416                 ignore = (merge == MERGE_AUGMENT ? def->real : old->real);
 417
 418                 log_warn(info->ctx,
 419                          XKB_WARNING_CONFLICTING_KEY_NAME,
 420                          "Multiple definitions for alias %s; "
 421                          "Using %s, ignoring %s\n",
 422                          KeyNameText(info->ctx, old->alias),
 423                          KeyNameText(info->ctx, use),
 424                          KeyNameText(info->ctx, ignore));
 425
 426                 old->real = use;
 427             }
 428
 429             old->merge = merge;
 430             return true;
 431         }
 432     }
 433
 434     InitAliasInfo(&new, merge, def->alias, def->real);
 435     darray_append(info->aliases, new);
 436     return true;
 437 }
 438
 439 static bool
 440 HandleKeyNameVar(KeyNamesInfo *info, VarDef *stmt)
 441 {
 442     const char *elem, *field;
 443     ExprDef *arrayNdx;
 444
 445     if (!ExprResolveLhs(info->ctx, stmt->name, &elem, &field, &arrayNdx))
 446         return false;
 447
 448     if (elem) {
 449         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown element %s encountered; "
 450                 "Default for field %s ignored\n", elem, field);
 451         return false;
 452     }
 453
 454     if (!istreq(field, "minimum") && !istreq(field, "maximum")) {
 455         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID, "Unknown field encountered; "
 456                 "Assignment to field %s ignored\n", field);
 457         return false;
 458     }
 459
 460     /* We ignore explicit min/max statements, we always use computed. */
 461     return true;
 462 }
 463
 464 static bool
 465 HandleLedNameDef(KeyNamesInfo *info, LedNameDef *def,
 466                  enum merge_mode merge)
 467 {
 468     LedNameInfo ledi;
 469     xkb_atom_t name;
 470
 471     if (def->ndx < 1 || def->ndx > XKB_MAX_LEDS) {
 472         info->errorCount++;
 473         log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 474                 "Illegal indicator index (%d) specified; must be between 1 .. %d; "
 475                 "Ignored\n", def->ndx, XKB_MAX_LEDS);
 476         return false;
 477     }
 478
 479     if (!ExprResolveString(info->ctx, def->name, &name)) {
 480         char buf[20];
 481         snprintf(buf, sizeof(buf), "%u", def->ndx);
 482         info->errorCount++;
 483         return ReportBadType(info->ctx, XKB_ERROR_WRONG_FIELD_TYPE,
 484                              "indicator", "name", buf, "string");
 485     }
 486
 487     ledi.merge = merge;
 488     ledi.name = name;
 489     return AddLedName(info, merge, true, &ledi, def->ndx - 1);
 490 }
 491
 492 static void
 493 HandleKeycodesFile(KeyNamesInfo *info, XkbFile *file, enum merge_mode merge)
 494 {
 495     bool ok;
 496
 497     free(info->name);
 498     info->name = strdup_safe(file->name);
 499
 500     for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
 501         switch (stmt->type) {
 502         case STMT_INCLUDE:
 503             ok = HandleIncludeKeycodes(info, (IncludeStmt *) stmt);
 504             break;
 505         case STMT_KEYCODE:
 506             ok = HandleKeycodeDef(info, (KeycodeDef *) stmt, merge);
 507             break;
 508         case STMT_ALIAS:
 509             ok = HandleAliasDef(info, (KeyAliasDef *) stmt, merge);
 510             break;
 511         case STMT_VAR:
 512             ok = HandleKeyNameVar(info, (VarDef *) stmt);
 513             break;
 514         case STMT_LED_NAME:
 515             ok = HandleLedNameDef(info, (LedNameDef *) stmt, merge);
 516             break;
 517         default:
 518             log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 519                     "Keycode files may define key and indicator names only; "
 520                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
 521             ok = false;
 522             break;
 523         }
 524
 525         if (!ok)
 526             info->errorCount++;
 527
 528         if (info->errorCount > 10) {
 529             log_err(info->ctx, XKB_LOG_MESSAGE_NO_ID,
 530                     "Abandoning keycodes file \"%s\"\n",
 531                     file->name);
 532             break;
 533         }
 534     }
 535 }
 536
 537 /***====================================================================***/
 538
 539 static bool
 540 CopyKeyNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 541 {
 542     struct xkb_key *keys;
 543     xkb_keycode_t min_key_code, max_key_code, kc;
 544
 545     min_key_code = info->min_key_code;
 546     max_key_code = info->max_key_code;
 547     /* If the keymap has no keys, let's just use the safest pair we know. */
 548     if (min_key_code == XKB_KEYCODE_INVALID) {
 549         min_key_code = 8;
 550         max_key_code = 255;
 551     }
 552
 553     keys = calloc(max_key_code + 1, sizeof(*keys));
 554     if (!keys)
 555         return false;
 556
 557     for (kc = min_key_code; kc <= max_key_code; kc++)
 558         keys[kc].keycode = kc;
 559
 560     for (kc = info->min_key_code; kc <= info->max_key_code; kc++)
 561         keys[kc].name = darray_item(info->key_names, kc);
 562
 563     keymap->min_key_code = min_key_code;
 564     keymap->max_key_code = max_key_code;
 565     keymap->keys = keys;
 566     return true;
 567 }
 568
 569 static bool
 570 CopyKeyAliasesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 571 {
 572     AliasInfo *alias;
 573     unsigned i, num_key_aliases;
 574     struct xkb_key_alias *key_aliases;
 575
 576     /*
 577      * Do some sanity checking on the aliases. We can't do it before
 578      * because keys and their aliases may be added out-of-order.
 579      */
 580     num_key_aliases = 0;
 581     darray_foreach(alias, info->aliases) {
 582         /* Check that ->real is a key. */
 583         if (!XkbKeyByName(keymap, alias->real, false)) {
 584             log_vrb(info->ctx, 5,
 585                     XKB_WARNING_UNDEFINED_KEYCODE,
 586                     "Attempt to alias %s to non-existent key %s; Ignored\n",
 587                     KeyNameText(info->ctx, alias->alias),
 588                     KeyNameText(info->ctx, alias->real));
 589             alias->real = XKB_ATOM_NONE;
 590             continue;
 591         }
 592
 593         /* Check that ->alias is not a key. */
 594         if (XkbKeyByName(keymap, alias->alias, false)) {
 595             log_vrb(info->ctx, 5,
 596                     XKB_WARNING_ILLEGAL_KEYCODE_ALIAS,
 597                     "Attempt to create alias with the name of a real key; "
 598                     "Alias \"%s = %s\" ignored\n",
 599                     KeyNameText(info->ctx, alias->alias),
 600                     KeyNameText(info->ctx, alias->real));
 601             alias->real = XKB_ATOM_NONE;
 602             continue;
 603         }
 604
 605         num_key_aliases++;
 606     }
 607
 608     /* Copy key aliases. */
 609     key_aliases = NULL;
 610     if (num_key_aliases > 0) {
 611         key_aliases = calloc(num_key_aliases, sizeof(*key_aliases));
 612         if (!key_aliases)
 613             return false;
 614
 615         i = 0;
 616         darray_foreach(alias, info->aliases) {
 617             if (alias->real != XKB_ATOM_NONE) {
 618                 key_aliases[i].alias = alias->alias;
 619                 key_aliases[i].real = alias->real;
 620                 i++;
 621             }
 622         }
 623     }
 624
 625     keymap->num_key_aliases = num_key_aliases;
 626     keymap->key_aliases = key_aliases;
 627     return true;
 628 }
 629
 630 static bool
 631 CopyLedNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 632 {
 633     keymap->num_leds = info->num_led_names;
 634     for (xkb_led_index_t idx = 0; idx < info->num_led_names; idx++) {
 635         LedNameInfo *ledi = &info->led_names[idx];
 636
 637         if (ledi->name == XKB_ATOM_NONE)
 638             continue;
 639
 640         keymap->leds[idx].name = ledi->name;
 641     }
 642
 643     return true;
 644 }
 645
 646 static bool
 647 CopyKeyNamesInfoToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
 648 {
 649     /* This function trashes keymap on error, but that's OK. */
 650     if (!CopyKeyNamesToKeymap(keymap, info) ||
 651         !CopyKeyAliasesToKeymap(keymap, info) ||
 652         !CopyLedNamesToKeymap(keymap, info))
 653         return false;
 654
 655     keymap->keycodes_section_name = strdup_safe(info->name);
 656     XkbEscapeMapName(keymap->keycodes_section_name);
 657     return true;
 658 }
 659
 660 /***====================================================================***/
 661
 662 bool
 663 CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
 664                 enum merge_mode merge)
 665 {
 666     KeyNamesInfo info;
 667
 668     InitKeyNamesInfo(&info, keymap->ctx);
 669
 670     HandleKeycodesFile(&info, file, merge);
 671     if (info.errorCount != 0)
 672         goto err_info;
 673
 674     if (!CopyKeyNamesInfoToKeymap(keymap, &info))
 675         goto err_info;
 676
 677     ClearKeyNamesInfo(&info);
 678     return true;
 679
 680 err_info:
 681     ClearKeyNamesInfo(&info);
 682     return false;
 683 }