Copy these types in so we can extend the vmod size.
Signed-off-by: Daniel Stone <daniel@fooishbar.org>
unsigned char type;
} XkbcAction;
+typedef struct _XkbcMods {
+ uint32_t mask; /* effective mods */
+ uint32_t vmods;
+ uint8_t real_mods;
+} XkbcModsRec, *XkbcModsPtr;
+
+typedef struct _XkbcKTMapEntry {
+ Bool active;
+ uint16_t level;
+ XkbcModsRec mods;
+} XkbcKTMapEntryRec, *XkbcKTMapEntryPtr;
+
typedef struct _XkbcKeyType {
- XkbModsRec mods;
- unsigned char num_levels;
+ XkbcModsRec mods;
+ uint16_t num_levels;
unsigned char map_count;
- XkbKTMapEntryPtr map;
- XkbModsPtr preserve;
+ XkbcKTMapEntryPtr map;
+ XkbcModsPtr preserve;
CARD32 name;
CARD32 *level_names;
} XkbcKeyTypeRec, *XkbcKeyTypePtr;
typedef struct _XkbcCompatMapRec {
XkbcSymInterpretPtr sym_interpret;
- XkbModsRec groups[XkbNumKbdGroups];
+ XkbcModsRec groups[XkbNumKbdGroups];
unsigned short num_si;
unsigned short size_si;
} XkbcCompatMapRec, *XkbcCompatMapPtr;
}
compat->size_si = nSI;
compat->num_si = 0;
- bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(XkbModsRec));
+ bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(XkbcModsRec));
xkb->compat = compat;
return Success;
which = XkbAllCompatMask;
if (which & XkbGroupCompatMask)
- bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(XkbModsRec));
+ bzero(&compat->groups[0], XkbNumKbdGroups * sizeof(XkbcModsRec));
if (which & XkbSymInterpMask) {
if (compat->sym_interpret && (compat->size_si > 0))
*into = *from;
if (from->map && (into->map_count > 0)) {
- into->map = _XkbTypedCalloc(into->map_count, XkbKTMapEntryRec);
+ into->map = _XkbTypedCalloc(into->map_count, XkbcKTMapEntryRec);
if (!into->map)
return BadAlloc;
memcpy(into->map, from->map,
- into->map_count * sizeof(XkbKTMapEntryRec));
+ into->map_count * sizeof(XkbcKTMapEntryRec));
}
if (from->preserve && (into->map_count > 0)) {
- into->preserve = _XkbTypedCalloc(into->map_count, XkbModsRec);
+ into->preserve = _XkbTypedCalloc(into->map_count, XkbcModsRec);
if (!into->preserve)
return BadAlloc;
memcpy(into->preserve, from->preserve,
- into->map_count * sizeof(XkbModsRec));
+ into->map_count * sizeof(XkbcModsRec));
}
if (from->level_names && (into->num_levels > 0)) {
type->map_count = 0;
}
else {
- XkbKTMapEntryRec *prev_map = type->map;
+ XkbcKTMapEntryRec *prev_map = type->map;
if ((map_count > type->map_count) || !type->map)
type->map = _XkbTypedRealloc(type->map, map_count,
- XkbKTMapEntryRec);
+ XkbcKTMapEntryRec);
if (!type->map) {
if (prev_map)
_XkbFree(prev_map);
}
if (want_preserve) {
- XkbModsRec *prev_preserve = type->preserve;
+ XkbcModsRec *prev_preserve = type->preserve;
if ((map_count > type->map_count) || !type->preserve)
type->preserve = _XkbTypedRealloc(type->preserve, map_count,
- XkbModsRec);
+ XkbcModsRec);
if (!type->preserve) {
if (prev_preserve)
_XkbFree(prev_preserve);
#include <X11/keysym.h>
#include <X11/extensions/XKBfilecommon.h>
-#define mapSize(m) (sizeof(m) / sizeof(XkbKTMapEntryRec))
-static XkbKTMapEntryRec map2Level[]= {
+#define mapSize(m) (sizeof(m) / sizeof(XkbcKTMapEntryRec))
+static XkbcKTMapEntryRec map2Level[]= {
{ True, ShiftMask, {1, ShiftMask, 0} }
};
-static XkbKTMapEntryRec mapAlpha[]= {
+static XkbcKTMapEntryRec mapAlpha[]= {
{ True, ShiftMask, { 1, ShiftMask, 0 } },
{ True, LockMask, { 0, LockMask, 0 } }
};
-static XkbModsRec preAlpha[]= {
+static XkbcModsRec preAlpha[]= {
{ 0, 0, 0 },
{ LockMask, LockMask, 0 }
};
#define NL_VMOD_MASK 0
-static XkbKTMapEntryRec mapKeypad[]= {
+static XkbcKTMapEntryRec mapKeypad[]= {
{ True, ShiftMask, { 1, ShiftMask, 0 } },
{ False, 0, { 1, 0, NL_VMOD_MASK } }
};
{
int i;
unsigned tmp;
- XkbKTMapEntryPtr entry = NULL;
+ XkbcKTMapEntryPtr entry = NULL;
if (!xkb || !type || !xkb->server)
return False;
unsigned char fileID;
unsigned char merge;
unsigned char real_mods;
- unsigned short vmods;
+ uint32_t vmods;
} GroupCompatInfo;
typedef struct _CompatInfo
int numLevels;
int nEntries;
int szEntries;
- XkbKTMapEntryPtr entries;
+ XkbcKTMapEntryPtr entries;
PreserveInfo *preserve;
int szNames;
CARD32 *lvlNames;
extern Bool AddMapEntry(XkbcDescPtr /* xkb */ ,
KeyTypeInfo * /* type */ ,
- XkbKTMapEntryPtr /* new */ ,
+ XkbcKTMapEntryPtr /* new */ ,
Bool /* clobber */ ,
Bool /* report */
);
if (from->dflt.entries)
{
info->dflt.entries = uTypedCalloc(from->dflt.szEntries,
- XkbKTMapEntryRec);
+ XkbcKTMapEntryRec);
if (info->dflt.entries)
{
- unsigned sz = from->dflt.nEntries * sizeof(XkbKTMapEntryRec);
+ unsigned sz = from->dflt.nEntries * sizeof(XkbcKTMapEntryRec);
memcpy(info->dflt.entries, from->dflt.entries, sz);
}
}
/***====================================================================***/
-static XkbKTMapEntryPtr
+static XkbcKTMapEntryPtr
FindMatchingMapEntry(KeyTypeInfo * type, unsigned mask, unsigned vmask)
{
register int i;
- XkbKTMapEntryPtr entry;
+ XkbcKTMapEntryPtr entry;
for (i = 0, entry = type->entries; i < type->nEntries; i++, entry++)
{
}
/**
- * Return a pointer to the next free XkbKTMapEntry, reallocating space if
+ * Return a pointer to the next free XkbcKTMapEntry, reallocating space if
* necessary.
*/
-static XkbKTMapEntryPtr
+static XkbcKTMapEntryPtr
NextMapEntry(KeyTypeInfo * type)
{
if (type->entries == NULL)
{
- type->entries = uTypedCalloc(2, XkbKTMapEntryRec);
+ type->entries = uTypedCalloc(2, XkbcKTMapEntryRec);
if (type->entries == NULL)
{
ERROR("Couldn't allocate map entries for %s\n", TypeTxt(type));
type->szEntries *= 2;
type->entries = uTypedRecalloc(type->entries,
type->nEntries, type->szEntries,
- XkbKTMapEntryRec);
+ XkbcKTMapEntryRec);
if (type->entries == NULL)
{
ERROR("Couldn't reallocate map entries for %s\n", TypeTxt(type));
Bool
AddMapEntry(XkbcDescPtr xkb,
KeyTypeInfo * type,
- XkbKTMapEntryPtr new, Bool clobber, Bool report)
+ XkbcKTMapEntryPtr new, Bool clobber, Bool report)
{
- XkbKTMapEntryPtr old;
+ XkbcKTMapEntryPtr old;
if ((old =
FindMatchingMapEntry(type, new->mods.real_mods, new->mods.vmods)))
XkbcDescPtr xkb, ExprDef * arrayNdx, ExprDef * value)
{
ExprResult rtrn;
- XkbKTMapEntryRec entry;
+ XkbcKTMapEntryRec entry;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(type, "map entry");
/* default type */
for (i = 0; i < info->dflt.nEntries; i++)
{
- XkbKTMapEntryPtr dflt;
+ XkbcKTMapEntryPtr dflt;
dflt = &info->dflt.entries[i];
if (((dflt->mods.real_mods & type.mask) == dflt->mods.real_mods) &&
((dflt->mods.vmods & type.vmask) == dflt->mods.vmods))
for (pre = def->preserve; pre != NULL;
pre = (PreserveInfo *) pre->defs.next)
{
- XkbKTMapEntryPtr match;
- XkbKTMapEntryRec tmp;
+ XkbcKTMapEntryPtr match;
+ XkbcKTMapEntryRec tmp;
tmp.mods.real_mods = pre->indexMods;
tmp.mods.vmods = pre->indexVMods;
tmp.level = 0;
type->map = def->entries;
if (def->preserve)
{
- type->preserve = uTypedCalloc(type->map_count, XkbModsRec);
+ type->preserve = uTypedCalloc(type->map_count, XkbcModsRec);
if (!type->preserve)
{
WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");