diff options
Diffstat (limited to 'src/3rdparty/xkbcommon/src/xkbcomp/expr.c')
-rw-r--r-- | src/3rdparty/xkbcommon/src/xkbcomp/expr.c | 686 |
1 files changed, 0 insertions, 686 deletions
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/expr.c b/src/3rdparty/xkbcommon/src/xkbcomp/expr.c deleted file mode 100644 index b2567de3eb..0000000000 --- a/src/3rdparty/xkbcommon/src/xkbcomp/expr.c +++ /dev/null @@ -1,686 +0,0 @@ -/************************************************************ - * 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 (*field_rtrn != NULL); - 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 (*elem_rtrn != NULL && *field_rtrn != NULL); - 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; - if (expr->array_ref.element != XKB_ATOM_NONE && *elem_rtrn == NULL) - return false; - if (*field_rtrn == NULL) - return false; - 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 (!str) - return false; - - 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->unary.child, 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 = false; - unsigned int l = 0, r = 0; - 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"; - /* fallthrough */ - 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; -} |