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 ********************************************************/
29 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
30 xkb_atom_t field, enum expr_value_type type,
31 unsigned int *val_rtrn);
34 exprOpText(enum expr_op_type op)
40 strcpy(buf, "literal");
43 strcpy(buf, "identifier");
45 case EXPR_ACTION_DECL:
46 strcpy(buf, "action declaration");
49 strcpy(buf, "field reference");
52 strcpy(buf, "array reference");
54 case EXPR_KEYSYM_LIST:
55 strcpy(buf, "list of keysyms");
57 case EXPR_ACTION_LIST:
58 strcpy(buf, "list of actions");
61 strcpy(buf, "addition");
64 strcpy(buf, "subtraction");
67 strcpy(buf, "multiplication");
70 strcpy(buf, "division");
73 strcpy(buf, "assignment");
76 strcpy(buf, "logical not");
79 strcpy(buf, "arithmetic negation");
82 strcpy(buf, "bitwise inversion");
85 strcpy(buf, "unary plus");
88 snprintf(buf, sizeof(buf), "illegal(%d)", op);
95 exprValueTypeText(enum expr_value_type type)
100 case EXPR_TYPE_UNKNOWN:
101 strcpy(buf, "unknown");
103 case EXPR_TYPE_BOOLEAN:
104 strcpy(buf, "boolean");
109 case EXPR_TYPE_STRING:
110 strcpy(buf, "string");
112 case EXPR_TYPE_ACTION:
113 strcpy(buf, "action");
115 case EXPR_TYPE_KEYNAME:
116 strcpy(buf, "keyname");
119 snprintf(buf, sizeof(buf), "illegal(%d)", type);
126 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
127 const char **elem_rtrn, const char **field_rtrn,
128 ExprDef **index_rtrn)
133 *field_rtrn = xkb_atom_text(ctx, expr->value.str);
137 *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
138 *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
142 *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
143 *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
144 *index_rtrn = expr->value.array.entry;
149 log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
154 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
155 enum expr_value_type type, unsigned int *val_rtrn)
157 const LookupEntry *entry;
160 if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
163 str = xkb_atom_text(ctx, field);
164 for (entry = priv; entry && entry->name; entry++) {
165 if (istreq(str, entry->name)) {
166 *val_rtrn = entry->value;
175 LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
176 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
178 const char *name = xkb_atom_text(ctx, field);
180 if (istreq(name, "none")) {
181 *val_rtrn = XkbNoModifier;
185 *val_rtrn = ModNameToIndex(name);
186 return (*val_rtrn != XKB_MOD_INVALID);
190 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
191 enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
196 if (type != EXPR_TYPE_INT)
199 str = xkb_atom_text(ctx, field);
201 if (istreq(str, "all"))
203 else if (istreq(str, "none"))
205 else if (LookupModIndex(ctx, priv, field, type, &ndx))
206 *val_rtrn = (1 << ndx);
214 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
222 if (expr->value_type != EXPR_TYPE_BOOLEAN) {
224 "Found constant of type %s where boolean was expected\n",
225 exprValueTypeText(expr->value_type));
228 *set_rtrn = !!expr->value.ival;
232 ident = xkb_atom_text(ctx, expr->value.str);
234 if (istreq(ident, "true") ||
235 istreq(ident, "yes") ||
236 istreq(ident, "on")) {
240 else if (istreq(ident, "false") ||
241 istreq(ident, "no") ||
242 istreq(ident, "off")) {
247 log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
248 xkb_atom_text(ctx, expr->value.str));
252 log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
253 xkb_atom_text(ctx, expr->value.field.element),
254 xkb_atom_text(ctx, expr->value.field.field));
259 ok = ExprResolveBoolean(ctx, expr, set_rtrn);
261 *set_rtrn = !*set_rtrn;
269 case EXPR_UNARY_PLUS:
270 log_err(ctx, "%s of boolean values not permitted\n",
271 exprOpText(expr->op));
275 log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
283 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
286 xkb_keycode_t leftRtrn, rightRtrn;
287 ExprDef *left, *right;
291 if (expr->value_type != EXPR_TYPE_INT) {
293 "Found constant of type %s where an int was expected\n",
294 exprValueTypeText(expr->value_type));
298 *kc = expr->value.uval;
305 left = expr->value.binary.left;
306 right = expr->value.binary.right;
308 if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
309 !ExprResolveKeyCode(ctx, right, &rightRtrn))
314 *kc = leftRtrn + rightRtrn;
317 *kc = leftRtrn - rightRtrn;
320 *kc = leftRtrn * rightRtrn;
323 if (rightRtrn == 0) {
324 log_err(ctx, "Cannot divide by zero: %d / %d\n",
325 leftRtrn, rightRtrn);
329 *kc = leftRtrn / rightRtrn;
338 left = expr->value.child;
339 if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
345 case EXPR_UNARY_PLUS:
346 left = expr->value.child;
347 return ExprResolveKeyCode(ctx, left, kc);
350 log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
358 * This function returns ... something. It's a bit of a guess, really.
360 * If an integer is given in value ctx, it will be returned in ival.
361 * If an ident or field reference is given, the lookup function (if given)
362 * will be called. At the moment, only SimpleLookup use this, and they both
363 * return the results in uval. And don't support field references.
368 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
369 int *val_rtrn, IdentLookupFunc lookup,
370 const void *lookupPriv)
375 ExprDef *left, *right;
379 if (expr->value_type != EXPR_TYPE_INT) {
381 "Found constant of type %s where an int was expected\n",
382 exprValueTypeText(expr->value_type));
386 *val_rtrn = expr->value.ival;
391 ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
394 log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
395 xkb_atom_text(ctx, expr->value.str));
402 log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
403 xkb_atom_text(ctx, expr->value.field.element),
404 xkb_atom_text(ctx, expr->value.field.field));
411 left = expr->value.binary.left;
412 right = expr->value.binary.right;
413 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
414 !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
429 log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
441 log_wsgo(ctx, "Assignment operator not implemented yet\n");
445 log_err(ctx, "The ! operator cannot be applied to an integer\n");
450 left = expr->value.child;
451 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
454 *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
457 case EXPR_UNARY_PLUS:
458 left = expr->value.child;
459 return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
463 log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
471 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
474 return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
478 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
479 xkb_group_index_t *group_rtrn)
483 static const LookupEntry group_names[] = {
495 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
500 if (result <= 0 || result > XkbNumKbdGroups) {
501 log_err(ctx, "Group index %u is out of range (1..%d)\n",
502 result, XkbNumKbdGroups);
506 *group_rtrn = (xkb_group_index_t) result;
511 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
512 xkb_level_index_t *level_rtrn)
516 static const LookupEntry level_names[] = {
528 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
533 if (result < 1 || result > XkbMaxShiftLevel) {
534 log_err(ctx, "Shift level %d is out of range (1..%d)\n",
535 result, XkbMaxShiftLevel);
539 /* Level is zero-indexed from now on. */
540 *level_rtrn = (unsigned int) (result - 1);
545 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
548 static const LookupEntry button_names[] = {
558 if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
567 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
568 const char **val_rtrn)
572 if (expr->value_type != EXPR_TYPE_STRING) {
573 log_err(ctx, "Found constant of type %s, expected a string\n",
574 exprValueTypeText(expr->value_type));
578 *val_rtrn = xkb_atom_text(ctx, expr->value.str);
582 log_err(ctx, "Identifier \"%s\" of type string not found\n",
583 xkb_atom_text(ctx, expr->value.str));
587 log_err(ctx, "Default \"%s.%s\" of type string not found\n",
588 xkb_atom_text(ctx, expr->value.field.element),
589 xkb_atom_text(ctx, expr->value.field.field));
600 case EXPR_UNARY_PLUS:
601 log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
605 log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
612 ExprResolveKeyName(struct xkb_context *ctx, const ExprDef *expr,
613 char name[XkbKeyNameLength])
617 if (expr->value_type != EXPR_TYPE_KEYNAME) {
618 log_err(ctx, "Found constant of type %s, expected a key name\n",
619 exprValueTypeText(expr->value_type));
622 strncpy(name, expr->value.keyName, XkbKeyNameLength);
626 log_err(ctx, "Identifier \"%s\" of type string not found\n",
627 xkb_atom_text(ctx, expr->value.str));
631 log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
632 xkb_atom_text(ctx, expr->value.field.element),
633 xkb_atom_text(ctx, expr->value.field.field));
644 case EXPR_UNARY_PLUS:
645 log_err(ctx, "%s of key name values not permitted\n",
646 exprOpText(expr->op));
650 log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
657 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
658 unsigned int *val_rtrn, const LookupEntry *values)
660 if (expr->op != EXPR_IDENT) {
661 log_err(ctx, "Found a %s where an enumerated value was expected\n",
662 exprOpText(expr->op));
666 if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
668 log_err(ctx, "Illegal identifier %s; expected one of:\n",
669 xkb_atom_text(ctx, expr->value.str));
670 while (values && values->name)
672 log_err(ctx, "\t%s\n", values->name);
682 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
683 unsigned int *val_rtrn, IdentLookupFunc lookup,
684 const void *lookupPriv)
689 ExprDef *left, *right;
690 const char *bogus = NULL;
694 if (expr->value_type != EXPR_TYPE_INT) {
696 "Found constant of type %s where a mask was expected\n",
697 exprValueTypeText(expr->value_type));
700 *val_rtrn = (unsigned int) expr->value.ival;
704 ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
707 log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
708 xkb_atom_text(ctx, expr->value.str));
712 log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
713 xkb_atom_text(ctx, expr->value.field.element),
714 xkb_atom_text(ctx, expr->value.field.field));
718 bogus = "array reference";
720 case EXPR_ACTION_DECL:
722 bogus = "function use";
724 "Unexpected %s in mask expression; Expression Ignored\n",
732 left = expr->value.binary.left;
733 right = expr->value.binary.right;
734 if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
735 !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
743 *val_rtrn = l & (~r);
747 log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
748 (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
757 log_wsgo(ctx, "Assignment operator not implemented yet\n");
761 left = expr->value.child;
762 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
768 case EXPR_UNARY_PLUS:
771 left = expr->value.child;
772 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
773 log_err(ctx, "The %s operator cannot be used with a mask\n",
774 (expr->op == EXPR_NEGATE ? "-" : "!"));
778 log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
786 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
787 unsigned int *mask_rtrn, const LookupEntry *values)
789 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
793 ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
794 xkb_mod_mask_t *mask_rtrn)
796 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
800 ExprResolveVModMask(struct xkb_keymap *keymap, const ExprDef *expr,
801 xkb_mod_mask_t *mask_rtrn)
803 return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
808 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
809 xkb_keysym_t *sym_rtrn)
813 if (expr->op == EXPR_IDENT) {
815 str = xkb_atom_text(ctx, expr->value.str);
816 *sym_rtrn = xkb_keysym_from_name(str);
817 if (*sym_rtrn != XKB_KEY_NoSymbol)
821 if (!ExprResolveInteger(ctx, expr, &val))
824 if (val < 0 || val >= 10)
827 *sym_rtrn = ((xkb_keysym_t) val) + '0';