kc3-lang/libxkbcommon

diff --git a/src/alloc.c b/src/alloc.c
index 1e4b4d3..d29c740 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -27,38 +27,6 @@
 #include "alloc.h"
 
 int
-XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
-                   size_t nTotalTypes)
-{
-    if (!keymap || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
-        return BadValue;
-
-    if (!keymap->map) {
-        keymap->map = calloc(1, sizeof(*keymap->map));
-        if (!keymap->map)
-            return BadAlloc;
-        darray_init(keymap->map->types);
-    }
-
-    if (which & XkbKeyTypesMask)
-        darray_growalloc(keymap->map->types, nTotalTypes);
-
-    if (which & XkbKeySymsMask)
-        darray_resize0(keymap->map->key_sym_map, keymap->max_key_code + 1);
-
-    if (which & XkbModifierMapMask) {
-        if (!keymap->map->modmap) {
-            keymap->map->modmap = uTypedCalloc(keymap->max_key_code + 1,
-                                               unsigned char);
-            if (!keymap->map->modmap)
-                return BadAlloc;
-        }
-    }
-
-    return Success;
-}
-
-int
 XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which,
                    unsigned nNewActions)
 {
@@ -158,7 +126,7 @@ bool
 XkbcResizeKeySyms(struct xkb_keymap *keymap, xkb_keycode_t key,
                   unsigned int needed)
 {
-    darray_resize0(darray_item(keymap->map->key_sym_map, key).syms, needed);
+    darray_resize0(darray_item(keymap->key_sym_map, key).syms, needed);
     return true;
 }
 
@@ -203,19 +171,12 @@ XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t key,
     return XkbKeyActionsPtr(keymap, key);
 }
 
-void
-XkbcFreeClientMap(struct xkb_keymap *keymap)
+static void
+free_types(struct xkb_keymap *keymap)
 {
-    struct xkb_client_map * map;
-    struct xkb_key_type * type;
-    struct xkb_sym_map *sym_map;
-
-    if (!keymap || !keymap->map)
-        return;
-
-    map = keymap->map;
+    struct xkb_key_type *type;
 
-    darray_foreach(type, map->types) {
+    darray_foreach(type, keymap->types) {
         int j;
         darray_free(type->map);
         free(type->preserve);
@@ -224,18 +185,20 @@ XkbcFreeClientMap(struct xkb_keymap *keymap)
         free(type->level_names);
         free(type->name);
     }
-    darray_free(map->types);
+    darray_free(keymap->types);
+}
+
+static void
+free_sym_maps(struct xkb_keymap *keymap)
+{
+    struct xkb_sym_map *sym_map;
 
-    darray_foreach(sym_map, map->key_sym_map) {
+    darray_foreach(sym_map, keymap->key_sym_map) {
         free(sym_map->sym_index);
         free(sym_map->num_syms);
         darray_free(sym_map->syms);
     }
-    darray_free(map->key_sym_map);
-
-    free(map->modmap);
-    free(keymap->map);
-    keymap->map = NULL;
+    darray_free(keymap->key_sym_map);
 }
 
 void
@@ -306,10 +269,10 @@ XkbcAllocNames(struct xkb_keymap *keymap, unsigned which,
         darray_init(keymap->names->key_aliases);
     }
 
-    if ((which & XkbKTLevelNamesMask) && keymap->map) {
+    if ((which & XkbKTLevelNamesMask) && keymap) {
         struct xkb_key_type * type;
 
-        darray_foreach(type, keymap->map->types) {
+        darray_foreach(type, keymap->types) {
             if (!type->level_names) {
                 type->level_names = calloc(type->num_levels,
                                            sizeof(*type->level_names));
@@ -332,7 +295,6 @@ static void
 XkbcFreeNames(struct xkb_keymap *keymap)
 {
     struct xkb_names * names;
-    struct xkb_client_map * map;
     struct xkb_key_type *type;
     int i;
 
@@ -340,16 +302,13 @@ XkbcFreeNames(struct xkb_keymap *keymap)
         return;
 
     names = keymap->names;
-    map = keymap->map;
-
-    if (map) {
-        darray_foreach(type, map->types) {
-            int j;
-            for (j = 0; j < type->num_levels; j++)
-                free(type->level_names[j]);
-            free(type->level_names);
-            type->level_names = NULL;
-        }
+
+    darray_foreach(type, keymap->types) {
+        int j;
+        for (j = 0; j < type->num_levels; j++)
+            free(type->level_names[j]);
+        free(type->level_names);
+        type->level_names = NULL;
     }
 
     free(names->keycodes);
@@ -445,7 +404,9 @@ XkbcFreeKeyboard(struct xkb_keymap *keymap)
     if (!keymap)
         return;
 
-    XkbcFreeClientMap(keymap);
+    free_types(keymap);
+    free_sym_maps(keymap);
+    free(keymap->modmap);
     XkbcFreeServerMap(keymap);
     XkbcFreeCompatMap(keymap);
     XkbcFreeIndicatorMaps(keymap);
diff --git a/src/alloc.h b/src/alloc.h
index ed5983e..bea53cf 100644
--- a/src/alloc.h
+++ b/src/alloc.h
@@ -49,10 +49,6 @@ extern void
 XkbcFreeKeyboard(struct xkb_keymap *keymap);
 
 extern int
-XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
-                   size_t nTotalTypes);
-
-extern int
 XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which,
                    unsigned nNewActions);
 
@@ -68,9 +64,6 @@ XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t key,
                      uint32_t needed);
 
 extern void
-XkbcFreeClientMap(struct xkb_keymap *keymap);
-
-extern void
 XkbcFreeServerMap(struct xkb_keymap *keymap);
 
 #endif /* ALLOC_H */
diff --git a/src/keymap-dump.c b/src/keymap-dump.c
index e04a996..6870ca7 100644
--- a/src/keymap-dump.c
+++ b/src/keymap-dump.c
@@ -364,7 +364,7 @@ write_types(struct xkb_keymap *keymap, char **buf, size_t *size,
 
     write_vmods(keymap, buf, size, offset);
 
-    darray_foreach(type, keymap->map->types) {
+    darray_foreach(type, keymap->types) {
         write_buf(keymap, buf, size, offset, "\t\ttype \"%s\" {\n",
                   type->name);
         write_buf(keymap, buf, size, offset, "\t\t\tmodifiers= %s;\n",
@@ -779,7 +779,6 @@ static bool
 write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
               size_t *offset)
 {
-    struct xkb_client_map *map = keymap->map;
     struct xkb_server_map *srv = keymap->server;
     xkb_keycode_t key;
     int group, tmp;
@@ -834,13 +833,13 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
                         write_buf(keymap, buf, size, offset,
                                   "\n\t\t\ttype[group%d]= \"%s\",",
                                   group + 1,
-                                  darray_item(map->types, type).name);
+                                  darray_item(keymap->types, type).name);
                     }
                 }
                 else {
                     write_buf(keymap, buf, size, offset,
                               "\n\t\t\ttype= \"%s\",",
-                              darray_item(map->types, type).name);
+                              darray_item(keymap->types, type).name);
                 }
             }
             if (keymap->ctrls &&
@@ -922,16 +921,16 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
             write_buf(keymap, buf, size, offset, "\n\t\t};\n");
         }
     }
-    if (map && map->modmap) {
+    if (keymap->modmap) {
         for (key = keymap->min_key_code; key <= keymap->max_key_code;
              key++) {
             int mod;
 
-            if (map->modmap[key] == 0)
+            if (keymap->modmap[key] == 0)
                 continue;
 
             for (mod = 0; mod < XkbNumModifiers; mod++) {
-                if (!(map->modmap[key] & (1 << mod)))
+                if (!(keymap->modmap[key] & (1 << mod)))
                     continue;
 
                 write_buf(keymap, buf, size, offset,
diff --git a/src/xkb-priv.h b/src/xkb-priv.h
index e21b449..bb7410c 100644
--- a/src/xkb-priv.h
+++ b/src/xkb-priv.h
@@ -275,12 +275,6 @@ struct xkb_sym_map {
     darray(xkb_keysym_t) syms;
 };
 
-struct xkb_client_map {
-    darray(struct xkb_key_type) types;
-    darray(struct xkb_sym_map) key_sym_map;
-    unsigned char *modmap;
-};
-
 struct xkb_behavior {
     unsigned char type;
     unsigned char data;
@@ -361,10 +355,13 @@ struct xkb_keymap {
 
     struct xkb_controls *      ctrls;
     struct xkb_server_map *    server;
-    struct xkb_client_map *    map;
     struct xkb_indicator *     indicators;
     struct xkb_names *        names;
     struct xkb_compat_map *    compat;
+
+    darray(struct xkb_key_type) types;
+    darray(struct xkb_sym_map) key_sym_map;
+    unsigned char *modmap;
 };
 
 #define XkbNumGroups(g)             ((g) & 0x0f)
@@ -377,22 +374,22 @@ struct xkb_keymap {
 #define XkbSetNumGroups(g, n)       (((g) & 0xf0) | ((n) & 0x0f))
 
 #define XkbKeyGroupInfo(d, k) \
-    (darray_item((d)->map->key_sym_map, k).group_info)
+    (darray_item((d)->key_sym_map, k).group_info)
 #define XkbKeyNumGroups(d, k) \
-    (XkbNumGroups(darray_item((d)->map->key_sym_map, k).group_info))
+    (XkbNumGroups(darray_item((d)->key_sym_map, k).group_info))
 #define XkbKeyGroupWidth(d, k, g) \
     (XkbKeyType(d, k, g)->num_levels)
 #define XkbKeyGroupsWidth(d, k) \
-    (darray_item((d)->map->key_sym_map, k).width)
+    (darray_item((d)->key_sym_map, k).width)
 #define XkbKeyTypeIndex(d, k, g) \
-    (darray_item((d)->map->key_sym_map, k).kt_index[g & 0x3])
+    (darray_item((d)->key_sym_map, k).kt_index[g & 0x3])
 #define XkbKeyType(d, k, g) \
-    (&darray_item((d)->map->types, XkbKeyTypeIndex(d, k, g)))
+    (&darray_item((d)->types, XkbKeyTypeIndex(d, k, g)))
 #define XkbKeyNumSyms(d, k, g, sl) \
     (darray_item((d)->map->key_sym_map, \
                  k).num_syms[(g * XkbKeyGroupsWidth(d, k)) + sl])
 #define XkbKeySym(d, k, n) \
-    (&darray_item(darray_item((d)->map->key_sym_map, k).syms, n))
+    (&darray_item(darray_item((d)->key_sym_map, k).syms, n))
 #define XkbKeySymOffset(d, k, g, sl) \
     (darray_item((d)->map->key_sym_map, \
                  k).sym_index[(g * XkbKeyGroupsWidth(d, k)) + sl])
diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c
index 88d0ff5..ec743f2 100644
--- a/src/xkbcomp/compat.c
+++ b/src/xkbcomp/compat.c
@@ -853,7 +853,7 @@ FindInterpForKey(struct xkb_keymap *keymap, xkb_keycode_t key,
             continue;
 
         if (level == 0 || !(interp->match & XkbSI_LevelOneOnly))
-            mods = keymap->map->modmap[key];
+            mods = keymap->modmap[key];
         else
             mods = 0;
 
@@ -994,12 +994,12 @@ UpdateModifiersFromCompat(struct xkb_keymap *keymap)
         for (i = 0; i < XkbNumVirtualMods; i++) {
             if (!(keymap->server->vmodmap[key] & (1 << i)))
                 continue;
-            keymap->server->vmods[i] |= keymap->map->modmap[key];
+            keymap->server->vmods[i] |= keymap->modmap[key];
         }
     }
 
     /* Now update the level masks for all the types to reflect the vmods. */
-    darray_foreach(type, keymap->map->types) {
+    darray_foreach(type, keymap->types) {
         uint32_t mask = 0;
         int j;
         type->mods.mask = type->mods.real_mods;
@@ -1021,7 +1021,7 @@ UpdateModifiersFromCompat(struct xkb_keymap *keymap)
         for (i = 0; i < XkbKeyNumActions(keymap, key); i++) {
             if (acts[i].any.type == XkbSA_NoAction)
                 continue;
-            UpdateActionMods(keymap, &acts[i], keymap->map->modmap[key]);
+            UpdateActionMods(keymap, &acts[i], keymap->modmap[key]);
         }
     }
 
diff --git a/src/xkbcomp/keytypes.c b/src/xkbcomp/keytypes.c
index 51ef217..7a0874b 100644
--- a/src/xkbcomp/keytypes.c
+++ b/src/xkbcomp/keytypes.c
@@ -1084,15 +1084,11 @@ static int
 InitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
                       int keypadVMod)
 {
-    struct xkb_client_map *map;
     const struct xkb_key_type *from;
     int rtrn;
 
-    rtrn = XkbcAllocClientMap(keymap, XkbKeyTypesMask, XkbNumRequiredTypes);
-    if (rtrn != Success)
-        return rtrn;
+    darray_growalloc(keymap->types, XkbNumRequiredTypes);
 
-    map = keymap->map;
     if ((which & XkbAllRequiredTypes) == 0)
         return Success;
 
@@ -1101,22 +1097,22 @@ InitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
 
     if (which & XkbOneLevelMask)
         rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex],
-                               &darray_item(map->types, XkbOneLevelIndex));
+                               &darray_item(keymap->types, XkbOneLevelIndex));
 
     if ((which & XkbTwoLevelMask) && rtrn == Success)
         rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex],
-                               &darray_item(map->types, XkbTwoLevelIndex));
+                               &darray_item(keymap->types, XkbTwoLevelIndex));
 
     if ((which & XkbAlphabeticMask) && rtrn == Success)
         rtrn = XkbcCopyKeyType(&from[XkbAlphabeticIndex],
-                               &darray_item(map->types, XkbAlphabeticIndex));
+                               &darray_item(keymap->types, XkbAlphabeticIndex));
 
     if ((which & XkbKeypadMask) && rtrn == Success) {
         struct xkb_key_type *type;
 
         rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex],
-                               &darray_item(map->types, XkbKeypadIndex));
-        type = &darray_item(map->types, XkbKeypadIndex);
+                               &darray_item(keymap->types, XkbKeypadIndex));
+        type = &darray_item(keymap->types, XkbKeypadIndex);
 
         if (keypadVMod >= 0 && keypadVMod < XkbNumVirtualMods &&
             rtrn == Success) {
@@ -1172,12 +1168,7 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap,
     if ((info.stdPresent & XkbAlphabeticMask) == 0)
         i++;
 
-    if (XkbcAllocClientMap(keymap, XkbKeyTypesMask, i) != Success) {
-        WSGO("Couldn't allocate client map\n");
-        goto err_info;
-    }
-
-    darray_resize0(keymap->map->types, i);
+    darray_resize0(keymap->types, i);
 
     if (XkbAllRequiredTypes & (~info.stdPresent)) {
         unsigned missing, keypadVMod;
@@ -1191,29 +1182,29 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap,
         }
 
         if (missing & XkbOneLevelMask)
-            darray_item(keymap->map->types, XkbOneLevelIndex).name =
+            darray_item(keymap->types, XkbOneLevelIndex).name =
                 xkb_atom_strdup(keymap->ctx, tok_ONE_LEVEL);
         if (missing & XkbTwoLevelMask)
-            darray_item(keymap->map->types, XkbTwoLevelIndex).name =
+            darray_item(keymap->types, XkbTwoLevelIndex).name =
                 xkb_atom_strdup(keymap->ctx, tok_TWO_LEVEL);
         if (missing & XkbAlphabeticMask)
-            darray_item(keymap->map->types, XkbAlphabeticIndex).name =
+            darray_item(keymap->types, XkbAlphabeticIndex).name =
                 xkb_atom_strdup(keymap->ctx, tok_ALPHABETIC);
         if (missing & XkbKeypadMask)
-            darray_item(keymap->map->types, XkbKeypadIndex).name =
+            darray_item(keymap->types, XkbKeypadIndex).name =
                 xkb_atom_strdup(keymap->ctx, tok_KEYPAD);
     }
 
-    next = &darray_item(keymap->map->types, XkbLastRequiredType + 1);
+    next = &darray_item(keymap->types, XkbLastRequiredType + 1);
     for (i = 0, def = info.types; i < info.nTypes; i++) {
         if (def->name == tok_ONE_LEVEL)
-            type = &darray_item(keymap->map->types, XkbOneLevelIndex);
+            type = &darray_item(keymap->types, XkbOneLevelIndex);
         else if (def->name == tok_TWO_LEVEL)
-            type = &darray_item(keymap->map->types, XkbTwoLevelIndex);
+            type = &darray_item(keymap->types, XkbTwoLevelIndex);
         else if (def->name == tok_ALPHABETIC)
-            type = &darray_item(keymap->map->types, XkbAlphabeticIndex);
+            type = &darray_item(keymap->types, XkbAlphabeticIndex);
         else if (def->name == tok_KEYPAD)
-            type = &darray_item(keymap->map->types, XkbKeypadIndex);
+            type = &darray_item(keymap->types, XkbKeypadIndex);
         else
             type = next++;
 
diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index 543b0e0..d1d6b0b 100644
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -1494,8 +1494,8 @@ FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
     const char *name = xkb_atom_text(keymap->ctx, atom);
     struct xkb_key_type *type;
 
-    if (keymap && keymap->map) {
-        darray_foreach(type, keymap->map->types) {
+    if (keymap) {
+        darray_foreach(type, keymap->types) {
             if (strcmp(type->name, name) == 0) {
                 *type_rtrn = n;
                 return true;
@@ -1751,7 +1751,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
             types[i] = XkbTwoLevelIndex;
         }
         /* if the type specifies fewer levels than the key has, shrink the key */
-        type = &darray_item(keymap->map->types, types[i]);
+        type = &darray_item(keymap->types, types[i]);
         if (type->num_levels < key->numLevels[i]) {
             if (warningLevel > 0) {
                 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
@@ -1785,7 +1785,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
     else
         outActs = NULL;
 
-    sym_map = &darray_item(keymap->map->key_sym_map, kc);
+    sym_map = &darray_item(keymap->key_sym_map, kc);
 
     if (key->defs.defined & _Key_GroupInfo)
         i = key->groupInfo;
@@ -1887,7 +1887,7 @@ CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
         }
         return false;
     }
-    keymap->map->modmap[kc] |= (1 << entry->modifier);
+    keymap->modmap[kc] |= (1 << entry->modifier);
     return true;
 }
 
@@ -1924,12 +1924,11 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
         goto err_info;
     }
 
-    if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0)
-        != Success) {
-        WSGO("Could not allocate client map in CompileSymbols\n");
-        ACTION("Symbols not added\n");
+    darray_resize0(keymap->key_sym_map, keymap->max_key_code + 1);
+    keymap->modmap = calloc(keymap->max_key_code + 1,
+                            sizeof(*keymap->modmap));
+    if (!keymap->modmap)
         goto err_info;
-    }
 
     if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) {
         WSGO("Could not allocate server map in CompileSymbols\n");