};
const LookupEntry symInterpretMatchMaskNames[] = {
- { "NoneOf", XkbSI_NoneOf },
- { "AnyOfOrNone", XkbSI_AnyOfOrNone },
- { "AnyOf", XkbSI_AnyOf },
- { "AllOf", XkbSI_AllOf },
- { "Exactly", XkbSI_Exactly },
+ { "NoneOf", MATCH_NONE },
+ { "AnyOfOrNone", MATCH_ANY_OR_NONE },
+ { "AnyOf", MATCH_ANY },
+ { "AllOf", MATCH_ALL },
+ { "Exactly", MATCH_EXACTLY },
};
#define BUFFER_SIZE 1024
}
const char *
-SIMatchText(unsigned type)
+SIMatchText(enum xkb_match_operation type)
{
const char *name;
char *buf;
- type &= XkbSI_OpMask;
+ type &= MATCH_OP_MASK;
name = LookupValue(symInterpretMatchMaskNames, type);
if (name)
return name;
buf = GetBuffer(40);
- snprintf(buf, 40, "0x%x", type & XkbSI_OpMask);
+ snprintf(buf, 40, "0x%x", type);
return buf;
}
}
if (UseNewInterpField(SI_FIELD_LEVEL_ONE_ONLY, old, new, report,
&collide)) {
- old->interp.match &= ~XkbSI_LevelOneOnly;
- old->interp.match |= (new->interp.match & XkbSI_LevelOneOnly);
+ old->interp.match &= ~MATCH_LEVEL_ONE_ONLY;
+ old->interp.match |= (new->interp.match & MATCH_LEVEL_ONE_ONLY);
old->defined |= SI_FIELD_LEVEL_ONE_ONLY;
}
/***====================================================================***/
static bool
-ResolveStateAndPredicate(ExprDef *expr, unsigned *pred_rtrn,
+ResolveStateAndPredicate(ExprDef *expr, enum xkb_match_operation *pred_rtrn,
xkb_mod_mask_t *mods_rtrn, CompatInfo *info)
{
if (expr == NULL) {
- *pred_rtrn = XkbSI_AnyOfOrNone;
+ *pred_rtrn = MATCH_ANY_OR_NONE;
*mods_rtrn = ~0;
return true;
}
- *pred_rtrn = XkbSI_Exactly;
+ *pred_rtrn = MATCH_EXACTLY;
if (expr->op == EXPR_ACTION_DECL) {
const char *pred_txt = xkb_atom_text(info->keymap->ctx,
expr->value.action.name);
const char *pred_txt = xkb_atom_text(info->keymap->ctx,
expr->value.str);
if (pred_txt && istreq(pred_txt, "any")) {
- *pred_rtrn = XkbSI_AnyOf;
+ *pred_rtrn = MATCH_ANY;
*mods_rtrn = 0xff;
return true;
}
return ReportSIBadType(info, si, field, "level specification");
if (val)
- si->interp.match |= XkbSI_LevelOneOnly;
+ si->interp.match |= MATCH_LEVEL_ONE_ONLY;
else
- si->interp.match &= ~XkbSI_LevelOneOnly;
+ si->interp.match &= ~MATCH_LEVEL_ONE_ONLY;
si->defined |= SI_FIELD_LEVEL_ONE_ONLY;
}
return false;
}
- si.interp.match = pred & XkbSI_OpMask;
+ si.interp.match = pred & MATCH_OP_MASK;
si.interp.mods = mods;
}
static void
-CopyInterps(CompatInfo *info, bool needSymbol, unsigned pred)
+CopyInterps(CompatInfo *info, bool needSymbol, enum xkb_match_operation pred)
{
SymInterpInfo *si;
darray_foreach(si, info->interps) {
- if (((si->interp.match & XkbSI_OpMask) != pred) ||
+ if (((si->interp.match & MATCH_OP_MASK) != pred) ||
(needSymbol && si->interp.sym == XKB_KEY_NoSymbol) ||
(!needSymbol && si->interp.sym != XKB_KEY_NoSymbol))
continue;
if (!darray_empty(info->interps)) {
/* Most specific to least specific. */
- CopyInterps(info, true, XkbSI_Exactly);
- CopyInterps(info, true, XkbSI_AllOf | XkbSI_NoneOf);
- CopyInterps(info, true, XkbSI_AnyOf);
- CopyInterps(info, true, XkbSI_AnyOfOrNone);
- CopyInterps(info, false, XkbSI_Exactly);
- CopyInterps(info, false, XkbSI_AllOf | XkbSI_NoneOf);
- CopyInterps(info, false, XkbSI_AnyOf);
- CopyInterps(info, false, XkbSI_AnyOfOrNone);
+ CopyInterps(info, true, MATCH_EXACTLY);
+ CopyInterps(info, true, MATCH_ALL);
+ CopyInterps(info, true, MATCH_ANY);
+ CopyInterps(info, true, MATCH_ANY_OR_NONE);
+ CopyInterps(info, false, MATCH_EXACTLY);
+ CopyInterps(info, false, MATCH_ALL);
+ CopyInterps(info, false, MATCH_ANY);
+ CopyInterps(info, false, MATCH_ANY_OR_NONE);
}
CopyIndicatorMapDefs(info);
interp->sym != XKB_KEY_NoSymbol)
continue;
- if (level == 0 || !(interp->match & XkbSI_LevelOneOnly))
+ if (level == 0 || !(interp->match & MATCH_LEVEL_ONE_ONLY))
mods = key->modmap;
else
mods = 0;
- switch (interp->match & XkbSI_OpMask) {
- case XkbSI_NoneOf:
+ switch (interp->match & MATCH_OP_MASK) {
+ case MATCH_NONE:
found = !(interp->mods & mods);
break;
- case XkbSI_AnyOfOrNone:
+ case MATCH_ANY_OR_NONE:
found = (!mods || (interp->mods & mods));
break;
- case XkbSI_AnyOf:
+ case MATCH_ANY:
found = !!(interp->mods & mods);
break;
- case XkbSI_AllOf:
+ case MATCH_ALL:
found = ((interp->mods & mods) == interp->mods);
break;
- case XkbSI_Exactly:
+ case MATCH_EXACTLY:
found = (interp->mods == mods);
break;
default:
continue;
if ((group == 0 && level == 0) ||
- !(interp->match & XkbSI_LevelOneOnly)) {
+ !(interp->match & MATCH_LEVEL_ONE_ONLY)) {
if (interp->virtual_mod != XKB_MOD_INVALID)
vmodmask |= (1 << interp->virtual_mod);
}