#include "action.h"
#include "vmod.h"
+enum si_field {
+ SI_FIELD_VIRTUAL_MOD = (1 << 0),
+ SI_FIELD_ACTION = (1 << 1),
+ SI_FIELD_AUTO_REPEAT = (1 << 2),
+ SI_FIELD_LOCKING_KEY = (1 << 3),
+ SI_FIELD_LEVEL_ONE_ONLY = (1 << 4),
+};
+
typedef struct _SymInterpInfo {
- unsigned short defined;
+ enum si_field defined;
unsigned file_id;
enum merge_mode merge;
struct list entry;
struct xkb_sym_interpret interp;
} SymInterpInfo;
-#define _SI_VirtualMod (1 << 0)
-#define _SI_Action (1 << 1)
-#define _SI_AutoRepeat (1 << 2)
-#define _SI_LockingKey (1 << 3)
-#define _SI_LevelOneOnly (1 << 4)
+enum led_field {
+ LED_FIELD_INDEX = (1 << 0),
+ LED_FIELD_MODS = (1 << 1),
+ LED_FIELD_GROUPS = (1 << 2),
+ LED_FIELD_CTRLS = (1 << 3),
+ LED_FIELD_EXPLICIT = (1 << 4),
+ LED_FIELD_AUTOMATIC = (1 << 5),
+ LED_FIELD_DRIVES_KBD = (1 << 6),
+};
typedef struct _LEDInfo {
- unsigned short defined;
+ enum led_field defined;
unsigned file_id;
enum merge_mode merge;
struct list entry;
unsigned int ctrls;
} LEDInfo;
-#define _LED_Index (1 << 0)
-#define _LED_Mods (1 << 1)
-#define _LED_Groups (1 << 2)
-#define _LED_Ctrls (1 << 3)
-#define _LED_Explicit (1 << 4)
-#define _LED_Automatic (1 << 5)
-#define _LED_DrivesKbd (1 << 6)
-
typedef struct _GroupCompatInfo {
unsigned file_id;
enum merge_mode merge;
}
static bool
-UseNewInterpField(unsigned field, SymInterpInfo *old, SymInterpInfo *new,
- int verbosity, unsigned *collide)
+UseNewInterpField(enum si_field field, SymInterpInfo *old, SymInterpInfo *new,
+ int verbosity, enum si_field *collide)
{
if (!(old->defined & field))
return true;
static bool
AddInterp(CompatInfo * info, SymInterpInfo * new)
{
- unsigned collide;
+ enum si_field collide;
SymInterpInfo *old;
struct list entry;
int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
return true;
}
- if (UseNewInterpField(_SI_VirtualMod, old, new, verbosity,
+ if (UseNewInterpField(SI_FIELD_VIRTUAL_MOD, old, new, verbosity,
&collide)) {
old->interp.virtual_mod = new->interp.virtual_mod;
- old->defined |= _SI_VirtualMod;
+ old->defined |= SI_FIELD_VIRTUAL_MOD;
}
- if (UseNewInterpField(_SI_Action, old, new, verbosity,
+ if (UseNewInterpField(SI_FIELD_ACTION, old, new, verbosity,
&collide)) {
old->interp.act = new->interp.act;
- old->defined |= _SI_Action;
+ old->defined |= SI_FIELD_ACTION;
}
- if (UseNewInterpField(_SI_AutoRepeat, old, new, verbosity,
+ if (UseNewInterpField(SI_FIELD_AUTO_REPEAT, old, new, verbosity,
&collide)) {
old->interp.flags &= ~XkbSI_AutoRepeat;
old->interp.flags |= (new->interp.flags & XkbSI_AutoRepeat);
- old->defined |= _SI_AutoRepeat;
+ old->defined |= SI_FIELD_AUTO_REPEAT;
}
- if (UseNewInterpField(_SI_LockingKey, old, new, verbosity,
+ if (UseNewInterpField(SI_FIELD_LOCKING_KEY, old, new, verbosity,
&collide)) {
old->interp.flags &= ~XkbSI_LockingKey;
old->interp.flags |= (new->interp.flags & XkbSI_LockingKey);
- old->defined |= _SI_LockingKey;
+ old->defined |= SI_FIELD_LOCKING_KEY;
}
- if (UseNewInterpField(_SI_LevelOneOnly, old, new, verbosity,
+ if (UseNewInterpField(SI_FIELD_LEVEL_ONE_ONLY, old, new, verbosity,
&collide)) {
old->interp.match &= ~XkbSI_LevelOneOnly;
old->interp.match |= (new->interp.match & XkbSI_LevelOneOnly);
- old->defined |= _SI_LevelOneOnly;
+ old->defined |= SI_FIELD_LEVEL_ONE_ONLY;
}
if (collide) {
/***====================================================================***/
static bool
-UseNewLEDField(unsigned field, LEDInfo *old, LEDInfo *new,
- int verbosity, unsigned *collide)
+UseNewLEDField(enum led_field field, LEDInfo *old, LEDInfo *new,
+ int verbosity, enum led_field *collide)
{
if (!(old->defined & field))
return true;
AddIndicatorMap(CompatInfo *info, LEDInfo *new)
{
LEDInfo *old;
- unsigned collide;
+ enum led_field collide;
struct xkb_context *ctx = info->keymap->ctx;
int verbosity = xkb_get_log_verbosity(ctx);
}
collide = 0;
- if (UseNewLEDField(_LED_Index, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_INDEX, old, new, verbosity,
&collide)) {
old->indicator = new->indicator;
- old->defined |= _LED_Index;
+ old->defined |= LED_FIELD_INDEX;
}
- if (UseNewLEDField(_LED_Mods, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_MODS, old, new, verbosity,
&collide)) {
old->which_mods = new->which_mods;
old->real_mods = new->real_mods;
old->vmods = new->vmods;
- old->defined |= _LED_Mods;
+ old->defined |= LED_FIELD_MODS;
}
- if (UseNewLEDField(_LED_Groups, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_GROUPS, old, new, verbosity,
&collide)) {
old->which_groups = new->which_groups;
old->groups = new->groups;
- old->defined |= _LED_Groups;
+ old->defined |= LED_FIELD_GROUPS;
}
- if (UseNewLEDField(_LED_Ctrls, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_CTRLS, old, new, verbosity,
&collide)) {
old->ctrls = new->ctrls;
- old->defined |= _LED_Ctrls;
+ old->defined |= LED_FIELD_CTRLS;
}
- if (UseNewLEDField(_LED_Explicit, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_EXPLICIT, old, new, verbosity,
&collide)) {
old->flags &= ~XkbIM_NoExplicit;
old->flags |= (new->flags & XkbIM_NoExplicit);
- old->defined |= _LED_Explicit;
+ old->defined |= LED_FIELD_EXPLICIT;
}
- if (UseNewLEDField(_LED_Automatic, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_AUTOMATIC, old, new, verbosity,
&collide)) {
old->flags &= ~XkbIM_NoAutomatic;
old->flags |= (new->flags & XkbIM_NoAutomatic);
- old->defined |= _LED_Automatic;
+ old->defined |= LED_FIELD_AUTOMATIC;
}
- if (UseNewLEDField(_LED_DrivesKbd, old, new, verbosity,
+ if (UseNewLEDField(LED_FIELD_DRIVES_KBD, old, new, verbosity,
&collide)) {
old->flags &= ~XkbIM_LEDDrivesKB;
old->flags |= (new->flags & XkbIM_LEDDrivesKB);
- old->defined |= _LED_DrivesKbd;
+ old->defined |= LED_FIELD_DRIVES_KBD;
}
if (collide) {
if (!HandleActionDef(value, keymap, &si->interp.act.any, info->act))
return false;
- si->defined |= _SI_Action;
+ si->defined |= SI_FIELD_ACTION;
}
else if (istreq(field, "virtualmodifier") ||
istreq(field, "virtualmod")) {
return ReportSIBadType(info, si, field, "virtual modifier");
si->interp.virtual_mod = ndx;
- si->defined |= _SI_VirtualMod;
+ si->defined |= SI_FIELD_VIRTUAL_MOD;
}
else if (istreq(field, "repeat")) {
bool set;
else
si->interp.flags &= ~XkbSI_AutoRepeat;
- si->defined |= _SI_AutoRepeat;
+ si->defined |= SI_FIELD_AUTO_REPEAT;
}
else if (istreq(field, "locking")) {
bool set;
else
si->interp.flags &= ~XkbSI_LockingKey;
- si->defined |= _SI_LockingKey;
+ si->defined |= SI_FIELD_LOCKING_KEY;
}
else if (istreq(field, "usemodmap") ||
istreq(field, "usemodmapmods")) {
else
si->interp.match &= ~XkbSI_LevelOneOnly;
- si->defined |= _SI_LevelOneOnly;
+ si->defined |= SI_FIELD_LEVEL_ONE_ONLY;
}
else {
return ReportBadField(keymap, "symbol interpretation", field,
led->real_mods = mask & 0xff;
led->vmods = (mask >> 8) & 0xff;
- led->defined |= _LED_Mods;
+ led->defined |= LED_FIELD_MODS;
}
else if (istreq(field, "groups")) {
unsigned int mask;
return ReportIndicatorBadType(info, led, field, "group mask");
led->groups = mask;
- led->defined |= _LED_Groups;
+ led->defined |= LED_FIELD_GROUPS;
}
else if (istreq(field, "controls") || istreq(field, "ctrls")) {
unsigned int mask;
"controls mask");
led->ctrls = mask;
- led->defined |= _LED_Ctrls;
+ led->defined |= LED_FIELD_CTRLS;
}
else if (istreq(field, "allowexplicit")) {
bool set;
else
led->flags |= XkbIM_NoExplicit;
- led->defined |= _LED_Explicit;
+ led->defined |= LED_FIELD_EXPLICIT;
}
else if (istreq(field, "whichmodstate") ||
istreq(field, "whichmodifierstate")) {
else
led->flags &= ~XkbIM_LEDDrivesKB;
- led->defined |= _LED_DrivesKbd;
+ led->defined |= LED_FIELD_DRIVES_KBD;
}
else if (istreq(field, "index")) {
int ndx;
}
led->indicator = (xkb_led_index_t) ndx;
- led->defined |= _LED_Index;
+ led->defined |= LED_FIELD_INDEX;
}
else {
log_err(info->keymap->ctx,
typedef darray(xkb_keysym_t) darray_xkb_keysym_t;
typedef darray(union xkb_action) darray_xkb_action;
-#define RepeatYes 1
-#define RepeatNo 0
-#define RepeatUndefined ~((unsigned) 0)
-
-#define _Key_Syms (1 << 0)
-#define _Key_Acts (1 << 1)
-#define _Key_Repeat (1 << 2)
-#define _Key_Behavior (1 << 3)
-#define _Key_Type_Dflt (1 << 4)
-#define _Key_Types (1 << 5)
-#define _Key_GroupInfo (1 << 6)
-#define _Key_VModMap (1 << 7)
+enum key_repeat {
+ KEY_REPEAT_YES = 1,
+ KEY_REPEAT_NO = 0,
+ KEY_REPEAT_UNDEFINED = -1
+};
+
+enum key_field {
+ KEY_FIELD_SYMS = (1 << 0),
+ KEY_FIELD_ACTS = (1 << 1),
+ KEY_FIELD_REPEAT = (1 << 2),
+ KEY_FIELD_BEHAVIOR = (1 << 3),
+ KEY_FIELD_TYPE_DFLT = (1 << 4),
+ KEY_FIELD_TYPES = (1 << 5),
+ KEY_FIELD_GROUPINFO = (1 << 6),
+ KEY_FIELD_VMODMAP = (1 << 7),
+};
static inline const char *
longText(unsigned long val)
}
typedef struct _KeyInfo {
- unsigned short defined;
+ enum key_field defined;
unsigned file_id;
enum merge_mode merge;
darray_xkb_action acts[XkbNumKbdGroups];
xkb_atom_t types[XkbNumKbdGroups];
- unsigned repeat;
+ enum key_repeat repeat;
struct xkb_behavior behavior;
unsigned short vmodmap;
xkb_atom_t dfltType;
keyi->behavior.type = XkbKB_Default;
keyi->behavior.data = 0;
keyi->vmodmap = 0;
- keyi->repeat = RepeatUndefined;
+ keyi->repeat = KEY_REPEAT_UNDEFINED;
keyi->out_of_range_group_action = 0;
keyi->out_of_range_group_number = 0;
}
}
static bool
-UseNewKeyField(unsigned field, KeyInfo *old, KeyInfo *new, int verbosity,
- unsigned *collide)
+UseNewKeyField(enum key_field field, KeyInfo *old, KeyInfo *new,
+ int verbosity, enum key_field *collide)
{
if (!(old->defined & field))
return true;
MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
{
xkb_group_index_t i;
- unsigned collide = 0;
+ enum key_field collide = 0;
bool report;
int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
from->numLevels[i] = 0;
from->symsDefined &= ~(1 << i);
if (!darray_empty(into->syms[i]))
- into->defined |= _Key_Syms;
+ into->defined |= KEY_FIELD_SYMS;
if (!darray_empty(into->acts[i]))
- into->defined |= _Key_Acts;
+ into->defined |= KEY_FIELD_ACTS;
}
else {
if (report) {
if (!darray_empty(into->syms[i]))
- collide |= _Key_Syms;
+ collide |= KEY_FIELD_SYMS;
if (!darray_empty(into->acts[i]))
- collide |= _Key_Acts;
+ collide |= KEY_FIELD_ACTS;
}
MergeKeyGroups(info, into, from, (unsigned) i);
}
if ((into->types[i] != XKB_ATOM_NONE) && report &&
(into->types[i] != from->types[i])) {
xkb_atom_t use, ignore;
- collide |= _Key_Types;
+ collide |= KEY_FIELD_TYPES;
if (from->merge != MERGE_AUGMENT) {
use = from->types[i];
ignore = into->types[i];
}
}
- if (UseNewKeyField(_Key_Behavior, into, from, verbosity, &collide)) {
+ if (UseNewKeyField(KEY_FIELD_BEHAVIOR, into, from, verbosity, &collide)) {
into->behavior = from->behavior;
- into->defined |= _Key_Behavior;
+ into->defined |= KEY_FIELD_BEHAVIOR;
}
- if (UseNewKeyField(_Key_VModMap, into, from, verbosity, &collide)) {
+ if (UseNewKeyField(KEY_FIELD_VMODMAP, into, from, verbosity, &collide)) {
into->vmodmap = from->vmodmap;
- into->defined |= _Key_VModMap;
+ into->defined |= KEY_FIELD_VMODMAP;
}
- if (UseNewKeyField(_Key_Repeat, into, from, verbosity, &collide)) {
+ if (UseNewKeyField(KEY_FIELD_REPEAT, into, from, verbosity, &collide)) {
into->repeat = from->repeat;
- into->defined |= _Key_Repeat;
+ into->defined |= KEY_FIELD_REPEAT;
}
- if (UseNewKeyField(_Key_Type_Dflt, into, from, verbosity, &collide)) {
+ if (UseNewKeyField(KEY_FIELD_TYPE_DFLT, into, from, verbosity, &collide)) {
into->dfltType = from->dfltType;
- into->defined |= _Key_Type_Dflt;
+ into->defined |= KEY_FIELD_TYPE_DFLT;
}
- if (UseNewKeyField(_Key_GroupInfo, into, from, verbosity, &collide)) {
+ if (UseNewKeyField(KEY_FIELD_GROUPINFO, into, from, verbosity, &collide)) {
into->out_of_range_group_action = from->out_of_range_group_action;
into->out_of_range_group_number = from->out_of_range_group_number;
- into->defined |= _Key_GroupInfo;
+ into->defined |= KEY_FIELD_GROUPINFO;
}
if (collide)
};
static const LookupEntry repeatEntries[] = {
- { "true", RepeatYes },
- { "yes", RepeatYes },
- { "on", RepeatYes },
- { "false", RepeatNo },
- { "no", RepeatNo },
- { "off", RepeatNo },
- { "default", RepeatUndefined },
+ { "true", KEY_REPEAT_YES },
+ { "yes", KEY_REPEAT_YES },
+ { "on", KEY_REPEAT_YES },
+ { "false", KEY_REPEAT_NO },
+ { "no", KEY_REPEAT_NO },
+ { "off", KEY_REPEAT_NO },
+ { "default", KEY_REPEAT_UNDEFINED },
{ NULL, 0 }
};
if (arrayNdx == NULL) {
keyi->dfltType = xkb_atom_intern(ctx, str);
- keyi->defined |= _Key_Type_Dflt;
+ keyi->defined |= KEY_FIELD_TYPE_DFLT;
}
else if (!ExprResolveGroup(ctx, arrayNdx, &ndx)) {
log_err(info->keymap->ctx,
ok = ExprResolveVModMask(info->keymap, value, &mask);
if (ok) {
keyi->vmodmap = (mask >> 8);
- keyi->defined |= _Key_VModMap;
+ keyi->defined |= KEY_FIELD_VMODMAP;
}
else {
log_err(info->keymap->ctx,
ok = ExprResolveEnum(ctx, value, &val, lockingEntries);
if (ok)
keyi->behavior.type = val;
- keyi->defined |= _Key_Behavior;
+ keyi->defined |= KEY_FIELD_BEHAVIOR;
}
else if (istreq(field, "radiogroup") ||
istreq(field, "permanentradiogroup") ||
return false;
}
keyi->repeat = val;
- keyi->defined |= _Key_Repeat;
+ keyi->defined |= KEY_FIELD_REPEAT;
}
else if (istreq(field, "groupswrap") ||
istreq(field, "wrapgroups")) {
else
keyi->out_of_range_group_action = XkbClampIntoRange;
- keyi->defined |= _Key_GroupInfo;
+ keyi->defined |= KEY_FIELD_GROUPINFO;
}
else if (istreq(field, "groupsclamp") ||
istreq(field, "clampgroups")) {
else
keyi->out_of_range_group_action = XkbWrapIntoRange;
- keyi->defined |= _Key_GroupInfo;
+ keyi->defined |= KEY_FIELD_GROUPINFO;
}
else if (istreq(field, "groupsredirect") ||
istreq(field, "redirectgroups")) {
keyi->out_of_range_group_action = XkbRedirectIntoRange;
keyi->out_of_range_group_number = grp - 1;
- keyi->defined |= _Key_GroupInfo;
+ keyi->defined |= KEY_FIELD_GROUPINFO;
}
else {
log_err(info->keymap->ctx,
outActs = NULL;
key->num_groups = nGroups;
- if (keyi->defined & _Key_GroupInfo) {
+ if (keyi->defined & KEY_FIELD_GROUPINFO) {
key->out_of_range_group_number = keyi->out_of_range_group_number;
key->out_of_range_group_action = keyi->out_of_range_group_action;
}
key->explicit |= XkbExplicitBehaviorMask;
break;
}
- if (keyi->defined & _Key_VModMap) {
+ if (keyi->defined & KEY_FIELD_VMODMAP) {
key->vmodmap = keyi->vmodmap;
key->explicit |= XkbExplicitVModMapMask;
}
- if (keyi->repeat != RepeatUndefined) {
- key->repeats = keyi->repeat == RepeatYes;
+ if (keyi->repeat != KEY_REPEAT_UNDEFINED) {
+ key->repeats = (keyi->repeat == KEY_REPEAT_YES);
key->explicit |= XkbExplicitAutoRepeatMask;
}