#include <X11/extensions/XKBstrcommon.h>
#include <X11/extensions/XKBrulescommon.h>
+#define KeySym CARD32
+#define Atom CARD32
+
/* Action structures used in the server */
#define XkbcAnyActionDataSize 18
unsigned char type;
} XkbcAction;
+typedef struct _XkbcSymInterpretRec {
+ CARD32 sym;
+ unsigned char flags;
+ unsigned char match;
+ unsigned char mods;
+ unsigned char virtual_mod;
+ XkbcAnyAction act;
+} XkbcSymInterpretRec,*XkbcSymInterpretPtr;
+
+typedef struct _XkbcCompatMapRec {
+ XkbcSymInterpretPtr sym_interpret;
+ XkbModsRec groups[XkbNumKbdGroups];
+ unsigned short num_si;
+ unsigned short size_si;
+} XkbcCompatMapRec, *XkbcCompatMapPtr;
+
+typedef struct _XkbcClientMapRec {
+ unsigned char size_types;
+ unsigned char num_types;
+ XkbKeyTypePtr types;
+
+ unsigned short size_syms;
+ unsigned short num_syms;
+ uint32_t *syms;
+ XkbSymMapPtr key_sym_map;
+
+ unsigned char *modmap;
+} XkbcClientMapRec, *XkbcClientMapPtr;
+
typedef struct _XkbcServerMapRec {
unsigned short num_acts;
unsigned short size_acts;
XkbControlsPtr ctrls;
XkbcServerMapPtr server;
- XkbClientMapPtr map;
+ XkbcClientMapPtr map;
XkbIndicatorPtr indicators;
XkbNamesPtr names;
XkbCompatMapPtr compat;
* The string returned may become invalidated after the next call to
* XkbcKeysymToString: if you need to preserve it, then you must
* duplicate it.
+ *
+ * This is CARD32 rather than KeySym, as KeySym changes size between
+ * client and server (no, really).
*/
extern char *
-XkbcKeysymToString(KeySym ks);
+XkbcKeysymToString(CARD32 ks);
/*
* See XkbcKeysymToString comments: this function will accept any string
* from that function.
*/
-extern KeySym
+extern CARD32
XkbcStringToKeysym(const char *s);
_XFUNCPROTOEND
+#undef KeySym
+#undef Atom
+
#endif /* _XKBCOMMON_H_ */
type = xkb->map->types;
for (i = 0; i < xkb->map->num_types; i++, type++) {
if (!type->level_names) {
- type->level_names = _XkbTypedCalloc(type->num_levels, Atom);
+ type->level_names = _XkbTypedCalloc(type->num_levels, CARD32);
if (!type->level_names)
return BadAlloc;
}
if ((which & XkbRGNamesMask) && (nTotalRG > 0)) {
if (!names->radio_groups)
- names->radio_groups = _XkbTypedCalloc(nTotalRG, Atom);
+ names->radio_groups = _XkbTypedCalloc(nTotalRG, CARD32);
else if (nTotalRG > names->num_rg) {
- Atom *prev_radio_groups = names->radio_groups;
+ CARD32 *prev_radio_groups = names->radio_groups;
names->radio_groups = _XkbTypedRealloc(names->radio_groups,
- nTotalRG, Atom);
+ nTotalRG, CARD32);
if (names->radio_groups)
_XkbClearElems(names->radio_groups, names->num_rg,
- nTotalRG - 1, Atom);
+ nTotalRG - 1, CARD32);
else
_XkbFree(prev_radio_groups);
}
which = XkbAllNamesMask;
if (which & XkbKTLevelNamesMask) {
- XkbClientMapPtr map = xkb->map;
+ XkbcClientMapPtr map = xkb->map;
if (map && map->types) {
int i;
#include "ks_tables.h"
char *
-XkbcKeysymToString(KeySym ks)
+XkbcKeysymToString(CARD32 ks)
{
int i, n, h, idx;
const unsigned char *entry;
return ret;
}
-KeySym
+CARD32
XkbcStringToKeysym(const char *s)
{
int i, n, h, c, idx;
const char *p = s;
const unsigned char *entry;
unsigned char sig1, sig2;
- KeySym val;
+ CARD32 val;
while ((c = *p++))
sig = (sig << 1) + c;
XkbcAllocClientMap(XkbcDescPtr xkb, unsigned which, unsigned nTotalTypes)
{
int i;
- XkbClientMapPtr map;
+ XkbcClientMapPtr map;
if (!xkb || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
return BadValue;
}
if (!xkb->map) {
- map = _XkbTypedCalloc(1, XkbClientMapRec);
+ map = _XkbTypedCalloc(1, XkbcClientMapRec);
if (!map)
return BadAlloc;
xkb->map = map;
if (!map->syms) {
map->size_syms = (nKeys * 15) / 10;
- map->syms = _XkbTypedCalloc(map->size_syms, KeySym);
+ map->syms = _XkbTypedCalloc(map->size_syms, uint32_t);
if (!map->syms) {
map->size_syms = 0;
return BadAlloc;
}
if (from->level_names && (into->num_levels > 0)) {
- into->level_names = _XkbTypedCalloc(into->num_levels, Atom);
+ into->level_names = _XkbTypedCalloc(into->num_levels, CARD32);
if (!into->level_names)
return BadAlloc;
memcpy(into->level_names, from->level_names,
- into->num_levels * sizeof(Atom));
+ into->num_levels * sizeof(CARD32));
}
return Success;
}
if ((new_num_lvls > type->num_levels) || !type->level_names) {
- Atom *prev_level_names = type->level_names;
+ CARD32 *prev_level_names = type->level_names;
type->level_names = _XkbTypedRealloc(type->level_names, new_num_lvls,
- Atom);
+ CARD32);
if (!type->level_names) {
if (prev_level_names)
_XkbFree(prev_level_names);
nMatchingKeys = 0;
if (new_num_lvls > type->num_levels) {
int nTotal;
- KeySym *newSyms;
+ CARD32 *newSyms;
int width, match, nResize = 0;
int i, g, nSyms;
int nextMatch;
xkb->map->size_syms = (nTotal * 12) / 10;
- newSyms = _XkbTypedCalloc(xkb->map->size_syms, KeySym);
+ newSyms = _XkbTypedCalloc(xkb->map->size_syms, CARD32);
if (!newSyms)
return BadAlloc;
nextMatch = 0;
for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
if (matchingKeys[nextMatch] == i) {
- KeySym *pOld;
+ CARD32 *pOld;
nextMatch++;
width = XkbKeyGroupsWidth(xkb, i);
pOld = XkbKeySymsPtr(xkb, i);
for (g = XkbKeyNumGroups(xkb, i) - 1; g >= 0; g--)
memcpy(&newSyms[nSyms+(new_num_lvls * g)],
- &pOld[width * g], width * sizeof(KeySym));
+ &pOld[width * g], width * sizeof(CARD32));
xkb->map->key_sym_map[i].offset = nSyms;
nSyms += XkbKeyNumGroups(xkb, i) * new_num_lvls;
}
else {
memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
- XkbKeyNumSyms(xkb, i) * sizeof(KeySym));
+ XkbKeyNumSyms(xkb, i) * sizeof(CARD32));
xkb->map->key_sym_map[i].offset = nSyms;
nSyms += XkbKeyNumSyms(xkb,i);
}
firstClear = new_num_lvls;
for (i = 0; i < nMatchingKeys; i++) {
- KeySym *pSyms;
+ CARD32 *pSyms;
int width, nClear;
key = matchingKeys[i];
if (XkbKeyKeyTypeIndex(xkb, key, g) == type_ndx) {
if (nClear>0)
bzero(&pSyms[g * width + firstClear],
- nClear * sizeof(KeySym));
+ nClear * sizeof(CARD32));
}
}
}
return Success;
}
-KeySym *
+CARD32 *
XkbcResizeKeySyms(XkbcDescPtr xkb, int key, int needed)
{
int i, nSyms, nKeySyms;
unsigned nOldSyms;
- KeySym *newSyms;
+ CARD32 *newSyms;
if (needed == 0) {
xkb->map->key_sym_map[key].offset = 0;
if (xkb->map->size_syms - xkb->map->num_syms >= (unsigned)needed) {
if (nOldSyms > 0)
memcpy(&xkb->map->syms[xkb->map->num_syms],
- XkbKeySymsPtr(xkb, key), nOldSyms * sizeof(KeySym));
+ XkbKeySymsPtr(xkb, key), nOldSyms * sizeof(CARD32));
if ((needed - nOldSyms) > 0)
bzero(&xkb->map->syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)],
- (needed - nOldSyms) * sizeof(KeySym));
+ (needed - nOldSyms) * sizeof(CARD32));
xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
xkb->map->num_syms += needed;
}
xkb->map->size_syms += (needed > 32 ? needed : 32);
- newSyms = _XkbTypedCalloc(xkb->map->size_syms, KeySym);
+ newSyms = _XkbTypedCalloc(xkb->map->size_syms, CARD32);
if (!newSyms)
return NULL;
nKeySyms = needed;
if (nCopy != 0)
memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
- nCopy * sizeof(KeySym));
+ nCopy * sizeof(CARD32));
if (nKeySyms > nCopy)
- bzero(&newSyms[nSyms+nCopy], (nKeySyms - nCopy) * sizeof(KeySym));
+ bzero(&newSyms[nSyms+nCopy], (nKeySyms - nCopy) * sizeof(CARD32));
xkb->map->key_sym_map[i].offset = nSyms;
nSyms += nKeySyms;
void
XkbcFreeClientMap(XkbcDescPtr xkb, unsigned what, Bool freeMap)
{
- XkbClientMapPtr map;
+ XkbcClientMapPtr map;
if (!xkb || !xkb->map)
return;
int
XkbcInitCanonicalKeyTypes(XkbcDescPtr xkb, unsigned which, int keypadVMod)
{
- XkbClientMapPtr map;
+ XkbcClientMapPtr map;
XkbKeyTypePtr from,to;
int rtrn;
}
unsigned
-_XkbcKSCheckCase(KeySym ks)
+_XkbcKSCheckCase(CARD32 ks)
{
unsigned set = (ks & (~0xff)) >> 8;
unsigned rtrn = 0;
XkbcVModIndexText(XkbcDescPtr xkb, unsigned ndx)
{
int len;
- Atom *vmodNames;
+ CARD32 *vmodNames;
char *rtrn, *tmp = NULL;
if (xkb && xkb->names)
}
char *
-XkbcKeysymText(KeySym sym)
+XkbcKeysymText(CARD32 sym)
{
return XkbcKeysymToString(sym);
}
XkbcResizeKeyType(XkbcDescPtr xkb, int type_ndx, int map_count,
Bool want_preserve, int new_num_lvls);
-extern KeySym *
+extern CARD32 *
XkbcResizeKeySyms(XkbcDescPtr xkb, int key, int needed);
extern int
IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
- KeySym sym;
+ CARD32 sym;
if (expr->op == ExprIdent)
{
type->name = (Atom) def->name;
if (def->szNames > 0)
{
- type->level_names = uTypedCalloc(def->numLevels, Atom);
+ type->level_names = uTypedCalloc(def->numLevels, CARD32);
/* assert def->szNames<=def->numLevels */
for (i = 0; i < def->szNames; i++)
{
- type->level_names[i] = (Atom) def->lvlNames[i];
+ type->level_names[i] = (CARD32) def->lvlNames[i];
}
}
else
typedef struct _KeyNameDesc
{
- KeySym level1;
- KeySym level2;
+ CARD32 level1;
+ CARD32 level2;
char name[5];
Bool used;
} KeyNameDesc;
int rtrn;
register int i, tmp, nUnknown;
KeyNameDesc *name;
- KeySym *syms;
+ uint32_t *syms;
if ((xkb->names == NULL) || (xkb->names->keys == NULL))
{
}
InterpDef *
-InterpCreate(KeySym sym, ExprDef * match)
+InterpCreate(CARD32 sym, ExprDef * match)
{
InterpDef *def;
}
int
-LookupKeysym(char *str, KeySym * sym_rtrn)
+LookupKeysym(char *str, CARD32 * sym_rtrn)
{
- KeySym sym;
+ CARD32 sym;
if ((!str) || (uStrCaseCmp(str, "any") == 0)
|| (uStrCaseCmp(str, "nosymbol") == 0))
unsigned /* set */
);
-extern InterpDef *InterpCreate(KeySym /* sym */ ,
+extern InterpDef *InterpCreate(CARD32 /* sym */ ,
ExprDef * /* match */
);
);
extern int LookupKeysym(char * /* str */ ,
- KeySym * /* sym_rtrn */
+ CARD32 * /* sym_rtrn */
);
extern IncludeStmt *IncludeCreate(char * /* str */ ,
unsigned char symsDefined;
unsigned char actsDefined;
short numLevels[XkbNumKbdGroups];
- KeySym *syms[XkbNumKbdGroups];
+ CARD32 *syms[XkbNumKbdGroups];
XkbcAction *acts[XkbNumKbdGroups];
Atom types[XkbNumKbdGroups];
unsigned repeat;
width = new->numLevels[i];
if (old->syms[i] != NULL)
{
- new->syms[i] = uTypedCalloc(width, KeySym);
+ new->syms[i] = uTypedCalloc(width, CARD32);
if (!new->syms[i])
{
new->syms[i] = NULL;
return False;
}
memcpy((char *) new->syms[i], (char *) old->syms[i],
- width * sizeof(KeySym));
+ width * sizeof(CARD32));
}
if (old->acts[i] != NULL)
{
union
{
unsigned long keyName;
- KeySym keySym;
+ CARD32 keySym;
} u;
} ModMapEntry;
{
key->syms[group] = uTypedRecalloc(key->syms[group],
key->numLevels[group], newWidth,
- KeySym);
+ CARD32);
if (!key->syms[group])
return False;
}
MergeKeyGroups(SymbolsInfo * info,
KeyInfo * into, KeyInfo * from, unsigned group)
{
- KeySym *resultSyms;
+ CARD32 *resultSyms;
XkbcAction *resultActs;
int resultWidth;
register int i;
}
if (resultSyms == NULL)
{
- resultSyms = uTypedCalloc(resultWidth, KeySym);
+ resultSyms = uTypedCalloc(resultWidth, CARD32);
if (!resultSyms)
{
WSGO("Could not allocate symbols for group merge\n");
}
for (i = 0; i < resultWidth; i++)
{
- KeySym fromSym, toSym;
+ CARD32 fromSym, toSym;
if (from->syms[group] && (i < from->numLevels[group]))
fromSym = from->syms[group][i];
else
resultSyms[i] = fromSym;
else
{
- KeySym use, ignore;
+ CARD32 use, ignore;
if (clobber)
{
use = fromSym;
key->numLevels[i] = 0;
if (key->syms[i] != NULL)
uFree(key->syms[i]);
- key->syms[i] = (KeySym *) NULL;
+ key->syms[i] = (CARD32 *) NULL;
if (key->acts[i] != NULL)
uFree(key->acts[i]);
key->acts[i] = (XkbcAction *) NULL;
key->numLevels[group] = key->numLevels[0];
key->numLevels[0] = 0;
key->syms[group] = key->syms[0];
- key->syms[0] = (KeySym *) NULL;
+ key->syms[0] = (CARD32 *) NULL;
key->acts[group] = key->acts[0];
key->acts[0] = (XkbcAction *) NULL;
key->types[group] = key->types[0];
}
static Bool
-FindKeyForSymbol(XkbcDescPtr xkb, KeySym sym, unsigned int *kc_rtrn)
+FindKeyForSymbol(XkbcDescPtr xkb, CARD32 sym, unsigned int *kc_rtrn)
{
register int i, j;
register Bool gotOne;
* @returns True if a type could be found, False otherwise.
*/
static Bool
-FindAutomaticType(int width, KeySym * syms, Atom * typeNameRtrn,
+FindAutomaticType(int width, CARD32 * syms, Atom * typeNameRtrn,
Bool * autoType)
{
*autoType = False;
}
if ((key->symsDefined & 1) && key->syms[0])
{
- key->syms[i] = uTypedCalloc(width, KeySym);
+ key->syms[i] = uTypedCalloc(width, CARD32);
if (key->syms[i] == NULL)
continue;
memcpy((void *) key->syms[i], (void *) key->syms[0],
- width * sizeof(KeySym));
+ width * sizeof(CARD32));
key->symsDefined |= 1 << i;
}
if (defined & 1)
if ((key->syms[i] != key->syms[0]) &&
(key->syms[i] == NULL || key->syms[0] == NULL ||
memcmp((void *) key->syms[i], (void *) key->syms[0],
- sizeof(KeySym) * key->numLevels[0])))
+ sizeof(CARD32) * key->numLevels[0])))
{
identical = False;
break;
key->numLevels[i] = 0;
if (key->syms[i] != NULL)
uFree(key->syms[i]);
- key->syms[i] = (KeySym *) NULL;
+ key->syms[i] = (CARD32 *) NULL;
if (key->acts[i] != NULL)
uFree(key->acts[i]);
key->acts[i] = (XkbcAction *) NULL;
unsigned okc, kc, width, tmp, nGroups;
XkbKeyTypePtr type;
Bool haveActions, autoType, useAlias;
- KeySym *outSyms;
+ CARD32 *outSyms;
XkbcAction *outActs;
unsigned types[XkbNumKbdGroups];
{
ParseCommon common;
unsigned merge;
- KeySym sym;
+ CARD32 sym;
ExprDef *match;
VarDef *def;
} InterpDef;
XkbcEnsureSafeMapName(char *name);
extern unsigned
-_XkbcKSCheckCase(KeySym sym);
+_XkbcKSCheckCase(CARD32 sym);
#define XkbcKSIsLower(k) (_XkbcKSCheckCase(k) & _XkbKSLower)
#define XkbcKSIsUpper(k) (_XkbcKSCheckCase(k) & _XkbKSUpper)
XkbcActionTypeText(unsigned type);
extern char *
-XkbcKeysymText(KeySym sym);
+XkbcKeysymText(CARD32 sym);
extern char *
XkbcKeyNameText(char *name);