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 exprOpText(enum expr_op_type op)
42 strcpy(buf, "literal");
45 strcpy(buf, "identifier");
47 case EXPR_ACTION_DECL:
48 strcpy(buf, "action declaration");
51 strcpy(buf, "field reference");
54 strcpy(buf, "array reference");
56 case EXPR_KEYSYM_LIST:
57 strcpy(buf, "list of keysyms");
59 case EXPR_ACTION_LIST:
60 strcpy(buf, "list of actions");
63 strcpy(buf, "addition");
66 strcpy(buf, "subtraction");
69 strcpy(buf, "multiplication");
72 strcpy(buf, "division");
75 strcpy(buf, "assignment");
78 strcpy(buf, "logical not");
81 strcpy(buf, "arithmetic negation");
84 strcpy(buf, "bitwise inversion");
87 strcpy(buf, "unary plus");
90 snprintf(buf, sizeof(buf), "illegal(%d)", op);
97 exprValueTypeText(enum expr_value_type type)
102 case EXPR_TYPE_UNKNOWN:
103 strcpy(buf, "unknown");
105 case EXPR_TYPE_BOOLEAN:
106 strcpy(buf, "boolean");
111 case EXPR_TYPE_STRING:
112 strcpy(buf, "string");
114 case EXPR_TYPE_ACTION:
115 strcpy(buf, "action");
117 case EXPR_TYPE_KEYNAME:
118 strcpy(buf, "keyname");
121 snprintf(buf, sizeof(buf), "illegal(%d)", type);
128 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
129 const char **elem_rtrn, const char **field_rtrn,
130 ExprDef **index_rtrn)
135 *field_rtrn = xkb_atom_text(ctx, expr->value.str);
139 *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
140 *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
144 *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
145 *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
146 *index_rtrn = expr->value.array.entry;
151 log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
156 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
157 enum expr_value_type type, unsigned int *val_rtrn)
159 const LookupEntry *entry;
162 if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
165 str = xkb_atom_text(ctx, field);
166 for (entry = priv; entry && entry->name; entry++) {
167 if (istreq(str, entry->name)) {
168 *val_rtrn = entry->value;
177 LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
178 enum expr_value_type type, xkb_mod_index_t *val_rtrn)
180 const char *name = xkb_atom_text(ctx, field);
182 if (istreq(name, "none")) {
183 *val_rtrn = XkbNoModifier;
187 *val_rtrn = ModNameToIndex(name);
188 return (*val_rtrn != XKB_MOD_INVALID);
192 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
193 enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
198 if (type != EXPR_TYPE_INT)
201 str = xkb_atom_text(ctx, field);
203 if (istreq(str, "all"))
205 else if (istreq(str, "none"))
207 else if (LookupModIndex(ctx, priv, field, type, &ndx))
208 *val_rtrn = (1 << ndx);
216 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
224 if (expr->value_type != EXPR_TYPE_BOOLEAN) {
226 "Found constant of type %s where boolean was expected\n",
227 exprValueTypeText(expr->value_type));
230 *set_rtrn = !!expr->value.ival;
234 ident = xkb_atom_text(ctx, expr->value.str);
236 if (istreq(ident, "true") ||
237 istreq(ident, "yes") ||
238 istreq(ident, "on")) {
242 else if (istreq(ident, "false") ||
243 istreq(ident, "no") ||
244 istreq(ident, "off")) {
249 log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
250 xkb_atom_text(ctx, expr->value.str));
254 log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
255 xkb_atom_text(ctx, expr->value.field.element),
256 xkb_atom_text(ctx, expr->value.field.field));
261 ok = ExprResolveBoolean(ctx, expr, set_rtrn);
263 *set_rtrn = !*set_rtrn;
271 case EXPR_UNARY_PLUS:
272 log_err(ctx, "%s of boolean values not permitted\n",
273 exprOpText(expr->op));
277 log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
285 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
288 xkb_keycode_t leftRtrn, rightRtrn;
289 ExprDef *left, *right;
293 if (expr->value_type != EXPR_TYPE_INT) {
295 "Found constant of type %s where an int was expected\n",
296 exprValueTypeText(expr->value_type));
300 *kc = expr->value.uval;
307 left = expr->value.binary.left;
308 right = expr->value.binary.right;
310 if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
311 !ExprResolveKeyCode(ctx, right, &rightRtrn))
316 *kc = leftRtrn + rightRtrn;
319 *kc = leftRtrn - rightRtrn;
322 *kc = leftRtrn * rightRtrn;
325 if (rightRtrn == 0) {
326 log_err(ctx, "Cannot divide by zero: %d / %d\n",
327 leftRtrn, rightRtrn);
331 *kc = leftRtrn / rightRtrn;
340 left = expr->value.child;
341 if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
347 case EXPR_UNARY_PLUS:
348 left = expr->value.child;
349 return ExprResolveKeyCode(ctx, left, kc);
352 log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
360 * This function returns ... something. It's a bit of a guess, really.
362 * If an integer is given in value ctx, it will be returned in ival.
363 * If an ident or field reference is given, the lookup function (if given)
364 * will be called. At the moment, only SimpleLookup use this, and they both
365 * return the results in uval. And don't support field references.
370 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
371 int *val_rtrn, IdentLookupFunc lookup,
372 const void *lookupPriv)
377 ExprDef *left, *right;
381 if (expr->value_type != EXPR_TYPE_INT) {
383 "Found constant of type %s where an int was expected\n",
384 exprValueTypeText(expr->value_type));
388 *val_rtrn = expr->value.ival;
393 ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
396 log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
397 xkb_atom_text(ctx, expr->value.str));
404 log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
405 xkb_atom_text(ctx, expr->value.field.element),
406 xkb_atom_text(ctx, expr->value.field.field));
413 left = expr->value.binary.left;
414 right = expr->value.binary.right;
415 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
416 !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
431 log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
443 log_wsgo(ctx, "Assignment operator not implemented yet\n");
447 log_err(ctx, "The ! operator cannot be applied to an integer\n");
452 left = expr->value.child;
453 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
456 *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
459 case EXPR_UNARY_PLUS:
460 left = expr->value.child;
461 return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
465 log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
473 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
476 return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
480 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
481 xkb_group_index_t *group_rtrn)
485 static const LookupEntry group_names[] = {
497 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
502 if (result <= 0 || result > XkbNumKbdGroups) {
503 log_err(ctx, "Group index %u is out of range (1..%d)\n",
504 result, XkbNumKbdGroups);
508 *group_rtrn = (xkb_group_index_t) result;
513 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
514 xkb_level_index_t *level_rtrn)
518 static const LookupEntry level_names[] = {
530 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
535 if (result < 1 || result > XkbMaxShiftLevel) {
536 log_err(ctx, "Shift level %d is out of range (1..%d)\n",
537 result, XkbMaxShiftLevel);
541 /* Level is zero-indexed from now on. */
542 *level_rtrn = (unsigned int) (result - 1);
547 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
550 static const LookupEntry button_names[] = {
560 if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
569 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
570 const char **val_rtrn)
574 if (expr->value_type != EXPR_TYPE_STRING) {
575 log_err(ctx, "Found constant of type %s, expected a string\n",
576 exprValueTypeText(expr->value_type));
580 *val_rtrn = xkb_atom_text(ctx, expr->value.str);
584 log_err(ctx, "Identifier \"%s\" of type string not found\n",
585 xkb_atom_text(ctx, expr->value.str));
589 log_err(ctx, "Default \"%s.%s\" of type string not found\n",
590 xkb_atom_text(ctx, expr->value.field.element),
591 xkb_atom_text(ctx, expr->value.field.field));
602 case EXPR_UNARY_PLUS:
603 log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
607 log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
614 ExprResolveKeyName(struct xkb_context *ctx, const ExprDef *expr,
615 char name[XkbKeyNameLength])
619 if (expr->value_type != EXPR_TYPE_KEYNAME) {
620 log_err(ctx, "Found constant of type %s, expected a key name\n",
621 exprValueTypeText(expr->value_type));
624 strncpy(name, expr->value.keyName, XkbKeyNameLength);
628 log_err(ctx, "Identifier \"%s\" of type string not found\n",
629 xkb_atom_text(ctx, expr->value.str));
633 log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
634 xkb_atom_text(ctx, expr->value.field.element),
635 xkb_atom_text(ctx, expr->value.field.field));
646 case EXPR_UNARY_PLUS:
647 log_err(ctx, "%s of key name values not permitted\n",
648 exprOpText(expr->op));
652 log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
659 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
660 unsigned int *val_rtrn, const LookupEntry *values)
662 if (expr->op != EXPR_IDENT) {
663 log_err(ctx, "Found a %s where an enumerated value was expected\n",
664 exprOpText(expr->op));
668 if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
670 log_err(ctx, "Illegal identifier %s; expected one of:\n",
671 xkb_atom_text(ctx, expr->value.str));
672 while (values && values->name)
674 log_err(ctx, "\t%s\n", values->name);
684 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
685 unsigned int *val_rtrn, IdentLookupFunc lookup,
686 const void *lookupPriv)
691 ExprDef *left, *right;
692 const char *bogus = NULL;
696 if (expr->value_type != EXPR_TYPE_INT) {
698 "Found constant of type %s where a mask was expected\n",
699 exprValueTypeText(expr->value_type));
702 *val_rtrn = (unsigned int) expr->value.ival;
706 ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
709 log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
710 xkb_atom_text(ctx, expr->value.str));
714 log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
715 xkb_atom_text(ctx, expr->value.field.element),
716 xkb_atom_text(ctx, expr->value.field.field));
720 bogus = "array reference";
722 case EXPR_ACTION_DECL:
724 bogus = "function use";
726 "Unexpected %s in mask expression; Expression Ignored\n",
734 left = expr->value.binary.left;
735 right = expr->value.binary.right;
736 if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
737 !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
745 *val_rtrn = l & (~r);
749 log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
750 (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
759 log_wsgo(ctx, "Assignment operator not implemented yet\n");
763 left = expr->value.child;
764 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
770 case EXPR_UNARY_PLUS:
773 left = expr->value.child;
774 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
775 log_err(ctx, "The %s operator cannot be used with a mask\n",
776 (expr->op == EXPR_NEGATE ? "-" : "!"));
780 log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
788 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
789 unsigned int *mask_rtrn, const LookupEntry *values)
791 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
795 ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
796 xkb_mod_mask_t *mask_rtrn)
798 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
802 ExprResolveVModMask(struct xkb_keymap *keymap, const ExprDef *expr,
803 xkb_mod_mask_t *mask_rtrn)
805 return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
810 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
811 xkb_keysym_t *sym_rtrn)
815 if (expr->op == EXPR_IDENT) {
817 str = xkb_atom_text(ctx, expr->value.str);
818 *sym_rtrn = xkb_keysym_from_name(str);
819 if (*sym_rtrn != XKB_KEY_NoSymbol)
823 if (!ExprResolveInteger(ctx, expr, &val))
826 if (val < 0 || val >= 10)
829 *sym_rtrn = ((xkb_keysym_t) val) + '0';