#include "expr.h"
-/***====================================================================***/
-
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
xkb_atom_t field, unsigned type,
ExprResult *val_rtrn);
-/***====================================================================***/
-
const char *
exprOpText(unsigned type)
{
*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);
return false;
}
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 true;
}
}
- 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:
- 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:
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);
break;
case OpUnaryPlus:
- ERROR("Unary \"+\" operator not permitted for boolean values\n");
+ log_err(ctx,
+ "Unary \"+\" operator not permitted for boolean values\n");
break;
default:
- WSGO("Unknown operator %d in ResolveBoolean\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
break;
}
return false;
}
}
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 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:
- 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 OpAssign:
- WSGO("Assignment operator not implemented yet\n");
+ log_wsgo(ctx, "Assignment operator not implemented yet\n");
break;
case OpNot:
- 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 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);
break;
}
return false;
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 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);
break;
}
return false;
}
}
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;
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:
- 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 OpAssign:
- WSGO("Assignment operator not implemented yet\n");
+ log_wsgo(ctx, "Assignment operator not implemented yet\n");
break;
case OpNot:
- 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:
lookupPriv);
default:
- WSGO("Unknown operator %d in ResolveInteger\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
break;
}
return false;
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 false;
}
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);
return false;
}
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 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:
- 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:
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:
- 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:
- ERROR("The + operator cannot be applied to a string\n");
+ log_err(ctx, "The + operator cannot be applied to a string\n");
return false;
default:
- WSGO("Unknown operator %d in ResolveString\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
break;
}
return false;
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:
- 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:
- 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:
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:
- 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:
- 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;
default:
- WSGO("Unknown operator %d in ResolveKeyName\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
break;
}
return false;
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;
- 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)
- INFO(", %s", values->name);
+ log_info(ctx, ", %s", values->name);
else
- INFO("%s", values->name);
+ log_info(ctx, "%s", values->name);
values++;
nOut++;
}
- INFO(")\n");
+ log_info(ctx, ")\n");
return false;
}
return true;
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;
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:
- 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:
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:
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;
case OpAssign:
- WSGO("Assignment operator not implemented yet\n");
+ log_wsgo(ctx, "Assignment operator not implemented yet\n");
break;
case OpInvert:
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 ? "-" : "!"));
}
return false;
default:
- WSGO("Unknown operator %d in ResolveMask\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
break;
}
return false;
}
int
-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);