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 #include "xkbcomp-priv.h"
34 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
35 xkb_atom_t field, enum expr_value_type type,
36 unsigned int *val_rtrn);
39 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
40 const char **elem_rtrn, const char **field_rtrn,
43 switch (expr->expr.op) {
46 *field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
48 return (*field_rtrn != NULL);
50 *elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
51 *field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
53 return (*elem_rtrn != NULL && *field_rtrn != NULL);
55 *elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
56 *field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
57 *index_rtrn = expr->array_ref.entry;
58 if (expr->array_ref.element != XKB_ATOM_NONE && *elem_rtrn == NULL)
60 if (*field_rtrn == NULL)
67 XKB_ERROR_INVALID_SYNTAX,
68 "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
73 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
74 enum expr_value_type type, unsigned int *val_rtrn)
76 const LookupEntry *entry;
79 if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
82 str = xkb_atom_text(ctx, field);
83 for (entry = priv; entry && entry->name; entry++) {
84 if (istreq(str, entry->name)) {
85 *val_rtrn = entry->value;
93 /* Data passed in the *priv argument for LookupModMask. */
95 const struct xkb_mod_set *mods;
96 enum mod_type mod_type;
100 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
101 enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
105 const LookupModMaskPriv *arg = priv;
106 const struct xkb_mod_set *mods = arg->mods;
107 enum mod_type mod_type = arg->mod_type;
109 if (type != EXPR_TYPE_INT)
112 str = xkb_atom_text(ctx, field);
116 if (istreq(str, "all")) {
117 *val_rtrn = MOD_REAL_MASK_ALL;
121 if (istreq(str, "none")) {
126 ndx = XkbModNameToIndex(mods, field, mod_type);
127 if (ndx == XKB_MOD_INVALID)
130 *val_rtrn = (1u << ndx);
135 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
141 switch (expr->expr.op) {
143 if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
145 XKB_ERROR_WRONG_FIELD_TYPE,
146 "Found constant of type %s where boolean was expected\n",
147 expr_value_type_to_string(expr->expr.value_type));
150 *set_rtrn = expr->boolean.set;
154 ident = xkb_atom_text(ctx, expr->ident.ident);
156 if (istreq(ident, "true") ||
157 istreq(ident, "yes") ||
158 istreq(ident, "on")) {
162 else if (istreq(ident, "false") ||
163 istreq(ident, "no") ||
164 istreq(ident, "off")) {
170 XKB_ERROR_INVALID_IDENTIFIER,
171 "Identifier \"%s\" of type boolean is unknown\n", ident);
176 XKB_ERROR_INVALID_EXPRESSION_TYPE,
177 "Default \"%s.%s\" of type boolean is unknown\n",
178 xkb_atom_text(ctx, expr->field_ref.element),
179 xkb_atom_text(ctx, expr->field_ref.field));
184 ok = ExprResolveBoolean(ctx, expr->unary.child, set_rtrn);
186 *set_rtrn = !*set_rtrn;
194 case EXPR_UNARY_PLUS:
195 case EXPR_ACTION_DECL:
196 case EXPR_ACTION_LIST:
197 case EXPR_KEYSYM_LIST:
199 XKB_ERROR_INVALID_OPERATION,
200 "%s of boolean values not permitted\n",
201 expr_op_type_to_string(expr->expr.op));
206 XKB_ERROR_UNKNOWN_OPERATOR,
207 "Unknown operator %d in ResolveBoolean\n",
216 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
219 xkb_keycode_t leftRtrn, rightRtrn;
221 switch (expr->expr.op) {
223 if (expr->expr.value_type != EXPR_TYPE_INT) {
225 XKB_ERROR_WRONG_FIELD_TYPE,
226 "Found constant of type %s where an int was expected\n",
227 expr_value_type_to_string(expr->expr.value_type));
231 *kc = (xkb_keycode_t) expr->integer.ival;
238 if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
239 !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
242 switch (expr->expr.op) {
244 *kc = leftRtrn + rightRtrn;
247 *kc = leftRtrn - rightRtrn;
250 *kc = leftRtrn * rightRtrn;
253 if (rightRtrn == 0) {
255 XKB_ERROR_INVALID_OPERATION,
256 "Cannot divide by zero: %d / %d\n",
257 leftRtrn, rightRtrn);
261 *kc = leftRtrn / rightRtrn;
270 if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
276 case EXPR_UNARY_PLUS:
277 return ExprResolveKeyCode(ctx, expr->unary.child, kc);
281 XKB_ERROR_INVALID_SYNTAX,
282 "Unknown operator %d in ResolveKeyCode\n", expr->expr.op);
290 * This function returns ... something. It's a bit of a guess, really.
292 * If an integer is given in value ctx, it will be returned in ival.
293 * If an ident or field reference is given, the lookup function (if given)
294 * will be called. At the moment, only SimpleLookup use this, and they both
295 * return the results in uval. And don't support field references.
300 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
301 int *val_rtrn, IdentLookupFunc lookup,
302 const void *lookupPriv)
307 ExprDef *left, *right;
309 switch (expr->expr.op) {
311 if (expr->expr.value_type != EXPR_TYPE_INT) {
313 XKB_ERROR_WRONG_FIELD_TYPE,
314 "Found constant of type %s where an int was expected\n",
315 expr_value_type_to_string(expr->expr.value_type));
319 *val_rtrn = expr->integer.ival;
324 ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
328 XKB_ERROR_INVALID_IDENTIFIER,
329 "Identifier \"%s\" of type int is unknown\n",
330 xkb_atom_text(ctx, expr->ident.ident));
338 XKB_ERROR_INVALID_EXPRESSION_TYPE,
339 "Default \"%s.%s\" of type int is unknown\n",
340 xkb_atom_text(ctx, expr->field_ref.element),
341 xkb_atom_text(ctx, expr->field_ref.field));
348 left = expr->binary.left;
349 right = expr->binary.right;
350 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
351 !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
354 switch (expr->expr.op) {
367 XKB_ERROR_INVALID_OPERATION,
368 "Cannot divide by zero: %d / %d\n", l, r);
375 XKB_ERROR_INVALID_OPERATION,
376 "%s of integers not permitted\n",
377 expr_op_type_to_string(expr->expr.op));
385 XKB_ERROR_INVALID_OPERATION,
386 "Assignment operator not implemented yet\n");
391 XKB_ERROR_INVALID_OPERATION,
392 "The ! operator cannot be applied to an integer\n");
397 left = expr->unary.child;
398 if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
401 *val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
404 case EXPR_UNARY_PLUS:
405 left = expr->unary.child;
406 return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
411 XKB_ERROR_UNKNOWN_OPERATOR,
412 "Unknown operator %d in ResolveInteger\n",
421 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
424 return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
428 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
429 xkb_layout_index_t *group_rtrn)
434 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
439 if (result <= 0 || result > XKB_MAX_GROUPS) {
440 log_err(ctx, XKB_ERROR_UNSUPPORTED_GROUP_INDEX,
441 "Group index %u is out of range (1..%d)\n",
442 result, XKB_MAX_GROUPS);
446 *group_rtrn = (xkb_layout_index_t) result;
451 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
452 xkb_level_index_t *level_rtrn)
457 ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
463 log_err(ctx, XKB_ERROR_UNSUPPORTED_SHIFT_LEVEL,
464 "Shift level %d is out of range\n", result);
468 /* Level is zero-indexed from now on. */
469 *level_rtrn = (unsigned int) (result - 1);
474 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
476 return ExprResolveIntegerLookup(ctx, expr, btn_rtrn, SimpleLookup,
481 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
482 xkb_atom_t *val_rtrn)
484 switch (expr->expr.op) {
486 if (expr->expr.value_type != EXPR_TYPE_STRING) {
488 XKB_ERROR_WRONG_FIELD_TYPE,
489 "Found constant of type %s, expected a string\n",
490 expr_value_type_to_string(expr->expr.value_type));
494 *val_rtrn = expr->string.str;
499 XKB_ERROR_INVALID_IDENTIFIER,
500 "Identifier \"%s\" of type string not found\n",
501 xkb_atom_text(ctx, expr->ident.ident));
506 XKB_ERROR_INVALID_EXPRESSION_TYPE,
507 "Default \"%s.%s\" of type string not found\n",
508 xkb_atom_text(ctx, expr->field_ref.element),
509 xkb_atom_text(ctx, expr->field_ref.field));
520 case EXPR_UNARY_PLUS:
521 case EXPR_ACTION_DECL:
522 case EXPR_ACTION_LIST:
523 case EXPR_KEYSYM_LIST:
525 XKB_ERROR_INVALID_SYNTAX,
526 "%s of strings not permitted\n",
527 expr_op_type_to_string(expr->expr.op));
532 XKB_ERROR_UNKNOWN_OPERATOR,
533 "Unknown operator %d in ResolveString\n",
541 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
542 unsigned int *val_rtrn, const LookupEntry *values)
544 if (expr->expr.op != EXPR_IDENT) {
546 XKB_ERROR_WRONG_FIELD_TYPE,
547 "Found a %s where an enumerated value was expected\n",
548 expr_op_type_to_string(expr->expr.op));
552 if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
555 XKB_ERROR_INVALID_IDENTIFIER,
556 "Illegal identifier %s; expected one of:\n",
557 xkb_atom_text(ctx, expr->ident.ident));
558 while (values && values->name)
560 log_err(ctx, XKB_ERROR_INVALID_IDENTIFIER, "\t%s\n", values->name);
570 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
571 unsigned int *val_rtrn, IdentLookupFunc lookup,
572 const void *lookupPriv)
575 unsigned int l = 0, r = 0;
577 ExprDef *left, *right;
578 const char *bogus = NULL;
580 switch (expr->expr.op) {
582 if (expr->expr.value_type != EXPR_TYPE_INT) {
584 XKB_ERROR_WRONG_FIELD_TYPE,
585 "Found constant of type %s where a mask was expected\n",
586 expr_value_type_to_string(expr->expr.value_type));
589 *val_rtrn = (unsigned int) expr->integer.ival;
593 ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
597 XKB_ERROR_INVALID_IDENTIFIER,
598 "Identifier \"%s\" of type int is unknown\n",
599 xkb_atom_text(ctx, expr->ident.ident));
604 XKB_ERROR_INVALID_EXPRESSION_TYPE,
605 "Default \"%s.%s\" of type int is unknown\n",
606 xkb_atom_text(ctx, expr->field_ref.element),
607 xkb_atom_text(ctx, expr->field_ref.field));
611 bogus = "array reference";
613 case EXPR_ACTION_DECL:
615 bogus = "function use";
617 XKB_ERROR_WRONG_FIELD_TYPE,
618 "Unexpected %s in mask expression; Expression Ignored\n",
626 left = expr->binary.left;
627 right = expr->binary.right;
628 if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
629 !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
632 switch (expr->expr.op) {
637 *val_rtrn = l & (~r);
642 XKB_ERROR_INVALID_OPERATION,
643 "Cannot %s masks; Illegal operation ignored\n",
644 (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
654 XKB_ERROR_INVALID_OPERATION,
655 "Assignment operator not implemented yet\n");
659 left = expr->unary.child;
660 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
666 case EXPR_UNARY_PLUS:
669 left = expr->unary.child;
670 if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
672 XKB_ERROR_INVALID_OPERATION,
673 "The %s operator cannot be used with a mask\n",
674 (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
679 XKB_ERROR_UNKNOWN_OPERATOR,
680 "Unknown operator %d in ResolveMask\n",
689 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
690 unsigned int *mask_rtrn, const LookupEntry *values)
692 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
696 ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
697 enum mod_type mod_type, const struct xkb_mod_set *mods,
698 xkb_mod_mask_t *mask_rtrn)
700 LookupModMaskPriv priv = { .mods = mods, .mod_type = mod_type };
701 return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, &priv);
705 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
706 xkb_keysym_t *sym_rtrn)
710 if (expr->expr.op == EXPR_IDENT) {
711 const char *str = xkb_atom_text(ctx, expr->ident.ident);
712 *sym_rtrn = xkb_keysym_from_name(str, 0);
713 if (*sym_rtrn != XKB_KEY_NoSymbol)
717 if (!ExprResolveInteger(ctx, expr, &val))
720 if (val < XKB_KEYSYM_MIN) {
721 log_warn(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM,
722 "unrecognized keysym \"-0x%x\" (%d)\n",
723 (unsigned int) -val, val);
727 /* Special case for digits 0..9 */
729 *sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
733 if (val <= XKB_KEYSYM_MAX) {
734 log_warn(ctx, XKB_WARNING_NUMERIC_KEYSYM,
735 "numeric keysym \"0x%x\" (%d)",
736 (unsigned int) val, val);
737 *sym_rtrn = (xkb_keysym_t) val;
741 log_warn(ctx, XKB_WARNING_UNRECOGNIZED_KEYSYM,
742 "unrecognized keysym \"0x%x\" (%d)\n",
743 (unsigned int) val, val);
749 ExprResolveMod(struct xkb_context *ctx, const ExprDef *def,
750 enum mod_type mod_type, const struct xkb_mod_set *mods,
751 xkb_mod_index_t *ndx_rtrn)
756 if (def->expr.op != EXPR_IDENT) {
758 XKB_ERROR_WRONG_FIELD_TYPE,
759 "Cannot resolve virtual modifier: "
760 "found %s where a virtual modifier name was expected\n",
761 expr_op_type_to_string(def->expr.op));
765 name = def->ident.ident;
766 ndx = XkbModNameToIndex(mods, name, mod_type);
767 if (ndx == XKB_MOD_INVALID) {
769 XKB_ERROR_UNDECLARED_VIRTUAL_MODIFIER,
770 "Cannot resolve virtual modifier: "
771 "\"%s\" was not previously declared\n",
772 xkb_atom_text(ctx, name));