Signed-off-by: Ran Benita <ran234@gmail.com>
CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value,
unsigned *flags_inout, xkb_mod_mask_t *mods_rtrn)
{
CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value,
unsigned *flags_inout, xkb_mod_mask_t *mods_rtrn)
{
if (value->op == EXPR_IDENT) {
const char *valStr;
valStr = xkb_atom_text(keymap->ctx, value->value.str);
if (value->op == EXPR_IDENT) {
const char *valStr;
valStr = xkb_atom_text(keymap->ctx, value->value.str);
- if (!ExprResolveVModMask(keymap, value, &rtrn))
+ if (!ExprResolveVModMask(keymap, value, mods_rtrn))
return ReportMismatch(keymap, action, F_Modifiers, "modifier mask");
return ReportMismatch(keymap, action, F_Modifiers, "modifier mask");
- *mods_rtrn = (xkb_mod_mask_t) rtrn.ival;
*flags_inout &= ~XkbSA_UseModMapMods;
return true;
}
*flags_inout &= ~XkbSA_UseModMapMods;
return true;
}
HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
struct xkb_iso_action *act;
struct xkb_iso_action *act;
- unsigned flags;
- xkb_mod_mask_t mods;
- xkb_group_index_t group;
act = (struct xkb_iso_action *) action;
act = (struct xkb_iso_action *) action;
- switch (field) {
- case F_Modifiers:
- if (array_ndx != NULL)
+ if (field == F_Modifiers) {
+ unsigned flags;
+ xkb_mod_mask_t mods;
+
+ if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
return ReportActionNotArray(keymap, action->type, field);
- if (CheckModifierField(keymap, action->type, value, &flags, &mods)) {
- act->flags = flags & (~XkbSA_ISODfltIsGroup);
- act->real_mods = mods & 0xff;
- act->vmods = (mods >> 8) & 0xff;
- return true;
- }
- return false;
+ if (!CheckModifierField(keymap, action->type, value, &flags, &mods))
+ return false;
- case F_Group:
- if (array_ndx != NULL)
+ act->flags = flags & (~XkbSA_ISODfltIsGroup);
+ act->real_mods = mods & 0xff;
+ act->vmods = (mods >> 8) & 0xff;
+ return true;
+ }
+ else if (field == F_Group) {
+ xkb_group_index_t group;
+ unsigned flags;
+
+ if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
return ReportActionNotArray(keymap, action->type, field);
- if (CheckGroupField(keymap, action->type, value, &flags, &group)) {
- act->flags = flags | XkbSA_ISODfltIsGroup;
- act->group = group;
- return true;
- }
- return false;
+ if (!CheckGroupField(keymap, action->type, value, &flags, &group))
+ return false;
- case F_Affect:
- if (array_ndx != NULL)
+ act->flags = flags | XkbSA_ISODfltIsGroup;
+ act->group = group;
+ return true;
+ } else if (F_Affect) {
+ xkb_mod_mask_t mask;
+
+ if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
return ReportActionNotArray(keymap, action->type, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, isoNames))
+
+ if (!ExprResolveMask(keymap->ctx, value, &mask, isoNames))
return ReportMismatch(keymap, action->type, field,
"keyboard component");
return ReportMismatch(keymap, action->type, field,
"keyboard component");
- act->affect = (~rtrn.uval) & XkbSA_ISOAffectMask;
+
+ act->affect = (~mask) & XkbSA_ISOAffectMask;
return ReportIllegal(keymap, action->type, field);
}
return ReportIllegal(keymap, action->type, field);
}
unsigned field, ExprDef *array_ndx,
ExprDef *value)
{
unsigned field, ExprDef *array_ndx,
ExprDef *value)
{
struct xkb_controls_action *act;
act = (struct xkb_controls_action *) action;
if (field == F_Controls) {
struct xkb_controls_action *act;
act = (struct xkb_controls_action *) action;
if (field == F_Controls) {
+ unsigned int mask;
+
+ if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
return ReportActionNotArray(keymap, action->type, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, ctrlNames))
+
+ if (!ExprResolveMask(keymap->ctx, value, &mask, ctrlNames))
return ReportMismatch(keymap, action->type, field,
"controls mask");
return ReportMismatch(keymap, action->type, field,
"controls mask");
- act->ctrls = rtrn.uval;
return ReportIllegal(keymap, action->type, field);
}
return ReportIllegal(keymap, action->type, field);
}
HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
- ExprResult rtrn;
- const char *str;
- bool set;
struct xkb_message_action *act;
act = (struct xkb_message_action *) action;
struct xkb_message_action *act;
act = (struct xkb_message_action *) action;
- switch (field) {
- case F_Report:
- if (array_ndx != NULL)
+ if (field == F_Report) {
+ unsigned int mask;
+
+ if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
return ReportActionNotArray(keymap, action->type, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, evNames))
+
+ if (!ExprResolveMask(keymap->ctx, value, &mask, evNames))
return ReportMismatch(keymap, action->type, field,
"key event mask");
return ReportMismatch(keymap, action->type, field,
"key event mask");
+
+ /* FIXME: Something seems wrong here... */
act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
act->flags &= ~(XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
- act->flags =
- rtrn.uval & (XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
+ act->flags = mask & (XkbSA_MessageOnPress | XkbSA_MessageOnRelease);
+ }
+ else if (field == F_GenKeyEvent) {
+ bool set;
if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
if (array_ndx)
return ReportActionNotArray(keymap, action->type, field);
act->flags &= ~XkbSA_MessageGenKeyEvent;
return true;
act->flags &= ~XkbSA_MessageGenKeyEvent;
return true;
-
- case F_Data:
- if (array_ndx == NULL) {
- int len;
-
- if (!ExprResolveString(keymap->ctx, value, &str))
- return ReportMismatch(keymap, action->type, field, "string");
-
- len = strlen(str);
- if (len < 1 || len > 6) {
- log_warn(keymap->ctx,
- "An action message can hold only 6 bytes; "
- "Extra %d bytes ignored\n", len - 6);
- }
-
- strncpy((char *) act->message, str, 6);
- return true;
+ }
+ else if (field == F_Data && !array_ndx) {
+ const char *str;
+ int len;
+
+ if (!ExprResolveString(keymap->ctx, value, &str))
+ return ReportMismatch(keymap, action->type, field, "string");
+
+ len = strlen(str);
+ if (len < 1 || len > 6) {
+ log_warn(keymap->ctx,
+ "An action message can hold only 6 bytes; "
+ "Extra %d bytes ignored\n", len - 6);
- else {
- int ndx, datum;
- if (!ExprResolveInteger(keymap->ctx, array_ndx, &ndx)) {
- log_err(keymap->ctx,
- "Array subscript must be integer; "
- "Illegal subscript ignored\n");
- return false;
- }
+ strncpy((char *) act->message, str, 6);
+ return true;
+ }
+ else if (field == F_Data && array_ndx) {
+ int ndx, datum;
- if (ndx < 0 || ndx > 5) {
- log_err(keymap->ctx,
- "An action message is at most 6 bytes long; "
- "Attempt to use data[%d] ignored\n", ndx);
- return false;
- }
+ if (!ExprResolveInteger(keymap->ctx, array_ndx, &ndx)) {
+ log_err(keymap->ctx,
+ "Array subscript must be integer; "
+ "Illegal subscript ignored\n");
+ return false;
+ }
- if (!ExprResolveInteger(keymap->ctx, value, &datum))
- return ReportMismatch(keymap, action->type, field, "integer");
+ if (ndx < 0 || ndx > 5) {
+ log_err(keymap->ctx,
+ "An action message is at most 6 bytes long; "
+ "Attempt to use data[%d] ignored\n", ndx);
+ return false;
+ }
- if (datum < 0 || datum > 255) {
- log_err(keymap->ctx,
- "Message data must be in the range 0..255; "
- "Illegal datum %d ignored\n", datum);
- return false;
- }
+ if (!ExprResolveInteger(keymap->ctx, value, &datum))
+ return ReportMismatch(keymap, action->type, field, "integer");
- act->message[ndx] = (uint8_t) datum;
+ if (datum < 0 || datum > 255) {
+ log_err(keymap->ctx,
+ "Message data must be in the range 0..255; "
+ "Illegal datum %d ignored\n", datum);
+ return false;
+ act->message[ndx] = (uint8_t) datum;
static bool
ResolveStateAndPredicate(ExprDef * expr,
unsigned *pred_rtrn,
static bool
ResolveStateAndPredicate(ExprDef * expr,
unsigned *pred_rtrn,
- unsigned *mods_rtrn, CompatInfo * info)
+ xkb_mod_mask_t *mods_rtrn, CompatInfo * info)
if (expr == NULL) {
*pred_rtrn = XkbSI_AnyOfOrNone;
*mods_rtrn = ~0;
if (expr == NULL) {
*pred_rtrn = XkbSI_AnyOfOrNone;
*mods_rtrn = ~0;
- if (ExprResolveModMask(info->keymap->ctx, expr, &result)) {
- *mods_rtrn = result.uval;
- return true;
- }
- return false;
+ return ExprResolveModMask(info->keymap->ctx, expr, mods_rtrn);
}
/***====================================================================***/
}
/***====================================================================***/
struct xkb_keymap *keymap = info->keymap;
if (istreq(field, "modifiers") || istreq(field, "mods")) {
struct xkb_keymap *keymap = info->keymap;
if (istreq(field, "modifiers") || istreq(field, "mods")) {
+ xkb_mod_mask_t mask;
+
+ if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveVModMask(keymap, value, &rtrn))
+ if (!ExprResolveVModMask(keymap, value, &mask))
return ReportIndicatorBadType(info, led, field, "modifier mask");
return ReportIndicatorBadType(info, led, field, "modifier mask");
- led->real_mods = rtrn.uval & 0xff;
- led->vmods = (rtrn.uval >> 8) & 0xff;
+ led->real_mods = mask & 0xff;
+ led->vmods = (mask >> 8) & 0xff;
led->defined |= _LED_Mods;
}
else if (istreq(field, "groups")) {
led->defined |= _LED_Mods;
}
else if (istreq(field, "groups")) {
+ unsigned int mask;
+
+ if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, groupNames))
+ if (!ExprResolveMask(keymap->ctx, value, &mask, groupNames))
return ReportIndicatorBadType(info, led, field, "group mask");
return ReportIndicatorBadType(info, led, field, "group mask");
- led->groups = rtrn.uval;
led->defined |= _LED_Groups;
}
else if (istreq(field, "controls") || istreq(field, "ctrls")) {
led->defined |= _LED_Groups;
}
else if (istreq(field, "controls") || istreq(field, "ctrls")) {
+ unsigned int mask;
+
+ if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, ctrlNames))
+ if (!ExprResolveMask(keymap->ctx, value, &mask, ctrlNames))
return ReportIndicatorBadType(info, led, field,
"controls mask");
return ReportIndicatorBadType(info, led, field,
"controls mask");
- led->ctrls = rtrn.uval;
led->defined |= _LED_Ctrls;
}
else if (istreq(field, "allowexplicit")) {
led->defined |= _LED_Ctrls;
}
else if (istreq(field, "allowexplicit")) {
}
else if (istreq(field, "whichmodstate") ||
istreq(field, "whichmodifierstate")) {
}
else if (istreq(field, "whichmodstate") ||
istreq(field, "whichmodifierstate")) {
+ unsigned int mask;
+
+ if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, modComponentNames))
+ if (!ExprResolveMask(keymap->ctx, value, &mask, modComponentNames))
return ReportIndicatorBadType(info, led, field,
"mask of modifier state components");
return ReportIndicatorBadType(info, led, field,
"mask of modifier state components");
- led->which_mods = rtrn.uval;
+ led->which_mods = mask;
}
else if (istreq(field, "whichgroupstate")) {
}
else if (istreq(field, "whichgroupstate")) {
+ unsigned mask;
+
+ if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveMask(keymap->ctx, value, &rtrn, groupComponentNames))
+ if (!ExprResolveMask(keymap->ctx, value, &mask, groupComponentNames))
return ReportIndicatorBadType(info, led, field,
"mask of group state components");
return ReportIndicatorBadType(info, led, field,
"mask of group state components");
- led->which_groups = rtrn.uval;
+ led->which_groups = mask;
}
else if (istreq(field, "driveskbd") ||
istreq(field, "driveskeyboard") ||
}
else if (istreq(field, "driveskbd") ||
istreq(field, "driveskeyboard") ||
HandleGroupCompatDef(CompatInfo *info, GroupCompatDef *def,
enum merge_mode merge)
{
HandleGroupCompatDef(CompatInfo *info, GroupCompatDef *def,
enum merge_mode merge)
{
- if (def->merge != MERGE_DEFAULT)
- merge = def->merge;
+ merge = (def->merge == MERGE_DEFAULT ? merge : def->merge);
+
if (def->group < 1 || def->group > XkbNumKbdGroups) {
log_err(info->keymap->ctx,
"Keyboard group must be in the range 1..%u; "
if (def->group < 1 || def->group > XkbNumKbdGroups) {
log_err(info->keymap->ctx,
"Keyboard group must be in the range 1..%u; "
XkbNumKbdGroups, def->group);
return false;
}
XkbNumKbdGroups, def->group);
return false;
}
tmp.file_id = info->file_id;
tmp.merge = merge;
tmp.file_id = info->file_id;
tmp.merge = merge;
- if (!ExprResolveVModMask(info->keymap, def->def, &val)) {
+
+ if (!ExprResolveVModMask(info->keymap, def->def, &mask)) {
log_err(info->keymap->ctx,
"Expected a modifier mask in group compatibility definition; "
"Ignoring illegal compatibility map for group %u\n",
def->group);
return false;
}
log_err(info->keymap->ctx,
"Expected a modifier mask in group compatibility definition; "
"Ignoring illegal compatibility map for group %u\n",
def->group);
return false;
}
- tmp.real_mods = val.uval & 0xff;
- tmp.vmods = (val.uval >> 8) & 0xffff;
+
+ tmp.real_mods = mask & 0xff;
+ tmp.vmods = (mask >> 8) & 0xffff;
tmp.defined = true;
return AddGroupCompat(info, def->group - 1, &tmp);
}
tmp.defined = true;
return AddGroupCompat(info, def->group - 1, &tmp);
}
ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
- ExprResult *val_rtrn, const LookupEntry *values)
+ unsigned int *mask_rtrn, const LookupEntry *values)
- return ExprResolveMaskLookup(ctx, expr, val_rtrn, SimpleLookup, values);
+ ExprResult result;
+ bool ok;
+
+ ok = ExprResolveMaskLookup(ctx, expr, &result, SimpleLookup, values);
+ if (ok)
+ *mask_rtrn = (unsigned int) result.ival;
+ return ok;
ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
+ xkb_mod_mask_t *mask_rtrn)
- return ExprResolveMaskLookup(ctx, expr, val_rtrn, LookupModMask, NULL);
+ ExprResult result;
+ bool ok;
+
+ ok = ExprResolveMaskLookup(ctx, expr, &result, LookupModMask, NULL);
+ if (ok)
+ *mask_rtrn = (xkb_mod_mask_t) result.ival;
+ return ok;
ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
+ xkb_mod_mask_t *mask_rtrn)
- return ExprResolveMaskLookup(keymap->ctx, expr, val_rtrn, LookupVModMask,
- keymap);
+ ExprResult result;
+ bool ok;
+
+ ok = ExprResolveMaskLookup(keymap->ctx, expr, &result, LookupVModMask,
+ keymap);
+ if (ok)
+ *mask_rtrn = (xkb_mod_mask_t) result.ival;
+ return ok;
LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn);
LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn);
ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
+ xkb_mod_mask_t *mask_rtrn);
ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
+ xkb_mod_mask_t *mask_rtrn);
bool
ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr, bool *set_rtrn);
bool
ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr, bool *set_rtrn);
ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr, ExprResult *val_rtrn,
const LookupEntry *values);
ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr, ExprResult *val_rtrn,
const LookupEntry *values);
-extern int
-ExprResolveMask(struct xkb_context *ctx, ExprDef *expr, ExprResult *val_rtrn,
- const LookupEntry *values);
+bool
+ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
+ unsigned int *mask_rtrn, const LookupEntry *values);
bool
ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
bool
ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
unsigned int level;
struct xkb_kt_map_entry entry;
unsigned int level;
struct xkb_kt_map_entry entry;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
- if (!ExprResolveVModMask(info->keymap, arrayNdx, &rtrn))
+ if (!ExprResolveVModMask(info->keymap, arrayNdx, &mask))
return ReportTypeBadType(info, type, "map entry", "modifier mask");
return ReportTypeBadType(info, type, "map entry", "modifier mask");
- entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
- entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */
+ entry.mods.real_mods = mask & 0xff; /* modifiers < 512 */
+ entry.mods.vmods = (mask >> 8) & 0xffff; /* modifiers > 512 */
if ((entry.mods.real_mods & (~type->mask)) ||
if ((entry.mods.real_mods & (~type->mask)) ||
- ((entry.mods.vmods & (~type->vmask)) != 0)) {
+ (entry.mods.vmods & (~type->vmask))) {
log_lvl(info->keymap->ctx, 1,
"Map entry for unused modifiers in %s; "
"Using %s instead of %s\n",
log_lvl(info->keymap->ctx, 1,
"Map entry for unused modifiers in %s; "
"Using %s instead of %s\n",
SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
PreserveInfo new;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "preserve entry");
PreserveInfo new;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "preserve entry");
- if (!ExprResolveVModMask(info->keymap, arrayNdx, &rtrn))
+ if (!ExprResolveVModMask(info->keymap, arrayNdx, &mask))
return ReportTypeBadType(info, type, "preserve entry",
"modifier mask");
return ReportTypeBadType(info, type, "preserve entry",
"modifier mask");
- new.indexMods = rtrn.uval & 0xff;
- new.indexVMods = (rtrn.uval >> 8) & 0xffff;
+ new.indexMods = mask & 0xff;
+ new.indexVMods = (mask >> 8) & 0xffff;
if ((new.indexMods & (~type->mask)) ||
(new.indexVMods & (~type->vmask))) {
if ((new.indexMods & (~type->mask)) ||
(new.indexVMods & (~type->vmask))) {
PreserveIndexTxt(info, &new));
}
PreserveIndexTxt(info, &new));
}
- if (!ExprResolveVModMask(info->keymap, value, &rtrn)) {
+ if (!ExprResolveVModMask(info->keymap, value, &mask)) {
log_err(info->keymap->ctx,
"Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n",
log_err(info->keymap->ctx,
"Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n",
- new.preMods = rtrn.uval & 0xff;
- new.preVMods = (rtrn.uval >> 16) & 0xffff;
+ new.preMods = mask & 0xff;
+ new.preVMods = (mask >> 16) & 0xffff;
if ((new.preMods & (~new.indexMods)) ||
(new.preVMods & (~new.indexVMods))) {
if ((new.preMods & (~new.indexMods)) ||
(new.preVMods & (~new.indexVMods))) {
SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type,
const char *field, ExprDef *arrayNdx, ExprDef *value)
{
SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type,
const char *field, ExprDef *arrayNdx, ExprDef *value)
{
if (istreq(field, "modifiers")) {
if (istreq(field, "modifiers")) {
- unsigned mods, vmods;
- if (arrayNdx != NULL)
+ xkb_mod_mask_t mask, mods, vmods;
+
+ if (arrayNdx)
log_warn(info->keymap->ctx,
"The modifiers field of a key type is not an array; "
"Illegal array subscript ignored\n");
log_warn(info->keymap->ctx,
"The modifiers field of a key type is not an array; "
"Illegal array subscript ignored\n");
/* get modifier mask for current type */
/* get modifier mask for current type */
- if (!ExprResolveVModMask(info->keymap, value, &tmp)) {
+ if (!ExprResolveVModMask(info->keymap, value, &mask)) {
log_err(info->keymap->ctx,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
return false;
}
log_err(info->keymap->ctx,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
return false;
}
- mods = tmp.uval & 0xff; /* core mods */
- vmods = (tmp.uval >> 8) & 0xffff; /* xkb virtual mods */
+
+ mods = mask & 0xff; /* core mods */
+ vmods = (mask >> 8) & 0xffff; /* xkb virtual mods */
if (type->defined & _KT_Mask) {
log_warn(info->keymap->ctx,
"Multiple modifier mask definitions for key type %s; "
if (type->defined & _KT_Mask) {
log_warn(info->keymap->ctx,
"Multiple modifier mask definitions for key type %s; "
else if (istreq(field, "vmods") ||
istreq(field, "virtualmods") ||
istreq(field, "virtualmodifiers")) {
else if (istreq(field, "vmods") ||
istreq(field, "virtualmods") ||
istreq(field, "virtualmodifiers")) {
- ok = ExprResolveVModMask(info->keymap, value, &tmp);
+ xkb_mod_mask_t mask;
+
+ ok = ExprResolveVModMask(info->keymap, value, &mask);
- keyi->vmodmap = (tmp.uval >> 8);
+ keyi->vmodmap = (mask >> 8);
keyi->defined |= _Key_VModMap;
}
else {
keyi->defined |= _Key_VModMap;
}
else {
xkb_mod_index_t i;
int nextFree;
xkb_mod_mask_t bit;
xkb_mod_index_t i;
int nextFree;
xkb_mod_mask_t bit;
nextFree = -1;
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
nextFree = -1;
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
if (!stmt->value)
return true;
if (!stmt->value)
return true;
- if (!ExprResolveModMask(keymap->ctx, stmt->value, &mod)) {
+ if (!ExprResolveModMask(keymap->ctx, stmt->value, &mask)) {
log_err(keymap->ctx, "Declaration of %s ignored\n",
xkb_atom_text(keymap->ctx, stmt->name));
return false;
}
log_err(keymap->ctx, "Declaration of %s ignored\n",
xkb_atom_text(keymap->ctx, stmt->name));
return false;
}
- if (mod.uval == keymap->vmods[i])
+ if (mask == keymap->vmods[i])
return true;
str1 = ModMaskText(keymap->vmods[i], true);
if (mergeMode == MERGE_OVERRIDE) {
str2 = str1;
return true;
str1 = ModMaskText(keymap->vmods[i], true);
if (mergeMode == MERGE_OVERRIDE) {
str2 = str1;
- str1 = ModMaskText(mod.uval, true);
+ str1 = ModMaskText(mask, true);
xkb_atom_text(keymap->ctx, stmt->name), str1, str2);
if (mergeMode == MERGE_OVERRIDE)
xkb_atom_text(keymap->ctx, stmt->name), str1, str2);
if (mergeMode == MERGE_OVERRIDE)
- keymap->vmods[i] = mod.uval;
+ keymap->vmods[i] = mask;
if (!stmt->value)
return true;
if (!stmt->value)
return true;
- if (!ExprResolveModMask(keymap->ctx, stmt->value, &mod)) {
+ if (!ExprResolveModMask(keymap->ctx, stmt->value, &mask)) {
log_err(keymap->ctx, "Declaration of %s ignored\n",
xkb_atom_text(keymap->ctx, stmt->name));
return false;
}
log_err(keymap->ctx, "Declaration of %s ignored\n",
xkb_atom_text(keymap->ctx, stmt->name));
return false;
}
- keymap->vmods[nextFree] = mod.uval;
+ keymap->vmods[nextFree] = mask;