Signed-off-by: Ran Benita <ran234@gmail.com>
- if (!ExprResolveVModMask(value, &rtrn, keymap))
+ if (!ExprResolveVModMask(keymap, value, &rtrn))
return ReportMismatch(keymap, action, F_Modifiers, "modifier mask");
*mods_rtrn = rtrn.uval;
*flags_inout &= ~XkbSA_UseModMapMods;
return ReportMismatch(keymap, action, F_Modifiers, "modifier mask");
*mods_rtrn = rtrn.uval;
*flags_inout &= ~XkbSA_UseModMapMods;
if (arrayNdx != NULL)
return ReportIndicatorNotArray(info, led, field);
if (arrayNdx != NULL)
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveVModMask(value, &rtrn, keymap))
+ if (!ExprResolveVModMask(keymap, value, &rtrn))
return ReportIndicatorBadType(info, led, field, "modifier mask");
led->real_mods = rtrn.uval & 0xff;
return ReportIndicatorBadType(info, led, field, "modifier mask");
led->real_mods = rtrn.uval & 0xff;
}
tmp.file_id = info->file_id;
tmp.merge = merge;
}
tmp.file_id = info->file_id;
tmp.merge = merge;
- if (!ExprResolveVModMask(def->def, &val, info->keymap)) {
+ if (!ExprResolveVModMask(info->keymap, def->def, &val)) {
log_err(info->keymap->ctx,
"Expected a modifier mask in group compatibility definition; "
"Ignoring illegal compatibility map for group %u\n",
log_err(info->keymap->ctx,
"Expected a modifier mask in group compatibility definition; "
"Ignoring illegal compatibility map for group %u\n",
-/***====================================================================***/
-
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
xkb_atom_t field, unsigned type,
ExprResult *val_rtrn);
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
xkb_atom_t field, unsigned type,
ExprResult *val_rtrn);
-/***====================================================================***/
-
const char *
exprOpText(unsigned type)
{
const char *
exprOpText(unsigned type)
{
*index_rtrn = expr->value.array.entry;
return true;
}
*index_rtrn = expr->value.array.entry;
return true;
}
- WSGO("Unexpected operator %d in ResolveLhs\n", expr->op);
+ log_wsgo(keymap->ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
switch (expr->op) {
case ExprValue:
if (expr->type != TypeBoolean) {
switch (expr->op) {
case ExprValue:
if (expr->type != TypeBoolean) {
- ERROR
- ("Found constant of type %s where boolean was expected\n",
- exprTypeText(expr->type));
+ log_err(ctx,
+ "Found constant of type %s where boolean was expected\n",
+ exprTypeText(expr->type));
return false;
}
val_rtrn->ival = expr->value.ival;
return false;
}
val_rtrn->ival = expr->value.ival;
- ERROR("Identifier \"%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+ xkb_atom_text(ctx, expr->value.str));
return false;
case ExprFieldRef:
return false;
case ExprFieldRef:
- ERROR("Default \"%s.%s\" of type boolean is unknown\n",
- xkb_atom_text(ctx, expr->value.field.element),
- xkb_atom_text(ctx, expr->value.field.field));
+ log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
+ xkb_atom_text(ctx, expr->value.field.element),
+ xkb_atom_text(ctx, expr->value.field.field));
return false;
case OpInvert:
return false;
case OpInvert:
case OpNegate:
if (bogus == NULL)
bogus = "Negation";
case OpNegate:
if (bogus == NULL)
bogus = "Negation";
- ERROR("%s of boolean values not permitted\n", bogus);
+ log_err(ctx, "%s of boolean values not permitted\n", bogus);
- ERROR("Unary \"+\" operator not permitted for boolean values\n");
+ log_err(ctx,
+ "Unary \"+\" operator not permitted for boolean values\n");
- WSGO("Unknown operator %d in ResolveBoolean\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
}
}
if (expr->type != TypeInt) {
}
}
if (expr->type != TypeInt) {
- ERROR("Found constant of type %s, expected a number\n",
- exprTypeText(expr->type));
+ log_err(ctx, "Found constant of type %s, expected a number\n",
+ exprTypeText(expr->type));
return false;
}
val_rtrn->ival = expr->value.ival;
return false;
}
val_rtrn->ival = expr->value.ival;
return true;
case ExprIdent:
return true;
case ExprIdent:
- ERROR("Numeric identifier \"%s\" unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Numeric identifier \"%s\" unknown\n",
+ xkb_atom_text(ctx, expr->value.str));
return ok;
case ExprFieldRef:
return ok;
case ExprFieldRef:
- ERROR("Numeric default \"%s.%s\" unknown\n",
- xkb_atom_text(ctx, expr->value.field.element),
- xkb_atom_text(ctx, expr->value.field.field));
+ log_err(ctx, "Numeric default \"%s.%s\" unknown\n",
+ xkb_atom_text(ctx, expr->value.field.element),
+ xkb_atom_text(ctx, expr->value.field.field));
return false;
case OpAdd:
return false;
case OpAdd:
return false;
case OpAssign:
return false;
case OpAssign:
- WSGO("Assignment operator not implemented yet\n");
+ log_wsgo(ctx, "Assignment operator not implemented yet\n");
- ERROR("The ! operator cannot be applied to a number\n");
+ log_err(ctx, "The ! operator cannot be applied to a number\n");
return false;
case OpInvert:
return false;
case OpInvert:
return ExprResolveFloat(ctx, left, val_rtrn);
default:
return ExprResolveFloat(ctx, left, val_rtrn);
default:
- WSGO("Unknown operator %d in ResolveFloat\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveFloat\n", expr->op);
switch (expr->op) {
case ExprValue:
if (expr->type != TypeInt) {
switch (expr->op) {
case ExprValue:
if (expr->type != TypeInt) {
- ERROR
- ("Found constant of type %s where an int was expected\n",
- exprTypeText(expr->type));
+ log_err(ctx,
+ "Found constant of type %s where an int was expected\n",
+ exprTypeText(expr->type));
return false;
}
val_rtrn->uval = expr->value.uval;
return false;
}
val_rtrn->uval = expr->value.uval;
return ExprResolveKeyCode(ctx, left, val_rtrn);
default:
return ExprResolveKeyCode(ctx, left, val_rtrn);
default:
- WSGO("Unknown operator %d in ResolveKeyCode\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
}
}
if (expr->type != TypeInt) {
}
}
if (expr->type != TypeInt) {
- ERROR
- ("Found constant of type %s where an int was expected\n",
- exprTypeText(expr->type));
+ log_err(ctx,
+ "Found constant of type %s where an int was expected\n",
+ exprTypeText(expr->type));
return false;
}
val_rtrn->ival = expr->value.ival;
return false;
}
val_rtrn->ival = expr->value.ival;
ok = lookup(ctx, lookupPriv, expr->value.str,
TypeInt, val_rtrn);
if (!ok)
ok = lookup(ctx, lookupPriv, expr->value.str,
TypeInt, val_rtrn);
if (!ok)
- ERROR("Identifier \"%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+ xkb_atom_text(ctx, expr->value.str));
return ok;
case ExprFieldRef:
return ok;
case ExprFieldRef:
- ERROR("Default \"%s.%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.field.element),
- xkb_atom_text(ctx, expr->value.field.field));
+ log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
+ xkb_atom_text(ctx, expr->value.field.element),
+ xkb_atom_text(ctx, expr->value.field.field));
return false;
case OpAdd:
return false;
case OpAdd:
return false;
case OpAssign:
return false;
case OpAssign:
- WSGO("Assignment operator not implemented yet\n");
+ log_wsgo(ctx, "Assignment operator not implemented yet\n");
- ERROR("The ! operator cannot be applied to an integer\n");
+ log_err(ctx, "The ! operator cannot be applied to an integer\n");
return false;
case OpInvert:
return false;
case OpInvert:
- WSGO("Unknown operator %d in ResolveInteger\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
return ret;
if (val_rtrn->uval == 0 || val_rtrn->uval > XkbNumKbdGroups) {
return ret;
if (val_rtrn->uval == 0 || val_rtrn->uval > XkbNumKbdGroups) {
- ERROR("Group index %u is out of range (1..%d)\n",
- val_rtrn->uval, XkbNumKbdGroups);
+ log_err(ctx, "Group index %u is out of range (1..%d)\n",
+ val_rtrn->uval, XkbNumKbdGroups);
return ret;
if (val_rtrn->ival < 1 || val_rtrn->ival > XkbMaxShiftLevel) {
return ret;
if (val_rtrn->ival < 1 || val_rtrn->ival > XkbMaxShiftLevel) {
- ERROR("Shift level %d is out of range (1..%d)\n", val_rtrn->ival,
- XkbMaxShiftLevel);
+ log_err(ctx, "Shift level %d is out of range (1..%d)\n",
+ val_rtrn->ival, XkbMaxShiftLevel);
switch (expr->op) {
case ExprValue:
if (expr->type != TypeString) {
switch (expr->op) {
case ExprValue:
if (expr->type != TypeString) {
- ERROR("Found constant of type %s, expected a string\n",
- exprTypeText(expr->type));
+ log_err(ctx, "Found constant of type %s, expected a string\n",
+ exprTypeText(expr->type));
return false;
}
val_rtrn->str = xkb_atom_strdup(ctx, expr->value.str);
return false;
}
val_rtrn->str = xkb_atom_strdup(ctx, expr->value.str);
return true;
case ExprIdent:
return true;
case ExprIdent:
- ERROR("Identifier \"%s\" of type string not found\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Identifier \"%s\" of type string not found\n",
+ xkb_atom_text(ctx, expr->value.str));
return false;
case ExprFieldRef:
return false;
case ExprFieldRef:
- ERROR("Default \"%s.%s\" of type string not found\n",
- xkb_atom_text(ctx, expr->value.field.element),
- xkb_atom_text(ctx, expr->value.field.field));
+ log_err(ctx, "Default \"%s.%s\" of type string not found\n",
+ xkb_atom_text(ctx, expr->value.field.element),
+ xkb_atom_text(ctx, expr->value.field.field));
return false;
case OpAdd:
return false;
case OpAdd:
case OpInvert:
if (bogus == NULL)
bogus = "Bitwise complement";
case OpInvert:
if (bogus == NULL)
bogus = "Bitwise complement";
- ERROR("%s of string values not permitted\n", bogus);
+ log_err(ctx, "%s of string values not permitted\n", bogus);
return false;
case OpNot:
return false;
case OpNot:
- ERROR("The ! operator cannot be applied to a string\n");
+ log_err(ctx, "The ! operator cannot be applied to a string\n");
return false;
case OpUnaryPlus:
return false;
case OpUnaryPlus:
- ERROR("The + operator cannot be applied to a string\n");
+ log_err(ctx, "The + operator cannot be applied to a string\n");
- WSGO("Unknown operator %d in ResolveString\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
switch (expr->op) {
case ExprValue:
if (expr->type != TypeKeyName) {
switch (expr->op) {
case ExprValue:
if (expr->type != TypeKeyName) {
- ERROR("Found constant of type %s, expected a key name\n",
- exprTypeText(expr->type));
+ log_err(ctx, "Found constant of type %s, expected a key name\n",
+ exprTypeText(expr->type));
return false;
}
memcpy(val_rtrn->name, expr->value.keyName, XkbKeyNameLength);
return true;
case ExprIdent:
return false;
}
memcpy(val_rtrn->name, expr->value.keyName, XkbKeyNameLength);
return true;
case ExprIdent:
- ERROR("Identifier \"%s\" of type string not found\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Identifier \"%s\" of type string not found\n",
+ xkb_atom_text(ctx, expr->value.str));
return false;
case ExprFieldRef:
return false;
case ExprFieldRef:
- ERROR("Default \"%s.%s\" of type key name not found\n",
- xkb_atom_text(ctx, expr->value.field.element),
- xkb_atom_text(ctx, expr->value.field.field));
+ log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
+ xkb_atom_text(ctx, expr->value.field.element),
+ xkb_atom_text(ctx, expr->value.field.field));
return false;
case OpAdd:
return false;
case OpAdd:
case OpInvert:
if (bogus == NULL)
bogus = "Bitwise complement";
case OpInvert:
if (bogus == NULL)
bogus = "Bitwise complement";
- ERROR("%s of key name values not permitted\n", bogus);
+ log_err(ctx, "%s of key name values not permitted\n", bogus);
return false;
case OpNot:
return false;
case OpNot:
- ERROR("The ! operator cannot be applied to a key name\n");
+ log_err(ctx, "The ! operator cannot be applied to a key name\n");
return false;
case OpUnaryPlus:
return false;
case OpUnaryPlus:
- ERROR("The + operator cannot be applied to a key name\n");
+ log_err(ctx, "The + operator cannot be applied to a key name\n");
- WSGO("Unknown operator %d in ResolveKeyName\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
ExprResult *val_rtrn, const LookupEntry *values)
{
if (expr->op != ExprIdent) {
ExprResult *val_rtrn, const LookupEntry *values)
{
if (expr->op != ExprIdent) {
- ERROR("Found a %s where an enumerated value was expected\n",
- exprOpText(expr->op));
+ 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, TypeInt, val_rtrn)) {
int nOut = 0;
return false;
}
if (!SimpleLookup(ctx, values, expr->value.str, TypeInt, val_rtrn)) {
int nOut = 0;
- ERROR("Illegal identifier %s (expected one of: ",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Illegal identifier %s (expected one of: ",
+ xkb_atom_text(ctx, expr->value.str));
while (values && values->name)
{
if (nOut != 0)
while (values && values->name)
{
if (nOut != 0)
- INFO(", %s", values->name);
+ log_info(ctx, ", %s", values->name);
- INFO("%s", values->name);
+ log_info(ctx, "%s", values->name);
return false;
}
return true;
return false;
}
return true;
switch (expr->op) {
case ExprValue:
if (expr->type != TypeInt) {
switch (expr->op) {
case ExprValue:
if (expr->type != TypeInt) {
- ERROR
- ("Found constant of type %s where a mask was expected\n",
- exprTypeText(expr->type));
+ log_err(ctx,
+ "Found constant of type %s where a mask was expected\n",
+ exprTypeText(expr->type));
return false;
}
val_rtrn->ival = expr->value.ival;
return false;
}
val_rtrn->ival = expr->value.ival;
case ExprIdent:
ok = lookup(ctx, lookupPriv, expr->value.str, TypeInt, val_rtrn);
if (!ok)
case ExprIdent:
ok = lookup(ctx, lookupPriv, expr->value.str, TypeInt, val_rtrn);
if (!ok)
- ERROR("Identifier \"%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+ xkb_atom_text(ctx, expr->value.str));
return ok;
case ExprFieldRef:
return ok;
case ExprFieldRef:
- ERROR("Default \"%s.%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.field.element),
- xkb_atom_text(ctx, expr->value.field.field));
+ log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
+ xkb_atom_text(ctx, expr->value.field.element),
+ xkb_atom_text(ctx, expr->value.field.field));
return false;
case ExprArrayRef:
return false;
case ExprArrayRef:
case ExprActionDecl:
if (bogus == NULL)
bogus = "function use";
case ExprActionDecl:
if (bogus == NULL)
bogus = "function use";
- ERROR("Unexpected %s in mask expression\n", bogus);
- ACTION("Expression ignored\n");
+ log_err(ctx,
+ "Unexpected %s in mask expression; Expression Ignored\n",
+ bogus);
return false;
case OpAdd:
return false;
case OpAdd:
break;
case OpMultiply:
case OpDivide:
break;
case OpMultiply:
case OpDivide:
- ERROR("Cannot %s masks\n",
- expr->op == OpDivide ? "divide" : "multiply");
- ACTION("Illegal operation ignored\n");
+ log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
+ (expr->op == OpDivide ? "divide" : "multiply"));
return false;
}
return true;
return false;
}
return true;
return false;
case OpAssign:
return false;
case OpAssign:
- WSGO("Assignment operator not implemented yet\n");
+ log_wsgo(ctx, "Assignment operator not implemented yet\n");
left = expr->value.child;
if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
lookupPriv)) {
left = expr->value.child;
if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
lookupPriv)) {
- ERROR("The %s operator cannot be used with a mask\n",
- (expr->op == OpNegate ? "-" : "!"));
+ log_err(ctx, "The %s operator cannot be used with a mask\n",
+ (expr->op == OpNegate ? "-" : "!"));
- WSGO("Unknown operator %d in ResolveMask\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
-ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
- struct xkb_keymap *keymap)
+ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
+ ExprResult *val_rtrn)
{
return ExprResolveMaskLookup(keymap->ctx, expr, val_rtrn, LookupVModMask,
keymap);
{
return ExprResolveMaskLookup(keymap->ctx, expr, val_rtrn, LookupVModMask,
keymap);
ExprResult *val_rtrn);
extern int
ExprResult *val_rtrn);
extern int
-ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
- struct xkb_keymap *keymap);
+ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
+ ExprResult *val_rtrn);
extern int
ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr,
extern int
ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr,
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
- if (!ExprResolveVModMask(arrayNdx, &rtrn, info->keymap))
+ if (!ExprResolveVModMask(info->keymap, arrayNdx, &rtrn))
return ReportTypeBadType(info, type, "map entry", "modifier mask");
entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
return ReportTypeBadType(info, type, "map entry", "modifier mask");
entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "preserve entry");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "preserve entry");
- if (!ExprResolveVModMask(arrayNdx, &rtrn, info->keymap))
+ if (!ExprResolveVModMask(info->keymap, arrayNdx, &rtrn))
return ReportTypeBadType(info, type, "preserve entry",
"modifier mask");
return ReportTypeBadType(info, type, "preserve entry",
"modifier mask");
PreserveIndexTxt(info, &new));
}
PreserveIndexTxt(info, &new));
}
- if (!ExprResolveVModMask(value, &rtrn, info->keymap)) {
+ if (!ExprResolveVModMask(info->keymap, value, &rtrn)) {
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",
"The modifiers field of a key type is not an array; "
"Illegal array subscript ignored\n");
/* get modifier mask for current type */
"The modifiers field of a key type is not an array; "
"Illegal array subscript ignored\n");
/* get modifier mask for current type */
- if (!ExprResolveVModMask(value, &tmp, info->keymap)) {
+ if (!ExprResolveVModMask(info->keymap, value, &tmp)) {
log_err(info->keymap->ctx,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
log_err(info->keymap->ctx,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
else if ((strcasecmp(field, "vmods") == 0) ||
(strcasecmp(field, "virtualmods") == 0) ||
(strcasecmp(field, "virtualmodifiers") == 0)) {
else if ((strcasecmp(field, "vmods") == 0) ||
(strcasecmp(field, "virtualmods") == 0) ||
(strcasecmp(field, "virtualmodifiers") == 0)) {
- ok = ExprResolveVModMask(value, &tmp, info->keymap);
+ ok = ExprResolveVModMask(info->keymap, value, &tmp);
if (ok) {
keyi->vmodmap = (tmp.uval >> 8);
keyi->defined |= _Key_VModMap;
if (ok) {
keyi->vmodmap = (tmp.uval >> 8);
keyi->defined |= _Key_VModMap;