Get rid of group_info

This is 8 bits which hold how many groups the key has, what to do the
key group is out of bound and the group to redirect to if want to. This
may save a few bytes, but is really annoying. So instead, just lay out
the fields separately. We can optimize later in a sane way, with pahole,
bitfields, etc. if we want.

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

diff --git a/src/keymap-dump.c b/src/keymap-dump.c
index 1d99e35..893453d 100644 (file)
--- a/src/keymap-dump.c
+++ b/src/keymap-dump.c
@@ -862,7 +862,7 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
                       get_mod_mask_text(keymap, 0, key->vmodmap));
         }
 
-        switch (XkbOutOfRangeGroupAction(XkbKeyGroupInfo(keymap, kc))) {
+        switch (key->out_of_range_group_action) {
         case XkbClampIntoRange:
             write_buf(keymap, buf, size, offset, "\n\t\t\tgroupsClamp,");
             break;
@@ -870,8 +870,7 @@ write_symbols(struct xkb_keymap *keymap, char **buf, size_t *size,
         case XkbRedirectIntoRange:
             write_buf(keymap, buf, size, offset,
                       "\n\t\t\tgroupsRedirect= Group%d,",
-                      XkbOutOfRangeGroupNumber(XkbKeyGroupInfo(keymap,
-                                                               kc)) + 1);
+                      key->out_of_range_group_number + 1);
             break;
         }
 

diff --git a/src/map.c b/src/map.c
index 91b2a65..1cbbc38 100644 (file)
--- a/src/map.c
+++ b/src/map.c
@@ -187,7 +187,9 @@ xkb_map_group_get_index(struct xkb_keymap *keymap, const char *name)
 _X_EXPORT xkb_group_index_t
 xkb_key_num_groups(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    return XkbKeyNumGroups(keymap, kc);
+    if (XkbKeycodeInRange(keymap, kc))
+        return XkbKey(keymap, kc)->num_groups;
+    return 0;
 }
 
 /**
@@ -268,27 +270,26 @@ _X_EXPORT unsigned int
 xkb_key_get_group(struct xkb_state *state, xkb_keycode_t kc)
 {
     struct xkb_keymap *keymap = xkb_state_get_map(state);
-    unsigned int info = XkbKeyGroupInfo(keymap, kc);
-    unsigned int num_groups = XkbKeyNumGroups(keymap, kc);
     unsigned int ret = xkb_state_serialize_group(state, XKB_STATE_EFFECTIVE);
+    struct xkb_key *key = XkbKey(keymap, kc);
 
-    if (ret < XkbKeyNumGroups(keymap, kc))
+    if (ret < key->num_groups)
         return ret;
 
-    switch (XkbOutOfRangeGroupAction(info)) {
+    switch (key->out_of_range_group_action) {
     case XkbRedirectIntoRange:
-        ret = XkbOutOfRangeGroupNumber(info);
-        if (ret >= num_groups)
+        ret = key->out_of_range_group_number;
+        if (ret >= key->num_groups)
             ret = 0;
         break;
 
     case XkbClampIntoRange:
-        ret = num_groups - 1;
+        ret = key->num_groups - 1;
         break;
 
     case XkbWrapIntoRange:
     default:
-        ret %= num_groups;
+        ret %= key->num_groups;
         break;
     }
 
@@ -304,8 +305,9 @@ xkb_key_get_syms_by_level(struct xkb_keymap *keymap, xkb_keycode_t kc,
                           const xkb_keysym_t **syms_out)
 {
     int num_syms;
+    struct xkb_key *key = XkbKey(keymap, kc);
 
-    if (group >= XkbKeyNumGroups(keymap, kc))
+    if (group >= key->num_groups)
         goto err;
     if (level >= XkbKeyGroupWidth(keymap, kc, group))
         goto err;

diff --git a/src/xkb-priv.h b/src/xkb-priv.h
index 28be176..bef38c3 100644 (file)
--- a/src/xkb-priv.h
+++ b/src/xkb-priv.h
@@ -312,9 +312,14 @@ struct xkb_key {
     size_t acts_index;
 
     unsigned char kt_index[XkbNumKbdGroups];
-    unsigned char group_info;
+
+    unsigned int num_groups;
+    /* How many levels the largest group has. */
     unsigned char width;
 
+    uint8_t out_of_range_group_action;
+    uint8_t out_of_range_group_number;
+
     /* per level/group index into 'syms' */
     int *sym_index;
     /* per level/group */
@@ -368,59 +373,6 @@ XkbKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
 }
 
 static inline unsigned char
-XkbNumGroups(unsigned char group_info)
-{
-    return group_info & 0x0f;
-}
-
-static inline unsigned char
-XkbOutOfRangeGroupInfo(unsigned char group_info)
-{
-    return group_info & 0xf0;
-}
-
-static inline unsigned char
-XkbOutOfRangeGroupAction(unsigned char group_info)
-{
-    return group_info & 0xc0;
-}
-
-static inline unsigned char
-XkbOutOfRangeGroupNumber(unsigned char group_info)
-{
-    return (group_info & 0x30) >> 4;
-}
-
-static inline unsigned char
-XkbSetGroupInfo(unsigned char group_info,
-                unsigned char out_of_range_group_action,
-                unsigned char out_of_range_group_number)
-{
-    return
-        (out_of_range_group_action & 0xc0) |
-        ((out_of_range_group_number & 3) << 4) |
-        (XkbNumGroups(group_info));
-}
-
-static inline unsigned char
-XkbSetNumGroups(unsigned char group_info, unsigned char num_groups)
-{
-    return (group_info & 0xf0) | (num_groups & 0x0f);
-}
-
-static inline unsigned char
-XkbKeyGroupInfo(struct xkb_keymap *keymap, xkb_keycode_t kc)
-{
-    return XkbKey(keymap, kc)->group_info;
-}
-
-static inline unsigned char
-XkbKeyNumGroups(struct xkb_keymap *keymap, xkb_keycode_t kc)
-{
-    return XkbNumGroups(XkbKeyGroupInfo(keymap, kc));
-}
-
-static inline unsigned char
 XkbKeyTypeIndex(struct xkb_keymap *keymap, xkb_keycode_t kc,
                 unsigned int group)
 {
@@ -484,8 +436,9 @@ XkbKeyHasActions(struct xkb_keymap *keymap, xkb_keycode_t kc)
 static inline unsigned char
 XkbKeyNumActions(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
+    struct xkb_key *key = XkbKey(keymap, kc);
     if (XkbKeyHasActions(keymap, kc))
-        return XkbKeyGroupsWidth(keymap, kc) * XkbKeyNumGroups(keymap, kc);
+        return key->width * key->num_groups;
     return 1;
 }
 

diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c
index 9c551c9..93b8480 100644 (file)
--- a/src/xkbcomp/compat.c
+++ b/src/xkbcomp/compat.c
@@ -905,7 +905,7 @@ ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
     for (i = 0; i < INTERP_SIZE; i++)
         interps[i] = NULL;
 
-    for (group = 0; group < XkbKeyNumGroups(keymap, kc); group++) {
+    for (group = 0; group < key->num_groups; group++) {
         for (level = 0; level < XkbKeyGroupWidth(keymap, kc, group);
              level++) {
             i = (group * width) + level;
@@ -918,12 +918,12 @@ ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t kc)
     }
 
     if (num_acts)
-        num_acts = XkbKeyNumGroups(keymap, kc) * width;
+        num_acts = key->num_groups * width;
     acts = XkbcResizeKeyActions(keymap, kc, num_acts);
     if (num_acts && !acts)
         return false;
 
-    for (group = 0; group < XkbKeyNumGroups(keymap, kc); group++) {
+    for (group = 0; group < key->num_groups; group++) {
         for (level = 0; level < XkbKeyGroupWidth(keymap, kc, group);
              level++) {
             struct xkb_sym_interpret *interp;

diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index b3fda43..4b64a82 100644 (file)
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -55,7 +55,6 @@ typedef darray (union xkb_action) darray_xkb_action;
 typedef struct _KeyInfo {
     CommonInfo defs;
     unsigned long name; /* the 4 chars of the key name, as long */
-    unsigned char groupInfo;
     unsigned char typesDefined;
     unsigned char symsDefined;
     unsigned char actsDefined;
@@ -83,6 +82,9 @@ typedef struct _KeyInfo {
     struct xkb_behavior behavior;
     unsigned short vmodmap;
     xkb_atom_t dfltType;
+
+    uint8_t out_of_range_group_action;
+    uint8_t out_of_range_group_number;
 } KeyInfo;
 
 /**
@@ -99,7 +101,6 @@ InitKeyInfo(KeyInfo *keyi, unsigned file_id)
     keyi->defs.merge = MERGE_OVERRIDE;
     keyi->defs.next = NULL;
     keyi->name = KeyNameToLong(dflt);
-    keyi->groupInfo = 0;
     keyi->typesDefined = keyi->symsDefined = keyi->actsDefined = 0;
 
     for (i = 0; i < XkbNumKbdGroups; i++) {
@@ -116,35 +117,21 @@ InitKeyInfo(KeyInfo *keyi, unsigned file_id)
     keyi->behavior.data = 0;
     keyi->vmodmap = 0;
     keyi->repeat = RepeatUndefined;
+    keyi->out_of_range_group_action = 0;
+    keyi->out_of_range_group_number = 0;
 }
 
-/**
- * Free memory associated with this key keyi and reset to sane values.
- */
 static void
 FreeKeyInfo(KeyInfo *keyi)
 {
     int i;
 
-    keyi->defs.defined = 0;
-    keyi->defs.file_id = 0;
-    keyi->defs.merge = MERGE_OVERRIDE;
-    keyi->defs.next = NULL;
-    keyi->groupkeyi = 0;
-    keyi->typesDefined = keyi->symsDefined = keyi->actsDefined = 0;
     for (i = 0; i < XkbNumKbdGroups; i++) {
-        keyi->numLevels[i] = 0;
-        keyi->types[i] = XKB_ATOM_NONE;
         darray_free(keyi->syms[i]);
         darray_free(keyi->symsMapIndex[i]);
         darray_free(keyi->symsMapNumEntries[i]);
         darray_free(keyi->acts[i]);
     }
-    keyi->dfltType = XKB_ATOM_NONE;
-    keyi->behavior.type = XkbKB_Default;
-    keyi->behavior.data = 0;
-    keyi->vmodmap = 0;
-    keyi->repeat = RepeatUndefined;
 }
 
 /**
@@ -237,8 +224,9 @@ FreeSymbolsInfo(SymbolsInfo * info)
     KeyInfo *keyi;
 
     free(info->name);
-    darray_foreach(keyi, info->keys)
+    darray_foreach(keyi, info->keys) {
         FreeKeyInfo(keyi);
+    }
     darray_free(info->keys);
     if (info->modMap)
         ClearCommonInfo(&info->modMap->defs);
@@ -583,7 +571,8 @@ MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap,
         into->defs.defined |= _Key_Type_Dflt;
     }
     if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide)) {
-        into->groupInfo = from->groupInfo;
+        into->out_of_range_group_action = from->out_of_range_group_action;
+        into->out_of_range_group_number = from->out_of_range_group_number;
         into->defs.defined |= _Key_GroupInfo;
     }
     if (collide) {
@@ -1114,9 +1103,9 @@ SetSymbolsField(KeyInfo *keyi, struct xkb_keymap *keymap, char *field,
             return false;
         }
         if (tmp.uval)
-            keyi->groupInfo = XkbWrapIntoRange;
+            keyi->out_of_range_group_action = XkbWrapIntoRange;
         else
-            keyi->groupInfo = XkbClampIntoRange;
+            keyi->out_of_range_group_action = XkbClampIntoRange;
         keyi->defs.defined |= _Key_GroupInfo;
     }
     else if ((strcasecmp(field, "groupsclamp") == 0) ||
@@ -1129,9 +1118,9 @@ SetSymbolsField(KeyInfo *keyi, struct xkb_keymap *keymap, char *field,
             return false;
         }
         if (tmp.uval)
-            keyi->groupInfo = XkbClampIntoRange;
+            keyi->out_of_range_group_action = XkbClampIntoRange;
         else
-            keyi->groupInfo = XkbWrapIntoRange;
+            keyi->out_of_range_group_action = XkbWrapIntoRange;
         keyi->defs.defined |= _Key_GroupInfo;
     }
     else if ((strcasecmp(field, "groupsredirect") == 0) ||
@@ -1142,8 +1131,8 @@ SetSymbolsField(KeyInfo *keyi, struct xkb_keymap *keymap, char *field,
             ACTION("Definition with non-integer group ignored\n");
             return false;
         }
-        keyi->groupInfo =
-            XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
+        keyi->out_of_range_group_action = XkbRedirectIntoRange;
+        keyi->out_of_range_group_number = tmp.uval - 1;
         keyi->defs.defined |= _Key_GroupInfo;
     }
     else {
@@ -1448,10 +1437,13 @@ FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
                  xkb_keycode_t *kc_rtrn)
 {
     xkb_keycode_t kc;
+    struct xkb_key *key;
     unsigned int group, level, min_group = UINT_MAX, min_level = UINT_MAX;
 
     for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {
-        for (group = 0; group < XkbKeyNumGroups(keymap, kc); group++) {
+        key = XkbKey(keymap, kc);
+
+        for (group = 0; group < key->num_groups; group++) {
             for (level = 0; level < XkbKeyGroupWidth(keymap, kc, group);
                  level++) {
                 if (XkbKeyNumSyms(keymap, kc, group, level) != 1 ||
@@ -1787,15 +1779,14 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from)
     else
         outActs = NULL;
 
-    if (keyi->defs.defined & _Key_GroupInfo)
-        i = keyi->groupInfo;
-    else
-        i = key->group_info;
-
-    key->group_info = XkbSetNumGroups(i, nGroups);
+    key->num_groups = nGroups;
+    if (keyi->defs.defined & _Key_GroupInfo) {
+        key->out_of_range_group_number = keyi->out_of_range_group_number;
+        key->out_of_range_group_action = keyi->out_of_range_group_action;
+    }
     key->width = width;
-    key->sym_index = uTypedCalloc(nGroups * width, int);
-    key->num_syms = uTypedCalloc(nGroups * width, unsigned int);
+    key->sym_index = calloc(nGroups * width, sizeof(*key->sym_index));
+    key->num_syms = calloc(nGroups * width, sizeof(*key->num_syms));
 
     for (i = 0; i < nGroups; i++) {
         /* assign kt_index[i] to the index of the type in map->types.
@@ -1963,7 +1954,7 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
             if (key->name[0] == '\0')
                 continue;
 
-            if (XkbKeyNumGroups(keymap, kc) < 1)
+            if (key->num_groups < 1)
                 WARN("No symbols defined for <%.4s> (keycode %d)\n",
                      key->name, kc);
         }