src/xkbcomp/types.c

   1 /************************************************************
   2  * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of Silicon Graphics not be
  10  * used in advertising or publicity pertaining to distribution
  11  * of the software without specific prior written permission.
  12  * Silicon Graphics makes no representation about the suitability
  13  * of this software for any purpose. It is provided "as is"
  14  * without any express or implied warranty.
  15  *
  16  * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  * THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  ********************************************************/
  26
  27 #include "xkbcomp-priv.h"
  28 #include "text.h"
  29 #include "vmod.h"
  30 #include "expr.h"
  31 #include "include.h"
  32
  33 enum type_field {
  34     TYPE_FIELD_MASK       = (1 << 0),
  35     TYPE_FIELD_MAP        = (1 << 1),
  36     TYPE_FIELD_PRESERVE   = (1 << 2),
  37     TYPE_FIELD_LEVEL_NAME = (1 << 3),
  38 };
  39
  40 typedef struct {
  41     enum type_field defined;
  42     enum merge_mode merge;
  43
  44     xkb_atom_t name;
  45     xkb_mod_mask_t mods;
  46     xkb_level_index_t num_levels;
  47     darray(struct xkb_key_type_entry) entries;
  48     darray(xkb_atom_t) level_names;
  49 } KeyTypeInfo;
  50
  51 typedef struct {
  52     char *name;
  53     int errorCount;
  54
  55     darray(KeyTypeInfo) types;
  56     struct xkb_context *ctx;
  57     struct xkb_keymap *keymap;
  58 } KeyTypesInfo;
  59
  60 /***====================================================================***/
  61
  62 static inline const char *
  63 MapEntryTxt(KeyTypesInfo *info, struct xkb_key_type_entry *entry)
  64 {
  65     return ModMaskText(info->ctx, &info->keymap->mods, entry->mods.mods);
  66 }
  67
  68 static inline const char *
  69 TypeTxt(KeyTypesInfo *info, KeyTypeInfo *type)
  70 {
  71     return xkb_atom_text(info->ctx, type->name);
  72 }
  73
  74 static inline const char *
  75 TypeMaskTxt(KeyTypesInfo *info, KeyTypeInfo *type)
  76 {
  77     return ModMaskText(info->ctx, &info->keymap->mods, type->mods);
  78 }
  79
  80 static inline bool
  81 ReportTypeShouldBeArray(KeyTypesInfo *info, KeyTypeInfo *type,
  82                         const char *field)
  83 {
  84     return ReportShouldBeArray(info->ctx, "key type", field,
  85                                TypeTxt(info, type));
  86 }
  87
  88 static inline bool
  89 ReportTypeBadType(KeyTypesInfo *info, KeyTypeInfo *type,
  90                   const char *field, const char *wanted)
  91 {
  92     return ReportBadType(info->ctx, "key type", field,
  93                          TypeTxt(info, type), wanted);
  94 }
  95
  96 /***====================================================================***/
  97
  98 static void
  99 InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_keymap *keymap)
 100 {
 101     memset(info, 0, sizeof(*info));
 102     info->keymap = keymap;
 103     info->ctx = keymap->ctx;
 104 }
 105
 106 static void
 107 ClearKeyTypeInfo(KeyTypeInfo *type)
 108 {
 109     darray_free(type->entries);
 110     darray_free(type->level_names);
 111 }
 112
 113 static void
 114 ClearKeyTypesInfo(KeyTypesInfo *info)
 115 {
 116     free(info->name);
 117     darray_free(info->types);
 118 }
 119
 120 static KeyTypeInfo *
 121 FindMatchingKeyType(KeyTypesInfo *info, xkb_atom_t name)
 122 {
 123     KeyTypeInfo *old;
 124
 125     darray_foreach(old, info->types)
 126         if (old->name == name)
 127             return old;
 128
 129     return NULL;
 130 }
 131
 132 static bool
 133 AddKeyType(KeyTypesInfo *info, KeyTypeInfo *new, bool same_file)
 134 {
 135     KeyTypeInfo *old;
 136     const int verbosity = xkb_context_get_log_verbosity(info->ctx);
 137
 138     old = FindMatchingKeyType(info, new->name);
 139     if (old) {
 140         if (new->merge == MERGE_REPLACE || new->merge == MERGE_OVERRIDE) {
 141             if ((same_file && verbosity > 0) || verbosity > 9) {
 142                 log_warn(info->ctx,
 143                          "Multiple definitions of the %s key type; "
 144                          "Earlier definition ignored\n",
 145                          xkb_atom_text(info->ctx, new->name));
 146             }
 147
 148             ClearKeyTypeInfo(old);
 149             *old = *new;
 150             darray_init(new->entries);
 151             darray_init(new->level_names);
 152             return true;
 153         }
 154
 155         if (same_file)
 156             log_vrb(info->ctx, 4,
 157                     "Multiple definitions of the %s key type; "
 158                     "Later definition ignored\n",
 159                     xkb_atom_text(info->ctx, new->name));
 160
 161         ClearKeyTypeInfo(new);
 162         return true;
 163     }
 164
 165     darray_append(info->types, *new);
 166     return true;
 167 }
 168
 169 /***====================================================================***/
 170
 171 static void
 172 MergeIncludedKeyTypes(KeyTypesInfo *into, KeyTypesInfo *from,
 173                       enum merge_mode merge)
 174 {
 175     KeyTypeInfo *type;
 176
 177     if (from->errorCount > 0) {
 178         into->errorCount += from->errorCount;
 179         return;
 180     }
 181
 182     if (into->name == NULL) {
 183         into->name = from->name;
 184         from->name = NULL;
 185     }
 186
 187     if (darray_empty(into->types)) {
 188         into->types = from->types;
 189         darray_init(from->types);
 190     }
 191     else {
 192         darray_foreach(type, from->types) {
 193             type->merge = (merge == MERGE_DEFAULT ? type->merge : merge);
 194             if (!AddKeyType(into, type, false))
 195                 into->errorCount++;
 196         }
 197     }
 198 }
 199
 200 static void
 201 HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge);
 202
 203 static bool
 204 HandleIncludeKeyTypes(KeyTypesInfo *info, IncludeStmt *include)
 205 {
 206     KeyTypesInfo included;
 207
 208     InitKeyTypesInfo(&included, info->keymap);
 209     included.name = include->stmt;
 210     include->stmt = NULL;
 211
 212     for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
 213         KeyTypesInfo next_incl;
 214         XkbFile *file;
 215
 216         file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_TYPES);
 217         if (!file) {
 218             info->errorCount += 10;
 219             ClearKeyTypesInfo(&included);
 220             return false;
 221         }
 222
 223         InitKeyTypesInfo(&next_incl, info->keymap);
 224
 225         HandleKeyTypesFile(&next_incl, file, stmt->merge);
 226
 227         MergeIncludedKeyTypes(&included, &next_incl, stmt->merge);
 228
 229         ClearKeyTypesInfo(&next_incl);
 230         FreeXkbFile(file);
 231     }
 232
 233     MergeIncludedKeyTypes(info, &included, include->merge);
 234     ClearKeyTypesInfo(&included);
 235
 236     return (info->errorCount == 0);
 237 }
 238
 239 /***====================================================================***/
 240
 241 static bool
 242 SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
 243              ExprDef *value)
 244 {
 245     xkb_mod_mask_t mods;
 246
 247     if (arrayNdx)
 248         log_warn(info->ctx,
 249                  "The modifiers field of a key type is not an array; "
 250                  "Illegal array subscript ignored\n");
 251
 252     if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->keymap->mods,
 253                             &mods)) {
 254         log_err(info->ctx,
 255                 "Key type mask field must be a modifier mask; "
 256                 "Key type definition ignored\n");
 257         return false;
 258     }
 259
 260     if (type->defined & TYPE_FIELD_MASK) {
 261         log_warn(info->ctx,
 262                  "Multiple modifier mask definitions for key type %s; "
 263                  "Using %s, ignoring %s\n",
 264                  xkb_atom_text(info->ctx, type->name),
 265                  TypeMaskTxt(info, type),
 266                  ModMaskText(info->ctx, &info->keymap->mods, mods));
 267         return false;
 268     }
 269
 270     type->mods = mods;
 271     return true;
 272 }
 273
 274 /***====================================================================***/
 275
 276 static struct xkb_key_type_entry *
 277 FindMatchingMapEntry(KeyTypeInfo *type, xkb_mod_mask_t mods)
 278 {
 279     struct xkb_key_type_entry *entry;
 280
 281     darray_foreach(entry, type->entries)
 282         if (entry->mods.mods == mods)
 283             return entry;
 284
 285     return NULL;
 286 }
 287
 288 static bool
 289 AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type,
 290             struct xkb_key_type_entry *new, bool clobber, bool report)
 291 {
 292     struct xkb_key_type_entry *old;
 293
 294     old = FindMatchingMapEntry(type, new->mods.mods);
 295     if (old) {
 296         if (report && old->level != new->level) {
 297             log_warn(info->ctx,
 298                      "Multiple map entries for %s in %s; "
 299                      "Using %d, ignoring %d\n",
 300                      MapEntryTxt(info, new), TypeTxt(info, type),
 301                      (clobber ? new->level : old->level) + 1,
 302                      (clobber ? old->level : new->level) + 1);
 303         }
 304         else {
 305             log_vrb(info->ctx, 10,
 306                     "Multiple occurrences of map[%s]= %d in %s; Ignored\n",
 307                     MapEntryTxt(info, new), new->level + 1,
 308                     TypeTxt(info, type));
 309             return true;
 310         }
 311
 312         if (clobber) {
 313             if (new->level >= type->num_levels)
 314                 type->num_levels = new->level + 1;
 315             old->level = new->level;
 316         }
 317
 318         return true;
 319     }
 320
 321     if (new->level >= type->num_levels)
 322         type->num_levels = new->level + 1;
 323
 324     darray_append(type->entries, *new);
 325     return true;
 326 }
 327
 328 static bool
 329 SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
 330             ExprDef *value)
 331 {
 332     struct xkb_key_type_entry entry;
 333
 334     if (arrayNdx == NULL)
 335         return ReportTypeShouldBeArray(info, type, "map entry");
 336
 337     if (!ExprResolveModMask(info->ctx, arrayNdx, MOD_BOTH,
 338                             &info->keymap->mods, &entry.mods.mods))
 339         return ReportTypeBadType(info, type, "map entry", "modifier mask");
 340
 341     if (entry.mods.mods & (~type->mods)) {
 342         log_vrb(info->ctx, 1,
 343                 "Map entry for unused modifiers in %s; "
 344                 "Using %s instead of %s\n",
 345                 TypeTxt(info, type),
 346                 ModMaskText(info->ctx, &info->keymap->mods,
 347                             entry.mods.mods & type->mods),
 348                 MapEntryTxt(info, &entry));
 349         entry.mods.mods &= type->mods;
 350     }
 351
 352     if (!ExprResolveLevel(info->ctx, value, &entry.level)) {
 353         log_err(info->ctx,
 354                 "Level specifications in a key type must be integer; "
 355                 "Ignoring malformed level specification\n");
 356         return false;
 357     }
 358
 359     entry.preserve.mods = 0;
 360
 361     return AddMapEntry(info, type, &entry, true, true);
 362 }
 363
 364 /***====================================================================***/
 365
 366 static bool
 367 AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type,
 368             xkb_mod_mask_t mods, xkb_mod_mask_t preserve_mods)
 369 {
 370     struct xkb_key_type_entry *entry;
 371     struct xkb_key_type_entry new;
 372
 373     darray_foreach(entry, type->entries) {
 374         if (entry->mods.mods != mods)
 375             continue;
 376
 377         /* Map exists without previous preserve (or "None"); override. */
 378         if (entry->preserve.mods == 0) {
 379             entry->preserve.mods = preserve_mods;
 380             return true;
 381         }
 382
 383         /* Map exists with same preserve; do nothing. */
 384         if (entry->preserve.mods == preserve_mods) {
 385             log_vrb(info->ctx, 10,
 386                     "Identical definitions for preserve[%s] in %s; "
 387                     "Ignored\n",
 388                     ModMaskText(info->ctx, &info->keymap->mods, mods),
 389                     TypeTxt(info, type));
 390             return true;
 391         }
 392
 393         /* Map exists with different preserve; latter wins. */
 394         log_vrb(info->ctx, 1,
 395                 "Multiple definitions for preserve[%s] in %s; "
 396                 "Using %s, ignoring %s\n",
 397                 ModMaskText(info->ctx, &info->keymap->mods, mods),
 398                 TypeTxt(info, type),
 399                 ModMaskText(info->ctx, &info->keymap->mods, preserve_mods),
 400                 ModMaskText(info->ctx, &info->keymap->mods, entry->preserve.mods));
 401
 402         entry->preserve.mods = preserve_mods;
 403         return true;
 404     }
 405
 406     /*
 407      * Map does not exist, i.e. preserve[] came before map[].
 408      * Create a map with the specified mask mapping to Level1. The level
 409      * may be overridden later with an explicit map[] statement.
 410      */
 411     new.level = 0;
 412     new.mods.mods = mods;
 413     new.preserve.mods = preserve_mods;
 414     darray_append(type->entries, new);
 415     return true;
 416 }
 417
 418 static bool
 419 SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
 420             ExprDef *value)
 421 {
 422     xkb_mod_mask_t mods, preserve_mods;
 423
 424     if (arrayNdx == NULL)
 425         return ReportTypeShouldBeArray(info, type, "preserve entry");
 426
 427     if (!ExprResolveModMask(info->ctx, arrayNdx, MOD_BOTH, &info->keymap->mods,
 428                             &mods))
 429         return ReportTypeBadType(info, type, "preserve entry",
 430                                  "modifier mask");
 431
 432     if (mods & ~type->mods) {
 433         const char *before, *after;
 434
 435         before = ModMaskText(info->ctx, &info->keymap->mods, mods);
 436         mods &= type->mods;
 437         after = ModMaskText(info->ctx, &info->keymap->mods, mods);
 438
 439         log_vrb(info->ctx, 1,
 440                 "Preserve for modifiers not used by the %s type; "
 441                 "Index %s converted to %s\n",
 442                 TypeTxt(info, type), before, after);
 443     }
 444
 445     if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->keymap->mods,
 446                             &preserve_mods)) {
 447         log_err(info->ctx,
 448                 "Preserve value in a key type is not a modifier mask; "
 449                 "Ignoring preserve[%s] in type %s\n",
 450                 ModMaskText(info->ctx, &info->keymap->mods, mods),
 451                 TypeTxt(info, type));
 452         return false;
 453     }
 454
 455     if (preserve_mods & ~mods) {
 456         const char *before, *after;
 457
 458         before = ModMaskText(info->ctx, &info->keymap->mods, preserve_mods);
 459         preserve_mods &= mods;
 460         after = ModMaskText(info->ctx, &info->keymap->mods, preserve_mods);
 461
 462         log_vrb(info->ctx, 1,
 463                 "Illegal value for preserve[%s] in type %s; "
 464                 "Converted %s to %s\n",
 465                 ModMaskText(info->ctx, &info->keymap->mods, mods),
 466                 TypeTxt(info, type), before, after);
 467     }
 468
 469     return AddPreserve(info, type, mods, preserve_mods);
 470 }
 471
 472 /***====================================================================***/
 473
 474 static bool
 475 AddLevelName(KeyTypesInfo *info, KeyTypeInfo *type,
 476              xkb_level_index_t level, xkb_atom_t name, bool clobber)
 477 {
 478     /* New name. */
 479     if (level >= darray_size(type->level_names)) {
 480         darray_resize0(type->level_names, level + 1);
 481         goto finish;
 482     }
 483
 484     /* Same level, same name. */
 485     if (darray_item(type->level_names, level) == name) {
 486         log_vrb(info->ctx, 10,
 487                 "Duplicate names for level %d of key type %s; Ignored\n",
 488                 level + 1, TypeTxt(info, type));
 489         return true;
 490     }
 491
 492     /* Same level, different name. */
 493     if (darray_item(type->level_names, level) != XKB_ATOM_NONE) {
 494         const char *old, *new;
 495         old = xkb_atom_text(info->ctx,
 496                             darray_item(type->level_names, level));
 497         new = xkb_atom_text(info->ctx, name);
 498         log_vrb(info->ctx, 1,
 499                 "Multiple names for level %d of key type %s; "
 500                 "Using %s, ignoring %s\n",
 501                 level + 1, TypeTxt(info, type),
 502                 (clobber ? new : old), (clobber ? old : new));
 503
 504         if (!clobber)
 505             return true;
 506     }
 507
 508     /* XXX: What about different level, same name? */
 509
 510 finish:
 511     darray_item(type->level_names, level) = name;
 512     return true;
 513 }
 514
 515 static bool
 516 SetLevelName(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
 517              ExprDef *value)
 518 {
 519     xkb_level_index_t level;
 520     xkb_atom_t level_name;
 521
 522     if (arrayNdx == NULL)
 523         return ReportTypeShouldBeArray(info, type, "level name");
 524
 525     if (!ExprResolveLevel(info->ctx, arrayNdx, &level))
 526         return ReportTypeBadType(info, type, "level name", "integer");
 527
 528     if (!ExprResolveString(info->ctx, value, &level_name)) {
 529         log_err(info->ctx,
 530                 "Non-string name for level %d in key type %s; "
 531                 "Ignoring illegal level name definition\n",
 532                 level + 1, xkb_atom_text(info->ctx, type->name));
 533         return false;
 534     }
 535
 536     return AddLevelName(info, type, level, level_name, true);
 537 }
 538
 539 /***====================================================================***/
 540
 541 static bool
 542 SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type,
 543                 const char *field, ExprDef *arrayNdx, ExprDef *value)
 544 {
 545     bool ok = false;
 546     enum type_field type_field = 0;
 547
 548     if (istreq(field, "modifiers")) {
 549         type_field = TYPE_FIELD_MASK;
 550         ok = SetModifiers(info, type, arrayNdx, value);
 551     }
 552     else if (istreq(field, "map")) {
 553         type_field = TYPE_FIELD_MAP;
 554         ok = SetMapEntry(info, type, arrayNdx, value);
 555     }
 556     else if (istreq(field, "preserve")) {
 557         type_field = TYPE_FIELD_PRESERVE;
 558         ok = SetPreserve(info, type, arrayNdx, value);
 559     }
 560     else if (istreq(field, "levelname") || istreq(field, "level_name")) {
 561         type_field = TYPE_FIELD_LEVEL_NAME;
 562         ok = SetLevelName(info, type, arrayNdx, value);
 563     } else {
 564         log_err(info->ctx,
 565                 "Unknown field %s in key type %s; Definition ignored\n",
 566                 field, TypeTxt(info, type));
 567     }
 568
 569     type->defined |= type_field;
 570     return ok;
 571 }
 572
 573 static bool
 574 HandleKeyTypeBody(KeyTypesInfo *info, VarDef *def, KeyTypeInfo *type)
 575 {
 576     bool ok = true;
 577     const char *elem, *field;
 578     ExprDef *arrayNdx;
 579
 580     for (; def; def = (VarDef *) def->common.next) {
 581         ok = ExprResolveLhs(info->ctx, def->name, &elem, &field,
 582                             &arrayNdx);
 583         if (!ok)
 584             continue;
 585
 586         if (elem && istreq(elem, "type")) {
 587             log_err(info->ctx,
 588                     "Support for changing the default type has been removed; "
 589                     "Statement ignored\n");
 590             continue;
 591         }
 592
 593         ok = SetKeyTypeField(info, type, field, arrayNdx, def->value);
 594     }
 595
 596     return ok;
 597 }
 598
 599 static bool
 600 HandleKeyTypeDef(KeyTypesInfo *info, KeyTypeDef *def, enum merge_mode merge)
 601 {
 602     KeyTypeInfo type = {
 603         .defined = 0,
 604         .merge = (def->merge == MERGE_DEFAULT ? merge : def->merge),
 605         .name = def->name,
 606         .mods = 0,
 607         .num_levels = 1,
 608         .entries = darray_new(),
 609         .level_names = darray_new(),
 610     };
 611
 612     if (!HandleKeyTypeBody(info, def->body, &type)) {
 613         info->errorCount++;
 614         return false;
 615     }
 616
 617     if (!AddKeyType(info, &type, true)) {
 618         info->errorCount++;
 619         return false;
 620     }
 621
 622     return true;
 623 }
 624
 625 static void
 626 HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
 627 {
 628     bool ok;
 629
 630     free(info->name);
 631     info->name = strdup_safe(file->name);
 632
 633     for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
 634         switch (stmt->type) {
 635         case STMT_INCLUDE:
 636             ok = HandleIncludeKeyTypes(info, (IncludeStmt *) stmt);
 637             break;
 638         case STMT_TYPE:
 639             ok = HandleKeyTypeDef(info, (KeyTypeDef *) stmt, merge);
 640             break;
 641         case STMT_VAR:
 642             log_err(info->ctx,
 643                     "Support for changing the default type has been removed; "
 644                     "Statement ignored\n");
 645             ok = true;
 646             break;
 647         case STMT_VMOD:
 648             ok = HandleVModDef(info->ctx, &info->keymap->mods,
 649                                (VModDef *) stmt, merge);
 650             break;
 651         default:
 652             log_err(info->ctx,
 653                     "Key type files may not include other declarations; "
 654                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
 655             ok = false;
 656             break;
 657         }
 658
 659         if (!ok)
 660             info->errorCount++;
 661
 662         if (info->errorCount > 10) {
 663             log_err(info->ctx,
 664                     "Abandoning keytypes file \"%s\"\n", file->topName);
 665             break;
 666         }
 667     }
 668 }
 669
 670 /***====================================================================***/
 671
 672 static bool
 673 CopyKeyTypesToKeymap(struct xkb_keymap *keymap, KeyTypesInfo *info)
 674 {
 675     keymap->types_section_name = strdup_safe(info->name);
 676     XkbEscapeMapName(keymap->types_section_name);
 677
 678     keymap->num_types = darray_size(info->types);
 679     if (keymap->num_types == 0)
 680         keymap->num_types = 1;
 681
 682     keymap->types = calloc(keymap->num_types, sizeof(*keymap->types));
 683
 684     /*
 685      * If no types were specified, a default unnamed one-level type is
 686      * used for all keys.
 687      */
 688     if (darray_empty(info->types)) {
 689         struct xkb_key_type *type = &keymap->types[0];
 690
 691         type->mods.mods = 0;
 692         type->num_levels = 1;
 693         type->entries = NULL;
 694         type->num_entries = 0;
 695         type->name = xkb_atom_intern_literal(keymap->ctx, "default");
 696         type->level_names = NULL;
 697
 698         return true;
 699     }
 700
 701     for (unsigned i = 0; i < keymap->num_types; i++) {
 702         KeyTypeInfo *def = &darray_item(info->types, i);
 703         struct xkb_key_type *type = &keymap->types[i];
 704
 705         type->mods.mods = def->mods;
 706         type->num_levels = def->num_levels;
 707         type->entries = darray_mem(def->entries, 0);
 708         type->num_entries = darray_size(def->entries);
 709         darray_init(def->entries);
 710         type->name = def->name;
 711         type->level_names = darray_mem(def->level_names, 0);
 712         darray_init(def->level_names);
 713     }
 714
 715     return true;
 716 }
 717
 718 /***====================================================================***/
 719
 720 bool
 721 CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap,
 722                 enum merge_mode merge)
 723 {
 724     KeyTypesInfo info;
 725
 726     InitKeyTypesInfo(&info, keymap);
 727
 728     HandleKeyTypesFile(&info, file, merge);
 729     if (info.errorCount != 0)
 730         goto err_info;
 731
 732     if (!CopyKeyTypesToKeymap(keymap, &info))
 733         goto err_info;
 734
 735     ClearKeyTypesInfo(&info);
 736     return true;
 737
 738 err_info:
 739     ClearKeyTypesInfo(&info);
 740     return false;
 741 }