1 /************************************************************
2 * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
4 * Permission to use, copy, modify, and distribute this
5 * software and its documentation for any purpose and without
6 * fee is hereby granted, provided that the above copyright
7 * notice appear in all copies and that both that copyright
8 * notice and this permission notice appear in supporting
9 * documentation, and that the name of Silicon Graphics not be
10 * used in advertising or publicity pertaining to distribution
11 * of the software without specific prior written permission.
12 * Silicon Graphics makes no representation about the suitability
13 * of this software for any purpose. It is provided "as is"
14 * without any express or implied warranty.
16 * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18 * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19 * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23 * THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 ********************************************************/
27 #include "xkbcomp-priv.h"
31 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
32 xkb_atom_t field, enum expr_value_type type,
33 unsigned int *val_rtrn);
36 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
37 const char **elem_rtrn, const char **field_rtrn,
43 *field_rtrn = xkb_atom_text(ctx, expr->value.str);
47 *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
48 *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
52 *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
53 *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
54 *index_rtrn = expr->value.array.entry;
59 log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
64 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
65 enum expr_value_type type, unsigned int *val_rtrn)
67 const LookupEntry *entry;
70 if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
73 str = xkb_atom_text(ctx, field);
74 for (entry = priv; entry && entry->name; entry++) {
75 if (istreq(str, entry->name)) {
76 *val_rtrn = entry->value;
85 LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
86 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
88 const char *name = xkb_atom_text(ctx, field);
89 *val_rtrn = ModNameToIndex(name);
90 return (*val_rtrn != XKB_MOD_INVALID);
94 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
95 enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
100 if (type != EXPR_TYPE_INT)
103 str = xkb_atom_text(ctx, field);
105 if (istreq(str, "all"))
107 else if (istreq(str, "none"))
109 else if (LookupModIndex(ctx, priv, field, type, &ndx))
110 *val_rtrn = (1 << ndx);
118 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
126 if (expr->value_type != EXPR_TYPE_BOOLEAN) {
128 "Found constant of type %s where boolean was expected\n",
129 expr_value_type_to_string(expr->value_type));
132 *set_rtrn = !!expr->value.ival;
136 ident = xkb_atom_text(ctx, expr->value.str);
138 if (istreq(ident, "true") ||
139 istreq(ident, "yes") ||
140 istreq(ident, "on")) {
144 else if (istreq(ident, "false") ||
145 istreq(ident, "no") ||
146 istreq(ident, "off")) {
151 log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
152 xkb_atom_text(ctx, expr->value.str));
156 log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
157 xkb_atom_text(ctx, expr->value.field.element),
158 xkb_atom_text(ctx, expr->value.field.field));
163 ok = ExprResolveBoolean(ctx, expr, set_rtrn);
165 *set_rtrn = !*set_rtrn;
173 case EXPR_UNARY_PLUS:
174 log_err(ctx, "%s of boolean values not permitted\n",
175 expr_op_type_to_string(expr->op));
179 log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
187 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
190 xkb_keycode_t leftRtrn, rightRtrn;
191 ExprDef *left, *right;
195 if (expr->value_type != EXPR_TYPE_INT) {
197 "Found constant of type %s where an int was expected\n",
198 expr_value_type_to_string(expr->value_type));
202 *kc = expr->value.uval;
209 left = expr->value.binary.left;
210 right = expr->value.binary.right;
212 if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
213 !ExprResolveKeyCode(ctx, right, &rightRtrn))
218 *kc = leftRtrn + rightRtrn;
221 *kc = leftRtrn - rightRtrn;
224 *kc = leftRtrn * rightRtrn;
227 if (rightRtrn == 0) {
228 log_err(ctx, "Cannot divide by zero: %d / %d\n",
229 leftRtrn, rightRtrn);
233 *kc = leftRtrn / rightRtrn;
242 left = expr->value.child;
243 if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
249 case EXPR_UNARY_PLUS:
250 left = expr->value.child;
251 return ExprResolveKeyCode(ctx, left, kc);
254 log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
262 * This function returns ... something. It's a bit of a guess, really.
264 * If an integer is given in value ctx, it will be returned in ival.
265 * If an ident or field reference is given, the lookup function (if given)
266 * will be called. At the moment, only SimpleLookup use this, and they both
267 * return the results in uval. And don't support field references.
272 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
273 int *val_rtrn, IdentLookupFunc lookup,
274 const void *lookupPriv)
279 ExprDef *left, *right;
283 if (expr->value_type != EXPR_TYPE_INT) {
285 "Found constant of type %s where an int was expected\n",
286 expr_value_type_to_string(expr->value_type));
290 *val_rtrn = expr->value.ival;
295 ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
298 log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
299 xkb_atom_text(ctx, expr->value.str));
306 log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
307 xkb_atom_text(ctx, expr->value.field.element),
308 xkb_atom_text(ctx, expr->value.field.field));
315 left = expr->value.binary.left;
316 right = expr->value.binary.right;
317 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
318 !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
333 log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
345 log_wsgo(ctx, "Assignment operator not implemented yet\n");
349 log_err(ctx, "The ! operator cannot be applied to an integer\n");
354 left = expr->value.child;
355 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
358 *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
361 case EXPR_UNARY_PLUS:
362 left = expr->value.child;
363 return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
367 log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
375 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
378 return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
382 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
383 xkb_layout_index_t *group_rtrn)
388 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
393 if (result <= 0 || result > XKB_NUM_GROUPS) {
394 log_err(ctx, "Group index %u is out of range (1..%d)\n",
395 result, XKB_NUM_GROUPS);
399 *group_rtrn = (xkb_layout_index_t) result;
404 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
405 xkb_level_index_t *level_rtrn)
410 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
416 log_err(ctx, "Shift level %d is out of range\n", result);
420 /* Level is zero-indexed from now on. */
421 *level_rtrn = (unsigned int) (result - 1);
426 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
430 if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
439 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
440 xkb_atom_t *val_rtrn)
444 if (expr->value_type != EXPR_TYPE_STRING) {
445 log_err(ctx, "Found constant of type %s, expected a string\n",
446 expr_value_type_to_string(expr->value_type));
450 *val_rtrn = expr->value.str;
454 log_err(ctx, "Identifier \"%s\" of type string not found\n",
455 xkb_atom_text(ctx, expr->value.str));
459 log_err(ctx, "Default \"%s.%s\" of type string not found\n",
460 xkb_atom_text(ctx, expr->value.field.element),
461 xkb_atom_text(ctx, expr->value.field.field));
472 case EXPR_UNARY_PLUS:
473 log_err(ctx, "%s of strings not permitted\n",
474 expr_op_type_to_string(expr->op));
478 log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
485 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
486 unsigned int *val_rtrn, const LookupEntry *values)
488 if (expr->op != EXPR_IDENT) {
489 log_err(ctx, "Found a %s where an enumerated value was expected\n",
490 expr_op_type_to_string(expr->op));
494 if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
496 log_err(ctx, "Illegal identifier %s; expected one of:\n",
497 xkb_atom_text(ctx, expr->value.str));
498 while (values && values->name)
500 log_err(ctx, "\t%s\n", values->name);
510 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
511 unsigned int *val_rtrn, IdentLookupFunc lookup,
512 const void *lookupPriv)
517 ExprDef *left, *right;
518 const char *bogus = NULL;
522 if (expr->value_type != EXPR_TYPE_INT) {
524 "Found constant of type %s where a mask was expected\n",
525 expr_value_type_to_string(expr->value_type));
528 *val_rtrn = (unsigned int) expr->value.ival;
532 ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
535 log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
536 xkb_atom_text(ctx, expr->value.str));
540 log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
541 xkb_atom_text(ctx, expr->value.field.element),
542 xkb_atom_text(ctx, expr->value.field.field));
546 bogus = "array reference";
548 case EXPR_ACTION_DECL:
550 bogus = "function use";
552 "Unexpected %s in mask expression; Expression Ignored\n",
560 left = expr->value.binary.left;
561 right = expr->value.binary.right;
562 if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
563 !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
571 *val_rtrn = l & (~r);
575 log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
576 (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
585 log_wsgo(ctx, "Assignment operator not implemented yet\n");
589 left = expr->value.child;
590 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
596 case EXPR_UNARY_PLUS:
599 left = expr->value.child;
600 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
601 log_err(ctx, "The %s operator cannot be used with a mask\n",
602 (expr->op == EXPR_NEGATE ? "-" : "!"));
606 log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
614 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
615 unsigned int *mask_rtrn, const LookupEntry *values)
617 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
621 ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
622 xkb_mod_mask_t *mask_rtrn)
624 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
628 LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
629 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
631 const struct xkb_vmod *vmod;
634 if (type != EXPR_TYPE_INT)
637 darray_enumerate(i, vmod, keymap->vmods) {
638 if (vmod->name == field) {
639 *val_rtrn = XKB_NUM_CORE_MODS + i;
648 LookupVModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
649 enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
653 if (LookupModMask(ctx, NULL, field, type, val_rtrn)) {
656 else if (LookupVModIndex(priv, field, type, &ndx)) {
657 *val_rtrn = (1 << ndx);
666 ExprResolveVModMask(struct xkb_keymap *keymap, const ExprDef *expr,
667 xkb_mod_mask_t *mask_rtrn)
669 return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
674 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
675 xkb_keysym_t *sym_rtrn)
679 if (expr->op == EXPR_IDENT) {
681 str = xkb_atom_text(ctx, expr->value.str);
682 *sym_rtrn = xkb_keysym_from_name(str);
683 if (*sym_rtrn != XKB_KEY_NoSymbol)
687 if (!ExprResolveInteger(ctx, expr, &val))
690 if (val < 0 || val >= 10)
693 *sym_rtrn = ((xkb_keysym_t) val) + '0';
698 ExprResolveVMod(struct xkb_keymap *keymap, const ExprDef *def,
699 xkb_mod_index_t *ndx_rtrn)
701 const struct xkb_vmod *vmod;
703 xkb_atom_t name = def->value.str;
705 if (def->op != EXPR_IDENT) {
707 "Cannot resolve virtual modifier: "
708 "found %s where a virtual modifier name was expected\n",
709 expr_op_type_to_string(def->op));
713 darray_enumerate(i, vmod, keymap->vmods) {
714 if (vmod->name == name) {
715 *ndx_rtrn = XKB_NUM_CORE_MODS + i;
721 "Cannot resolve virtual modifier: "
722 "\"%s\" was not previously declared\n",
723 xkb_atom_text(keymap->ctx, name));