/************************************************************
|
* Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
|
*
|
* Permission to use, copy, modify, and distribute this
|
* software and its documentation for any purpose and without
|
* fee is hereby granted, provided that the above copyright
|
* notice appear in all copies and that both that copyright
|
* notice and this permission notice appear in supporting
|
* documentation, and that the name of Silicon Graphics not be
|
* used in advertising or publicity pertaining to distribution
|
* of the software without specific prior written permission.
|
* Silicon Graphics makes no representation about the suitability
|
* of this software for any purpose. It is provided "as is"
|
* without any express or implied warranty.
|
*
|
* SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
|
* GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
* THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
*
|
********************************************************/
|
|
#include "xkbcomp-priv.h"
|
#include "text.h"
|
#include "expr.h"
|
|
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
|
xkb_atom_t field, enum expr_value_type type,
|
unsigned int *val_rtrn);
|
|
bool
|
ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
|
const char **elem_rtrn, const char **field_rtrn,
|
ExprDef **index_rtrn)
|
{
|
switch (expr->expr.op) {
|
case EXPR_IDENT:
|
*elem_rtrn = NULL;
|
*field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
|
*index_rtrn = NULL;
|
return true;
|
case EXPR_FIELD_REF:
|
*elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
|
*field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
|
*index_rtrn = NULL;
|
return true;
|
case EXPR_ARRAY_REF:
|
*elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
|
*field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
|
*index_rtrn = expr->array_ref.entry;
|
return true;
|
default:
|
break;
|
}
|
log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
|
return false;
|
}
|
|
static bool
|
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;
|
|
if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
|
return false;
|
|
str = xkb_atom_text(ctx, field);
|
for (entry = priv; entry && entry->name; entry++) {
|
if (istreq(str, entry->name)) {
|
*val_rtrn = entry->value;
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
/* Data passed in the *priv argument for LookupModMask. */
|
typedef struct {
|
const struct xkb_mod_set *mods;
|
enum mod_type mod_type;
|
} LookupModMaskPriv;
|
|
static bool
|
LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
|
enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
|
{
|
const char *str;
|
xkb_mod_index_t ndx;
|
const LookupModMaskPriv *arg = priv;
|
const struct xkb_mod_set *mods = arg->mods;
|
enum mod_type mod_type = arg->mod_type;
|
|
if (type != EXPR_TYPE_INT)
|
return false;
|
|
str = xkb_atom_text(ctx, field);
|
|
if (istreq(str, "all")) {
|
*val_rtrn = MOD_REAL_MASK_ALL;
|
return true;
|
}
|
|
if (istreq(str, "none")) {
|
*val_rtrn = 0;
|
return true;
|
}
|
|
ndx = XkbModNameToIndex(mods, field, mod_type);
|
if (ndx == XKB_MOD_INVALID)
|
return false;
|
|
*val_rtrn = (1u << ndx);
|
return true;
|
}
|
|
bool
|
ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
|
bool *set_rtrn)
|
{
|
bool ok = false;
|
const char *ident;
|
|
switch (expr->expr.op) {
|
case EXPR_VALUE:
|
if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
|
log_err(ctx,
|
"Found constant of type %s where boolean was expected\n",
|
expr_value_type_to_string(expr->expr.value_type));
|
return false;
|
}
|
*set_rtrn = expr->boolean.set;
|
return true;
|
|
case EXPR_IDENT:
|
ident = xkb_atom_text(ctx, expr->ident.ident);
|
if (ident) {
|
if (istreq(ident, "true") ||
|
istreq(ident, "yes") ||
|
istreq(ident, "on")) {
|
*set_rtrn = true;
|
return true;
|
}
|
else if (istreq(ident, "false") ||
|
istreq(ident, "no") ||
|
istreq(ident, "off")) {
|
*set_rtrn = false;
|
return true;
|
}
|
}
|
log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n", ident);
|
return false;
|
|
case EXPR_FIELD_REF:
|
log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
|
xkb_atom_text(ctx, expr->field_ref.element),
|
xkb_atom_text(ctx, expr->field_ref.field));
|
return false;
|
|
case EXPR_INVERT:
|
case EXPR_NOT:
|
ok = ExprResolveBoolean(ctx, expr, set_rtrn);
|
if (ok)
|
*set_rtrn = !*set_rtrn;
|
return ok;
|
case EXPR_ADD:
|
case EXPR_SUBTRACT:
|
case EXPR_MULTIPLY:
|
case EXPR_DIVIDE:
|
case EXPR_ASSIGN:
|
case EXPR_NEGATE:
|
case EXPR_UNARY_PLUS:
|
log_err(ctx, "%s of boolean values not permitted\n",
|
expr_op_type_to_string(expr->expr.op));
|
break;
|
|
default:
|
log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n",
|
expr->expr.op);
|
break;
|
}
|
|
return false;
|
}
|
|
bool
|
ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
|
xkb_keycode_t *kc)
|
{
|
xkb_keycode_t leftRtrn, rightRtrn;
|
|
switch (expr->expr.op) {
|
case EXPR_VALUE:
|
if (expr->expr.value_type != EXPR_TYPE_INT) {
|
log_err(ctx,
|
"Found constant of type %s where an int was expected\n",
|
expr_value_type_to_string(expr->expr.value_type));
|
return false;
|
}
|
|
*kc = (xkb_keycode_t) expr->integer.ival;
|
return true;
|
|
case EXPR_ADD:
|
case EXPR_SUBTRACT:
|
case EXPR_MULTIPLY:
|
case EXPR_DIVIDE:
|
if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
|
!ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
|
return false;
|
|
switch (expr->expr.op) {
|
case EXPR_ADD:
|
*kc = leftRtrn + rightRtrn;
|
break;
|
case EXPR_SUBTRACT:
|
*kc = leftRtrn - rightRtrn;
|
break;
|
case EXPR_MULTIPLY:
|
*kc = leftRtrn * rightRtrn;
|
break;
|
case EXPR_DIVIDE:
|
if (rightRtrn == 0) {
|
log_err(ctx, "Cannot divide by zero: %d / %d\n",
|
leftRtrn, rightRtrn);
|
return false;
|
}
|
|
*kc = leftRtrn / rightRtrn;
|
break;
|
default:
|
break;
|
}
|
|
return true;
|
|
case EXPR_NEGATE:
|
if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
|
return false;
|
|
*kc = ~leftRtrn;
|
return true;
|
|
case EXPR_UNARY_PLUS:
|
return ExprResolveKeyCode(ctx, expr->unary.child, kc);
|
|
default:
|
log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n",
|
expr->expr.op);
|
break;
|
}
|
|
return false;
|
}
|
|
/**
|
* This function returns ... something. It's a bit of a guess, really.
|
*
|
* If an integer is given in value ctx, it will be returned in ival.
|
* If an ident or field reference is given, the lookup function (if given)
|
* will be called. At the moment, only SimpleLookup use this, and they both
|
* return the results in uval. And don't support field references.
|
*
|
* Cool.
|
*/
|
static bool
|
ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
|
int *val_rtrn, IdentLookupFunc lookup,
|
const void *lookupPriv)
|
{
|
bool ok = false;
|
int l, r;
|
unsigned u;
|
ExprDef *left, *right;
|
|
switch (expr->expr.op) {
|
case EXPR_VALUE:
|
if (expr->expr.value_type != EXPR_TYPE_INT) {
|
log_err(ctx,
|
"Found constant of type %s where an int was expected\n",
|
expr_value_type_to_string(expr->expr.value_type));
|
return false;
|
}
|
|
*val_rtrn = expr->integer.ival;
|
return true;
|
|
case EXPR_IDENT:
|
if (lookup)
|
ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
|
|
if (!ok)
|
log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
|
xkb_atom_text(ctx, expr->ident.ident));
|
else
|
*val_rtrn = (int) u;
|
|
return ok;
|
|
case EXPR_FIELD_REF:
|
log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
|
xkb_atom_text(ctx, expr->field_ref.element),
|
xkb_atom_text(ctx, expr->field_ref.field));
|
return false;
|
|
case EXPR_ADD:
|
case EXPR_SUBTRACT:
|
case EXPR_MULTIPLY:
|
case EXPR_DIVIDE:
|
left = expr->binary.left;
|
right = expr->binary.right;
|
if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
|
!ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
|
return false;
|
|
switch (expr->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;
|
}
|
*val_rtrn = l / r;
|
break;
|
default:
|
log_err(ctx, "%s of integers not permitted\n",
|
expr_op_type_to_string(expr->expr.op));
|
return false;
|
}
|
|
return true;
|
|
case EXPR_ASSIGN:
|
log_wsgo(ctx, "Assignment operator not implemented yet\n");
|
break;
|
|
case EXPR_NOT:
|
log_err(ctx, "The ! operator cannot be applied to an integer\n");
|
return false;
|
|
case EXPR_INVERT:
|
case EXPR_NEGATE:
|
left = expr->unary.child;
|
if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
|
return false;
|
|
*val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
|
return true;
|
|
case EXPR_UNARY_PLUS:
|
left = expr->unary.child;
|
return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
|
lookupPriv);
|
|
default:
|
log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n",
|
expr->expr.op);
|
break;
|
}
|
|
return false;
|
}
|
|
bool
|
ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
|
int *val_rtrn)
|
{
|
return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
|
}
|
|
bool
|
ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
|
xkb_layout_index_t *group_rtrn)
|
{
|
bool ok;
|
int result;
|
|
ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
|
groupNames);
|
if (!ok)
|
return false;
|
|
if (result <= 0 || result > XKB_MAX_GROUPS) {
|
log_err(ctx, "Group index %u is out of range (1..%d)\n",
|
result, XKB_MAX_GROUPS);
|
return false;
|
}
|
|
*group_rtrn = (xkb_layout_index_t) result;
|
return true;
|
}
|
|
bool
|
ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
|
xkb_level_index_t *level_rtrn)
|
{
|
bool ok;
|
int result;
|
|
ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
|
levelNames);
|
if (!ok)
|
return false;
|
|
if (result < 1) {
|
log_err(ctx, "Shift level %d is out of range\n", result);
|
return false;
|
}
|
|
/* Level is zero-indexed from now on. */
|
*level_rtrn = (unsigned int) (result - 1);
|
return true;
|
}
|
|
bool
|
ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
|
{
|
return ExprResolveIntegerLookup(ctx, expr, btn_rtrn, SimpleLookup,
|
buttonNames);
|
}
|
|
bool
|
ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
|
xkb_atom_t *val_rtrn)
|
{
|
switch (expr->expr.op) {
|
case EXPR_VALUE:
|
if (expr->expr.value_type != EXPR_TYPE_STRING) {
|
log_err(ctx, "Found constant of type %s, expected a string\n",
|
expr_value_type_to_string(expr->expr.value_type));
|
return false;
|
}
|
|
*val_rtrn = expr->string.str;
|
return true;
|
|
case EXPR_IDENT:
|
log_err(ctx, "Identifier \"%s\" of type string not found\n",
|
xkb_atom_text(ctx, expr->ident.ident));
|
return false;
|
|
case EXPR_FIELD_REF:
|
log_err(ctx, "Default \"%s.%s\" of type string not found\n",
|
xkb_atom_text(ctx, expr->field_ref.element),
|
xkb_atom_text(ctx, expr->field_ref.field));
|
return false;
|
|
case EXPR_ADD:
|
case EXPR_SUBTRACT:
|
case EXPR_MULTIPLY:
|
case EXPR_DIVIDE:
|
case EXPR_ASSIGN:
|
case EXPR_NEGATE:
|
case EXPR_INVERT:
|
case EXPR_NOT:
|
case EXPR_UNARY_PLUS:
|
log_err(ctx, "%s of strings not permitted\n",
|
expr_op_type_to_string(expr->expr.op));
|
return false;
|
|
default:
|
log_wsgo(ctx, "Unknown operator %d in ResolveString\n",
|
expr->expr.op);
|
break;
|
}
|
return false;
|
}
|
|
bool
|
ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
|
unsigned int *val_rtrn, const LookupEntry *values)
|
{
|
if (expr->expr.op != EXPR_IDENT) {
|
log_err(ctx, "Found a %s where an enumerated value was expected\n",
|
expr_op_type_to_string(expr->expr.op));
|
return false;
|
}
|
|
if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
|
val_rtrn)) {
|
log_err(ctx, "Illegal identifier %s; expected one of:\n",
|
xkb_atom_text(ctx, expr->ident.ident));
|
while (values && values->name)
|
{
|
log_err(ctx, "\t%s\n", values->name);
|
values++;
|
}
|
return false;
|
}
|
|
return true;
|
}
|
|
static bool
|
ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
|
unsigned int *val_rtrn, IdentLookupFunc lookup,
|
const void *lookupPriv)
|
{
|
bool ok = 0;
|
unsigned int l, r;
|
int v;
|
ExprDef *left, *right;
|
const char *bogus = NULL;
|
|
switch (expr->expr.op) {
|
case EXPR_VALUE:
|
if (expr->expr.value_type != EXPR_TYPE_INT) {
|
log_err(ctx,
|
"Found constant of type %s where a mask was expected\n",
|
expr_value_type_to_string(expr->expr.value_type));
|
return false;
|
}
|
*val_rtrn = (unsigned int) expr->integer.ival;
|
return true;
|
|
case EXPR_IDENT:
|
ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
|
val_rtrn);
|
if (!ok)
|
log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
|
xkb_atom_text(ctx, expr->ident.ident));
|
return ok;
|
|
case EXPR_FIELD_REF:
|
log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
|
xkb_atom_text(ctx, expr->field_ref.element),
|
xkb_atom_text(ctx, expr->field_ref.field));
|
return false;
|
|
case EXPR_ARRAY_REF:
|
bogus = "array reference";
|
|
case EXPR_ACTION_DECL:
|
if (bogus == NULL)
|
bogus = "function use";
|
log_err(ctx,
|
"Unexpected %s in mask expression; Expression Ignored\n",
|
bogus);
|
return false;
|
|
case EXPR_ADD:
|
case EXPR_SUBTRACT:
|
case EXPR_MULTIPLY:
|
case EXPR_DIVIDE:
|
left = expr->binary.left;
|
right = expr->binary.right;
|
if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
|
!ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
|
return false;
|
|
switch (expr->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->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
|
return false;
|
default:
|
break;
|
}
|
|
return true;
|
|
case EXPR_ASSIGN:
|
log_wsgo(ctx, "Assignment operator not implemented yet\n");
|
break;
|
|
case EXPR_INVERT:
|
left = expr->unary.child;
|
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->unary.child;
|
if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
|
log_err(ctx, "The %s operator cannot be used with a mask\n",
|
(expr->expr.op == EXPR_NEGATE ? "-" : "!"));
|
return false;
|
|
default:
|
log_wsgo(ctx, "Unknown operator %d in ResolveMask\n",
|
expr->expr.op);
|
break;
|
}
|
|
return false;
|
}
|
|
bool
|
ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
|
unsigned int *mask_rtrn, const LookupEntry *values)
|
{
|
return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
|
}
|
|
bool
|
ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
|
enum mod_type mod_type, const struct xkb_mod_set *mods,
|
xkb_mod_mask_t *mask_rtrn)
|
{
|
LookupModMaskPriv priv = { .mods = mods, .mod_type = mod_type };
|
return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, &priv);
|
}
|
|
bool
|
ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
|
xkb_keysym_t *sym_rtrn)
|
{
|
int val;
|
|
if (expr->expr.op == EXPR_IDENT) {
|
const char *str = xkb_atom_text(ctx, expr->ident.ident);
|
*sym_rtrn = xkb_keysym_from_name(str, 0);
|
if (*sym_rtrn != XKB_KEY_NoSymbol)
|
return true;
|
}
|
|
if (!ExprResolveInteger(ctx, expr, &val))
|
return false;
|
|
if (val < 0 || val >= 10)
|
return false;
|
|
*sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
|
return true;
|
}
|
|
bool
|
ExprResolveMod(struct xkb_context *ctx, const ExprDef *def,
|
enum mod_type mod_type, const struct xkb_mod_set *mods,
|
xkb_mod_index_t *ndx_rtrn)
|
{
|
xkb_mod_index_t ndx;
|
xkb_atom_t name;
|
|
if (def->expr.op != EXPR_IDENT) {
|
log_err(ctx,
|
"Cannot resolve virtual modifier: "
|
"found %s where a virtual modifier name was expected\n",
|
expr_op_type_to_string(def->expr.op));
|
return false;
|
}
|
|
name = def->ident.ident;
|
ndx = XkbModNameToIndex(mods, name, mod_type);
|
if (ndx == XKB_MOD_INVALID) {
|
log_err(ctx,
|
"Cannot resolve virtual modifier: "
|
"\"%s\" was not previously declared\n",
|
xkb_atom_text(ctx, name));
|
return false;
|
}
|
|
*ndx_rtrn = ndx;
|
return true;
|
}
|
