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
stringToValue(const LookupEntry tab[], const char *string,
unsigned *value_rtrn)
unsigned int *value_rtrn)
{
const LookupEntry *entry;
if (!string)
return false;
for (entry = tab; entry->name != NULL; entry++) {
for (entry = tab; entry->name; entry++) {
if (istreq(entry->name, string)) {
*value_rtrn = entry->result;
*value_rtrn = entry->value;
return true;
}
}
@ -134,12 +134,12 @@ stringToValue(const LookupEntry tab[], const char *string,
}
static const char *
valueToString(const LookupEntry tab[], unsigned value)
valueToString(const LookupEntry tab[], unsigned int value)
{
const LookupEntry *entry;
for (entry = tab; entry->name != NULL; entry++)
if (entry->result == value)
for (entry = tab; entry->name; entry++)
if (entry->value == value)
return entry->name;
return "unknown";
@ -483,7 +483,6 @@ static bool
HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_pointer_button_action *act;
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) {
log_err(keymap->ctx,
"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;
}
@ -555,7 +554,6 @@ static bool
HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_pointer_default_action *act;
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) {
log_err(keymap->ctx,
"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;
}
if (btn == 0) {
@ -683,7 +681,6 @@ static bool
HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_switch_screen_action *act;
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) {
log_err(keymap->ctx,
"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;
}
@ -938,7 +935,6 @@ static bool
HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_device_button_action *act;
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) {
log_err(keymap->ctx,
"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;
}

9
src/xkbcomp/compat.c
View File

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

266
src/xkbcomp/expr.c
View File

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

19
src/xkbcomp/expr.h
View File

@ -29,14 +29,9 @@
#include "xkbcomp-priv.h"
typedef union _ExprResult {
int ival;
unsigned uval;
} ExprResult;
typedef struct _LookupEntry {
const char *name;
unsigned result;
unsigned int value;
} LookupEntry;
extern const char *
@ -46,17 +41,17 @@ bool
ExprResolveLhs(struct xkb_context *ctx, ExprDef *expr, const char **elem_rtrn,
const char **field_rtrn, ExprDef **index_rtrn);
extern bool
bool
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,
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,
enum expr_value_type type, ExprResult *val_rtrn);
enum expr_value_type type, xkb_mod_index_t *val_rtrn);
bool
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;
ModMapEntry tmp;
ExprResult rtrn;
xkb_mod_index_t ndx;
bool ok;
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,
"Illegal modifier map definition; "
"Ignoring map for non-modifier \"%s\"\n",
xkb_atom_text(ctx, def->modifier));
return false;
}
ok = true;
tmp.modifier = rtrn.uval;
tmp.modifier = ndx;
for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next) {
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
* undefined.
*/
static int
static bool
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;
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++) {
if (keymap->vmod_names[i] && streq(keymap->vmod_names[i], name)) {
val_rtrn->uval = i;
*val_rtrn = i;
return true;
}
}
@ -192,35 +192,37 @@ LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
*/
bool
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)) {
return true;
}
else if (LookupVModIndex(priv, field, type, val_rtrn)) {
unsigned ndx = val_rtrn->uval;
val_rtrn->uval = (1 << (XkbNumModifiers + ndx));
else if (LookupVModIndex(priv, field, type, &ndx)) {
*val_rtrn = (1 << (XkbNumModifiers + ndx));
return true;
}
return false;
}
int
xkb_mod_index_t
FindKeypadVMod(struct xkb_keymap *keymap)
{
xkb_atom_t name;
ExprResult rtrn;
xkb_mod_index_t ndx;
name = xkb_atom_intern(keymap->ctx, "NumLock");
if ((keymap) && LookupVModIndex(keymap, name, EXPR_TYPE_INT, &rtrn)) {
return rtrn.ival;
}
if (LookupVModIndex(keymap, name, EXPR_TYPE_INT, &ndx))
return ndx;
return -1;
}
bool
ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
ExprResult *val_rtrn, VModInfo *info)
xkb_mod_index_t *ndx_rtrn, VModInfo *info)
{
int val;
@ -232,7 +234,7 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
if ((info->available & bit) && keymap->vmod_names[i] &&
streq(keymap->vmod_names[i], name)) {
val_rtrn->uval = i;
*ndx_rtrn = i;
return true;
}
}
@ -248,6 +250,6 @@ ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
return false;
}
val_rtrn->uval = (unsigned int) val;
*ndx_rtrn = (xkb_mod_index_t) val;
return true;
}

7
src/xkbcomp/vmod.h
View File

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