From cdd2906de3db99f63c9dba0de27d8299198d2517 Mon Sep 17 00:00:00 2001 From: Ran Benita Date: Wed, 9 May 2012 13:50:05 +0300 Subject: [PATCH] Make the context available for XkbcAtomText And rename the function to xkb_atom_text. Signed-off-by: Ran Benita [daniels: Updated for xkb -> keymap.] --- src/atom.c | 4 +- src/atom.h | 2 +- src/xkbcomp/action.c | 72 ++++++++--------- src/xkbcomp/compat.c | 16 ++-- src/xkbcomp/expr.c | 207 ++++++++++++++++++++++++----------------------- src/xkbcomp/expr.h | 53 +++++++----- src/xkbcomp/indicators.c | 79 +++++++++--------- src/xkbcomp/indicators.h | 2 +- src/xkbcomp/keycodes.c | 28 ++++--- src/xkbcomp/keytypes.c | 89 ++++++++++---------- src/xkbcomp/symbols.c | 61 +++++++------- src/xkbcomp/vmod.c | 27 ++++--- 12 files changed, 337 insertions(+), 303 deletions(-) diff --git a/src/atom.c b/src/atom.c index 5d785d9..bca64d5 100644 --- a/src/atom.c +++ b/src/atom.c @@ -89,7 +89,7 @@ static unsigned long tableLength; static NodePtr *nodeTable; const char * -XkbcAtomText(xkb_atom_t atom) +xkb_atom_text(struct xkb_context *context, xkb_atom_t atom) { NodePtr node; @@ -103,7 +103,7 @@ XkbcAtomText(xkb_atom_t atom) 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; } diff --git a/src/atom.h b/src/atom.h index 117e82d..d9fc0b8 100644 --- a/src/atom.h +++ b/src/atom.h @@ -40,7 +40,7 @@ extern char * 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); diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c index 1081f4d..1c6eee1 100644 --- a/src/xkbcomp/action.c +++ b/src/xkbcomp/action.c @@ -210,7 +210,7 @@ HandleNoAction(struct xkb_keymap *keymap, struct xkb_any_action *action, } static bool -CheckLatchLockFlags(unsigned action, +CheckLatchLockFlags(struct xkb_keymap *keymap, unsigned action, unsigned field, ExprDef * value, unsigned *flags_inout) { unsigned tmp; @@ -222,7 +222,7 @@ CheckLatchLockFlags(unsigned action, 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; @@ -240,7 +240,7 @@ CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value, 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))) { @@ -281,7 +281,7 @@ HandleSetLatchMods(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -328,7 +328,7 @@ HandleLockMods(struct xkb_keymap *keymap, struct xkb_any_action *action, } static bool -CheckGroupField(unsigned action, +CheckGroupField(struct xkb_keymap *keymap, unsigned action, ExprDef * value, unsigned *flags_inout, int *grp_rtrn) { ExprDef *spec; @@ -345,7 +345,7 @@ CheckGroupField(unsigned action, 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; @@ -381,7 +381,7 @@ HandleSetLatchGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -389,7 +389,7 @@ HandleSetLatchGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -414,7 +414,7 @@ HandleLockGroup(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -443,7 +443,7 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, 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) { @@ -461,7 +461,7 @@ HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action, } 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; @@ -491,7 +491,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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)) @@ -507,7 +507,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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; @@ -517,7 +517,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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)) { @@ -550,7 +550,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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; @@ -571,7 +571,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, 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)) @@ -637,7 +637,7 @@ HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -647,7 +647,7 @@ HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -679,7 +679,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, 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)) { @@ -697,7 +697,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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; @@ -741,7 +741,7 @@ HandleSetLockControls(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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; @@ -772,7 +772,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, 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 = @@ -781,7 +781,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, 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; @@ -791,7 +791,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, 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 { @@ -808,7 +808,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, 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"); @@ -821,7 +821,7 @@ HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action, 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)) { @@ -853,7 +853,7 @@ HandleRedirectKey(struct xkb_keymap *keymap, struct xkb_any_action *action, 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)) @@ -899,7 +899,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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)) @@ -915,7 +915,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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; @@ -925,7 +925,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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)) { @@ -940,7 +940,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, { 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)) @@ -978,7 +978,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, 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)) { @@ -991,7 +991,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, 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 { @@ -1010,7 +1010,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, 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"); @@ -1023,7 +1023,7 @@ HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action, 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)) { @@ -1105,7 +1105,7 @@ HandleActionDef(ExprDef * def, 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"); diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c index 53214ea..af5c600 100644 --- a/src/xkbcomp/compat.c +++ b/src/xkbcomp/compat.c @@ -299,7 +299,8 @@ ResolveStateAndPredicate(ExprDef * expr, *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) @@ -320,7 +321,8 @@ ResolveStateAndPredicate(ExprDef * expr, } 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; @@ -329,7 +331,7 @@ ResolveStateAndPredicate(ExprDef * expr, } } - if (ExprResolveModMask(expr, &result)) + if (ExprResolveModMask(info->keymap->context, expr, &result)) { *mods_rtrn = result.uval; return true; @@ -376,7 +378,7 @@ MergeIncludedCompatMaps(CompatInfo * into, CompatInfo * from, unsigned merge) 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 @@ -520,7 +522,7 @@ SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = ExprResolveBoolean(value, &tmp); + ok = ExprResolveBoolean(keymap->context, value, &tmp); if (ok) { if (tmp.uval) @@ -536,7 +538,7 @@ SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, { if (arrayNdx != NULL) return ReportSINotArray(si, field, info); - ok = ExprResolveBoolean(value, &tmp); + ok = ExprResolveBoolean(keymap->context, value, &tmp); if (ok) { if (tmp.uval) @@ -553,7 +555,7 @@ SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field, { 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) diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c index a7740b3..1353a28 100644 --- a/src/xkbcomp/expr.c +++ b/src/xkbcomp/expr.c @@ -28,8 +28,9 @@ /***====================================================================***/ -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); /***====================================================================***/ @@ -160,8 +161,8 @@ ExprResolveLhs(struct xkb_keymap *keymap, ExprDef *expr, } 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; @@ -170,7 +171,7 @@ SimpleLookup(const void * priv, xkb_atom_t field, unsigned type, { 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) @@ -196,29 +197,29 @@ static const LookupEntry modIndexNames[] = { }; 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; @@ -226,8 +227,8 @@ LookupModMask(const void * priv, xkb_atom_t field, unsigned type, } int -ExprResolveBoolean(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveBoolean(struct xkb_context *context, ExprDef *expr, + ExprResult *val_rtrn) { int ok = 0; const char *bogus = NULL; @@ -245,7 +246,7 @@ ExprResolveBoolean(ExprDef * expr, 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) || @@ -264,16 +265,16 @@ ExprResolveBoolean(ExprDef * expr, } } 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; @@ -308,8 +309,8 @@ ExprResolveBoolean(ExprDef * expr, } int -ExprResolveFloat(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveFloat(struct xkb_context *context, ExprDef *expr, + ExprResult *val_rtrn) { int ok = 0; ExprResult leftRtrn, rightRtrn; @@ -321,7 +322,7 @@ ExprResolveFloat(ExprDef * expr, 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; @@ -340,12 +341,12 @@ ExprResolveFloat(ExprDef * expr, 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: @@ -353,8 +354,8 @@ ExprResolveFloat(ExprDef * expr, 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) { @@ -383,7 +384,7 @@ ExprResolveFloat(ExprDef * expr, 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; @@ -394,7 +395,7 @@ ExprResolveFloat(ExprDef * expr, 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; @@ -403,8 +404,8 @@ ExprResolveFloat(ExprDef * expr, } int -ExprResolveKeyCode(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveKeyCode(struct xkb_context *context, ExprDef *expr, + ExprResult *val_rtrn) { ExprResult leftRtrn, rightRtrn; ExprDef *left, *right; @@ -427,8 +428,8 @@ ExprResolveKeyCode(ExprDef * expr, 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) { @@ -450,7 +451,7 @@ ExprResolveKeyCode(ExprDef * expr, return false; case OpNegate: left = expr->value.child; - if (ExprResolveKeyCode(left, &leftRtrn)) + if (ExprResolveKeyCode(context, left, &leftRtrn)) { val_rtrn->uval = ~leftRtrn.uval; return true; @@ -458,7 +459,7 @@ ExprResolveKeyCode(ExprDef * expr, 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; @@ -481,9 +482,9 @@ ExprResolveKeyCode(ExprDef * expr, * 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; @@ -495,7 +496,7 @@ ExprResolveIntegerLookup(ExprDef * expr, 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)) { @@ -520,17 +521,16 @@ ExprResolveIntegerLookup(ExprDef * expr, 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: @@ -538,8 +538,8 @@ ExprResolveIntegerLookup(ExprDef * expr, 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) { @@ -568,7 +568,8 @@ ExprResolveIntegerLookup(ExprDef * expr, 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; @@ -579,7 +580,8 @@ ExprResolveIntegerLookup(ExprDef * expr, 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; @@ -588,15 +590,15 @@ ExprResolveIntegerLookup(ExprDef * expr, } 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[] = { @@ -611,7 +613,8 @@ ExprResolveGroup(ExprDef * expr, { NULL, 0 } }; - ret = ExprResolveIntegerLookup(expr, val_rtrn, SimpleLookup, group_names); + ret = ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup, + group_names); if (ret == false) return ret; @@ -625,8 +628,8 @@ ExprResolveGroup(ExprDef * expr, } int -ExprResolveLevel(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveLevel(struct xkb_context *context, ExprDef *expr, + ExprResult *val_rtrn) { int ret; static const LookupEntry level_names[] = { @@ -641,7 +644,8 @@ ExprResolveLevel(ExprDef * expr, { NULL, 0 } }; - ret = ExprResolveIntegerLookup(expr, val_rtrn, SimpleLookup, level_names); + ret = ExprResolveIntegerLookup(context, expr, val_rtrn, SimpleLookup, + level_names); if (ret == false) return ret; @@ -655,8 +659,8 @@ ExprResolveLevel(ExprDef * expr, } int -ExprResolveButton(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveButton(struct xkb_context *context, ExprDef *expr, + ExprResult *val_rtrn) { static const LookupEntry button_names[] = { { "button1", 1 }, @@ -668,12 +672,12 @@ ExprResolveButton(ExprDef * expr, { 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; @@ -690,31 +694,31 @@ ExprResolveString(struct xkb_keymap *keymap, ExprDef *expr, 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; @@ -758,8 +762,8 @@ ExprResolveString(struct xkb_keymap *keymap, ExprDef *expr, } int -ExprResolveKeyName(ExprDef * expr, - ExprResult * val_rtrn) +ExprResolveKeyName(struct xkb_context *context, ExprDef *expr, + ExprResult *val_rtrn) { const char *bogus = NULL; @@ -776,12 +780,12 @@ ExprResolveKeyName(ExprDef * expr, 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) @@ -822,7 +826,8 @@ ExprResolveKeyName(ExprDef * expr, /***====================================================================***/ 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) { @@ -830,11 +835,11 @@ ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, const LookupEntry * value 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) @@ -851,10 +856,9 @@ ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, const LookupEntry * value } 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; @@ -874,15 +878,15 @@ ExprResolveMaskLookup(ExprDef * expr, 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"; @@ -898,8 +902,8 @@ ExprResolveMaskLookup(ExprDef * expr, 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) { @@ -924,7 +928,8 @@ ExprResolveMaskLookup(ExprDef * expr, 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; @@ -934,7 +939,8 @@ ExprResolveMaskLookup(ExprDef * expr, 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 ? "-" : "!")); @@ -948,27 +954,30 @@ ExprResolveMaskLookup(ExprDef * expr, } 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; @@ -976,7 +985,7 @@ ExprResolveKeySym(ExprDef *expr, ExprResult *val_rtrn) 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) { @@ -985,7 +994,7 @@ ExprResolveKeySym(ExprDef *expr, ExprResult *val_rtrn) } } } - ok = ExprResolveInteger(expr, val_rtrn); + ok = ExprResolveInteger(context, expr, val_rtrn); if ((ok) && (val_rtrn->uval < 10)) val_rtrn->uval += '0'; return ok; diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h index fa115c7..9582234 100644 --- a/src/xkbcomp/expr.h +++ b/src/xkbcomp/expr.h @@ -53,60 +53,71 @@ extern const char * 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 */ diff --git a/src/xkbcomp/indicators.c b/src/xkbcomp/indicators.c index cbc5669..746a7ed 100644 --- a/src/xkbcomp/indicators.c +++ b/src/xkbcomp/indicators.c @@ -30,10 +30,12 @@ /***====================================================================***/ -#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)) /***====================================================================***/ @@ -49,7 +51,7 @@ ClearIndicatorMapInfo(struct xkb_context *context, LEDInfo * info) } LEDInfo * -AddIndicatorMap(LEDInfo * oldLEDs, LEDInfo * new) +AddIndicatorMap(struct xkb_keymap *keymap, LEDInfo *oldLEDs, LEDInfo *new) { LEDInfo *old, *last; unsigned collide; @@ -76,7 +78,7 @@ AddIndicatorMap(LEDInfo * oldLEDs, LEDInfo * new) && (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; @@ -128,7 +130,7 @@ AddIndicatorMap(LEDInfo * oldLEDs, LEDInfo * 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")); } @@ -143,7 +145,7 @@ AddIndicatorMap(LEDInfo * oldLEDs, LEDInfo * new) { 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; @@ -202,9 +204,9 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, (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; @@ -212,9 +214,9 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, 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; } @@ -222,9 +224,9 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, (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; @@ -232,9 +234,9 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, 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 @@ -245,10 +247,10 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, (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; @@ -256,10 +258,10 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, 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; @@ -272,9 +274,9 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, (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 @@ -284,16 +286,16 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, 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; @@ -302,7 +304,7 @@ SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, 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; } @@ -352,7 +354,7 @@ HandleIndicatorMapDef(IndicatorMapDef *def, struct xkb_keymap *keymap, } if (ok) { - rtrn = AddIndicatorMap(oldLEDs, &led); + rtrn = AddIndicatorMap(keymap, oldLEDs, &led); return rtrn; } return NULL; @@ -447,7 +449,7 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, { 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; @@ -476,7 +478,7 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, 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; } } @@ -506,12 +508,13 @@ BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound, { 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) { diff --git a/src/xkbcomp/indicators.h b/src/xkbcomp/indicators.h index 83cd408..d2c8899 100644 --- a/src/xkbcomp/indicators.h +++ b/src/xkbcomp/indicators.h @@ -58,7 +58,7 @@ ClearIndicatorMapInfo(struct xkb_context *context, LEDInfo *info); 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, diff --git a/src/xkbcomp/keycodes.c b/src/xkbcomp/keycodes.c index a2f6d1f..6bdf7fd 100644 --- a/src/xkbcomp/keycodes.c +++ b/src/xkbcomp/keycodes.c @@ -193,7 +193,8 @@ FindIndicatorByName(KeyNamesInfo * info, xkb_atom_t name) } static bool -AddIndicatorName(KeyNamesInfo * info, IndicatorNameInfo * new) +AddIndicatorName(KeyNamesInfo *info, struct xkb_keymap *keymap, + IndicatorNameInfo *new) { IndicatorNameInfo *old; bool replace; @@ -206,7 +207,8 @@ AddIndicatorName(KeyNamesInfo * info, IndicatorNameInfo * new) 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) @@ -284,8 +286,8 @@ AddIndicatorName(KeyNamesInfo * info, IndicatorNameInfo * new) 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) @@ -465,8 +467,8 @@ AddKeyName(KeyNamesInfo * info, /***====================================================================***/ 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]; @@ -510,7 +512,7 @@ MergeIncludedKeycodes(KeyNamesInfo * into, KeyNamesInfo * from, { if (merge != MergeDefault) led->defs.merge = merge; - if (!AddIndicatorName(into, led)) + if (!AddIndicatorName(into, keymap, led)) into->errorCount++; next = (IndicatorNameInfo *) led->defs.next; } @@ -593,7 +595,7 @@ HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap, 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, @@ -601,7 +603,7 @@ HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap, { 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); } @@ -617,7 +619,7 @@ HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap, *info = included; else { - MergeIncludedKeycodes(info, &included, newMerge); + MergeIncludedKeycodes(info, keymap, &included, newMerge); ClearKeyNamesInfo(&included); } return (info->errorCount == 0); @@ -692,7 +694,7 @@ HandleKeyNameVar(VarDef *stmt, struct xkb_keymap *keymap, KeyNamesInfo *info) 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; @@ -769,7 +771,7 @@ HandleIndicatorNameDef(IndicatorNameDef *def, struct xkb_keymap *keymap, } 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); @@ -779,7 +781,7 @@ HandleIndicatorNameDef(IndicatorNameDef *def, struct xkb_keymap *keymap, 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; } diff --git a/src/xkbcomp/keytypes.c b/src/xkbcomp/keytypes.c index bee7685..f94a45c 100644 --- a/src/xkbcomp/keytypes.c +++ b/src/xkbcomp/keytypes.c @@ -80,10 +80,10 @@ static xkb_atom_t tok_KEYPAD; /***====================================================================***/ -#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)) /***====================================================================***/ @@ -93,8 +93,8 @@ static xkb_atom_t tok_KEYPAD; 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) @@ -289,7 +289,7 @@ AddKeyType(struct xkb_keymap *keymap, KeyTypesInfo *info, KeyTypeInfo *new) && (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); @@ -305,7 +305,7 @@ AddKeyType(struct xkb_keymap *keymap, KeyTypesInfo *info, KeyTypeInfo *new) 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); @@ -474,14 +474,15 @@ DeleteLevel1MapEntries(KeyTypeInfo * type) * 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; } @@ -496,7 +497,8 @@ NextMapEntry(KeyTypeInfo * type) 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; } @@ -525,7 +527,7 @@ AddPreserve(struct xkb_keymap *keymap, KeyTypeInfo *type, 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; @@ -534,7 +536,7 @@ AddPreserve(struct xkb_keymap *keymap, KeyTypeInfo *type, { 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); @@ -557,7 +559,7 @@ AddPreserve(struct xkb_keymap *keymap, KeyTypeInfo *type, 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; } @@ -599,13 +601,14 @@ AddMapEntry(struct xkb_keymap *keymap, KeyTypeInfo *type, 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; } @@ -613,7 +616,7 @@ AddMapEntry(struct xkb_keymap *keymap, KeyTypeInfo *type, 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; @@ -636,9 +639,9 @@ SetMapEntry(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, 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)) || @@ -646,7 +649,7 @@ SetMapEntry(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, { 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, @@ -656,7 +659,7 @@ SetMapEntry(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, 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"); @@ -674,9 +677,10 @@ SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap, 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; @@ -686,7 +690,7 @@ SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap, 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; @@ -698,7 +702,7 @@ SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap, { 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; @@ -709,7 +713,7 @@ SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap, 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; @@ -725,7 +729,8 @@ SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap, /***====================================================================***/ 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)) { @@ -734,7 +739,7 @@ AddLevelName(KeyTypeInfo *type, unsigned level, xkb_atom_t name, bool clobber) 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; @@ -746,7 +751,7 @@ AddLevelName(KeyTypeInfo *type, unsigned level, xkb_atom_t name, bool clobber) 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; @@ -756,10 +761,10 @@ AddLevelName(KeyTypeInfo *type, unsigned level, xkb_atom_t name, bool clobber) 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 @@ -783,20 +788,20 @@ SetLevelName(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx, 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); } /***====================================================================***/ @@ -833,7 +838,7 @@ SetKeyTypeField(KeyTypeInfo *type, struct xkb_keymap *keymap, 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; @@ -859,7 +864,7 @@ SetKeyTypeField(KeyTypeInfo *type, struct xkb_keymap *keymap, 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; } @@ -979,7 +984,7 @@ HandleKeyTypeDef(KeyTypeDef *def, struct xkb_keymap *keymap, { 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 */ @@ -1097,7 +1102,7 @@ CopyDefToKeyType(struct xkb_keymap *keymap, struct xkb_key_type *type, { 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 { diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c index f2b3e22..b56e012 100644 --- a/src/xkbcomp/symbols.c +++ b/src/xkbcomp/symbols.c @@ -581,7 +581,8 @@ out: } 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; @@ -662,8 +663,8 @@ MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from) ("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)) @@ -716,14 +717,14 @@ AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap) 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) @@ -975,7 +976,7 @@ HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap, #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; @@ -1008,7 +1009,7 @@ GetGroupIndex(KeyInfo * key, 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)); @@ -1027,7 +1028,7 @@ AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap, unsigned int i; long j; - if (!GetGroupIndex(key, arrayNdx, SYMBOLS, &ndx)) + if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx)) return false; if (value == NULL) { @@ -1069,7 +1070,7 @@ AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap, &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; @@ -1093,7 +1094,7 @@ AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx, 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) @@ -1180,7 +1181,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, 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"); @@ -1191,7 +1192,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, 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)); @@ -1233,7 +1234,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, (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; @@ -1256,7 +1257,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, (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", @@ -1270,7 +1271,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, 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", @@ -1287,7 +1288,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, 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", @@ -1304,7 +1305,7 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, 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)); @@ -1336,13 +1337,13 @@ SetGroupName(SymbolsInfo *info, struct xkb_keymap *keymap, ExprDef *arrayNdx, 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); @@ -1379,7 +1380,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) && ((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"); @@ -1397,7 +1398,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) && ((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"); @@ -1415,7 +1416,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) && ((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"); @@ -1565,11 +1566,11 @@ HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info) 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; @@ -1581,7 +1582,7 @@ HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info) 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; @@ -1687,7 +1688,7 @@ FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym, } /** - * 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. @@ -1698,7 +1699,7 @@ static bool 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) { @@ -1984,7 +1985,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) 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); } } @@ -1999,7 +2000,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) 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); } @@ -2013,7 +2014,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) { 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; diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c index 61d16d5..42fd8e3 100644 --- a/src/xkbcomp/vmod.c +++ b/src/xkbcomp/vmod.c @@ -82,7 +82,8 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, 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) @@ -91,16 +92,16 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, { 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) @@ -130,17 +131,17 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode, 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) @@ -155,7 +156,7 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field, 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)) { @@ -189,10 +190,10 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field, * 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; } @@ -228,7 +229,7 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, 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] && @@ -239,7 +240,7 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, } } } - if (ExprResolveInteger(def, val_rtrn)) + if (ExprResolveInteger(keymap->context, def, val_rtrn)) { if (val_rtrn->uval < XkbNumVirtualMods) return true; -- 2.7.4