1 files changed, 100 insertions, 92 deletions

diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/types.c b/src/3rdparty/xkbcommon/src/xkbcomp/types.c
index 7708da3882..e85b67e893 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/types.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/types.c
@@ -31,9 +31,9 @@
 #include "include.h"
 
 enum type_field {
-    TYPE_FIELD_MASK       = (1 << 0),
-    TYPE_FIELD_MAP        = (1 << 1),
-    TYPE_FIELD_PRESERVE   = (1 << 2),
+    TYPE_FIELD_MASK = (1 << 0),
+    TYPE_FIELD_MAP = (1 << 1),
+    TYPE_FIELD_PRESERVE = (1 << 2),
     TYPE_FIELD_LEVEL_NAME = (1 << 3),
 };
 
@@ -53,7 +53,9 @@ typedef struct {
     int errorCount;
 
     darray(KeyTypeInfo) types;
-    struct xkb_keymap *keymap;
+    struct xkb_mod_set mods;
+
+    struct xkb_context *ctx;
 } KeyTypesInfo;
 
 /***====================================================================***/
@@ -61,26 +63,26 @@ typedef struct {
 static inline const char *
 MapEntryTxt(KeyTypesInfo *info, struct xkb_key_type_entry *entry)
 {
-    return ModMaskText(info->keymap, entry->mods.mods);
+    return ModMaskText(info->ctx, &info->mods, entry->mods.mods);
 }
 
 static inline const char *
 TypeTxt(KeyTypesInfo *info, KeyTypeInfo *type)
 {
-    return xkb_atom_text(info->keymap->ctx, type->name);
+    return xkb_atom_text(info->ctx, type->name);
 }
 
 static inline const char *
 TypeMaskTxt(KeyTypesInfo *info, KeyTypeInfo *type)
 {
-    return ModMaskText(info->keymap, type->mods);
+    return ModMaskText(info->ctx, &info->mods, type->mods);
 }
 
 static inline bool
 ReportTypeShouldBeArray(KeyTypesInfo *info, KeyTypeInfo *type,
                         const char *field)
 {
-    return ReportShouldBeArray(info->keymap->ctx, "key type", field,
+    return ReportShouldBeArray(info->ctx, "key type", field,
                                TypeTxt(info, type));
 }
 
@@ -88,17 +90,19 @@ static inline bool
 ReportTypeBadType(KeyTypesInfo *info, KeyTypeInfo *type,
                   const char *field, const char *wanted)
 {
-    return ReportBadType(info->keymap->ctx, "key type", field,
+    return ReportBadType(info->ctx, "key type", field,
                          TypeTxt(info, type), wanted);
 }
 
 /***====================================================================***/
 
 static void
-InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_keymap *keymap)
+InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_context *ctx,
+                 const struct xkb_mod_set *mods)
 {
     memset(info, 0, sizeof(*info));
-    info->keymap = keymap;
+    info->ctx = ctx;
+    info->mods = *mods;
 }
 
 static void
@@ -131,16 +135,16 @@ static bool
 AddKeyType(KeyTypesInfo *info, KeyTypeInfo *new, bool same_file)
 {
     KeyTypeInfo *old;
-    const int verbosity = xkb_context_get_log_verbosity(info->keymap->ctx);
+    const int verbosity = xkb_context_get_log_verbosity(info->ctx);
 
     old = FindMatchingKeyType(info, new->name);
     if (old) {
         if (new->merge == MERGE_REPLACE || new->merge == MERGE_OVERRIDE) {
             if ((same_file && verbosity > 0) || verbosity > 9) {
-                log_warn(info->keymap->ctx,
+                log_warn(info->ctx,
                          "Multiple definitions of the %s key type; "
                          "Earlier definition ignored\n",
-                         xkb_atom_text(info->keymap->ctx, new->name));
+                         xkb_atom_text(info->ctx, new->name));
             }
 
             ClearKeyTypeInfo(old);
@@ -151,10 +155,10 @@ AddKeyType(KeyTypesInfo *info, KeyTypeInfo *new, bool same_file)
         }
 
         if (same_file)
-            log_vrb(info->keymap->ctx, 4,
+            log_vrb(info->ctx, 4,
                     "Multiple definitions of the %s key type; "
                     "Later definition ignored\n",
-                    xkb_atom_text(info->keymap->ctx, new->name));
+                    xkb_atom_text(info->ctx, new->name));
 
         ClearKeyTypeInfo(new);
         return true;
@@ -170,13 +174,13 @@ static void
 MergeIncludedKeyTypes(KeyTypesInfo *into, KeyTypesInfo *from,
                       enum merge_mode merge)
 {
-    KeyTypeInfo *type;
-
     if (from->errorCount > 0) {
         into->errorCount += from->errorCount;
         return;
     }
 
+    into->mods = from->mods;
+
     if (into->name == NULL) {
         into->name = from->name;
         from->name = NULL;
@@ -187,6 +191,7 @@ MergeIncludedKeyTypes(KeyTypesInfo *into, KeyTypesInfo *from,
         darray_init(from->types);
     }
     else {
+        KeyTypeInfo *type;
         darray_foreach(type, from->types) {
             type->merge = (merge == MERGE_DEFAULT ? type->merge : merge);
             if (!AddKeyType(into, type, false))
@@ -203,7 +208,7 @@ HandleIncludeKeyTypes(KeyTypesInfo *info, IncludeStmt *include)
 {
     KeyTypesInfo included;
 
-    InitKeyTypesInfo(&included, info->keymap);
+    InitKeyTypesInfo(&included, info->ctx, &info->mods);
     included.name = include->stmt;
     include->stmt = NULL;
 
@@ -211,14 +216,14 @@ HandleIncludeKeyTypes(KeyTypesInfo *info, IncludeStmt *include)
         KeyTypesInfo next_incl;
         XkbFile *file;
 
-        file = ProcessIncludeFile(info->keymap->ctx, stmt, FILE_TYPE_TYPES);
+        file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_TYPES);
         if (!file) {
             info->errorCount += 10;
             ClearKeyTypesInfo(&included);
             return false;
         }
 
-        InitKeyTypesInfo(&next_incl, info->keymap);
+        InitKeyTypesInfo(&next_incl, info->ctx, &included.mods);
 
         HandleKeyTypesFile(&next_incl, file, stmt->merge);
 
@@ -243,24 +248,24 @@ SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
     xkb_mod_mask_t mods;
 
     if (arrayNdx)
-        log_warn(info->keymap->ctx,
+        log_warn(info->ctx,
                  "The modifiers field of a key type is not an array; "
                  "Illegal array subscript ignored\n");
 
-    if (!ExprResolveModMask(info->keymap, value, MOD_BOTH, &mods)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, &mods)) {
+        log_err(info->ctx,
                 "Key type mask field must be a modifier mask; "
                 "Key type definition ignored\n");
         return false;
     }
 
     if (type->defined & TYPE_FIELD_MASK) {
-        log_warn(info->keymap->ctx,
+        log_warn(info->ctx,
                  "Multiple modifier mask definitions for key type %s; "
                  "Using %s, ignoring %s\n",
-                 xkb_atom_text(info->keymap->ctx, type->name),
+                 xkb_atom_text(info->ctx, type->name),
                  TypeMaskTxt(info, type),
-                 ModMaskText(info->keymap, mods));
+                 ModMaskText(info->ctx, &info->mods, mods));
         return false;
     }
 
@@ -291,7 +296,7 @@ AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type,
     old = FindMatchingMapEntry(type, new->mods.mods);
     if (old) {
         if (report && old->level != new->level) {
-            log_warn(info->keymap->ctx,
+            log_warn(info->ctx,
                      "Multiple map entries for %s in %s; "
                      "Using %d, ignoring %d\n",
                      MapEntryTxt(info, new), TypeTxt(info, type),
@@ -299,7 +304,7 @@ AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type,
                      (clobber ? old->level : new->level) + 1);
         }
         else {
-            log_vrb(info->keymap->ctx, 10,
+            log_vrb(info->ctx, 10,
                     "Multiple occurrences of map[%s]= %d in %s; Ignored\n",
                     MapEntryTxt(info, new), new->level + 1,
                     TypeTxt(info, type));
@@ -331,21 +336,23 @@ SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
     if (arrayNdx == NULL)
         return ReportTypeShouldBeArray(info, type, "map entry");
 
-    if (!ExprResolveModMask(info->keymap, arrayNdx, MOD_BOTH, &entry.mods.mods))
+    if (!ExprResolveModMask(info->ctx, arrayNdx, MOD_BOTH, &info->mods,
+                            &entry.mods.mods))
         return ReportTypeBadType(info, type, "map entry", "modifier mask");
 
     if (entry.mods.mods & (~type->mods)) {
-        log_vrb(info->keymap->ctx, 1,
+        log_vrb(info->ctx, 1,
                 "Map entry for unused modifiers in %s; "
                 "Using %s instead of %s\n",
                 TypeTxt(info, type),
-                ModMaskText(info->keymap, entry.mods.mods & type->mods),
+                ModMaskText(info->ctx, &info->mods,
+                            entry.mods.mods & type->mods),
                 MapEntryTxt(info, &entry));
         entry.mods.mods &= type->mods;
     }
 
-    if (!ExprResolveLevel(info->keymap->ctx, value, &entry.level)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveLevel(info->ctx, value, &entry.level)) {
+        log_err(info->ctx,
                 "Level specifications in a key type must be integer; "
                 "Ignoring malformed level specification\n");
         return false;
@@ -377,22 +384,22 @@ AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type,
 
         /* Map exists with same preserve; do nothing. */
         if (entry->preserve.mods == preserve_mods) {
-            log_vrb(info->keymap->ctx, 10,
+            log_vrb(info->ctx, 10,
                     "Identical definitions for preserve[%s] in %s; "
                     "Ignored\n",
-                    ModMaskText(info->keymap, mods),
+                    ModMaskText(info->ctx, &info->mods, mods),
                     TypeTxt(info, type));
             return true;
         }
 
         /* Map exists with different preserve; latter wins. */
-        log_vrb(info->keymap->ctx, 1,
+        log_vrb(info->ctx, 1,
                 "Multiple definitions for preserve[%s] in %s; "
                 "Using %s, ignoring %s\n",
-                ModMaskText(info->keymap, mods),
+                ModMaskText(info->ctx, &info->mods, mods),
                 TypeTxt(info, type),
-                ModMaskText(info->keymap, preserve_mods),
-                ModMaskText(info->keymap, entry->preserve.mods));
+                ModMaskText(info->ctx, &info->mods, preserve_mods),
+                ModMaskText(info->ctx, &info->mods, entry->preserve.mods));
 
         entry->preserve.mods = preserve_mods;
         return true;
@@ -419,28 +426,29 @@ SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
     if (arrayNdx == NULL)
         return ReportTypeShouldBeArray(info, type, "preserve entry");
 
-    if (!ExprResolveModMask(info->keymap, arrayNdx, MOD_BOTH, &mods))
+    if (!ExprResolveModMask(info->ctx, arrayNdx, MOD_BOTH, &info->mods, &mods))
         return ReportTypeBadType(info, type, "preserve entry",
                                  "modifier mask");
 
     if (mods & ~type->mods) {
         const char *before, *after;
 
-        before = ModMaskText(info->keymap, mods);
+        before = ModMaskText(info->ctx, &info->mods, mods);
         mods &= type->mods;
-        after = ModMaskText(info->keymap, mods);
+        after = ModMaskText(info->ctx, &info->mods, mods);
 
-        log_vrb(info->keymap->ctx, 1,
+        log_vrb(info->ctx, 1,
                 "Preserve for modifiers not used by the %s type; "
                 "Index %s converted to %s\n",
                 TypeTxt(info, type), before, after);
     }
 
-    if (!ExprResolveModMask(info->keymap, value, MOD_BOTH, &preserve_mods)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods,
+                            &preserve_mods)) {
+        log_err(info->ctx,
                 "Preserve value in a key type is not a modifier mask; "
                 "Ignoring preserve[%s] in type %s\n",
-                ModMaskText(info->keymap, mods),
+                ModMaskText(info->ctx, &info->mods, mods),
                 TypeTxt(info, type));
         return false;
     }
@@ -448,14 +456,14 @@ SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
     if (preserve_mods & ~mods) {
         const char *before, *after;
 
-        before = ModMaskText(info->keymap, preserve_mods);
+        before = ModMaskText(info->ctx, &info->mods, preserve_mods);
         preserve_mods &= mods;
-        after = ModMaskText(info->keymap, preserve_mods);
+        after = ModMaskText(info->ctx, &info->mods, preserve_mods);
 
-        log_vrb(info->keymap->ctx, 1,
+        log_vrb(info->ctx, 1,
                 "Illegal value for preserve[%s] in type %s; "
                 "Converted %s to %s\n",
-                ModMaskText(info->keymap, mods),
+                ModMaskText(info->ctx, &info->mods, mods),
                 TypeTxt(info, type), before, after);
     }
 
@@ -476,7 +484,7 @@ AddLevelName(KeyTypesInfo *info, KeyTypeInfo *type,
 
     /* Same level, same name. */
     if (darray_item(type->level_names, level) == name) {
-        log_vrb(info->keymap->ctx, 10,
+        log_vrb(info->ctx, 10,
                 "Duplicate names for level %d of key type %s; Ignored\n",
                 level + 1, TypeTxt(info, type));
         return true;
@@ -485,10 +493,10 @@ AddLevelName(KeyTypesInfo *info, KeyTypeInfo *type,
     /* Same level, different name. */
     if (darray_item(type->level_names, level) != XKB_ATOM_NONE) {
         const char *old, *new;
-        old = xkb_atom_text(info->keymap->ctx,
+        old = xkb_atom_text(info->ctx,
                             darray_item(type->level_names, level));
-        new = xkb_atom_text(info->keymap->ctx, name);
-        log_vrb(info->keymap->ctx, 1,
+        new = xkb_atom_text(info->ctx, name);
+        log_vrb(info->ctx, 1,
                 "Multiple names for level %d of key type %s; "
                 "Using %s, ignoring %s\n",
                 level + 1, TypeTxt(info, type),
@@ -511,19 +519,18 @@ SetLevelName(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
 {
     xkb_level_index_t level;
     xkb_atom_t level_name;
-    struct xkb_context *ctx = info->keymap->ctx;
 
     if (arrayNdx == NULL)
         return ReportTypeShouldBeArray(info, type, "level name");
 
-    if (!ExprResolveLevel(ctx, arrayNdx, &level))
+    if (!ExprResolveLevel(info->ctx, arrayNdx, &level))
         return ReportTypeBadType(info, type, "level name", "integer");
 
-    if (!ExprResolveString(ctx, value, &level_name)) {
-        log_err(info->keymap->ctx,
+    if (!ExprResolveString(info->ctx, value, &level_name)) {
+        log_err(info->ctx,
                 "Non-string name for level %d in key type %s; "
                 "Ignoring illegal level name definition\n",
-                level + 1, xkb_atom_text(ctx, type->name));
+                level + 1, xkb_atom_text(info->ctx, type->name));
         return false;
     }
 
@@ -555,7 +562,7 @@ SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type,
         type_field = TYPE_FIELD_LEVEL_NAME;
         ok = SetLevelName(info, type, arrayNdx, value);
     } else {
-        log_err(info->keymap->ctx,
+        log_err(info->ctx,
                 "Unknown field %s in key type %s; Definition ignored\n",
                 field, TypeTxt(info, type));
     }
@@ -572,13 +579,13 @@ HandleKeyTypeBody(KeyTypesInfo *info, VarDef *def, KeyTypeInfo *type)
     ExprDef *arrayNdx;
 
     for (; def; def = (VarDef *) def->common.next) {
-        ok = ExprResolveLhs(info->keymap->ctx, def->name, &elem, &field,
+        ok = ExprResolveLhs(info->ctx, def->name, &elem, &field,
                             &arrayNdx);
         if (!ok)
             continue;
 
         if (elem && istreq(elem, "type")) {
-            log_err(info->keymap->ctx,
+            log_err(info->ctx,
                     "Support for changing the default type has been removed; "
                     "Statement ignored\n");
             continue;
@@ -633,16 +640,16 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
             ok = HandleKeyTypeDef(info, (KeyTypeDef *) stmt, merge);
             break;
         case STMT_VAR:
-            log_err(info->keymap->ctx,
+            log_err(info->ctx,
                     "Support for changing the default type has been removed; "
                     "Statement ignored\n");
             ok = true;
             break;
         case STMT_VMOD:
-            ok = HandleVModDef(info->keymap, (VModDef *) stmt, merge);
+            ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge);
             break;
         default:
-            log_err(info->keymap->ctx,
+            log_err(info->ctx,
                     "Key type files may not include other declarations; "
                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
             ok = false;
@@ -653,8 +660,8 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
             info->errorCount++;
 
         if (info->errorCount > 10) {
-            log_err(info->keymap->ctx,
-                    "Abandoning keytypes file \"%s\"\n", file->topName);
+            log_err(info->ctx,
+                    "Abandoning keytypes file \"%s\"\n", file->name);
             break;
         }
     }
@@ -665,21 +672,20 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
 static bool
 CopyKeyTypesToKeymap(struct xkb_keymap *keymap, KeyTypesInfo *info)
 {
-    keymap->types_section_name = strdup_safe(info->name);
-    XkbEscapeMapName(keymap->types_section_name);
-
-    keymap->num_types = darray_size(info->types);
-    if (keymap->num_types == 0)
-        keymap->num_types = 1;
+    unsigned num_types;
+    struct xkb_key_type *types;
 
-    keymap->types = calloc(keymap->num_types, sizeof(*keymap->types));
+    num_types = darray_empty(info->types) ? 1 : darray_size(info->types);
+    types = calloc(num_types, sizeof(*types));
+    if (!types)
+        return false;
 
     /*
      * If no types were specified, a default unnamed one-level type is
      * used for all keys.
      */
     if (darray_empty(info->types)) {
-        struct xkb_key_type *type = &keymap->types[0];
+        struct xkb_key_type *type = &types[0];
 
         type->mods.mods = 0;
         type->num_levels = 1;
@@ -687,24 +693,26 @@ CopyKeyTypesToKeymap(struct xkb_keymap *keymap, KeyTypesInfo *info)
         type->num_entries = 0;
         type->name = xkb_atom_intern_literal(keymap->ctx, "default");
         type->level_names = NULL;
-
-        return true;
+        type->num_level_names = 0;
     }
-
-    for (unsigned i = 0; i < keymap->num_types; i++) {
-        KeyTypeInfo *def = &darray_item(info->types, i);
-        struct xkb_key_type *type = &keymap->types[i];
-
-        type->mods.mods = def->mods;
-        type->num_levels = def->num_levels;
-        type->entries = darray_mem(def->entries, 0);
-        type->num_entries = darray_size(def->entries);
-        darray_init(def->entries);
-        type->name = def->name;
-        type->level_names = darray_mem(def->level_names, 0);
-        darray_init(def->level_names);
+    else {
+        for (unsigned i = 0; i < num_types; i++) {
+            KeyTypeInfo *def = &darray_item(info->types, i);
+            struct xkb_key_type *type = &types[i];
+
+            type->name = def->name;
+            type->mods.mods = def->mods;
+            type->num_levels = def->num_levels;
+            darray_steal(def->level_names, &type->level_names, &type->num_level_names);
+            darray_steal(def->entries, &type->entries, &type->num_entries);
+        }
     }
 
+    keymap->types_section_name = strdup_safe(info->name);
+    XkbEscapeMapName(keymap->types_section_name);
+    keymap->num_types = num_types;
+    keymap->types = types;
+    keymap->mods = info->mods;
     return true;
 }
 
@@ -716,7 +724,7 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap,
 {
     KeyTypesInfo info;
 
-    InitKeyTypesInfo(&info, keymap);
+    InitKeyTypesInfo(&info, keymap->ctx, &keymap->mods);
 
     HandleKeyTypesFile(&info, file, merge);
     if (info.errorCount != 0)