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