StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove ExprResult 

Convert the IdentLookup typedef away from ExprResult, which drags along
everything else. This should also make all of the conversions explicit.

Signed-off-by: Ran Benita <ran234@gmail.com>
master
Ran Benita 2012-07-27 15:31:03 +03:00
parent 6917901f81
commit 41d9afc556
7 changed files with 163 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/xkbcomp/action.c
View File

@ -116,16 +116,16 @@ static const LookupEntry fieldStrings[] = {
static bool static bool
stringToValue(const LookupEntry tab[], const char *string, stringToValue(const LookupEntry tab[], const char *string,
unsigned *value_rtrn) unsigned int *value_rtrn)
{ {
const LookupEntry *entry; const LookupEntry *entry;
if (!string) if (!string)
return false; return false;
for (entry = tab; entry->name != NULL; entry++) { for (entry = tab; entry->name; entry++) {
if (istreq(entry->name, string)) { if (istreq(entry->name, string)) {
*value_rtrn = entry->result; *value_rtrn = entry->value;
return true; return true;
} }
} }
@ -134,12 +134,12 @@ stringToValue(const LookupEntry tab[], const char *string,
} }
static const char * static const char *
valueToString(const LookupEntry tab[], unsigned value) valueToString(const LookupEntry tab[], unsigned int value)
{ {
const LookupEntry *entry; const LookupEntry *entry;
for (entry = tab; entry->name != NULL; entry++) for (entry = tab; entry->name; entry++)
if (entry->result == value) if (entry->value == value)
return entry->name; return entry->name;
return "unknown"; return "unknown";
@ -483,7 +483,6 @@ static bool
HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value) unsigned field, ExprDef *array_ndx, ExprDef *value)
{ {
ExprResult rtrn;
struct xkb_pointer_button_action *act; struct xkb_pointer_button_action *act;
act = (struct xkb_pointer_button_action *) action; act = (struct xkb_pointer_button_action *) action;
@ -534,7 +533,7 @@ HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
if (btn < 0 || btn > 255) { if (btn < 0 || btn > 255) {
log_err(keymap->ctx, log_err(keymap->ctx,
"The count field must have a value in the range 0..255; " "The count field must have a value in the range 0..255; "
"Illegal count %d ignored\n", rtrn.ival); "Illegal count %d ignored\n", btn);
return false; return false;
} }
@ -555,7 +554,6 @@ static bool
HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action, HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value) unsigned field, ExprDef *array_ndx, ExprDef *value)
{ {
ExprResult rtrn;
struct xkb_pointer_default_action *act; struct xkb_pointer_default_action *act;
act = (struct xkb_pointer_default_action *) action; act = (struct xkb_pointer_default_action *) action;
@ -594,7 +592,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action,
if (btn < 0 || btn > 5) { if (btn < 0 || btn > 5) {
log_err(keymap->ctx, log_err(keymap->ctx,
"New default button value must be in the range 1..5; " "New default button value must be in the range 1..5; "
"Illegal default button value %d ignored\n", rtrn.ival); "Illegal default button value %d ignored\n", btn);
return false; return false;
} }
if (btn == 0) { if (btn == 0) {
@ -683,7 +681,6 @@ static bool
HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action, HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value) unsigned field, ExprDef *array_ndx, ExprDef *value)
{ {
ExprResult rtrn;
struct xkb_switch_screen_action *act; struct xkb_switch_screen_action *act;
act = (struct xkb_switch_screen_action *) action; act = (struct xkb_switch_screen_action *) action;
@ -710,7 +707,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action,
if (val < 0 || val > 255) { if (val < 0 || val > 255) {
log_err(keymap->ctx, log_err(keymap->ctx,
"Screen index must be in the range 1..255; " "Screen index must be in the range 1..255; "
"Illegal screen value %d ignored\n", rtrn.ival); "Illegal screen value %d ignored\n", val);
return false; return false;
} }
@ -938,7 +935,6 @@ static bool
HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action, HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value) unsigned field, ExprDef *array_ndx, ExprDef *value)
{ {
ExprResult rtrn;
struct xkb_device_button_action *act; struct xkb_device_button_action *act;
act = (struct xkb_device_button_action *) action; act = (struct xkb_device_button_action *) action;
@ -989,7 +985,7 @@ HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
if (btn < 0 || btn > 255) { if (btn < 0 || btn > 255) {
log_err(keymap->ctx, log_err(keymap->ctx,
"The count field must have a value in the range 0..255; " "The count field must have a value in the range 0..255; "
"Illegal count %d ignored\n", rtrn.ival); "Illegal count %d ignored\n", btn);
return false; return false;
} }

9
src/xkbcomp/compat.c
View File

@ -635,7 +635,7 @@ SetInterpField(CompatInfo *info, SymInterpInfo *si, const char *field,
ExprDef *arrayNdx, ExprDef *value) ExprDef *arrayNdx, ExprDef *value)
{ {
struct xkb_keymap *keymap = info->keymap; struct xkb_keymap *keymap = info->keymap;
ExprResult tmp; xkb_mod_index_t ndx;
if (istreq(field, "action")) { if (istreq(field, "action")) {
if (arrayNdx) if (arrayNdx)
@ -651,10 +651,10 @@ SetInterpField(CompatInfo *info, SymInterpInfo *si, const char *field,
if (arrayNdx) if (arrayNdx)
return ReportSINotArray(info, si, field); return ReportSINotArray(info, si, field);
if (!ResolveVirtualModifier(value, keymap, &tmp, &info->vmods)) if (!ResolveVirtualModifier(value, keymap, &ndx, &info->vmods))
return ReportSIBadType(info, si, field, "virtual modifier"); return ReportSIBadType(info, si, field, "virtual modifier");
si->interp.virtual_mod = tmp.uval; si->interp.virtual_mod = ndx;
si->defined |= _SI_VirtualMod; si->defined |= _SI_VirtualMod;
} }
else if (istreq(field, "repeat")) { else if (istreq(field, "repeat")) {
@ -752,7 +752,6 @@ static int
SetIndicatorMapField(CompatInfo *info, LEDInfo *led, SetIndicatorMapField(CompatInfo *info, LEDInfo *led,
const char *field, ExprDef *arrayNdx, ExprDef *value) const char *field, ExprDef *arrayNdx, ExprDef *value)
{ {
ExprResult rtrn;
bool ok = true; bool ok = true;
struct xkb_keymap *keymap = info->keymap; struct xkb_keymap *keymap = info->keymap;
@ -870,7 +869,7 @@ SetIndicatorMapField(CompatInfo *info, LEDInfo *led,
log_err(info->keymap->ctx, log_err(info->keymap->ctx,
"Illegal indicator index %d (range 1..%d); " "Illegal indicator index %d (range 1..%d); "
"Index definition for %s indicator ignored\n", "Index definition for %s indicator ignored\n",
rtrn.uval, XkbNumIndicators, ndx, XkbNumIndicators,
xkb_atom_text(keymap->ctx, led->name)); xkb_atom_text(keymap->ctx, led->name));
return false; return false;
} }

266
src/xkbcomp/expr.c
View File

@ -28,7 +28,7 @@
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv, typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
xkb_atom_t field, enum expr_value_type type, xkb_atom_t field, enum expr_value_type type,
ExprResult *val_rtrn); unsigned int *val_rtrn);
const char * const char *
exprOpText(enum expr_op_type op) exprOpText(enum expr_op_type op)
@ -150,9 +150,8 @@ ExprResolveLhs(struct xkb_context *ctx, ExprDef *expr, const char **elem_rtrn,
} }
static bool static bool
SimpleLookup(struct xkb_context *ctx, const void *priv, SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
xkb_atom_t field, enum expr_value_type type, enum expr_value_type type, unsigned int *val_rtrn)
ExprResult *val_rtrn)
{ {
const LookupEntry *entry; const LookupEntry *entry;
const char *str; const char *str;
@ -163,7 +162,7 @@ SimpleLookup(struct xkb_context *ctx, const void *priv,
str = xkb_atom_text(ctx, field); str = xkb_atom_text(ctx, field);
for (entry = priv; entry && entry->name; entry++) { for (entry = priv; entry && entry->name; entry++) {
if (istreq(str, entry->name)) { if (istreq(str, entry->name)) {
val_rtrn->uval = entry->result; *val_rtrn = entry->value;
return true; return true;
} }
} }
@ -186,32 +185,33 @@ static const LookupEntry modIndexNames[] = {
bool bool
LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field, LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn) enum expr_value_type type, xkb_mod_index_t *val_rtrn)
{ {
return SimpleLookup(ctx, modIndexNames, field, type, val_rtrn); return SimpleLookup(ctx, modIndexNames, field, type, val_rtrn);
} }
bool bool
LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field, LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn) enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
{ {
const char *str; const char *str;
bool ret = true; xkb_mod_index_t ndx;
if (type != EXPR_TYPE_INT) if (type != EXPR_TYPE_INT)
return false; return false;
str = xkb_atom_text(ctx, field); str = xkb_atom_text(ctx, field);
if (str == NULL)
return false;
if (istreq(str, "all")) if (istreq(str, "all"))
val_rtrn->uval = 0xff; *val_rtrn = 0xff;
else if (istreq(str, "none")) else if (istreq(str, "none"))
val_rtrn->uval = 0; *val_rtrn = 0;
else if (LookupModIndex(ctx, priv, field, type, val_rtrn)) else if (LookupModIndex(ctx, priv, field, type, &ndx))
val_rtrn->uval = (1 << val_rtrn->uval); *val_rtrn = (1 << ndx);
else else
ret = false; return false;
return ret;
return true;
} }
bool bool
@ -366,13 +366,14 @@ ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr, xkb_keycode_t *kc)
* *
* Cool. * Cool.
*/ */
static int static bool
ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr, ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
ExprResult *val_rtrn, IdentLookupFunc lookup, int *val_rtrn, IdentLookupFunc lookup,
const void *lookupPriv) const void *lookupPriv)
{ {
int ok = 0; bool ok = false;
ExprResult leftRtrn, rightRtrn; int l, r;
unsigned u;
ExprDef *left, *right; ExprDef *left, *right;
switch (expr->op) { switch (expr->op) {
@ -383,16 +384,20 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
exprValueTypeText(expr->value_type)); exprValueTypeText(expr->value_type));
return false; return false;
} }
val_rtrn->ival = expr->value.ival;
*val_rtrn = expr->value.ival;
return true; return true;
case EXPR_IDENT: case EXPR_IDENT:
if (lookup) if (lookup)
ok = lookup(ctx, lookupPriv, expr->value.str, ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
EXPR_TYPE_INT, val_rtrn);
if (!ok) if (!ok)
log_err(ctx, "Identifier \"%s\" of type int is unknown\n", log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->value.str)); xkb_atom_text(ctx, expr->value.str));
else
*val_rtrn = (int) u;
return ok; return ok;
case EXPR_FIELD_REF: case EXPR_FIELD_REF:
@ -407,34 +412,32 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
case EXPR_DIVIDE: case EXPR_DIVIDE:
left = expr->value.binary.left; left = expr->value.binary.left;
right = expr->value.binary.right; right = expr->value.binary.right;
if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
lookupPriv) && !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
ExprResolveIntegerLookup(ctx, right, &rightRtrn, lookup, return false;
lookupPriv)) {
switch (expr->op) { switch (expr->op) {
case EXPR_ADD: case EXPR_ADD:
val_rtrn->ival = leftRtrn.ival + rightRtrn.ival; *val_rtrn = l + r;
break; break;
case EXPR_SUBTRACT: case EXPR_SUBTRACT:
val_rtrn->ival = leftRtrn.ival - rightRtrn.ival; *val_rtrn = l - r;
break; break;
case EXPR_MULTIPLY: case EXPR_MULTIPLY:
val_rtrn->ival = leftRtrn.ival * rightRtrn.ival; *val_rtrn = l * r;
break; break;
case EXPR_DIVIDE: case EXPR_DIVIDE:
if (rightRtrn.ival == 0) { if (r == 0) {
log_err(ctx, "Cannot divide by zero: %d / %d\n", log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
leftRtrn.ival, rightRtrn.ival); return false;
return false;
}
val_rtrn->ival = leftRtrn.ival / rightRtrn.ival;
break;
default:
break;
} }
return true; *val_rtrn = l / r;
break;
default:
break;
} }
return false;
return true;
case EXPR_ASSIGN: case EXPR_ASSIGN:
log_wsgo(ctx, "Assignment operator not implemented yet\n"); log_wsgo(ctx, "Assignment operator not implemented yet\n");
@ -447,15 +450,11 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
case EXPR_INVERT: case EXPR_INVERT:
case EXPR_NEGATE: case EXPR_NEGATE:
left = expr->value.child; left = expr->value.child;
if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
lookupPriv)) { return false;
if (expr->op == EXPR_NEGATE)
val_rtrn->ival = -leftRtrn.ival; *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
else return true;
val_rtrn->ival = ~leftRtrn.ival;
return true;
}
return false;
case EXPR_UNARY_PLUS: case EXPR_UNARY_PLUS:
left = expr->value.child; left = expr->value.child;
@ -466,18 +465,14 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op); log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
break; break;
} }
return false; return false;
} }
bool bool
ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr, int *val_rtrn) ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr, int *val_rtrn)
{ {
ExprResult result; return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
bool ok;
ok = ExprResolveIntegerLookup(ctx, expr, &result, NULL, NULL);
if (ok)
*val_rtrn = result.ival;
return ok;
} }
bool bool
@ -485,7 +480,7 @@ ExprResolveGroup(struct xkb_context *ctx, ExprDef *expr,
xkb_group_index_t *group_rtrn) xkb_group_index_t *group_rtrn)
{ {
bool ok; bool ok;
ExprResult result; int result;
static const LookupEntry group_names[] = { static const LookupEntry group_names[] = {
{ "group1", 1 }, { "group1", 1 },
{ "group2", 2 }, { "group2", 2 },
@ -503,13 +498,13 @@ ExprResolveGroup(struct xkb_context *ctx, ExprDef *expr,
if (!ok) if (!ok)
return false; return false;
if (result.uval == 0 || result.uval > XkbNumKbdGroups) { if (result <= 0 || result > XkbNumKbdGroups) {
log_err(ctx, "Group index %u is out of range (1..%d)\n", log_err(ctx, "Group index %u is out of range (1..%d)\n",
result.uval, XkbNumKbdGroups); result, XkbNumKbdGroups);
return false; return false;
} }
*group_rtrn = result.uval; *group_rtrn = (xkb_group_index_t) result;
return true; return true;
} }
@ -518,7 +513,7 @@ ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
unsigned int *level_rtrn) unsigned int *level_rtrn)
{ {
bool ok; bool ok;
ExprResult result; int result;
static const LookupEntry level_names[] = { static const LookupEntry level_names[] = {
{ "level1", 1 }, { "level1", 1 },
{ "level2", 2 }, { "level2", 2 },
@ -536,21 +531,20 @@ ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
if (!ok) if (!ok)
return false; return false;
if (result.uval < 1 || result.uval > XkbMaxShiftLevel) { if (result < 1 || result > XkbMaxShiftLevel) {
log_err(ctx, "Shift level %d is out of range (1..%d)\n", log_err(ctx, "Shift level %d is out of range (1..%d)\n",
result.uval, XkbMaxShiftLevel); result, XkbMaxShiftLevel);
return false; return false;
} }
*level_rtrn = result.uval; *level_rtrn = (unsigned int) result;
return true; return true;
} }
bool bool
ExprResolveButton(struct xkb_context *ctx, ExprDef *expr, int *btn_rtrn) ExprResolveButton(struct xkb_context *ctx, ExprDef *expr, int *btn_rtrn)
{ {
bool ok; int result;
ExprResult result;
static const LookupEntry button_names[] = { static const LookupEntry button_names[] = {
{ "button1", 1 }, { "button1", 1 },
{ "button2", 2 }, { "button2", 2 },
@ -561,11 +555,12 @@ ExprResolveButton(struct xkb_context *ctx, ExprDef *expr, int *btn_rtrn)
{ NULL, 0 } { NULL, 0 }
}; };
ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup, if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
button_names); button_names))
if (ok) return false;
*btn_rtrn = result.ival;
return ok; *btn_rtrn = result;
return true;
} }
bool bool
@ -662,42 +657,35 @@ bool
ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr, ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr,
unsigned int *val_rtrn, const LookupEntry *values) unsigned int *val_rtrn, const LookupEntry *values)
{ {
ExprResult result;
if (expr->op != EXPR_IDENT) { if (expr->op != EXPR_IDENT) {
log_err(ctx, "Found a %s where an enumerated value was expected\n", log_err(ctx, "Found a %s where an enumerated value was expected\n",
exprOpText(expr->op)); exprOpText(expr->op));
return false; return false;
} }
if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT, &result)) { if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
int nOut = 0; val_rtrn)) {
log_err(ctx, "Illegal identifier %s (expected one of: ", log_err(ctx, "Illegal identifier %s; expected one of:\n",
xkb_atom_text(ctx, expr->value.str)); xkb_atom_text(ctx, expr->value.str));
while (values && values->name) while (values && values->name)
{ {
if (nOut != 0) log_err(ctx, "\t%s\n", values->name);
log_info(ctx, ", %s", values->name);
else
log_info(ctx, "%s", values->name);
values++; values++;
nOut++;
} }
log_info(ctx, ")\n");
return false; return false;
} }
*val_rtrn = result.uval;
return true; return true;
} }
static int static bool
ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr, ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
ExprResult *val_rtrn, IdentLookupFunc lookup, unsigned int *val_rtrn, IdentLookupFunc lookup,
const void *lookupPriv) const void *lookupPriv)
{ {
int ok = 0; bool ok = 0;
ExprResult leftRtrn, rightRtrn; unsigned int l, r;
int v;
ExprDef *left, *right; ExprDef *left, *right;
const char *bogus = NULL; const char *bogus = NULL;
@ -709,11 +697,12 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
exprValueTypeText(expr->value_type)); exprValueTypeText(expr->value_type));
return false; return false;
} }
val_rtrn->ival = expr->value.ival; *val_rtrn = (unsigned int) expr->value.ival;
return true; return true;
case EXPR_IDENT: case EXPR_IDENT:
ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, val_rtrn); ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
val_rtrn);
if (!ok) if (!ok)
log_err(ctx, "Identifier \"%s\" of type int is unknown\n", log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
xkb_atom_text(ctx, expr->value.str)); xkb_atom_text(ctx, expr->value.str));
@ -742,28 +731,27 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
case EXPR_DIVIDE: case EXPR_DIVIDE:
left = expr->value.binary.left; left = expr->value.binary.left;
right = expr->value.binary.right; right = expr->value.binary.right;
if (ExprResolveMaskLookup(ctx, left, &leftRtrn, lookup, if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
lookupPriv) && !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
ExprResolveMaskLookup(ctx, right, &rightRtrn, lookup, return false;
lookupPriv)) {
switch (expr->op) { switch (expr->op) {
case EXPR_ADD: case EXPR_ADD:
val_rtrn->ival = leftRtrn.ival | rightRtrn.ival; *val_rtrn = l | r;
break; break;
case EXPR_SUBTRACT: case EXPR_SUBTRACT:
val_rtrn->ival = leftRtrn.ival & (~rightRtrn.ival); *val_rtrn = l & (~r);
break; break;
case EXPR_MULTIPLY: case EXPR_MULTIPLY:
case EXPR_DIVIDE: case EXPR_DIVIDE:
log_err(ctx, "Cannot %s masks; Illegal operation ignored\n", log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
(expr->op == EXPR_DIVIDE ? "divide" : "multiply")); (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
return false; return false;
default: default:
break; break;
}
return true;
} }
return false;
return true;
case EXPR_ASSIGN: case EXPR_ASSIGN:
log_wsgo(ctx, "Assignment operator not implemented yet\n"); log_wsgo(ctx, "Assignment operator not implemented yet\n");
@ -771,28 +759,26 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
case EXPR_INVERT: case EXPR_INVERT:
left = expr->value.child; left = expr->value.child;
if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
lookupPriv)) { return false;
val_rtrn->ival = ~leftRtrn.ival;
return true; *val_rtrn = ~v;
} return true;
return false;
case EXPR_UNARY_PLUS: case EXPR_UNARY_PLUS:
case EXPR_NEGATE: case EXPR_NEGATE:
case EXPR_NOT: case EXPR_NOT:
left = expr->value.child; left = expr->value.child;
if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup, if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
lookupPriv)) {
log_err(ctx, "The %s operator cannot be used with a mask\n", log_err(ctx, "The %s operator cannot be used with a mask\n",
(expr->op == EXPR_NEGATE ? "-" : "!")); (expr->op == EXPR_NEGATE ? "-" : "!"));
}
return false; return false;
default: default:
log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op); log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
break; break;
} }
return false; return false;
} }
@ -800,40 +786,22 @@ bool
ExprResolveMask(struct xkb_context *ctx, ExprDef *expr, ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
unsigned int *mask_rtrn, const LookupEntry *values) unsigned int *mask_rtrn, const LookupEntry *values)
{ {
ExprResult result; return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
bool ok;
ok = ExprResolveMaskLookup(ctx, expr, &result, SimpleLookup, values);
if (ok)
*mask_rtrn = (unsigned int) result.ival;
return ok;
} }
bool bool
ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr, ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
xkb_mod_mask_t *mask_rtrn) xkb_mod_mask_t *mask_rtrn)
{ {
ExprResult result; return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
bool ok;
ok = ExprResolveMaskLookup(ctx, expr, &result, LookupModMask, NULL);
if (ok)
*mask_rtrn = (xkb_mod_mask_t) result.ival;
return ok;
} }
bool bool
ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr, ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
xkb_mod_mask_t *mask_rtrn) xkb_mod_mask_t *mask_rtrn)
{ {
ExprResult result; return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
bool ok; keymap);
ok = ExprResolveMaskLookup(keymap->ctx, expr, &result, LookupVModMask,
keymap);
if (ok)
*mask_rtrn = (xkb_mod_mask_t) result.ival;
return ok;
} }
bool bool

19
src/xkbcomp/expr.h
View File

@ -29,14 +29,9 @@
#include "xkbcomp-priv.h" #include "xkbcomp-priv.h"
typedef union _ExprResult {
int ival;
unsigned uval;
} ExprResult;
typedef struct _LookupEntry { typedef struct _LookupEntry {
const char *name; const char *name;
unsigned result; unsigned int value;
} LookupEntry; } LookupEntry;
extern const char * extern const char *
@ -46,17 +41,17 @@ bool
ExprResolveLhs(struct xkb_context *ctx, ExprDef *expr, const char **elem_rtrn, ExprResolveLhs(struct xkb_context *ctx, ExprDef *expr, const char **elem_rtrn,
const char **field_rtrn, ExprDef **index_rtrn); const char **field_rtrn, ExprDef **index_rtrn);
extern bool bool
LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field, LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn); enum expr_value_type type, xkb_mod_mask_t *val_rtrn);
extern bool bool
LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field, LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn); enum expr_value_type type, xkb_mod_mask_t *val_rtrn);
extern bool bool
LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field, LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn); enum expr_value_type type, xkb_mod_index_t *val_rtrn);
bool bool
ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr, ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,

8
src/xkbcomp/symbols.c
View File

@ -1367,19 +1367,21 @@ HandleModMapDef(SymbolsInfo *info, ModMapDef *def)
{ {
ExprDef *key; ExprDef *key;
ModMapEntry tmp; ModMapEntry tmp;
ExprResult rtrn; xkb_mod_index_t ndx;
bool ok; bool ok;
struct xkb_context *ctx = info->keymap->ctx; struct xkb_context *ctx = info->keymap->ctx;
if (!LookupModIndex(ctx, NULL, def->modifier, EXPR_TYPE_INT, &rtrn)) { if (!LookupModIndex(ctx, NULL, def->modifier, EXPR_TYPE_INT, &ndx)) {
log_err(info->keymap->ctx, log_err(info->keymap->ctx,
"Illegal modifier map definition; " "Illegal modifier map definition; "
"Ignoring map for non-modifier \"%s\"\n", "Ignoring map for non-modifier \"%s\"\n",
xkb_atom_text(ctx, def->modifier)); xkb_atom_text(ctx, def->modifier));
return false; return false;
} }
ok = true; ok = true;
tmp.modifier = rtrn.uval; tmp.modifier = ndx;
for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next) { for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next) {
xkb_keysym_t sym; xkb_keysym_t sym;

32
src/xkbcomp/vmod.c
View File

@ -155,9 +155,9 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap,
* @return true on success, false otherwise. If false is returned, val_rtrn is * @return true on success, false otherwise. If false is returned, val_rtrn is
* undefined. * undefined.
*/ */
static int static bool
LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field, LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
enum expr_value_type type, ExprResult * val_rtrn) enum expr_value_type type, xkb_mod_index_t *val_rtrn)
{ {
xkb_mod_index_t i; xkb_mod_index_t i;
const char *name = xkb_atom_text(keymap->ctx, field); const char *name = xkb_atom_text(keymap->ctx, field);
@ -172,7 +172,7 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
*/ */
for (i = 0; i < XkbNumVirtualMods; i++) { for (i = 0; i < XkbNumVirtualMods; i++) {
if (keymap->vmod_names[i] && streq(keymap->vmod_names[i], name)) { if (keymap->vmod_names[i] && streq(keymap->vmod_names[i], name)) {
val_rtrn->uval = i; *val_rtrn = i;
return true; return true;
} }
} }
@ -192,35 +192,37 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
*/ */
bool bool
LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field, LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, ExprResult *val_rtrn) enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
{ {
xkb_mod_index_t ndx;
if (LookupModMask(ctx, NULL, field, type, val_rtrn)) { if (LookupModMask(ctx, NULL, field, type, val_rtrn)) {
return true; return true;
} }
else if (LookupVModIndex(priv, field, type, val_rtrn)) { else if (LookupVModIndex(priv, field, type, &ndx)) {
unsigned ndx = val_rtrn->uval; *val_rtrn = (1 << (XkbNumModifiers + ndx));
val_rtrn->uval = (1 << (XkbNumModifiers + ndx));
return true; return true;
} }
return false; return false;
} }
int xkb_mod_index_t
FindKeypadVMod(struct xkb_keymap *keymap) FindKeypadVMod(struct xkb_keymap *keymap)
{ {
xkb_atom_t name; xkb_atom_t name;
ExprResult rtrn; xkb_mod_index_t ndx;
name = xkb_atom_intern(keymap->ctx, "NumLock"); name = xkb_atom_intern(keymap->ctx, "NumLock");
if ((keymap) && LookupVModIndex(keymap, name, EXPR_TYPE_INT, &rtrn)) { if (LookupVModIndex(keymap, name, EXPR_TYPE_INT, &ndx))
return rtrn.ival; return ndx;
}
return -1; return -1;
} }
bool bool
ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
ExprResult *val_rtrn, VModInfo *info) xkb_mod_index_t *ndx_rtrn, VModInfo *info)
{ {
int val; int val;
@ -232,7 +234,7 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) { for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
if ((info->available & bit) && keymap->vmod_names[i] && if ((info->available & bit) && keymap->vmod_names[i] &&
streq(keymap->vmod_names[i], name)) { streq(keymap->vmod_names[i], name)) {
val_rtrn->uval = i; *ndx_rtrn = i;
return true; return true;
} }
} }
@ -248,6 +250,6 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
return false; return false;
} }
val_rtrn->uval = (unsigned int) val; *ndx_rtrn = (xkb_mod_index_t) val;
return true; return true;
} }

7
src/xkbcomp/vmod.h
View File

@ -51,12 +51,11 @@ HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap,
extern bool extern bool
ApplyVModDefs(VModInfo *info, struct xkb_keymap *keymap); ApplyVModDefs(VModInfo *info, struct xkb_keymap *keymap);
extern int xkb_mod_index_t
FindKeypadVMod(struct xkb_keymap *keymap); FindKeypadVMod(struct xkb_keymap *keymap);
extern bool bool
ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap, ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
ExprResult *value_rtrn, xkb_mod_index_t *ndx_rtrn, VModInfo *info);
VModInfo *info);
#endif /* VMOD_H */ #endif /* VMOD_H */