And rename the function to xkb_atom_text.
Signed-off-by: Ran Benita <ran234@gmail.com>
[daniels: Updated for xkb -> keymap.]
static NodePtr *nodeTable;
const char *
-XkbcAtomText(xkb_atom_t atom)
+xkb_atom_text(struct xkb_context *context, xkb_atom_t atom)
{
NodePtr node;
char *
xkb_atom_strdup(struct xkb_context *context, xkb_atom_t atom)
{
- const char *ret = XkbcAtomText(atom);
+ const char *ret = xkb_atom_text(context, atom);
return ret ? strdup(ret) : NULL;
}
xkb_atom_strdup(struct xkb_context *context, xkb_atom_t atom);
extern const char *
-XkbcAtomText(xkb_atom_t atm);
+xkb_atom_text(struct xkb_context *context, xkb_atom_t atom);
extern void
XkbcFreeAllAtoms(void);
}
static bool
-CheckLatchLockFlags(unsigned action,
+CheckLatchLockFlags(struct xkb_keymap *keymap, unsigned action,
unsigned field, ExprDef * value, unsigned *flags_inout)
{
unsigned tmp;
tmp = XkbSA_LatchToLock;
else
return false; /* WSGO! */
- if (!ExprResolveBoolean(value, &result))
+ if (!ExprResolveBoolean(keymap->context, value, &result))
return ReportMismatch(action, field, "boolean");
if (result.uval)
*flags_inout |= tmp;
if (value->op == ExprIdent)
{
const char *valStr;
- valStr = XkbcAtomText(value->value.str);
+ valStr = xkb_atom_text(keymap->context, value->value.str);
if (valStr && ((strcasecmp(valStr, "usemodmapmods") == 0) ||
(strcasecmp(valStr, "modmapmods") == 0)))
{
case F_ClearLocks:
case F_LatchToLock:
rtrn = act->flags;
- if (CheckLatchLockFlags(action->type, field, value, &rtrn))
+ if (CheckLatchLockFlags(keymap, action->type, field, value, &rtrn))
{
act->flags = rtrn;
return true;
}
static bool
-CheckGroupField(unsigned action,
+CheckGroupField(struct xkb_keymap *keymap, unsigned action,
ExprDef * value, unsigned *flags_inout, int *grp_rtrn)
{
ExprDef *spec;
spec = value;
}
- if (!ExprResolveGroup(spec, &rtrn))
+ if (!ExprResolveGroup(keymap->context, spec, &rtrn))
return ReportMismatch(action, F_Group, "integer (range 1..8)");
if (value->op == OpNegate)
*grp_rtrn = -rtrn.ival;
case F_ClearLocks:
case F_LatchToLock:
rtrn = act->flags;
- if (CheckLatchLockFlags(action->type, field, value, &rtrn))
+ if (CheckLatchLockFlags(keymap, action->type, field, value, &rtrn))
{
act->flags = rtrn;
return true;
return false;
case F_Group:
t1 = act->flags;
- if (CheckGroupField(action->type, value, &t1, &t2))
+ if (CheckGroupField(keymap, action->type, value, &t1, &t2))
{
act->flags = t1;
act->group = t2;
if (field == F_Group)
{
t1 = act->flags;
- if (CheckGroupField(action->type, value, &t1, &t2))
+ if (CheckGroupField(keymap, action->type, value, &t1, &t2))
{
act->flags = t1;
act->group = t2;
absolute = false;
else
absolute = true;
- if (!ExprResolveInteger(value, &rtrn))
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "integer");
if (field == F_X)
{
}
else if (field == F_Accel)
{
- if (!ExprResolveBoolean(value, &rtrn))
+ if (!ExprResolveBoolean(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "boolean");
if (rtrn.uval)
act->flags &= ~XkbSA_NoAcceleration;
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveButton(value, &rtrn))
+ if (!ExprResolveButton(keymap->context, value, &rtrn))
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 (!ExprResolveEnum(value, &rtrn, lockWhich))
+ if (!ExprResolveEnum(keymap->context, value, &rtrn, lockWhich))
return ReportMismatch(action->type, field, "lock or unlock");
act->flags &= ~(XkbSA_LockNoLock | XkbSA_LockNoUnlock);
act->flags |= rtrn.ival;
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveButton(value, &rtrn))
+ if (!ExprResolveButton(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveEnum(value, &rtrn, ptrDflts))
+ if (!ExprResolveEnum(keymap->context, value, &rtrn, ptrDflts))
return ReportMismatch(action->type, field, "pointer component");
act->affect = rtrn.uval;
return true;
btn = value;
}
- if (!ExprResolveButton(btn, &rtrn))
+ if (!ExprResolveButton(keymap->context, btn, &rtrn))
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);
flags = act->flags;
- if (CheckGroupField(action->type, value, &flags, &group))
+ if (CheckGroupField(keymap, action->type, value, &flags, &group))
{
act->flags = flags | XkbSA_ISODfltIsGroup;
act->group = group;
case F_Affect:
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveMask(value, &rtrn, isoNames))
+ if (!ExprResolveMask(keymap->context, value, &rtrn, isoNames))
return ReportMismatch(action->type, field, "keyboard component");
act->affect = (~rtrn.uval) & XkbSA_ISOAffectMask;
return true;
scrn = value;
}
- if (!ExprResolveInteger(scrn, &rtrn))
+ if (!ExprResolveInteger(keymap->context, scrn, &rtrn))
return ReportMismatch(action->type, field, "integer (0..255)");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveBoolean(value, &rtrn))
+ if (!ExprResolveBoolean(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "boolean");
if (rtrn.uval)
act->flags &= ~XkbSA_SwitchApplication;
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveMask(value, &rtrn, ctrlNames))
+ if (!ExprResolveMask(keymap->context, value, &rtrn, ctrlNames))
return ReportMismatch(action->type, field, "controls mask");
act->ctrls = rtrn.uval;
return true;
case F_Report:
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveMask(value, &rtrn, evNames))
+ if (!ExprResolveMask(keymap->context, value, &rtrn, evNames))
return ReportMismatch(action->type, field, "key event mask");
act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
act->flags =
case F_GenKeyEvent:
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveBoolean(value, &rtrn))
+ if (!ExprResolveBoolean(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "boolean");
if (rtrn.uval)
act->flags |= XkbSA_MessageGenKeyEvent;
case F_Data:
if (array_ndx == NULL)
{
- if (!ExprResolveString(keymap, value, &rtrn))
+ if (!ExprResolveString(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "string");
else
{
else
{
unsigned ndx;
- if (!ExprResolveInteger(array_ndx, &rtrn))
+ if (!ExprResolveInteger(keymap->context, array_ndx, &rtrn))
{
ERROR("Array subscript must be integer\n");
ACTION("Illegal subscript ignored\n");
ACTION("Attempt to use data[%d] ignored\n", ndx);
return false;
}
- if (!ExprResolveInteger(value, &rtrn))
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
switch (field)
{
case F_Keycode:
- if (!ExprResolveKeyName(value, &rtrn))
+ if (!ExprResolveKeyName(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "key name");
tmp = KeyNameToLong(rtrn.keyName.name);
if (!FindNamedKey(keymap, tmp, &kc, true, CreateKeyNames(keymap), 0))
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveInteger(value, &rtrn))
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field,
"integer (range 1..255)");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveEnum(value, &rtrn, lockWhich))
+ if (!ExprResolveEnum(keymap->context, value, &rtrn, lockWhich))
return ReportMismatch(action->type, field, "lock or unlock");
act->flags &= ~(XkbSA_LockNoLock | XkbSA_LockNoUnlock);
act->flags |= rtrn.ival;
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveButton(value, &rtrn))
+ if (!ExprResolveButton(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
{
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
- if (!ExprResolveInteger(value, &rtrn))
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field,
"integer (range 1..255)");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
switch (field)
{
case F_Type:
- if (!ExprResolveInteger(value, &rtrn))
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
return ReportMismatch(PrivateAction, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
case F_Data:
if (array_ndx == NULL)
{
- if (!ExprResolveString(keymap, value, &rtrn))
+ if (!ExprResolveString(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "string");
else
{
else
{
unsigned ndx;
- if (!ExprResolveInteger(array_ndx, &rtrn))
+ if (!ExprResolveInteger(keymap->context, array_ndx, &rtrn))
{
ERROR("Array subscript must be integer\n");
ACTION("Illegal subscript ignored\n");
ACTION("Attempt to use data[%d] ignored\n", ndx);
return false;
}
- if (!ExprResolveInteger(value, &rtrn))
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
return ReportMismatch(action->type, field, "integer");
if ((rtrn.ival < 0) || (rtrn.ival > 255))
{
exprOpText(def->op));
return false;
}
- str = XkbcAtomText(def->value.action.name);
+ str = xkb_atom_text(keymap->context, def->value.action.name);
if (!str)
{
WSGO("Missing name in action definition!!\n");
*pred_rtrn = XkbSI_Exactly;
if (expr->op == ExprActionDecl)
{
- const char *pred_txt = XkbcAtomText(expr->value.action.name);
+ const char *pred_txt = xkb_atom_text(info->keymap->context,
+ expr->value.action.name);
if (strcasecmp(pred_txt, "noneof") == 0)
*pred_rtrn = XkbSI_NoneOf;
else if (strcasecmp(pred_txt, "anyofornone") == 0)
}
else if (expr->op == ExprIdent)
{
- const char *pred_txt = XkbcAtomText(expr->value.str);
+ const char *pred_txt = xkb_atom_text(info->keymap->context,
+ expr->value.str);
if ((pred_txt) && (strcasecmp(pred_txt, "any") == 0))
{
*pred_rtrn = XkbSI_AnyOf;
}
}
- if (ExprResolveModMask(expr, &result))
+ if (ExprResolveModMask(info->keymap->context, expr, &result))
{
*mods_rtrn = result.uval;
return true;
next = (LEDInfo *) led->defs.next;
if (merge != MergeDefault)
led->defs.merge = merge;
- rtrn = AddIndicatorMap(into->leds, led);
+ rtrn = AddIndicatorMap(from->keymap, into->leds, led);
if (rtrn != NULL)
into->leds = rtrn;
else
{
if (arrayNdx != NULL)
return ReportSINotArray(si, field, info);
- ok = ExprResolveBoolean(value, &tmp);
+ ok = ExprResolveBoolean(keymap->context, value, &tmp);
if (ok)
{
if (tmp.uval)
{
if (arrayNdx != NULL)
return ReportSINotArray(si, field, info);
- ok = ExprResolveBoolean(value, &tmp);
+ ok = ExprResolveBoolean(keymap->context, value, &tmp);
if (ok)
{
if (tmp.uval)
{
if (arrayNdx != NULL)
return ReportSINotArray(si, field, info);
- ok = ExprResolveEnum(value, &tmp, useModMapValues);
+ ok = ExprResolveEnum(keymap->context, value, &tmp, useModMapValues);
if (ok)
{
if (tmp.uval)
/***====================================================================***/
-typedef bool (*IdentLookupFunc) (const void *priv, xkb_atom_t field,
- unsigned type, ExprResult *val_rtrn);
+typedef bool (*IdentLookupFunc) (struct xkb_context *context, const void *priv,
+ xkb_atom_t field, unsigned type,
+ ExprResult *val_rtrn);
/***====================================================================***/
}
static bool
-SimpleLookup(const void * priv, xkb_atom_t field, unsigned type,
- ExprResult * val_rtrn)
+SimpleLookup(struct xkb_context *context, const void *priv,
+ xkb_atom_t field, unsigned type, ExprResult *val_rtrn)
{
const LookupEntry *entry;
const char *str;
{
return false;
}
- str = XkbcAtomText(field);
+ str = xkb_atom_text(context, field);
for (entry = priv; (entry != NULL) && (entry->name != NULL); entry++)
{
if (strcasecmp(str, entry->name) == 0)
};
bool
-LookupModIndex(const void * priv, xkb_atom_t field, unsigned type,
- ExprResult * val_rtrn)
+LookupModIndex(struct xkb_context *context, const void *priv, xkb_atom_t field,
+ unsigned type, ExprResult *val_rtrn)
{
- return SimpleLookup(modIndexNames, field, type, val_rtrn);
+ return SimpleLookup(context, modIndexNames, field, type, val_rtrn);
}
bool
-LookupModMask(const void * priv, xkb_atom_t field, unsigned type,
- ExprResult * val_rtrn)
+LookupModMask(struct xkb_context *context, const void *priv, xkb_atom_t field,
+ unsigned type, ExprResult *val_rtrn)
{
const char *str;
bool ret = true;
if (type != TypeInt)
return false;
- str = XkbcAtomText(field);
+ str = xkb_atom_text(context, field);
if (str == NULL)
return false;
if (strcasecmp(str, "all") == 0)
val_rtrn->uval = 0xff;
else if (strcasecmp(str, "none") == 0)
val_rtrn->uval = 0;
- else if (LookupModIndex(priv, field, type, val_rtrn))
+ else if (LookupModIndex(context, priv, field, type, val_rtrn))
val_rtrn->uval = (1 << val_rtrn->uval);
else
ret = false;
}
int
-ExprResolveBoolean(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveBoolean(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
int ok = 0;
const char *bogus = NULL;
val_rtrn->ival = expr->value.ival;
return true;
case ExprIdent:
- bogus = XkbcAtomText(expr->value.str);
+ bogus = xkb_atom_text(context, expr->value.str);
if (bogus)
{
if ((strcasecmp(bogus, "true") == 0) ||
}
}
ERROR("Identifier \"%s\" of type int is unknown\n",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
return false;
case ExprFieldRef:
ERROR("Default \"%s.%s\" of type boolean is unknown\n",
- XkbcAtomText(expr->value.field.element),
- XkbcAtomText(expr->value.field.field));
+ xkb_atom_text(context, expr->value.field.element),
+ xkb_atom_text(context, expr->value.field.field));
return false;
case OpInvert:
case OpNot:
- ok = ExprResolveBoolean(expr, val_rtrn);
+ ok = ExprResolveBoolean(context, expr, val_rtrn);
if (ok)
val_rtrn->uval = !val_rtrn->uval;
return ok;
}
int
-ExprResolveFloat(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveFloat(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
if (expr->type == TypeString)
{
const char *str;
- str = XkbcAtomText(expr->value.str);
+ str = xkb_atom_text(context, expr->value.str);
if ((str != NULL) && (strlen(str) == 1))
{
val_rtrn->uval = str[0] * XkbGeomPtsPerMM;
return true;
case ExprIdent:
ERROR("Numeric identifier \"%s\" unknown\n",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
return ok;
case ExprFieldRef:
ERROR("Numeric default \"%s.%s\" unknown\n",
- XkbcAtomText(expr->value.field.element),
- XkbcAtomText(expr->value.field.field));
+ xkb_atom_text(context, expr->value.field.element),
+ xkb_atom_text(context, expr->value.field.field));
return false;
case OpAdd:
case OpSubtract:
case OpDivide:
left = expr->value.binary.left;
right = expr->value.binary.right;
- if (ExprResolveFloat(left, &leftRtrn) &&
- ExprResolveFloat(right, &rightRtrn))
+ if (ExprResolveFloat(context, left, &leftRtrn) &&
+ ExprResolveFloat(context, right, &rightRtrn))
{
switch (expr->op)
{
case OpInvert:
case OpNegate:
left = expr->value.child;
- if (ExprResolveFloat(left, &leftRtrn))
+ if (ExprResolveFloat(context, left, &leftRtrn))
{
if (expr->op == OpNegate)
val_rtrn->ival = -leftRtrn.ival;
return false;
case OpUnaryPlus:
left = expr->value.child;
- return ExprResolveFloat(left, val_rtrn);
+ return ExprResolveFloat(context, left, val_rtrn);
default:
WSGO("Unknown operator %d in ResolveFloat\n", expr->op);
break;
}
int
-ExprResolveKeyCode(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
ExprResult leftRtrn, rightRtrn;
ExprDef *left, *right;
case OpDivide:
left = expr->value.binary.left;
right = expr->value.binary.right;
- if (ExprResolveKeyCode(left, &leftRtrn) &&
- ExprResolveKeyCode(right, &rightRtrn))
+ if (ExprResolveKeyCode(context, left, &leftRtrn) &&
+ ExprResolveKeyCode(context, right, &rightRtrn))
{
switch (expr->op)
{
return false;
case OpNegate:
left = expr->value.child;
- if (ExprResolveKeyCode(left, &leftRtrn))
+ if (ExprResolveKeyCode(context, left, &leftRtrn))
{
val_rtrn->uval = ~leftRtrn.uval;
return true;
return false;
case OpUnaryPlus:
left = expr->value.child;
- return ExprResolveKeyCode(left, val_rtrn);
+ return ExprResolveKeyCode(context, left, val_rtrn);
default:
WSGO("Unknown operator %d in ResolveKeyCode\n", expr->op);
break;
* Cool.
*/
static int
-ExprResolveIntegerLookup(ExprDef * expr,
- ExprResult * val_rtrn,
- IdentLookupFunc lookup, const void * lookupPriv)
+ExprResolveIntegerLookup(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn, IdentLookupFunc lookup,
+ const void *lookupPriv)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
if (expr->type == TypeString)
{
const char *str;
- str = XkbcAtomText(expr->value.str);
+ str = xkb_atom_text(context, expr->value.str);
if (str != NULL)
switch (strlen(str))
{
return true;
case ExprIdent:
if (lookup)
- {
- ok = (*lookup) (lookupPriv, expr->value.str, TypeInt, val_rtrn);
- }
+ ok = lookup(context, lookupPriv, expr->value.str,
+ TypeInt, val_rtrn);
if (!ok)
ERROR("Identifier \"%s\" of type int is unknown\n",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
return ok;
case ExprFieldRef:
ERROR("Default \"%s.%s\" of type int is unknown\n",
- XkbcAtomText(expr->value.field.element),
- XkbcAtomText(expr->value.field.field));
+ xkb_atom_text(context, expr->value.field.element),
+ xkb_atom_text(context, expr->value.field.field));
return false;
case OpAdd:
case OpSubtract:
case OpDivide:
left = expr->value.binary.left;
right = expr->value.binary.right;
- if (ExprResolveIntegerLookup(left, &leftRtrn, lookup, lookupPriv) &&
- ExprResolveIntegerLookup(right, &rightRtrn, lookup, lookupPriv))
+ if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup, lookupPriv) &&
+ ExprResolveIntegerLookup(context, right, &rightRtrn, lookup, lookupPriv))
{
switch (expr->op)
{
case OpInvert:
case OpNegate:
left = expr->value.child;
- if (ExprResolveIntegerLookup(left, &leftRtrn, lookup, lookupPriv))
+ if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup,
+ lookupPriv))
{
if (expr->op == OpNegate)
val_rtrn->ival = -leftRtrn.ival;
return false;
case OpUnaryPlus:
left = expr->value.child;
- return ExprResolveIntegerLookup(left, val_rtrn, lookup, lookupPriv);
+ return ExprResolveIntegerLookup(context, left, val_rtrn, lookup,
+ lookupPriv);
default:
WSGO("Unknown operator %d in ResolveInteger\n", expr->op);
break;
}
int
-ExprResolveInteger(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveInteger(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
- return ExprResolveIntegerLookup(expr, val_rtrn, NULL, NULL);
+ return ExprResolveIntegerLookup(context, expr, val_rtrn, NULL, NULL);
}
int
-ExprResolveGroup(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveGroup(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
int ret;
static const LookupEntry group_names[] = {
{ NULL, 0 }
};
- ret = ExprResolveIntegerLookup(expr, val_rtrn, SimpleLookup, group_names);
+ ret = ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup,
+ group_names);
if (ret == false)
return ret;
}
int
-ExprResolveLevel(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveLevel(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
int ret;
static const LookupEntry level_names[] = {
{ NULL, 0 }
};
- ret = ExprResolveIntegerLookup(expr, val_rtrn, SimpleLookup, level_names);
+ ret = ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup,
+ level_names);
if (ret == false)
return ret;
}
int
-ExprResolveButton(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveButton(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
static const LookupEntry button_names[] = {
{ "button1", 1 },
{ NULL, 0 }
};
- return ExprResolveIntegerLookup(expr, val_rtrn, SimpleLookup,
+ return ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup,
button_names);
}
int
-ExprResolveString(struct xkb_keymap *keymap, ExprDef *expr,
+ExprResolveString(struct xkb_context *context, ExprDef *expr,
ExprResult *val_rtrn)
{
ExprResult leftRtrn, rightRtrn;
exprTypeText(expr->type));
return false;
}
- val_rtrn->str = xkb_atom_strdup(keymap->context, expr->value.str);
+ val_rtrn->str = xkb_atom_strdup(context, expr->value.str);
if (val_rtrn->str == NULL)
val_rtrn->str = strdup("");
return true;
case ExprIdent:
ERROR("Identifier \"%s\" of type string not found\n",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
return false;
case ExprFieldRef:
ERROR("Default \"%s.%s\" of type string not found\n",
- XkbcAtomText(expr->value.field.element),
- XkbcAtomText(expr->value.field.field));
+ xkb_atom_text(context, expr->value.field.element),
+ xkb_atom_text(context, expr->value.field.field));
return false;
case OpAdd:
left = expr->value.binary.left;
right = expr->value.binary.right;
- if (ExprResolveString(keymap, left, &leftRtrn) &&
- ExprResolveString(keymap, right, &rightRtrn))
+ if (ExprResolveString(context, left, &leftRtrn) &&
+ ExprResolveString(context, right, &rightRtrn))
{
int len;
char *new;
len = strlen(leftRtrn.str) + strlen(rightRtrn.str) + 1;
new = malloc(len);
- if (new)
- { sprintf(new, "%s%s", leftRtrn.str, rightRtrn.str);
+ if (new) {
+ sprintf(new, "%s%s", leftRtrn.str, rightRtrn.str);
free(leftRtrn.str);
free(rightRtrn.str);
val_rtrn->str = new;
}
int
-ExprResolveKeyName(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveKeyName(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
const char *bogus = NULL;
return true;
case ExprIdent:
ERROR("Identifier \"%s\" of type string not found\n",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
return false;
case ExprFieldRef:
ERROR("Default \"%s.%s\" of type key name not found\n",
- XkbcAtomText(expr->value.field.element),
- XkbcAtomText(expr->value.field.field));
+ xkb_atom_text(context, expr->value.field.element),
+ xkb_atom_text(context, expr->value.field.field));
return false;
case OpAdd:
if (bogus == NULL)
/***====================================================================***/
int
-ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, const LookupEntry * values)
+ExprResolveEnum(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn, const LookupEntry *values)
{
if (expr->op != ExprIdent)
{
exprOpText(expr->op));
return false;
}
- if (!SimpleLookup(values, expr->value.str, TypeInt, val_rtrn))
+ if (!SimpleLookup(context, values, expr->value.str, TypeInt, val_rtrn))
{
int nOut = 0;
ERROR("Illegal identifier %s (expected one of: ",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
while (values && values->name)
{
if (nOut != 0)
}
static int
-ExprResolveMaskLookup(ExprDef * expr,
- ExprResult * val_rtrn,
- IdentLookupFunc lookup,
- const void * lookupPriv)
+ExprResolveMaskLookup(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn, IdentLookupFunc lookup,
+ const void *lookupPriv)
{
int ok = 0;
ExprResult leftRtrn, rightRtrn;
val_rtrn->ival = expr->value.ival;
return true;
case ExprIdent:
- ok = (*lookup) (lookupPriv, expr->value.str, TypeInt, val_rtrn);
+ ok = lookup(context, lookupPriv, expr->value.str, TypeInt, val_rtrn);
if (!ok)
ERROR("Identifier \"%s\" of type int is unknown\n",
- XkbcAtomText(expr->value.str));
+ xkb_atom_text(context, expr->value.str));
return ok;
case ExprFieldRef:
ERROR("Default \"%s.%s\" of type int is unknown\n",
- XkbcAtomText(expr->value.field.element),
- XkbcAtomText(expr->value.field.field));
+ xkb_atom_text(context, expr->value.field.element),
+ xkb_atom_text(context, expr->value.field.field));
return false;
case ExprArrayRef:
bogus = "array reference";
case OpDivide:
left = expr->value.binary.left;
right = expr->value.binary.right;
- if (ExprResolveMaskLookup(left, &leftRtrn, lookup, lookupPriv) &&
- ExprResolveMaskLookup(right, &rightRtrn, lookup, lookupPriv))
+ if (ExprResolveMaskLookup(context, left, &leftRtrn, lookup, lookupPriv) &&
+ ExprResolveMaskLookup(context, right, &rightRtrn, lookup, lookupPriv))
{
switch (expr->op)
{
break;
case OpInvert:
left = expr->value.child;
- if (ExprResolveIntegerLookup(left, &leftRtrn, lookup, lookupPriv))
+ if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup,
+ lookupPriv))
{
val_rtrn->ival = ~leftRtrn.ival;
return true;
case OpNegate:
case OpNot:
left = expr->value.child;
- if (ExprResolveIntegerLookup(left, &leftRtrn, lookup, lookupPriv))
+ if (ExprResolveIntegerLookup(context, left, &leftRtrn, lookup,
+ lookupPriv))
{
ERROR("The %s operator cannot be used with a mask\n",
(expr->op == OpNegate ? "-" : "!"));
}
int
-ExprResolveMask(ExprDef *expr, ExprResult *val_rtrn,
- const LookupEntry * values)
+ExprResolveMask(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn, const LookupEntry *values)
{
- return ExprResolveMaskLookup(expr, val_rtrn, SimpleLookup, values);
+ return ExprResolveMaskLookup(context, expr, val_rtrn, SimpleLookup, values);
}
int
-ExprResolveModMask(ExprDef *expr, ExprResult *val_rtrn)
+ExprResolveModMask(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
- return ExprResolveMaskLookup(expr, val_rtrn, LookupModMask, NULL);
+ return ExprResolveMaskLookup(context, expr, val_rtrn, LookupModMask, NULL);
}
int
ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
struct xkb_keymap *keymap)
{
- return ExprResolveMaskLookup(expr, val_rtrn, LookupVModMask, keymap);
+ return ExprResolveMaskLookup(keymap->context, expr, val_rtrn,
+ LookupVModMask, keymap);
}
int
-ExprResolveKeySym(ExprDef *expr, ExprResult *val_rtrn)
+ExprResolveKeySym(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn)
{
int ok = 0;
xkb_keysym_t sym;
if (expr->op == ExprIdent)
{
const char *str;
- str = XkbcAtomText(expr->value.str);
+ str = xkb_atom_text(context, expr->value.str);
if (str) {
sym = xkb_keysym_from_name(str);
if (sym != XKB_KEYSYM_NO_SYMBOL) {
}
}
}
- ok = ExprResolveInteger(expr, val_rtrn);
+ ok = ExprResolveInteger(context, expr, val_rtrn);
if ((ok) && (val_rtrn->uval < 10))
val_rtrn->uval += '0';
return ok;
exprOpText(unsigned type);
extern bool
-LookupModMask(const void *priv, xkb_atom_t field, unsigned type,
- ExprResult *val_rtrn);
+LookupModMask(struct xkb_context *context, const void *priv, xkb_atom_t field,
+ unsigned type, ExprResult *val_rtrn);
extern bool
-LookupVModMask(const void *priv, xkb_atom_t field, unsigned type,
- ExprResult *val_rtrn);
+LookupVModMask(struct xkb_context *context, const void *priv, xkb_atom_t field,
+ unsigned type, ExprResult *val_rtrn);
extern bool
-LookupModIndex(const void *priv, xkb_atom_t field, unsigned type,
- ExprResult *val_rtrn);
+LookupModIndex(struct xkb_context *context, const void *priv, xkb_atom_t field,
+ unsigned type, ExprResult *val_rtrn);
extern int
-ExprResolveModMask(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveModMask(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
struct xkb_keymap *keymap);
extern int
-ExprResolveBoolean(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveBoolean(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveKeyCode(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveInteger(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveInteger(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveLevel(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveLevel(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveGroup(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveGroup(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveButton(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveButton(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveFloat(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveFloat(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveString(struct xkb_keymap *keymap, ExprDef *expr,
+ExprResolveString(struct xkb_context *context, ExprDef *expr,
ExprResult *val_rtrn);
extern int
-ExprResolveKeyName(ExprDef *expr, ExprResult *val_rtrn);
+ExprResolveKeyName(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
-ExprResolveEnum(ExprDef *expr, ExprResult *val_rtrn,
- const LookupEntry *values);
+ExprResolveEnum(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn, const LookupEntry *values);
extern int
-ExprResolveMask(ExprDef *expr, ExprResult *val_rtrn,
- const LookupEntry *values);
+ExprResolveMask(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn, const LookupEntry *values);
-extern int ExprResolveKeySym(ExprDef *expr, ExprResult *val_rtrn);
+extern int
+ExprResolveKeySym(struct xkb_context *context, ExprDef *expr,
+ ExprResult *val_rtrn);
#endif /* EXPR_H */
/***====================================================================***/
-#define ReportIndicatorBadType(l, f, w) \
- ReportBadType("indicator map", (f), XkbcAtomText((l)->name), (w))
-#define ReportIndicatorNotArray(l, f) \
- ReportNotArray("indicator map", (f), XkbcAtomText((l)->name))
+#define ReportIndicatorBadType(keymap, l, f, w) \
+ ReportBadType("indicator map", (f), \
+ xkb_atom_text((keymap)->context, (l)->name), (w))
+#define ReportIndicatorNotArray(keymap, l, f) \
+ ReportNotArray("indicator map", (f), \
+ xkb_atom_text((keymap)->context, (l)->name))
/***====================================================================***/
}
LEDInfo *
-AddIndicatorMap(LEDInfo * oldLEDs, LEDInfo * new)
+AddIndicatorMap(struct xkb_keymap *keymap, LEDInfo *oldLEDs, LEDInfo *new)
{
LEDInfo *old, *last;
unsigned collide;
&& (warningLevel > 0)) || (warningLevel > 9))
{
WARN("Map for indicator %s redefined\n",
- XkbcAtomText(old->name));
+ xkb_atom_text(keymap->context, old->name));
ACTION("Earlier definition ignored\n");
}
*old = *new;
if (collide)
{
WARN("Map for indicator %s redefined\n",
- XkbcAtomText(old->name));
+ xkb_atom_text(keymap->context, old->name));
ACTION("Using %s definition for duplicate fields\n",
(new->defs.merge == MergeAugment ? "first" : "last"));
}
{
WSGO("Couldn't allocate indicator map\n");
ACTION("Map for indicator %s not compiled\n",
- XkbcAtomText(new->name));
+ xkb_atom_text(keymap->context, new->name));
return NULL;
}
*old = *new;
(strcasecmp(field, "mods") == 0))
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
+ return ReportIndicatorNotArray(keymap, led, field);
if (!ExprResolveVModMask(value, &rtrn, keymap))
- return ReportIndicatorBadType(led, field, "modifier mask");
+ return ReportIndicatorBadType(keymap, led, field, "modifier mask");
led->real_mods = rtrn.uval & 0xff;
led->vmods = (rtrn.uval >> 8) & 0xff;
led->defs.defined |= _LED_Mods;
else if (strcasecmp(field, "groups") == 0)
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveMask(value, &rtrn, groupNames))
- return ReportIndicatorBadType(led, field, "group mask");
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveMask(keymap->context, value, &rtrn, groupNames))
+ return ReportIndicatorBadType(keymap, led, field, "group mask");
led->groups = rtrn.uval;
led->defs.defined |= _LED_Groups;
}
(strcasecmp(field, "ctrls") == 0))
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveMask(value, &rtrn, ctrlNames))
- return ReportIndicatorBadType(led, field,
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveMask(keymap->context, value, &rtrn, ctrlNames))
+ return ReportIndicatorBadType(keymap, led, field,
"controls mask");
led->ctrls = rtrn.uval;
led->defs.defined |= _LED_Ctrls;
else if (strcasecmp(field, "allowexplicit") == 0)
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveBoolean(value, &rtrn))
- return ReportIndicatorBadType(led, field, "boolean");
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveBoolean(keymap->context, value, &rtrn))
+ return ReportIndicatorBadType(keymap, led, field, "boolean");
if (rtrn.uval)
led->flags &= ~XkbIM_NoExplicit;
else
(strcasecmp(field, "whichmodifierstate") == 0))
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveMask(value, &rtrn, modComponentNames))
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveMask(keymap->context, value, &rtrn, modComponentNames))
{
- return ReportIndicatorBadType(led, field,
+ return ReportIndicatorBadType(keymap, led, field,
"mask of modifier state components");
}
led->which_mods = rtrn.uval;
else if (strcasecmp(field, "whichgroupstate") == 0)
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveMask(value, &rtrn, groupComponentNames))
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveMask(keymap->context, value, &rtrn, groupComponentNames))
{
- return ReportIndicatorBadType(led, field,
+ return ReportIndicatorBadType(keymap, led, field,
"mask of group state components");
}
led->which_groups = rtrn.uval;
(strcasecmp(field, "indicatordriveskeyboard") == 0))
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveBoolean(value, &rtrn))
- return ReportIndicatorBadType(led, field, "boolean");
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveBoolean(keymap->context, value, &rtrn))
+ return ReportIndicatorBadType(keymap, led, field, "boolean");
if (rtrn.uval)
led->flags |= XkbIM_LEDDrivesKB;
else
else if (strcasecmp(field, "index") == 0)
{
if (arrayNdx != NULL)
- return ReportIndicatorNotArray(led, field);
- if (!ExprResolveInteger(value, &rtrn))
- return ReportIndicatorBadType(led, field,
+ return ReportIndicatorNotArray(keymap, led, field);
+ if (!ExprResolveInteger(keymap->context, value, &rtrn))
+ return ReportIndicatorBadType(keymap, led, field,
"indicator index");
if ((rtrn.uval < 1) || (rtrn.uval > 32))
{
ERROR("Illegal indicator index %d (range 1..%d)\n",
rtrn.uval, XkbNumIndicators);
ACTION("Index definition for %s indicator ignored\n",
- XkbcAtomText(led->name));
+ xkb_atom_text(keymap->context, led->name));
return false;
}
led->indicator = rtrn.uval;
else
{
ERROR("Unknown field %s in map for %s indicator\n", field,
- XkbcAtomText(led->name));
+ xkb_atom_text(keymap->context, led->name));
ACTION("Definition ignored\n");
ok = false;
}
}
if (ok)
{
- rtrn = AddIndicatorMap(oldLEDs, &led);
+ rtrn = AddIndicatorMap(keymap, oldLEDs, &led);
return rtrn;
}
return NULL;
{
if (keymap->names->indicators[i] &&
strcmp(keymap->names->indicators[i],
- XkbcAtomText(led->name)) == 0)
+ xkb_atom_text(keymap->context, led->name)) == 0)
{
led->indicator = i + 1;
break;
ERROR("No unnamed indicators found\n");
ACTION
("Virtual indicator map \"%s\" not bound\n",
- XkbcAtomText(led->name));
+ xkb_atom_text(keymap->context, led->name));
continue;
}
}
{
if ((keymap->names != NULL) &&
(strcmp(keymap->names->indicators[led->indicator - 1],
- XkbcAtomText(led->name)) != 0))
+ xkb_atom_text(keymap->context, led->name)) != 0))
{
const char *old = keymap->names->indicators[led->indicator - 1];
ERROR("Multiple names bound to indicator %d\n",
(unsigned int) led->indicator);
- ACTION("Using %s, ignoring %s\n", old, XkbcAtomText(led->name));
+ ACTION("Using %s, ignoring %s\n", old,
+ xkb_atom_text(keymap->context, led->name));
led->indicator = _LED_NotBound;
if (force)
{
extern LEDInfo *
-AddIndicatorMap(LEDInfo *oldLEDs, LEDInfo *newLED);
+AddIndicatorMap(struct xkb_keymap *keymap, LEDInfo *oldLEDs, LEDInfo *newLED);
extern int
SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, char *field,
}
static bool
-AddIndicatorName(KeyNamesInfo * info, IndicatorNameInfo * new)
+AddIndicatorName(KeyNamesInfo *info, struct xkb_keymap *keymap,
+ IndicatorNameInfo *new)
{
IndicatorNameInfo *old;
bool replace;
if (((old->defs.fileID == new->defs.fileID) && (warningLevel > 0))
|| (warningLevel > 9))
{
- WARN("Multiple indicators named %s\n", XkbcAtomText(new->name));
+ WARN("Multiple indicators named %s\n",
+ xkb_atom_text(keymap->context, new->name));
if (old->ndx == new->ndx)
{
if (old->virtual != new->virtual)
ignoring = new->name;
}
ACTION("Using %s %s, ignoring %s %s\n",
- oldType, XkbcAtomText(using),
- newType, XkbcAtomText(ignoring));
+ oldType, xkb_atom_text(keymap->context, using),
+ newType, xkb_atom_text(keymap->context, ignoring));
}
}
if (replace)
/***====================================================================***/
static void
-MergeIncludedKeycodes(KeyNamesInfo * into, KeyNamesInfo * from,
- unsigned merge)
+MergeIncludedKeycodes(KeyNamesInfo *into, struct xkb_keymap *keymap,
+ KeyNamesInfo *from, unsigned merge)
{
uint64_t i;
char buf[5];
{
if (merge != MergeDefault)
led->defs.merge = merge;
- if (!AddIndicatorName(into, led))
+ if (!AddIndicatorName(into, keymap, led))
into->errorCount++;
next = (IndicatorNameInfo *) led->defs.next;
}
if ((next->file == NULL) && (next->map == NULL))
{
haveSelf = true;
- MergeIncludedKeycodes(&included, info, next->merge);
+ MergeIncludedKeycodes(&included, keymap, info, next->merge);
ClearKeyNamesInfo(info);
}
else if (ProcessIncludeFile(keymap->context, next,
{
InitKeyNamesInfo(&next_incl);
HandleKeycodesFile(rtrn, keymap, MergeOverride, &next_incl);
- MergeIncludedKeycodes(&included, &next_incl, op);
+ MergeIncludedKeycodes(&included, keymap, &next_incl, op);
ClearKeyNamesInfo(&next_incl);
FreeXKBFile(rtrn);
}
*info = included;
else
{
- MergeIncludedKeycodes(info, &included, newMerge);
+ MergeIncludedKeycodes(info, keymap, &included, newMerge);
ClearKeyNamesInfo(&included);
}
return (info->errorCount == 0);
goto err_out;
}
- if (ExprResolveKeyCode(stmt->value, &tmp) == 0)
+ if (ExprResolveKeyCode(keymap->context, stmt->value, &tmp) == 0)
{
ACTION("Assignment to field %s ignored\n", field.str);
goto err_out;
}
InitIndicatorNameInfo(&ii, info);
ii.ndx = def->ndx;
- if (!ExprResolveString(keymap, def->name, &tmp))
+ if (!ExprResolveString(keymap->context, def->name, &tmp))
{
char buf[20];
snprintf(buf, sizeof(buf), "%d", def->ndx);
ii.name = xkb_atom_intern(keymap->context, tmp.str);
free(tmp.str);
ii.virtual = def->virtual;
- if (!AddIndicatorName(info, &ii))
+ if (!AddIndicatorName(info, keymap, &ii))
return false;
return true;
}
/***====================================================================***/
-#define ReportTypeShouldBeArray(t, f) \
- ReportShouldBeArray("key type", (f), TypeTxt(t))
-#define ReportTypeBadType(t, f, w) \
- ReportBadType("key type", (f), TypeTxt(t), (w))
+#define ReportTypeShouldBeArray(keymap, t, f) \
+ ReportShouldBeArray("key type", (f), TypeTxt((keymap), (t)))
+#define ReportTypeBadType(keymap, t, f, w) \
+ ReportBadType("key type", (f), TypeTxt((keymap), (t)), (w))
/***====================================================================***/
XkbcVModMaskText((x), (p)->indexMods, (p)->indexVMods)
#define PreserveTxt(x, p) \
XkbcVModMaskText((x), (p)->preMods, (p)->preVMods)
-#define TypeTxt(t) \
- XkbcAtomText((t)->name)
+#define TypeTxt(keymap, t) \
+ xkb_atom_text((keymap)->context, (t)->name)
#define TypeMaskTxt(t, x) \
XkbcVModMaskText((x), (t)->mask, (t)->vmask)
&& (warningLevel > 0)) || (warningLevel > 9))
{
WARN("Multiple definitions of the %s key type\n",
- XkbcAtomText(new->name));
+ xkb_atom_text(keymap->context, new->name));
ACTION("Earlier definition ignored\n");
}
FreeKeyTypeInfo(old);
if (report)
{
WARN("Multiple definitions of the %s key type\n",
- XkbcAtomText(new->name));
+ xkb_atom_text(keymap->context, new->name));
ACTION("Later definition ignored\n");
}
FreeKeyTypeInfo(new);
* necessary.
*/
static struct xkb_kt_map_entry *
-NextMapEntry(KeyTypeInfo * type)
+NextMapEntry(struct xkb_keymap *keymap, KeyTypeInfo * type)
{
if (type->entries == NULL)
{
type->entries = uTypedCalloc(2, struct xkb_kt_map_entry);
if (type->entries == NULL)
{
- ERROR("Couldn't allocate map entries for %s\n", TypeTxt(type));
+ ERROR("Couldn't allocate map entries for %s\n",
+ TypeTxt(keymap, type));
ACTION("Map entries lost\n");
return NULL;
}
struct xkb_kt_map_entry);
if (type->entries == NULL)
{
- ERROR("Couldn't reallocate map entries for %s\n", TypeTxt(type));
+ ERROR("Couldn't reallocate map entries for %s\n",
+ TypeTxt(keymap, type));
ACTION("Map entries lost\n");
return NULL;
}
if (warningLevel > 9)
{
WARN("Identical definitions for preserve[%s] in %s\n",
- PreserveIndexTxt(keymap, old), TypeTxt(type));
+ PreserveIndexTxt(keymap, old), TypeTxt(keymap, type));
ACTION("Ignored\n");
}
return true;
{
const char *str;
WARN("Multiple definitions for preserve[%s] in %s\n",
- PreserveIndexTxt(keymap, old), TypeTxt(type));
+ PreserveIndexTxt(keymap, old), TypeTxt(keymap, type));
if (clobber)
str = PreserveTxt(keymap, new);
old = uTypedAlloc(PreserveInfo);
if (!old)
{
- WSGO("Couldn't allocate preserve in %s\n", TypeTxt(type));
+ WSGO("Couldn't allocate preserve in %s\n", TypeTxt(keymap, type));
ACTION("Preserve[%s] lost\n", PreserveIndexTxt(keymap, new));
return false;
}
ignore = new->level + 1;
}
WARN("Multiple map entries for %s in %s\n",
- MapEntryTxt(keymap, new), TypeTxt(type));
+ MapEntryTxt(keymap, new), TypeTxt(keymap, type));
ACTION("Using %d, ignoring %d\n", use, ignore);
}
else if (warningLevel > 9)
{
WARN("Multiple occurences of map[%s]= %d in %s\n",
- MapEntryTxt(keymap, new), new->level + 1, TypeTxt(type));
+ MapEntryTxt(keymap, new), new->level + 1,
+ TypeTxt(keymap, type));
ACTION("Ignored\n");
return true;
}
old->level = new->level;
return true;
}
- if ((old = NextMapEntry(type)) == NULL)
+ if ((old = NextMapEntry(keymap, type)) == NULL)
return false; /* allocation failure, already reported */
if (new->level >= type->numLevels)
type->numLevels = new->level + 1;
struct xkb_kt_map_entry entry;
if (arrayNdx == NULL)
- return ReportTypeShouldBeArray(type, "map entry");
+ return ReportTypeShouldBeArray(keymap, type, "map entry");
if (!ExprResolveVModMask(arrayNdx, &rtrn, keymap))
- return ReportTypeBadType(type, "map entry", "modifier mask");
+ return ReportTypeBadType(keymap, type, "map entry", "modifier mask");
entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */
if ((entry.mods.real_mods & (~type->mask)) ||
{
if (warningLevel > 0)
{
- WARN("Map entry for unused modifiers in %s\n", TypeTxt(type));
+ WARN("Map entry for unused modifiers in %s\n", TypeTxt(keymap, type));
ACTION("Using %s instead of ",
XkbcVModMaskText(keymap,
entry.mods.real_mods & type->mask,
entry.mods.real_mods &= type->mask;
entry.mods.vmods &= type->vmask;
}
- if (!ExprResolveLevel(value, &rtrn))
+ if (!ExprResolveLevel(keymap->context, value, &rtrn))
{
ERROR("Level specifications in a key type must be integer\n");
ACTION("Ignoring malformed level specification\n");
PreserveInfo new;
if (arrayNdx == NULL)
- return ReportTypeShouldBeArray(type, "preserve entry");
+ return ReportTypeShouldBeArray(keymap, type, "preserve entry");
if (!ExprResolveVModMask(arrayNdx, &rtrn, keymap))
- return ReportTypeBadType(type, "preserve entry", "modifier mask");
+ return ReportTypeBadType(keymap, type, "preserve entry",
+ "modifier mask");
new.defs = type->defs;
new.defs.next = NULL;
new.indexMods = rtrn.uval & 0xff;
if (warningLevel > 0)
{
WARN("Preserve for modifiers not used by the %s type\n",
- TypeTxt(type));
+ TypeTxt(keymap, type));
ACTION("Index %s converted to ", PreserveIndexTxt(keymap, &new));
}
new.indexMods &= type->mask;
{
ERROR("Preserve value in a key type is not a modifier mask\n");
ACTION("Ignoring preserve[%s] in type %s\n",
- PreserveIndexTxt(keymap, &new), TypeTxt(type));
+ PreserveIndexTxt(keymap, &new), TypeTxt(keymap, type));
return false;
}
new.preMods = rtrn.uval & 0xff;
if (warningLevel > 0)
{
WARN("Illegal value for preserve[%s] in type %s\n",
- PreserveTxt(keymap, &new), TypeTxt(type));
+ PreserveTxt(keymap, &new), TypeTxt(keymap, type));
ACTION("Converted %s to ", PreserveIndexTxt(keymap, &new));
}
new.preMods &= new.indexMods;
/***====================================================================***/
static bool
-AddLevelName(KeyTypeInfo *type, unsigned level, xkb_atom_t name, bool clobber)
+AddLevelName(struct xkb_keymap *keymap, KeyTypeInfo *type,
+ unsigned level, xkb_atom_t name, bool clobber)
{
if ((type->lvlNames == NULL) || (type->szNames <= level))
{
if (type->lvlNames == NULL)
{
ERROR("Couldn't allocate level names for type %s\n",
- TypeTxt(type));
+ TypeTxt(keymap, type));
ACTION("Level names lost\n");
type->szNames = 0;
return false;
if (warningLevel > 9)
{
WARN("Duplicate names for level %d of key type %s\n",
- level + 1, TypeTxt(type));
+ level + 1, TypeTxt(keymap, type));
ACTION("Ignored\n");
}
return true;
if (warningLevel > 0)
{
const char *old, *new;
- old = XkbcAtomText(type->lvlNames[level]);
- new = XkbcAtomText(name);
+ old = xkb_atom_text(keymap->context, type->lvlNames[level]);
+ new = xkb_atom_text(keymap->context, name);
WARN("Multiple names for level %d of key type %s\n",
- level + 1, TypeTxt(type));
+ level + 1, TypeTxt(keymap, type));
if (clobber)
ACTION("Using %s, ignoring %s\n", new, old);
else
xkb_atom_t level_name;
if (arrayNdx == NULL)
- return ReportTypeShouldBeArray(type, "level name");
- if (!ExprResolveLevel(arrayNdx, &rtrn))
- return ReportTypeBadType(type, "level name", "integer");
+ return ReportTypeShouldBeArray(keymap, type, "level name");
+ if (!ExprResolveLevel(keymap->context, arrayNdx, &rtrn))
+ return ReportTypeBadType(keymap, type, "level name", "integer");
level = rtrn.ival - 1;
- if (!ExprResolveString(keymap, value, &rtrn))
+ if (!ExprResolveString(keymap->context, value, &rtrn))
{
ERROR("Non-string name for level %d in key type %s\n", level + 1,
- XkbcAtomText(type->name));
+ xkb_atom_text(keymap->context, type->name));
ACTION("Ignoring illegal level name definition\n");
return false;
}
level_name = xkb_atom_intern(keymap->context, rtrn.str);
free(rtrn.str);
- return AddLevelName(type, level, level_name, true);
+ return AddLevelName(keymap, type, level, level_name, true);
}
/***====================================================================***/
if (type->defs.defined & _KT_Mask)
{
WARN("Multiple modifier mask definitions for key type %s\n",
- XkbcAtomText(type->name));
+ xkb_atom_text(keymap->context, type->name));
ACTION("Using %s, ", TypeMaskTxt(type, keymap));
INFO("ignoring %s\n", XkbcVModMaskText(keymap, mods, vmods));
return false;
type->defs.defined |= _KT_LevelNames;
return SetLevelName(type, keymap, arrayNdx, value);
}
- ERROR("Unknown field %s in key type %s\n", field, TypeTxt(type));
+ ERROR("Unknown field %s in key type %s\n", field, TypeTxt(keymap, type));
ACTION("Definition ignored\n");
return false;
}
{
if ((i < type.numLevels) && (info->dflt.lvlNames[i] != XKB_ATOM_NONE))
{
- AddLevelName(&type, i, info->dflt.lvlNames[i], false);
+ AddLevelName(keymap, &type, i, info->dflt.lvlNames[i], false);
}
}
/* Now add the new keytype to the info struct */
{
WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");
ACTION("Preserve setting for type %s lost\n",
- XkbcAtomText(def->name));
+ xkb_atom_text(keymap->context, def->name));
}
else
{
}
static bool
-MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from)
+MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap,
+ KeyInfo *into, KeyInfo *from)
{
int i;
unsigned collide = 0;
("Multiple definitions for group %d type of key %s\n",
i, longText(into->name));
ACTION("Using %s, ignoring %s\n",
- XkbcAtomText(use),
- XkbcAtomText(ignore));
+ xkb_atom_text(keymap->context, use),
+ xkb_atom_text(keymap->context, ignore));
}
if ((from->defs.merge != MergeAugment)
|| (into->types[i] == XKB_ATOM_NONE))
for (i = 0; i < info->nKeys; i++)
{
if (info->keys[i].name == key->name)
- return MergeKeys(info, &info->keys[i], key);
+ return MergeKeys(info, keymap, &info->keys[i], key);
}
if (FindKeyNameForAlias(keymap, key->name, &real_name))
{
for (i = 0; i < info->nKeys; i++)
{
if (info->keys[i].name == real_name)
- return MergeKeys(info, &info->keys[i], key);
+ return MergeKeys(info, keymap, &info->keys[i], key);
}
}
if (info->nKeys >= info->szKeys)
#define ACTIONS 2
static bool
-GetGroupIndex(KeyInfo * key,
+GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap,
ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
{
const char *name;
ACTION("Ignoring %s defined for extra groups\n", name);
return false;
}
- if (!ExprResolveGroup(arrayNdx, &tmp))
+ if (!ExprResolveGroup(keymap->context, arrayNdx, &tmp))
{
ERROR("Illegal group index for %s of key %s\n", name,
longText(key->name));
unsigned int i;
long j;
- if (!GetGroupIndex(key, arrayNdx, SYMBOLS, &ndx))
+ if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx))
return false;
if (value == NULL)
{
&key->syms[ndx][key->symsMapIndex[ndx][i] + j])) {
WARN("Could not resolve keysym %s for key %s, group %d (%s), level %d\n",
value->value.list.syms[i], longText(key->name), ndx + 1,
- XkbcAtomText(info->groupNames[ndx]), nSyms);
+ xkb_atom_text(keymap->context, info->groupNames[ndx]), nSyms);
while (--j >= 0)
key->syms[ndx][key->symsMapIndex[ndx][i] + j] = NoSymbol;
key->symsMapIndex[ndx][i] = -1;
ExprDef *act;
struct xkb_any_action *toAct;
- if (!GetGroupIndex(key, arrayNdx, ACTIONS, &ndx))
+ if (!GetGroupIndex(key, keymap, arrayNdx, ACTIONS, &ndx))
return false;
if (value == NULL)
if (strcasecmp(field, "type") == 0)
{
ExprResult ndx;
- if ((!ExprResolveString(keymap, value, &tmp))
+ if ((!ExprResolveString(keymap->context, value, &tmp))
&& (warningLevel > 0))
{
WARN("The type field of a key symbol map must be a string\n");
key->dfltType = xkb_atom_intern(keymap->context, tmp.str);
key->defs.defined |= _Key_Type_Dflt;
}
- else if (!ExprResolveGroup(arrayNdx, &ndx))
+ else if (!ExprResolveGroup(keymap->context, arrayNdx, &ndx))
{
ERROR("Illegal group index for type of key %s\n",
longText(key->name));
(strcasecmp(field, "lock") == 0) ||
(strcasecmp(field, "locks") == 0))
{
- ok = ExprResolveEnum(value, &tmp, lockingEntries);
+ ok = ExprResolveEnum(keymap->context, value, &tmp, lockingEntries);
if (ok)
key->behavior.type = tmp.uval;
key->defs.defined |= _Key_Behavior;
(strcasecmp(field, "repeats") == 0) ||
(strcasecmp(field, "repeat") == 0))
{
- ok = ExprResolveEnum(value, &tmp, repeatEntries);
+ ok = ExprResolveEnum(keymap->context, value, &tmp, repeatEntries);
if (!ok)
{
ERROR("Illegal repeat setting for %s\n",
else if ((strcasecmp(field, "groupswrap") == 0) ||
(strcasecmp(field, "wrapgroups") == 0))
{
- ok = ExprResolveBoolean(value, &tmp);
+ ok = ExprResolveBoolean(keymap->context, value, &tmp);
if (!ok)
{
ERROR("Illegal groupsWrap setting for %s\n",
else if ((strcasecmp(field, "groupsclamp") == 0) ||
(strcasecmp(field, "clampgroups") == 0))
{
- ok = ExprResolveBoolean(value, &tmp);
+ ok = ExprResolveBoolean(keymap->context, value, &tmp);
if (!ok)
{
ERROR("Illegal groupsClamp setting for %s\n",
else if ((strcasecmp(field, "groupsredirect") == 0) ||
(strcasecmp(field, "redirectgroups") == 0))
{
- if (!ExprResolveGroup(value, &tmp))
+ if (!ExprResolveGroup(keymap->context, value, &tmp))
{
ERROR("Illegal group index for redirect of key %s\n",
longText(key->name));
ACTION("Group name definition without array subscript ignored\n");
return false;
}
- if (!ExprResolveGroup(arrayNdx, &tmp))
+ if (!ExprResolveGroup(keymap->context, arrayNdx, &tmp))
{
ERROR("Illegal index in group name definition\n");
ACTION("Definition with non-integer array index ignored\n");
return false;
}
- if (!ExprResolveString(keymap, value, &name))
+ if (!ExprResolveString(keymap->context, value, &name))
{
ERROR("Group name must be a string\n");
ACTION("Illegal name for group %d ignored\n", tmp.uval);
&& ((strcasecmp(field.str, "groupswrap") == 0) ||
(strcasecmp(field.str, "wrapgroups") == 0)))
{
- if (!ExprResolveBoolean(stmt->value, &tmp))
+ if (!ExprResolveBoolean(keymap->context, stmt->value, &tmp))
{
ERROR("Illegal setting for global groupsWrap\n");
ACTION("Non-boolean value ignored\n");
&& ((strcasecmp(field.str, "groupsclamp") == 0) ||
(strcasecmp(field.str, "clampgroups") == 0)))
{
- if (!ExprResolveBoolean(stmt->value, &tmp))
+ if (!ExprResolveBoolean(keymap->context, stmt->value, &tmp))
{
ERROR("Illegal setting for global groupsClamp\n");
ACTION("Non-boolean value ignored\n");
&& ((strcasecmp(field.str, "groupsredirect") == 0) ||
(strcasecmp(field.str, "redirectgroups") == 0)))
{
- if (!ExprResolveGroup(stmt->value, &tmp))
+ if (!ExprResolveGroup(keymap->context, stmt->value, &tmp))
{
ERROR("Illegal group index for global groupsRedirect\n");
ACTION("Definition with non-integer group ignored\n");
ExprResult rtrn;
bool ok;
- if (!LookupModIndex(NULL, def->modifier, TypeInt, &rtrn))
+ if (!LookupModIndex(keymap->context, NULL, def->modifier, TypeInt, &rtrn))
{
ERROR("Illegal modifier map definition\n");
ACTION("Ignoring map for non-modifier \"%s\"\n",
- XkbcAtomText(def->modifier));
+ xkb_atom_text(keymap->context, def->modifier));
return false;
}
ok = true;
tmp.haveSymbol = false;
tmp.u.keyName = KeyNameToLong(key->value.keyName);
}
- else if (ExprResolveKeySym(key, &rtrn))
+ else if (ExprResolveKeySym(keymap->context, key, &rtrn))
{
tmp.haveSymbol = true;
tmp.u.keySym = rtrn.uval;
}
/**
- * Find the given name in the xkb->map->types and return its index.
+ * Find the given name in the keymap->map->types and return its index.
*
* @param atom The atom to search for.
* @param type_rtrn Set to the index of the name if found.
FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
{
unsigned n;
- const char *name = XkbcAtomText(atom);
+ const char *name = xkb_atom_text(keymap->context, atom);
if (keymap && keymap->map && keymap->map->types)
{
WARN("No automatic type for %d symbols\n",
(unsigned int) key->numLevels[i]);
ACTION("Using %s for the %s key (keycode %d)\n",
- XkbcAtomText(key->types[i]),
+ xkb_atom_text(keymap->context, key->types[i]),
longText(key->name), kc);
}
}
if (warningLevel >= 3)
{
WARN("Type \"%s\" is not defined\n",
- XkbcAtomText(key->types[i]));
+ xkb_atom_text(keymap->context, key->types[i]));
ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
longText(key->name), kc);
}
{
WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
type->name, type->num_levels,
- XkbcAtomText(key->name), key->numLevels[i]);
+ xkb_atom_text(keymap->context, key->name), key->numLevels[i]);
ACTION("Ignoring extra symbols\n");
}
key->numLevels[i] = type->num_levels;
if (info->defined & bit)
{
if (names->vmods[i] &&
- strcmp(names->vmods[i], XkbcAtomText(stmt->name)) == 0)
+ strcmp(names->vmods[i],
+ xkb_atom_text(keymap->context, stmt->name)) == 0)
{ /* already defined */
info->available |= bit;
if (stmt->value == NULL)
{
const char *str1;
const char *str2 = "";
- if (!ExprResolveModMask(stmt->value, &mod))
+ if (!ExprResolveModMask(keymap->context, stmt->value, &mod))
{
- str1 = XkbcAtomText(stmt->name);
+ str1 = xkb_atom_text(keymap->context, stmt->name);
ACTION("Declaration of %s ignored\n", str1);
return false;
}
if (mod.uval == srv->vmods[i])
return true;
- str1 = XkbcAtomText(stmt->name);
+ str1 = xkb_atom_text(keymap->context, stmt->name);
WARN("Virtual modifier %s multiply defined\n", str1);
str1 = XkbcModMaskText(srv->vmods[i], true);
if (mergeMode == MergeOverride)
names->vmods[nextFree] = xkb_atom_strdup(keymap->context, stmt->name);
if (stmt->value == NULL)
return true;
- if (ExprResolveModMask(stmt->value, &mod))
+ if (ExprResolveModMask(keymap->context, stmt->value, &mod))
{
srv->vmods[nextFree] = mod.uval;
return true;
}
- ACTION("Declaration of %s ignored\n", XkbcAtomText(stmt->name));
+ ACTION("Declaration of %s ignored\n", xkb_atom_text(keymap->context, stmt->name));
return false;
}
/**
- * Returns the index of the given modifier in the xkb->names->vmods array.
+ * Returns the index of the given modifier in the keymap->names->vmods array.
*
* @param keymap Pointer to the xkb data structure.
* @param field The Atom of the modifier's name (e.g. Atom for LAlt)
unsigned type, ExprResult * val_rtrn)
{
int i;
- const char *name = XkbcAtomText(field);
+ const char *name = xkb_atom_text(keymap->context, field);
if ((keymap == NULL) || (keymap->names == NULL) || (type != TypeInt))
{
* undefined.
*/
bool
-LookupVModMask(const void * priv, xkb_atom_t field, unsigned type,
- ExprResult * val_rtrn)
+LookupVModMask(struct xkb_context *context, const void *priv, xkb_atom_t field,
+ unsigned type, ExprResult *val_rtrn)
{
- if (LookupModMask(NULL, field, type, val_rtrn))
+ if (LookupModMask(context, NULL, field, type, val_rtrn))
{
return true;
}
if (def->op == ExprIdent)
{
int i, bit;
- const char *name = XkbcAtomText(def->value.str);
+ const char *name = xkb_atom_text(keymap->context, def->value.str);
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1)
{
if ((info->available & bit) && names->vmods[i] &&
}
}
}
- if (ExprResolveInteger(def, val_rtrn))
+ if (ExprResolveInteger(keymap->context, def, val_rtrn))
{
if (val_rtrn->uval < XkbNumVirtualMods)
return true;
projects / platform / upstream / libxkbcommon.git / commitdiff