StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

keytypes: use darray for key types in the client map 

Signed-off-by: Ran Benita <ran234@gmail.com>
master
Ran Benita 2012-05-22 08:07:52 +03:00
parent 561504162f
commit c2ac3a2b20
7 changed files with 52 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
src/alloc.c
View File

@ -28,62 +28,35 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
int
XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
unsigned nTotalTypes)
size_t nTotalTypes)
{
struct xkb_client_map * map;
if (!keymap || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
return BadValue;
if (!keymap->map) {
map = uTypedCalloc(1, struct xkb_client_map);
if (!map)
keymap->map = calloc(1, sizeof(*keymap->map));
if (!keymap->map)
return BadAlloc;
keymap->map = map;
darray_init(keymap->map->types);
}
else
map = keymap->map;
if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
if (!map->types) {
map->types = uTypedCalloc(nTotalTypes, struct xkb_key_type);
if (!map->types)
return BadAlloc;
map->num_types = 0;
map->size_types = nTotalTypes;
}
else if (map->size_types < nTotalTypes) {
struct xkb_key_type *prev_types = map->types;
map->types = uTypedRealloc(map->types, nTotalTypes,
struct xkb_key_type);
if (!map->types) {
free(prev_types);
map->num_types = map->size_types = 0;
return BadAlloc;
}
map->size_types = nTotalTypes;
memset(&map->types[map->num_types], 0,
(map->size_types - map->num_types) * sizeof(struct xkb_key_type));
}
}
if (which & XkbKeyTypesMask)
darray_growalloc(keymap->map->types, nTotalTypes);
if (which & XkbKeySymsMask) {
if (!map->key_sym_map) {
map->key_sym_map = uTypedCalloc(keymap->max_key_code + 1,
struct xkb_sym_map);
if (!map->key_sym_map)
if (!keymap->map->key_sym_map) {
keymap->map->key_sym_map = uTypedCalloc(keymap->max_key_code + 1,
struct xkb_sym_map);
if (!keymap->map->key_sym_map)
return BadAlloc;
}
}
if (which & XkbModifierMapMask) {
if (!map->modmap) {
map->modmap = uTypedCalloc(keymap->max_key_code + 1,
unsigned char);
if (!map->modmap)
if (!keymap->map->modmap) {
keymap->map->modmap = uTypedCalloc(keymap->max_key_code + 1,
unsigned char);
if (!keymap->map->modmap)
return BadAlloc;
}
}
@ -309,14 +282,13 @@ XkbcFreeClientMap(struct xkb_keymap *keymap)
struct xkb_client_map * map;
struct xkb_key_type * type;
xkb_keycode_t key;
int i;
if (!keymap || !keymap->map)
return;
map = keymap->map;
for (i = 0, type = map->types; i < map->num_types && type; i++, type++) {
darray_foreach(type, map->types) {
int j;
free(type->map);
free(type->preserve);
@ -325,7 +297,7 @@ XkbcFreeClientMap(struct xkb_keymap *keymap)
free(type->level_names);
free(UNCONSTIFY(type->name));
}
free(map->types);
darray_free(map->types);
if (map->key_sym_map) {
for (key = keymap->min_key_code; key < keymap->max_key_code; key++) {
@ -410,12 +382,10 @@ XkbcAllocNames(struct xkb_keymap *keymap, unsigned which,
}
names = keymap->names;
if ((which & XkbKTLevelNamesMask) && keymap->map && keymap->map->types) {
int i;
if ((which & XkbKTLevelNamesMask) && keymap->map) {
struct xkb_key_type * type;
type = keymap->map->types;
for (i = 0; i < keymap->map->num_types; i++, type++) {
darray_foreach(type, keymap->map->types) {
if (!type->level_names) {
type->level_names = uTypedCalloc(type->num_levels, const char *);
if (!type->level_names)
@ -462,6 +432,7 @@ XkbcFreeNames(struct xkb_keymap *keymap)
{
struct xkb_names * names;
struct xkb_client_map * map;
struct xkb_key_type *type;
int i;
if (!keymap || !keymap->names)
@ -470,10 +441,8 @@ XkbcFreeNames(struct xkb_keymap *keymap)
names = keymap->names;
map = keymap->map;
if (map && map->types) {
struct xkb_key_type * type = map->types;
for (i = 0; i < map->num_types; i++, type++) {
if (map) {
darray_foreach(type, map->types) {
int j;
for (j = 0; j < type->num_levels; j++)
free(UNCONSTIFY(type->level_names[j]));

2
src/alloc.h
View File

@ -50,7 +50,7 @@ XkbcFreeKeyboard(struct xkb_keymap *keymap);
extern int
XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
unsigned nTotalTypes);
size_t nTotalTypes);
extern int
XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which,

16
src/misc.c
View File

@ -80,7 +80,7 @@ XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
int keypadVMod)
{
struct xkb_client_map * map;
struct xkb_key_type *from, *to;
struct xkb_key_type *from;
int rtrn;
if (!keymap)
@ -96,23 +96,25 @@ XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
rtrn = Success;
from = canonicalTypes;
to = map->types;
if (which & XkbOneLevelMask)
rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex], &to[XkbOneLevelIndex]);
rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex],
&darray_item(map->types, XkbOneLevelIndex));
if ((which & XkbTwoLevelMask) && (rtrn == Success))
rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex], &to[XkbTwoLevelIndex]);
rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex],
&darray_item(map->types, XkbTwoLevelIndex));
if ((which & XkbAlphabeticMask) && (rtrn == Success))
rtrn = XkbcCopyKeyType(&from[XkbAlphabeticIndex],
&to[XkbAlphabeticIndex]);
&darray_item(map->types, XkbAlphabeticIndex));
if ((which & XkbKeypadMask) && (rtrn == Success)) {
struct xkb_key_type * type;
rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]);
type = &to[XkbKeypadIndex];
rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex],
&darray_item(map->types, XkbKeypadIndex));
type = &darray_item(map->types, XkbKeypadIndex);
if ((keypadVMod >= 0) && (keypadVMod < XkbNumVirtualMods) &&
(rtrn == Success)) {

6
src/xkb-priv.h
View File

@ -280,9 +280,7 @@ struct xkb_sym_map {
};
struct xkb_client_map {
unsigned char size_types;
unsigned char num_types;
struct xkb_key_type * types;
darray(struct xkb_key_type) types;
struct xkb_sym_map * key_sym_map;
unsigned char *modmap;
};
@ -387,7 +385,7 @@ struct xkb_keymap {
#define XkbKeyGroupWidth(d,k,g) (XkbKeyType(d,k,g)->num_levels)
#define XkbKeyGroupsWidth(d,k) ((d)->map->key_sym_map[k].width)
#define XkbKeyTypeIndex(d,k,g) ((d)->map->key_sym_map[k].kt_index[g&0x3])
#define XkbKeyType(d,k,g) (&(d)->map->types[XkbKeyTypeIndex(d,k,g)])
#define XkbKeyType(d,k,g) (&darray_item((d)->map->types, XkbKeyTypeIndex(d,k,g)))
#define XkbKeyNumSyms(d,k,g,sl) \
((d)->map->key_sym_map[k].num_syms[(g*XkbKeyGroupsWidth(d,k))+sl])
#define XkbKeySym(d,k,n) (&(d)->map->key_sym_map[k].syms[n])

4
src/xkbcomp/compat.c
View File

@ -1025,6 +1025,7 @@ UpdateModifiersFromCompat(struct xkb_keymap *keymap)
{
xkb_keycode_t key;
int i;
struct xkb_key_type *type;
/* Find all the interprets for the key and bind them to actions,
* which will also update the vmodmap. */
@ -1046,8 +1047,7 @@ UpdateModifiersFromCompat(struct xkb_keymap *keymap)
}
/* Now update the level masks for all the types to reflect the vmods. */
for (i = 0; i < keymap->map->num_types; i++) {
struct xkb_key_type *type = &keymap->map->types[i];
darray_foreach(type, keymap->map->types) {
uint32_t mask = 0;
int j;
type->mods.mask = type->mods.real_mods;

20
src/xkbcomp/keytypes.c
View File

@ -1171,7 +1171,7 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
goto err_info;
}
keymap->map->num_types = i;
darray_resize0(keymap->map->types, i);
if (XkbAllRequiredTypes & (~info.stdPresent)) {
unsigned missing, keypadVMod;
@ -1185,29 +1185,29 @@ CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
}
if (missing & XkbOneLevelMask)
keymap->map->types[XkbOneLevelIndex].name =
darray_item(keymap->map->types, XkbOneLevelIndex).name =
xkb_atom_strdup(keymap->ctx, tok_ONE_LEVEL);
if (missing & XkbTwoLevelMask)
keymap->map->types[XkbTwoLevelIndex].name =
darray_item(keymap->map->types, XkbTwoLevelIndex).name =
xkb_atom_strdup(keymap->ctx, tok_TWO_LEVEL);
if (missing & XkbAlphabeticMask)
keymap->map->types[XkbAlphabeticIndex].name =
darray_item(keymap->map->types, XkbAlphabeticIndex).name =
xkb_atom_strdup(keymap->ctx, tok_ALPHABETIC);
if (missing & XkbKeypadMask)
keymap->map->types[XkbKeypadIndex].name =
darray_item(keymap->map->types, XkbKeypadIndex).name =
xkb_atom_strdup(keymap->ctx, tok_KEYPAD);
}
next = &keymap->map->types[XkbLastRequiredType + 1];
next = &darray_item(keymap->map->types, XkbLastRequiredType + 1);
for (i = 0, def = info.types; i < info.nTypes; i++) {
if (def->name == tok_ONE_LEVEL)
type = &keymap->map->types[XkbOneLevelIndex];
type = &darray_item(keymap->map->types, XkbOneLevelIndex);
else if (def->name == tok_TWO_LEVEL)
type = &keymap->map->types[XkbTwoLevelIndex];
type = &darray_item(keymap->map->types, XkbTwoLevelIndex);
else if (def->name == tok_ALPHABETIC)
type = &keymap->map->types[XkbAlphabeticIndex];
type = &darray_item(keymap->map->types, XkbAlphabeticIndex);
else if (def->name == tok_KEYPAD)
type = &keymap->map->types[XkbKeypadIndex];
type = &darray_item(keymap->map->types, XkbKeypadIndex);
else
type = next++;

15
src/xkbcomp/symbols.c
View File

@ -1696,18 +1696,17 @@ FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
static bool
FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
{
unsigned n;
unsigned n = 0;
const char *name = xkb_atom_text(keymap->ctx, atom);
struct xkb_key_type *type;
if (keymap && keymap->map && keymap->map->types)
{
for (n = 0; n < keymap->map->num_types; n++)
{
if (strcmp(keymap->map->types[n].name, name) == 0)
{
if (keymap && keymap->map) {
darray_foreach(type, keymap->map->types) {
if (strcmp(type->name, name) == 0) {
*type_rtrn = n;
return true;
}
n++;
}
}
return false;
@ -2005,7 +2004,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 = &keymap->map->types[types[i]];
type = &darray_item(keymap->map->types, types[i]);
if (type->num_levels < key->numLevels[i])
{
if (warningLevel > 0)