return True;
}
}
- if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (char *) xkb))
return ReportMismatch(action, F_Modifiers, "modifier mask");
*mods_rtrn = rtrn.uval;
*flags_inout &= ~XkbSA_UseModMapMods;
spec = value;
}
- if (!ExprResolveInteger(spec, &rtrn, SimpleLookup, (XPointer) groupNames))
+ if (!ExprResolveInteger(spec, &rtrn, SimpleLookup, (char *) groupNames))
return ReportMismatch(action, F_Group, "integer (range 1..8)");
if ((rtrn.ival < 1) || (rtrn.ival > XkbNumKbdGroups))
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
if (!ExprResolveInteger
- (value, &rtrn, SimpleLookup, (XPointer) btnNames))
+ (value, &rtrn, SimpleLookup, (char *) btnNames))
return ReportMismatch(action->type, field,
"integer (range 1..5)");
if ((rtrn.ival < 0) || (rtrn.ival > 5))
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
if (!ExprResolveInteger
- (value, &rtrn, SimpleLookup, (XPointer) btnNames))
+ (value, &rtrn, SimpleLookup, (char *) btnNames))
return ReportMismatch(action->type, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
}
if (!ExprResolveInteger
- (btn, &rtrn, SimpleLookup, (XPointer) btnNames))
+ (btn, &rtrn, SimpleLookup, (char *) btnNames))
return ReportMismatch(action->type, field,
"integer (range 1..5)");
if ((rtrn.ival < 0) || (rtrn.ival > 5))
case F_Affect:
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveMask(value, &rtrn, SimpleLookup, (XPointer) isoNames))
+ if (!ExprResolveMask(value, &rtrn, SimpleLookup, (char *) isoNames))
return ReportMismatch(action->type, field, "keyboard component");
act->affect = (~rtrn.uval) & XkbSA_ISOAffectMask;
return True;
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
if (!ExprResolveMask
- (value, &rtrn, SimpleLookup, (XPointer) ctrlNames))
+ (value, &rtrn, SimpleLookup, (char *) ctrlNames))
return ReportMismatch(action->type, field, "controls mask");
XkbActionSetCtrls(act, rtrn.uval);
return True;
case F_Report:
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveMask(value, &rtrn, SimpleLookup, (XPointer) evNames))
+ if (!ExprResolveMask(value, &rtrn, SimpleLookup, (char *) evNames))
return ReportMismatch(action->type, field, "key event mask");
act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
act->flags =
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
if (!ExprResolveInteger
- (value, &rtrn, SimpleLookup, (XPointer) btnNames))
+ (value, &rtrn, SimpleLookup, (char *) btnNames))
return ReportMismatch(action->type, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
}
tmp.fileID = info->fileID;
tmp.merge = merge;
- if (!ExprResolveModMask(def->def, &val, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(def->def, &val, LookupVModMask, (char *) xkb))
{
ERROR("Expected a modifier mask in group compatibility definition\n");
ACTION1("Ignoring illegal compatibility map for group %d\n",
}
Bool
-SimpleLookup(XPointer priv,
+SimpleLookup(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
LookupEntry *entry;
}
Bool
-RadioLookup(XPointer priv,
+RadioLookup(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
register char *str;
}
int
-TableLookup(XPointer priv,
+TableLookup(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
LookupTable *tbl = (LookupTable *) priv;
}
if (tbl == NULL) /* didn't find a matching element */
return False;
- priv = (XPointer) tbl->entries;
+ priv = (char *) tbl->entries;
return SimpleLookup(priv, (Atom) None, field, type, val_rtrn);
}
};
int
-LookupModIndex(XPointer priv,
+LookupModIndex(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
- return SimpleLookup((XPointer) modIndexNames, elem, field, type,
+ return SimpleLookup((char *) modIndexNames, elem, field, type,
val_rtrn);
}
int
-LookupModMask(XPointer priv,
+LookupModMask(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
char *str;
int
ExprResolveModIndex(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
char *bogus = NULL;
int
ExprResolveModMask(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
LookupPriv priv;
priv.priv = NULL;
priv.chain = lookup;
priv.chainPriv = lookupPriv;
- return ExprResolveMask(expr, val_rtrn, LookupModMask, (XPointer) & priv);
+ return ExprResolveMask(expr, val_rtrn, LookupModMask, (char *) & priv);
}
int
ExprResolveBoolean(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
char *bogus = NULL;
int
ExprResolveFloat(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
int
ExprResolveInteger(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
int
ExprResolveString(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
int
ExprResolveKeyName(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
ExprDef *left;
exprOpText(expr->op));
return False;
}
- if (!SimpleLookup((XPointer) values, (Atom) None, expr->value.str,
+ if (!SimpleLookup((char *) values, (Atom) None, expr->value.str,
(unsigned) TypeInt, val_rtrn))
{
int nOut = 0;
int
ExprResolveMask(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
int
ExprResolveKeySym(ExprDef * expr,
ExprResult * val_rtrn,
- IdentLookupFunc lookup, XPointer lookupPriv)
+ IdentLookupFunc lookup, char * lookupPriv)
{
int ok = 0;
KeySym sym;
XkbKeyNameRec keyName;
} ExprResult;
-typedef Bool(*IdentLookupFunc) (XPointer /* priv */ ,
+typedef Bool(*IdentLookupFunc) (char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
typedef struct _LookupPriv
{
- XPointer priv;
+ char * priv;
IdentLookupFunc chain;
- XPointer chainPriv;
+ char * chainPriv;
} LookupPriv;
typedef struct _LookupEntry
extern char *exprOpText(unsigned /* type */
);
-extern int RadioLookup(XPointer /* priv */ ,
+extern int RadioLookup(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
ExprResult * /* val_rtrn */
);
-extern int SimpleLookup(XPointer /* priv */ ,
+extern int SimpleLookup(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
ExprResult * /* val_rtrn */
);
-extern int TableLookup(XPointer /* priv */ ,
+extern int TableLookup(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
ExprResult * /* val_rtrn */
);
-extern int LookupModIndex(XPointer /* priv */ ,
+extern int LookupModIndex(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
ExprResult * /* val_rtrn */
);
-extern int LookupModMask(XPointer /* priv */ ,
+extern int LookupModMask(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
extern int ExprResolveModIndex(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveModMask(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* priv */
+ char * /* priv */
);
extern int ExprResolveBoolean(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveInteger(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveFloat(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveString(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveKeyName(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveEnum(ExprDef * /* expr */ ,
extern int ExprResolveMask(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
extern int ExprResolveKeySym(ExprDef * /* expr */ ,
ExprResult * /* val_rtrn */ ,
IdentLookupFunc /* lookup */ ,
- XPointer /* lookupPriv */
+ char * /* lookupPriv */
);
#endif /* EXPR_H */
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
- if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (char *) xkb))
return ReportIndicatorBadType(xkb->dpy, led, field,
"modifier mask");
led->real_mods = rtrn.uval & 0xff;
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask
- (value, &rtrn, SimpleLookup, (XPointer) groupNames))
+ (value, &rtrn, SimpleLookup, (char *) groupNames))
return ReportIndicatorBadType(xkb->dpy, led, field, "group mask");
led->groups = rtrn.uval;
led->defs.defined |= _LED_Groups;
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask
- (value, &rtrn, SimpleLookup, (XPointer) ctrlNames))
+ (value, &rtrn, SimpleLookup, (char *) ctrlNames))
return ReportIndicatorBadType(xkb->dpy, led, field,
"controls mask");
led->ctrls = rtrn.uval;
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask(value, &rtrn, SimpleLookup,
- (XPointer) modComponentNames))
+ (char *) modComponentNames))
{
return ReportIndicatorBadType(xkb->dpy, led, field,
"mask of modifier state components");
if (arrayNdx != NULL)
return ReportIndicatorNotArray(xkb->dpy, led, field);
if (!ExprResolveMask(value, &rtrn, SimpleLookup,
- (XPointer) groupComponentNames))
+ (char *) groupComponentNames))
{
return ReportIndicatorBadType(xkb->dpy, led, field,
"mask of group state components");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(type, "map entry");
- if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (char *) xkb))
return ReportTypeBadType(type, "map entry", "modifier mask");
entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */
entry.mods.real_mods &= type->mask;
entry.mods.vmods &= type->vmask;
}
- if (!ExprResolveInteger(value, &rtrn, SimpleLookup, (XPointer) lnames))
+ if (!ExprResolveInteger(value, &rtrn, SimpleLookup, (char *) lnames))
{
ERROR("Level specifications in a key type must be integer\n");
ACTION("Ignoring malformed level specification\n");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(type, "preserve entry");
- if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(arrayNdx, &rtrn, LookupVModMask, (char *) xkb))
return ReportTypeBadType(type, "preserve entry", "modifier mask");
new.defs = type->defs;
new.defs.next = NULL;
if (warningLevel > 0)
INFO1("%s\n", PreserveIndexTxt(type, xkb, &new));
}
- if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(value, &rtrn, LookupVModMask, (char *) xkb))
{
ERROR("Preserve value in a key type is not a modifier mask\n");
ACTION2("Ignoring preserve[%s] in type %s\n",
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(type, "level name");
- if (!ExprResolveInteger(arrayNdx, &rtrn, SimpleLookup, (XPointer) lnames))
+ if (!ExprResolveInteger(arrayNdx, &rtrn, SimpleLookup, (char *) lnames))
return ReportTypeBadType(type, "level name", "integer");
if ((rtrn.ival < 1) || (rtrn.ival > XkbMaxShiftLevel + 1))
{
ACTION("Illegal array subscript ignored\n");
}
/* get modifier mask for current type */
- if (!ExprResolveModMask(value, &tmp, LookupVModMask, (XPointer) xkb))
+ if (!ExprResolveModMask(value, &tmp, LookupVModMask, (char *) xkb))
{
ERROR("Key type mask field must be a modifier mask\n");
ACTION("Key type definition ignored\n");
return False;
}
-XPointer
+char *
ClearCommonInfo(CommonInfo * cmn)
{
if (cmn != NULL)
return NULL;
}
-XPointer
+char *
AddCommonInfo(CommonInfo * old, CommonInfo * new)
{
CommonInfo *first;
if (old)
{
old->next = new;
- return (XPointer) first;
+ return (char *) first;
}
- return (XPointer) new;
+ return (char *) new;
}
/***====================================================================***/
unsigned * /* pCollide */
);
-extern XPointer ClearCommonInfo(CommonInfo * /* cmn */
+extern char * ClearCommonInfo(CommonInfo * /* cmn */
);
-extern XPointer AddCommonInfo(CommonInfo * /* old */ ,
+extern char * AddCommonInfo(CommonInfo * /* old */ ,
CommonInfo * /* new */
);
return False;
}
if (!ExprResolveInteger
- (arrayNdx, &tmp, SimpleLookup, (XPointer) groupNames))
+ (arrayNdx, &tmp, SimpleLookup, (char *) groupNames))
{
ERROR2("Illegal group index for %s of key %s\n", name,
longText(key->name, XkbMessage));
key->defs.defined |= _Key_Type_Dflt;
}
else if (!ExprResolveInteger(arrayNdx, &ndx, SimpleLookup,
- (XPointer) groupNames))
+ (char *) groupNames))
{
ERROR1("Illegal group index for type of key %s\n",
longText(key->name, XkbMessage));
(uStrCaseCmp(field, "virtualmods") == 0) ||
(uStrCaseCmp(field, "virtualmodifiers") == 0))
{
- ok = ExprResolveModMask(value, &tmp, LookupVModMask, (XPointer) xkb);
+ ok = ExprResolveModMask(value, &tmp, LookupVModMask, (char *) xkb);
if (ok)
{
key->vmodmap = (tmp.uval >> 8);
if (uStrCaseCmp(field, "permanentradiogroup") == 0)
permanent = True;
ok = ExprResolveInteger(value, &tmp, SimpleLookup,
- (XPointer) rgEntries);
+ (char *) rgEntries);
if (!ok)
{
ERROR1("Illegal radio group specification for %s\n",
(uStrCaseCmp(field, "redirectgroups") == 0))
{
if (!ExprResolveInteger
- (value, &tmp, SimpleLookup, (XPointer) groupNames))
+ (value, &tmp, SimpleLookup, (char *) groupNames))
{
ERROR1("Illegal group index for redirect of key %s\n",
longText(key->name, XkbMessage));
return False;
}
if (!ExprResolveInteger
- (arrayNdx, &tmp, SimpleLookup, (XPointer) groupNames))
+ (arrayNdx, &tmp, SimpleLookup, (char *) groupNames))
{
ERROR("Illegal index in group name definition\n");
ACTION("Definition with non-integer array index ignored\n");
|| (uStrCaseCmp(field.str, "redirectgroups") == 0)))
{
if (!ExprResolveInteger(stmt->value, &tmp,
- SimpleLookup, (XPointer) groupNames))
+ SimpleLookup, (char *) groupNames))
{
ERROR("Illegal group index for global groupsRedirect\n");
ACTION("Definition with non-integer group ignored\n");
* undefined.
*/
int
-LookupVModIndex(XPointer priv,
+LookupVModIndex(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
register int i;
* undefined.
*/
int
-LookupVModMask(XPointer priv,
+LookupVModMask(char * priv,
Atom elem, Atom field, unsigned type, ExprResult * val_rtrn)
{
if (LookupVModIndex(priv, elem, field, type, val_rtrn))
ExprResult rtrn;
name = XkbInternAtom(xkb->dpy, "NumLock", False);
- if ((xkb) && LookupVModIndex((XPointer) xkb, None, name, TypeInt, &rtrn))
+ if ((xkb) && LookupVModIndex((char *) xkb, None, name, TypeInt, &rtrn))
{
return rtrn.ival;
}
XkbcDescPtr /* xkb */
);
-extern int LookupVModIndex(XPointer /* priv */ ,
+extern int LookupVModIndex(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,
ExprResult * /* val_rtrn */
);
-extern int LookupVModMask(XPointer /* priv */ ,
+extern int LookupVModMask(char * /* priv */ ,
Atom /* elem */ ,
Atom /* field */ ,
unsigned /* type */ ,