Add common xkb_key struct

Instead of having a million arrays from the keycode to various
key-specific info in the keymap, add a single struct xkb_key to hold all
of the data for the key in one object. This way we can pass it around,
do some refactoring and make the code simpler. It's also nice to see
everything in one place.

The keys array is still indexed by keycode, which is suboptimal because
there may be a lot of holes (i.e. unused keycodes between min_key_code
and max_key_code). By the end of this series it would be abstracted
enough to replace it by a hash table or similar if there's ever a need.

Signed-off-by: Ran Benita <ran234@gmail.com>

diff --git a/src/alloc.c b/src/alloc.c
index caf28e0..97ca82b 100644 (file)
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -70,7 +70,7 @@ bool
 XkbcResizeKeySyms(struct xkb_keymap *keymap, xkb_keycode_t kc,
                   unsigned int needed)
 {
-    darray_resize0(darray_item(keymap->key_sym_map, kc).syms, needed);
+    darray_resize0(XkbKey(keymap, kc)->sym_map.syms, needed);
     return true;
 }
 
@@ -80,8 +80,10 @@ XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t kc,
 {
     size_t old_ndx, old_num_acts, new_ndx;
 
+    key = XkbKey(keymap, kc);
+
     if (needed == 0) {
-        darray_item(keymap->key_acts, kc) = 0;
+        key->acts_index = 0;
         return NULL;
     }
 
@@ -96,12 +98,12 @@ XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t kc,
      * space for the key at the end, and leave the old space alone.
      */
 
-    old_ndx = darray_item(keymap->key_acts, kc);
+    old_ndx = key->acts_index;
     old_num_acts = XkbKeyNumActions(keymap, kc);
     new_ndx = darray_size(keymap->acts);
 
     darray_resize0(keymap->acts, new_ndx + needed);
-    darray_item(keymap->key_acts, kc) = new_ndx;
+    key->acts_index = new_ndx;
 
     /*
      * The key was already in the array, copy the old actions to the
@@ -135,14 +137,13 @@ free_types(struct xkb_keymap *keymap)
 static void
 free_sym_maps(struct xkb_keymap *keymap)
 {
-    struct xkb_sym_map *sym_map;
+    struct xkb_key *key;
 
-    darray_foreach(sym_map, keymap->key_sym_map) {
-        free(sym_map->sym_index);
-        free(sym_map->num_syms);
-        darray_free(sym_map->syms);
+    darray_foreach(key, keymap->keys) {
+        free(key->sym_map.sym_index);
+        free(key->sym_map.num_syms);
+        darray_free(key->sym_map.syms);
     }
-    darray_free(keymap->key_sym_map);
 }
 
 static void
@@ -159,7 +160,6 @@ free_names(struct xkb_keymap *keymap)
     for (i = 0; i < XkbNumKbdGroups; i++)
         free(keymap->group_names[i]);
 
-    darray_free(keymap->key_names);
     darray_free(keymap->key_aliases);
 
     free(keymap->keycodes_section_name);
@@ -191,15 +191,10 @@ XkbcFreeKeyboard(struct xkb_keymap *keymap)
 
     free_types(keymap);
     free_sym_maps(keymap);
-    free(keymap->modmap);
-    free(keymap->explicit);
-    darray_free(keymap->key_acts);
     darray_free(keymap->acts);
-    free(keymap->behaviors);
-    free(keymap->vmodmap);
     darray_free(keymap->sym_interpret);
     free_names(keymap);
-    free(keymap->per_key_repeat);
+    darray_free(keymap->keys);
     xkb_context_unref(keymap->ctx);
     free(keymap);
 }

diff --git a/src/keymap-dump.c b/src/keymap-dump.c
index b44a909..fbe0c9b 100644 (file)
--- a/src/keymap-dump.c
+++ b/src/keymap-dump.c
@@ -310,6 +310,7 @@ write_keycodes(struct xkb_keymap *keymap, char **buf, size_t *size,
                size_t *offset)
 {
     xkb_keycode_t kc;
+    struct xkb_key *key;
     struct xkb_key_alias *alias;
     int i;
 
@@ -325,12 +326,12 @@ write_keycodes(struct xkb_keymap *keymap, char **buf, size_t *size,
               keymap->max_key_code);
 
     for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
-        if (darray_item(keymap->key_names, kc).name[0] == '\0')
+        key = XkbKey(keymap, kc);
+        if (key->name.name[0] == '\0')
             continue;
 
         write_buf(keymap, buf, size, offset, "\t\t%6s = %d;\n",
-                  XkbcKeyNameText(darray_item(keymap->key_names, kc).name),
-                  kc);
+                  XkbcKeyNameText(key->name.name), kc);
     }
 
     for (i = 0; i < XkbNumIndicators; i++) {
@@ -780,6 +781,7 @@ static bool
 write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
               size_t *offset)
 {
+    struct xkb_key *key;
     xkb_keycode_t kc;
     int group, tmp;
     bool showActions;
@@ -803,62 +805,63 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
 
     for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
         bool simple = true;
+        key = XkbKey(keymap, kc);
 
         if (xkb_key_num_groups(keymap, kc) == 0)
             continue;
 
         write_buf(keymap, buf, size, offset, "\t\tkey %6s {",
-                  XkbcKeyNameText(darray_item(keymap->key_names, kc).name));
-        if (keymap->explicit) {
-            if ((keymap->explicit[kc] & XkbExplicitKeyTypesMask)) {
-                bool multi_type = false;
-                int type = XkbKeyTypeIndex(keymap, kc, 0);
+                  XkbcKeyNameText(key->name.name));
 
-                simple = false;
+        if (key->explicit & XkbExplicitKeyTypesMask) {
+            bool multi_type = false;
+            int type = XkbKeyTypeIndex(keymap, kc, 0);
 
-                for (group = 0; group < xkb_key_num_groups(keymap, kc);
-                     group++) {
-                    if (XkbKeyTypeIndex(keymap, kc, group) != type) {
-                        multi_type = true;
-                        break;
-                    }
-                }
-                if (multi_type) {
-                    for (group = 0;
-                         group < xkb_key_num_groups(keymap, kc);
-                         group++) {
-                        if (!(keymap->explicit[kc] & (1 << group)))
-                            continue;
-                        type = XkbKeyTypeIndex(keymap, kc, group);
-                        write_buf(keymap, buf, size, offset,
-                                  "\n\t\t\ttype[group%d]= \"%s\",",
-                                  group + 1,
-                                  darray_item(keymap->types, type).name);
-                    }
+            simple = false;
+
+            for (group = 0; group < xkb_key_num_groups(keymap, kc);
+                 group++) {
+                if (XkbKeyTypeIndex(keymap, kc, group) != type) {
+                    multi_type = true;
+                    break;
                 }
-                else {
+            }
+
+            if (multi_type) {
+                for (group = 0;
+                     group < xkb_key_num_groups(keymap, kc);
+                     group++) {
+                    if (!(key->explicit & (1 << group)))
+                        continue;
+                    type = XkbKeyTypeIndex(keymap, kc, group);
                     write_buf(keymap, buf, size, offset,
-                              "\n\t\t\ttype= \"%s\",",
+                              "\n\t\t\ttype[group%d]= \"%s\",",
+                              group + 1,
                               darray_item(keymap->types, type).name);
                 }
             }
-            if (keymap->explicit[kc] & XkbExplicitAutoRepeatMask) {
-                if (keymap->per_key_repeat[kc / 8] & (1 << (kc % 8)))
-                    write_buf(keymap, buf, size, offset,
-                              "\n\t\t\trepeat= Yes,");
-                else
-                    write_buf(keymap, buf, size, offset,
-                              "\n\t\t\trepeat= No,");
-                simple = false;
-            }
-            if (keymap->vmodmap[kc] &&
-                (keymap->explicit[kc] & XkbExplicitVModMapMask)) {
+            else {
                 write_buf(keymap, buf, size, offset,
-                          "\n\t\t\tvirtualMods= %s,",
-                          get_mod_mask_text(keymap, 0, keymap->vmodmap[kc]));
+                          "\n\t\t\ttype= \"%s\",",
+                          darray_item(keymap->types, type).name);
             }
         }
 
+        if (key->explicit & XkbExplicitAutoRepeatMask) {
+            if (key->repeats)
+                write_buf(keymap, buf, size, offset,
+                          "\n\t\t\trepeat= Yes,");
+            else
+                write_buf(keymap, buf, size, offset,
+                          "\n\t\t\trepeat= No,");
+            simple = false;
+        }
+
+        if (key->vmodmap && (key->explicit & XkbExplicitVModMapMask)) {
+            write_buf(keymap, buf, size, offset, "\n\t\t\tvirtualMods= %s,",
+                      get_mod_mask_text(keymap, 0, key->vmodmap));
+        }
+
         switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(keymap, kc))) {
         case XkbClampIntoRange:
             write_buf(keymap, buf, size, offset, "\n\t\t\tgroupsClamp,");
@@ -872,8 +875,7 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
             break;
         }
 
-        if (keymap->explicit == NULL ||
-            (keymap->explicit[kc] & XkbExplicitInterpretMask))
+        if (key->explicit & XkbExplicitInterpretMask)
             showActions = XkbKeyHasActions(keymap, kc);
         else
             showActions = false;
@@ -918,23 +920,22 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
             write_buf(keymap, buf, size, offset, "\n\t\t};\n");
         }
     }
-    if (keymap->modmap) {
-        for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
-            int mod;
 
-            if (keymap->modmap[kc] == 0)
-                continue;
+    for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
+        int mod;
+        key = XkbKey(keymap, kc);
 
-            for (mod = 0; mod < XkbNumModifiers; mod++) {
-                if (!(keymap->modmap[kc] & (1 << mod)))
-                    continue;
+        if (key->modmap == 0)
+            continue;
 
-                write_buf(keymap, buf, size, offset,
-                          "\t\tmodifier_map %s { %s };\n",
-                          get_mod_index_text(mod),
-                          XkbcKeyNameText(darray_item(keymap->key_names,
-                                                      kc).name));
-            }
+        for (mod = 0; mod < XkbNumModifiers; mod++) {
+            if (!(key->modmap & (1 << mod)))
+                continue;
+
+            write_buf(keymap, buf, size, offset,
+                      "\t\tmodifier_map %s { %s };\n",
+                      get_mod_index_text(mod),
+                      XkbcKeyNameText(key->name.name));
         }
     }
 

diff --git a/src/map.c b/src/map.c
index 431019c..91b2a65 100644 (file)
--- a/src/map.c
+++ b/src/map.c
@@ -357,5 +357,7 @@ err:
 _X_EXPORT int
 xkb_key_repeats(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    return !!(keymap->per_key_repeat[kc / 8] & (1 << (kc % 8)));
+    if (!XkbKeycodeInRange(keymap, kc))
+        return 0;
+    return XkbKey(keymap, kc)->repeats;
 }

diff --git a/src/xkb-priv.h b/src/xkb-priv.h
index 0890290..3c0ecab 100644 (file)
--- a/src/xkb-priv.h
+++ b/src/xkb-priv.h
@@ -309,6 +309,18 @@ struct xkb_controls {
     unsigned int axt_ctrls_values;
 };
 
+struct xkb_key {
+    struct xkb_key_name name;
+    unsigned char explicit;
+    struct xkb_sym_map sym_map;
+    unsigned char modmap;
+    uint32_t vmodmap;
+    struct xkb_behavior behavior;
+    bool repeats;
+    /* Index into keymap->acts */
+    size_t acts_index;
+};
+
 /* Common keyboard description structure */
 struct xkb_keymap {
     struct xkb_context *ctx;
@@ -321,25 +333,15 @@ struct xkb_keymap {
     xkb_keycode_t min_key_code;
     xkb_keycode_t max_key_code;
 
-    /* key -> key name mapping */
-    darray(struct xkb_key_name) key_names;
+    darray(struct xkb_key) keys;
+
     /* aliases in no particular order */
     darray(struct xkb_key_alias) key_aliases;
 
-    /* key -> explicit flags mapping */
-    unsigned char *explicit;
-
     darray(struct xkb_key_type) types;
 
-    /* key -> symbols mapping */
-    darray(struct xkb_sym_map) key_sym_map;
-
     darray(struct xkb_sym_interpret) sym_interpret;
 
-    /* key -> mod mapping */
-    unsigned char *modmap;
-    /* key -> vmod mapping */
-    uint32_t *vmodmap;
     /* vmod -> mod mapping */
     uint32_t vmods[XkbNumVirtualMods];
     char *vmod_names[XkbNumVirtualMods];
@@ -347,15 +349,7 @@ struct xkb_keymap {
     struct xkb_mods groups[XkbNumKbdGroups];
     char *group_names[XkbNumKbdGroups];
 
-    /* key -> actions mapping: acts[key_acts[keycode]] */
     darray(union xkb_action) acts;
-    darray(size_t) key_acts;
-
-    /* key -> behavior mapping */
-    struct xkb_behavior *behaviors;
-
-    /* key -> should repeat mapping - one bit per key */
-    unsigned char *per_key_repeat;
 
     struct xkb_indicator_map indicators[XkbNumIndicators];
     char *indicator_names[XkbNumIndicators];
@@ -366,6 +360,12 @@ struct xkb_keymap {
     char *compat_section_name;
 };
 
+static inline struct xkb_key *
+XkbKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
+{
+    return &darray_item(keymap->keys, kc);
+}
+
 static inline unsigned char
 XkbNumGroups(unsigned char group_info)
 {
@@ -410,7 +410,7 @@ XkbSetNumGroups(unsigned char group_info, unsigned char num_groups)
 static inline unsigned char
 XkbKeyGroupInfo(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    return darray_item(keymap->key_sym_map, kc).group_info;
+    return XkbKey(keymap, kc)->sym_map.group_info;
 }
 
 static inline unsigned char
@@ -423,7 +423,7 @@ static inline unsigned char
 XkbKeyTypeIndex(struct xkb_keymap *keymap, xkb_keycode_t kc,
                 unsigned int group)
 {
-    return darray_item(keymap->key_sym_map, kc).kt_index[group & 0x3];
+    return XkbKey(keymap, kc)->sym_map.kt_index[group & 0x3];
 }
 
 static inline struct xkb_key_type *
@@ -442,7 +442,7 @@ XkbKeyGroupWidth(struct xkb_keymap *keymap, xkb_keycode_t kc,
 static inline unsigned char
 XkbKeyGroupsWidth(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    return darray_item(keymap->key_sym_map, kc).width;
+    return XkbKey(keymap, kc)->sym_map.width;
 }
 
 static inline unsigned int
@@ -450,14 +450,13 @@ XkbKeyNumSyms(struct xkb_keymap *keymap, xkb_keycode_t kc,
               unsigned int group, unsigned int level)
 {
     unsigned char width = XkbKeyGroupsWidth(keymap, kc);
-    return darray_item(keymap->key_sym_map,
-                       kc).num_syms[group * width + level];
+    return XkbKey(keymap, kc)->sym_map.num_syms[group * width + level];
 }
 
 static inline xkb_keysym_t *
 XkbKeySym(struct xkb_keymap *keymap, xkb_keycode_t kc, int ndx)
 {
-    return &darray_item(darray_item(keymap->key_sym_map, kc).syms, ndx);
+    return &darray_item(XkbKey(keymap, kc)->sym_map.syms, ndx);
 }
 
 static inline int
@@ -465,8 +464,7 @@ XkbKeySymOffset(struct xkb_keymap *keymap, xkb_keycode_t kc,
                 unsigned group, unsigned int level)
 {
     unsigned char width = XkbKeyGroupsWidth(keymap, kc);
-    return darray_item(keymap->key_sym_map,
-                       kc).sym_index[group * width + level];
+    return XkbKey(keymap, kc)->sym_map.sym_index[group * width + level];
 }
 
 static inline xkb_keysym_t *
@@ -479,7 +477,7 @@ XkbKeySymEntry(struct xkb_keymap *keymap, xkb_keycode_t kc,
 static inline bool
 XkbKeyHasActions(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    return darray_item(keymap->key_acts, kc) != 0;
+    return XkbKey(keymap, kc)->acts_index != 0;
 }
 
 static inline unsigned char
@@ -493,7 +491,8 @@ XkbKeyNumActions(struct xkb_keymap *keymap, xkb_keycode_t kc)
 static inline union xkb_action *
 XkbKeyActionsPtr(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    return darray_mem(keymap->acts, darray_item(keymap->key_acts, kc));
+    struct xkb_key *key = XkbKey(keymap, kc);
+    return darray_mem(keymap->acts, key->acts_index);
 }
 
 static inline union xkb_action *

diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c
index 1ab6754..9c551c9 100644 (file)
--- a/src/xkbcomp/compat.c
+++ b/src/xkbcomp/compat.c
@@ -847,7 +847,7 @@ FindInterpForKey(struct xkb_keymap *keymap, xkb_keycode_t kc,
             continue;
 
         if (level == 0 || !(interp->match & XkbSI_LevelOneOnly))
-            mods = keymap->modmap[kc];
+            mods = XkbKey(keymap, kc)->modmap;
         else
             mods = 0;
 
@@ -893,10 +893,13 @@ ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
     int num_acts = 0;
     int group, level;
     int width = XkbKeyGroupsWidth(keymap, kc);
+    struct xkb_key *key;
     int i;
 
+    key = XkbKey(keymap, kc);
+
     /* If we've been told not to bind interps to this key, then don't. */
-    if (keymap->explicit[kc] & XkbExplicitInterpretMask)
+    if (key->explicit & XkbExplicitInterpretMask)
         return true;
 
     for (i = 0; i < INTERP_SIZE; i++)
@@ -930,12 +933,12 @@ ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
 
             /* Infer default key behaviours from the base level. */
             if (group == 0 && level == 0) {
-                if (!(keymap->explicit[kc] & XkbExplicitAutoRepeatMask) &&
+                if (!(key->explicit & XkbExplicitAutoRepeatMask) &&
                     (!interp || interp->flags & XkbSI_AutoRepeat))
-                    keymap->per_key_repeat[kc / 8] |= (1 << (kc % 8));
-                if (!(keymap->explicit[kc] & XkbExplicitBehaviorMask) &&
+                    key->repeats = true;
+                if (!(key->explicit & XkbExplicitBehaviorMask) &&
                     interp && (interp->flags & XkbSI_LockingKey))
-                    keymap->behaviors[kc].type = XkbKB_Lock;
+                    key->behavior.type = XkbKB_Lock;
             }
 
             if (!interp)
@@ -950,8 +953,8 @@ ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
         }
     }
 
-    if (!(keymap->explicit[kc] & XkbExplicitVModMapMask))
-        keymap->vmodmap[kc] = vmodmask;
+    if (!(key->explicit & XkbExplicitVModMapMask))
+        key->vmodmap = vmodmask;
 
     return true;
 #undef INTERP_SIZE
@@ -967,6 +970,7 @@ bool
 UpdateModifiersFromCompat(struct xkb_keymap *keymap)
 {
     xkb_keycode_t kc;
+    struct xkb_key *key;
     int i;
     struct xkb_key_type *type;
     struct xkb_kt_map_entry *entry;
@@ -981,12 +985,13 @@ UpdateModifiersFromCompat(struct xkb_keymap *keymap)
     for (i = 0; i < XkbNumVirtualMods; i++)
         keymap->vmods[i] = 0;
     for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
-        if (!keymap->vmodmap[kc])
+        key = XkbKey(keymap, kc);
+        if (!key->vmodmap)
             continue;
         for (i = 0; i < XkbNumVirtualMods; i++) {
-            if (!(keymap->vmodmap[kc] & (1 << i)))
+            if (!(key->vmodmap & (1 << i)))
                 continue;
-            keymap->vmods[i] |= keymap->modmap[kc];
+            keymap->vmods[i] |= key->modmap;
         }
     }
 
@@ -1010,10 +1015,11 @@ UpdateModifiersFromCompat(struct xkb_keymap *keymap)
     /* Update action modifiers. */
     for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
         union xkb_action *acts = XkbKeyActionsPtr(keymap, kc);
+        key = XkbKey(keymap, kc);
         for (i = 0; i < XkbKeyNumActions(keymap, kc); i++) {
             if (acts[i].any.type == XkbSA_NoAction)
                 continue;
-            UpdateActionMods(keymap, &acts[i], keymap->modmap[kc]);
+            UpdateActionMods(keymap, &acts[i], key->modmap);
         }
     }
 

diff --git a/src/xkbcomp/keycodes.c b/src/xkbcomp/keycodes.c
index 3fba2a5..9ff9f37 100644 (file)
--- a/src/xkbcomp/keycodes.c
+++ b/src/xkbcomp/keycodes.c
@@ -754,10 +754,10 @@ CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
     else
         keymap->max_key_code = info.computedMax;
 
-    darray_resize0(keymap->key_names, keymap->max_key_code + 1);
+    darray_resize0(keymap->keys, keymap->max_key_code + 1);
     for (kc = info.computedMin; kc <= info.computedMax; kc++)
         LongToKeyName(darray_item(info.names, kc),
-                      darray_item(keymap->key_names, kc).name);
+                      XkbKey(keymap, kc)->name.name);
 
     if (info.name)
         keymap->keycodes_section_name = strdup(info.name);

diff --git a/src/xkbcomp/misc.c b/src/xkbcomp/misc.c
index 7692e8c..e10a23e 100644 (file)
--- a/src/xkbcomp/misc.c
+++ b/src/xkbcomp/misc.c
@@ -217,7 +217,8 @@ FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
              xkb_keycode_t *kc_rtrn, bool use_aliases, bool create,
              xkb_keycode_t start_from)
 {
-    unsigned n;
+    xkb_keycode_t kc;
+    struct xkb_key *key;
 
     if (start_from < keymap->min_key_code)
         start_from = keymap->min_key_code;
@@ -226,34 +227,36 @@ FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
 
     *kc_rtrn = 0;               /* some callers rely on this */
 
-    if (!darray_empty(keymap->key_names)) {
-        for (n = start_from; n <= keymap->max_key_code; n++) {
-            unsigned long tmp;
-            tmp = KeyNameToLong(darray_item(keymap->key_names, n).name);
-            if (tmp == name) {
-                *kc_rtrn = n;
-                return true;
-            }
-        }
-        if (use_aliases) {
-            unsigned long new_name;
-            if (FindKeyNameForAlias(keymap, name, &new_name))
-                return FindNamedKey(keymap, new_name, kc_rtrn, false,
-                                    create, 0);
+    for (kc = start_from; kc <= keymap->max_key_code; kc++) {
+        unsigned long tmp;
+        key = XkbKey(keymap, kc);
+
+        tmp = KeyNameToLong(key->name.name);
+        if (tmp == name) {
+            *kc_rtrn = kc;
+            return true;
         }
     }
 
+    if (use_aliases) {
+        unsigned long new_name;
+        if (FindKeyNameForAlias(keymap, name, &new_name))
+            return FindNamedKey(keymap, new_name, kc_rtrn, false,
+                                create, 0);
+    }
+
     if (create) {
-        darray_resize0(keymap->key_names, keymap->max_key_code + 1);
+        darray_resize0(keymap->keys, keymap->max_key_code + 1);
 
         /* Find first unused keycode and store our key here */
-        for (n = keymap->min_key_code; n <= keymap->max_key_code; n++) {
-            if (darray_item(keymap->key_names, n).name[0] == '\0') {
+        for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
+            key = XkbKey(keymap, kc);
+
+            if (key->name.name[0] == '\0') {
                 char buf[XkbKeyNameLength + 1];
                 LongToKeyName(name, buf);
-                memcpy(darray_item(keymap->key_names, n).name, buf,
-                       XkbKeyNameLength);
-                *kc_rtrn = n;
+                memcpy(key->name.name, buf, XkbKeyNameLength);
+                *kc_rtrn = kc;
                 return true;
             }
         }

diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index c67bf1d..0adc819 100644 (file)
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -1693,6 +1693,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from)
 {
     unsigned int i;
     xkb_keycode_t kc;
+    struct xkb_key *key;
     unsigned int sizeSyms = 0;
     unsigned width, tmp, nGroups;
     struct xkb_key_type * type;
@@ -1714,6 +1715,8 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from)
         return false;
     }
 
+    key = XkbKey(keymap, kc);
+
     haveActions = false;
     for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++) {
         if (((i + 1) > nGroups)
@@ -1742,7 +1745,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from)
         }
         if (FindNamedType(keymap, keyi->types[i], &types[i])) {
             if (!autoType || keyi->numLevels[i] > 2)
-                keymap->explicit[kc] |= (1 << i);
+                key->explicit |= (1 << i);
         }
         else {
             if (warningLevel >= 3) {
@@ -1783,12 +1786,12 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from)
                  longText(keyi->name), kc);
             return false;
         }
-        keymap->explicit[kc] |= XkbExplicitInterpretMask;
+        key->explicit |= XkbExplicitInterpretMask;
     }
     else
         outActs = NULL;
 
-    sym_map = &darray_item(keymap->key_sym_map, kc);
+    sym_map = &key->sym_map;
 
     if (keyi->defs.defined & _Key_GroupInfo)
         i = keyi->groupInfo;
@@ -1843,20 +1846,17 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from)
         break;
 
     default:
-        keymap->behaviors[kc] = keyi->behavior;
-        keymap->explicit[kc] |= XkbExplicitBehaviorMask;
+        key->behavior = keyi->behavior;
+        key->explicit |= XkbExplicitBehaviorMask;
         break;
     }
     if (keyi->defs.defined & _Key_VModMap) {
-        keymap->vmodmap[kc] = keyi->vmodmap;
-        keymap->explicit[kc] |= XkbExplicitVModMapMask;
+        key->vmodmap = keyi->vmodmap;
+        key->explicit |= XkbExplicitVModMapMask;
     }
     if (keyi->repeat != RepeatUndefined) {
-        if (keyi->repeat == RepeatYes)
-            keymap->per_key_repeat[kc / 8] |= (1 << (kc % 8));
-        else
-            keymap->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
-        keymap->explicit[kc] |= XkbExplicitAutoRepeatMask;
+        key->repeats = keyi->repeat == RepeatYes;
+        key->explicit |= XkbExplicitAutoRepeatMask;
     }
 
     /* do the same thing for the next key */
@@ -1890,7 +1890,8 @@ CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
         }
         return false;
     }
-    keymap->modmap[kc] |= (1 << entry->modifier);
+
+    XkbKey(keymap, kc)->modmap |= (1 << entry->modifier);
     return true;
 }
 
@@ -1899,30 +1900,9 @@ InitKeymapForSymbols(struct xkb_keymap *keymap)
 {
     size_t nKeys = keymap->max_key_code + 1;
 
-    darray_resize0(keymap->key_sym_map, nKeys);
-
-    keymap->modmap = calloc(nKeys, sizeof(*keymap->modmap));
-    if (!keymap->modmap)
-        return false;
-
-    keymap->explicit = calloc(nKeys, sizeof(*keymap->explicit));
-    if (!keymap->explicit)
-        return false;
+    darray_resize0(keymap->keys, nKeys);
 
     darray_resize0(keymap->acts, darray_size(keymap->acts) + 32 + 1);
-    darray_resize0(keymap->key_acts, nKeys);
-
-    keymap->behaviors = calloc(nKeys, sizeof(*keymap->behaviors));
-    if (!keymap->behaviors)
-        return false;
-
-    keymap->vmodmap = calloc(nKeys, sizeof(*keymap->vmodmap));
-    if (!keymap->vmodmap)
-        return false;
-
-    keymap->per_key_repeat = calloc(nKeys / 8, 1);
-    if (!keymap->per_key_repeat)
-        return false;
 
     return true;
 }
@@ -1941,6 +1921,7 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
     int i;
     bool ok;
     xkb_keycode_t kc;
+    struct xkb_key *key;
     SymbolsInfo info;
     KeyInfo *keyi;
 
@@ -1984,15 +1965,13 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
 
     if (warningLevel > 3) {
         for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
-            if (darray_item(keymap->key_names, kc).name[0] == '\0')
+            key = XkbKey(keymap, kc);
+            if (key->name.name[0] == '\0')
                 continue;
 
-            if (XkbKeyNumGroups(keymap, kc) < 1) {
-                char buf[5];
-                memcpy(buf, darray_item(keymap->key_names, kc).name, 4);
-                buf[4] = '\0';
-                WARN("No symbols defined for <%s> (keycode %d)\n", buf, kc);
-            }
+            if (XkbKeyNumGroups(keymap, kc) < 1)
+                WARN("No symbols defined for <%.4s> (keycode %d)\n",
+                     key->name.name, kc);
         }
     }