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