expr: drop ExprResult from ResolveButton
[platform/upstream/libxkbcommon.git] / src / xkbcomp / expr.c
1 /************************************************************
2  * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
3  *
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.
15  *
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.
24  *
25  ********************************************************/
26
27 #include "expr.h"
28
29 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
30                                 xkb_atom_t field, enum expr_value_type type,
31                                 ExprResult *val_rtrn);
32
33 const char *
34 exprOpText(enum expr_op_type op)
35 {
36     static char buf[32];
37
38     switch (op) {
39     case EXPR_VALUE:
40         strcpy(buf, "literal");
41         break;
42     case EXPR_IDENT:
43         strcpy(buf, "identifier");
44         break;
45     case EXPR_ACTION_DECL:
46         strcpy(buf, "action declaration");
47         break;
48     case EXPR_FIELD_REF:
49         strcpy(buf, "field reference");
50         break;
51     case EXPR_ARRAY_REF:
52         strcpy(buf, "array reference");
53         break;
54     case EXPR_KEYSYM_LIST:
55         strcpy(buf, "list of keysyms");
56         break;
57     case EXPR_ACTION_LIST:
58         strcpy(buf, "list of actions");
59         break;
60     case EXPR_ADD:
61         strcpy(buf, "addition");
62         break;
63     case EXPR_SUBTRACT:
64         strcpy(buf, "subtraction");
65         break;
66     case EXPR_MULTIPLY:
67         strcpy(buf, "multiplication");
68         break;
69     case EXPR_DIVIDE:
70         strcpy(buf, "division");
71         break;
72     case EXPR_ASSIGN:
73         strcpy(buf, "assignment");
74         break;
75     case EXPR_NOT:
76         strcpy(buf, "logical not");
77         break;
78     case EXPR_NEGATE:
79         strcpy(buf, "arithmetic negation");
80         break;
81     case EXPR_INVERT:
82         strcpy(buf, "bitwise inversion");
83         break;
84     case EXPR_UNARY_PLUS:
85         strcpy(buf, "unary plus");
86         break;
87     default:
88         snprintf(buf, sizeof(buf), "illegal(%d)", op);
89         break;
90     }
91     return buf;
92 }
93
94 static const char *
95 exprValueTypeText(enum expr_value_type type)
96 {
97     static char buf[20];
98
99     switch (type) {
100     case EXPR_TYPE_UNKNOWN:
101         strcpy(buf, "unknown");
102         break;
103     case EXPR_TYPE_BOOLEAN:
104         strcpy(buf, "boolean");
105         break;
106     case EXPR_TYPE_INT:
107         strcpy(buf, "int");
108         break;
109     case EXPR_TYPE_STRING:
110         strcpy(buf, "string");
111         break;
112     case EXPR_TYPE_ACTION:
113         strcpy(buf, "action");
114         break;
115     case EXPR_TYPE_KEYNAME:
116         strcpy(buf, "keyname");
117         break;
118     default:
119         snprintf(buf, sizeof(buf), "illegal(%d)", type);
120         break;
121     }
122     return buf;
123 }
124
125 bool
126 ExprResolveLhs(struct xkb_context *ctx, ExprDef *expr, const char **elem_rtrn,
127                const char **field_rtrn, ExprDef **index_rtrn)
128 {
129     switch (expr->op) {
130     case EXPR_IDENT:
131         *elem_rtrn = NULL;
132         *field_rtrn = xkb_atom_text(ctx, expr->value.str);
133         *index_rtrn = NULL;
134         return true;
135     case EXPR_FIELD_REF:
136         *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
137         *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
138         *index_rtrn = NULL;
139         return true;
140     case EXPR_ARRAY_REF:
141         *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
142         *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
143         *index_rtrn = expr->value.array.entry;
144         return true;
145     default:
146         break;
147     }
148     log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
149     return false;
150 }
151
152 static bool
153 SimpleLookup(struct xkb_context *ctx, const void *priv,
154              xkb_atom_t field, enum expr_value_type type,
155              ExprResult *val_rtrn)
156 {
157     const LookupEntry *entry;
158     const char *str;
159
160     if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
161         return false;
162
163     str = xkb_atom_text(ctx, field);
164     for (entry = priv; entry && entry->name; entry++) {
165         if (istreq(str, entry->name)) {
166             val_rtrn->uval = entry->result;
167             return true;
168         }
169     }
170
171     return false;
172 }
173
174 static const LookupEntry modIndexNames[] = {
175     { "shift", ShiftMapIndex },
176     { "control", ControlMapIndex },
177     { "lock", LockMapIndex },
178     { "mod1", Mod1MapIndex },
179     { "mod2", Mod2MapIndex },
180     { "mod3", Mod3MapIndex },
181     { "mod4", Mod4MapIndex },
182     { "mod5", Mod5MapIndex },
183     { "none", XkbNoModifier },
184     { NULL, 0 }
185 };
186
187 bool
188 LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
189                enum expr_value_type type, ExprResult *val_rtrn)
190 {
191     return SimpleLookup(ctx, modIndexNames, field, type, val_rtrn);
192 }
193
194 bool
195 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
196               enum expr_value_type type, ExprResult *val_rtrn)
197 {
198     const char *str;
199     bool ret = true;
200
201     if (type != EXPR_TYPE_INT)
202         return false;
203     str = xkb_atom_text(ctx, field);
204     if (str == NULL)
205         return false;
206     if (istreq(str, "all"))
207         val_rtrn->uval = 0xff;
208     else if (istreq(str, "none"))
209         val_rtrn->uval = 0;
210     else if (LookupModIndex(ctx, priv, field, type, val_rtrn))
211         val_rtrn->uval = (1 << val_rtrn->uval);
212     else
213         ret = false;
214     return ret;
215 }
216
217 bool
218 ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr, bool *set_rtrn)
219 {
220     bool ok = false;
221     const char *ident;
222
223     switch (expr->op) {
224     case EXPR_VALUE:
225         if (expr->value_type != EXPR_TYPE_BOOLEAN) {
226             log_err(ctx,
227                     "Found constant of type %s where boolean was expected\n",
228                     exprValueTypeText(expr->value_type));
229             return false;
230         }
231         *set_rtrn = !!expr->value.ival;
232         return true;
233
234     case EXPR_IDENT:
235         ident = xkb_atom_text(ctx, expr->value.str);
236         if (ident) {
237             if (istreq(ident, "true") ||
238                 istreq(ident, "yes") ||
239                 istreq(ident, "on")) {
240                 *set_rtrn = true;
241                 return true;
242             }
243             else if (istreq(ident, "false") ||
244                      istreq(ident, "no") ||
245                      istreq(ident, "off")) {
246                 *set_rtrn = false;
247                 return true;
248             }
249         }
250         log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
251                 xkb_atom_text(ctx, expr->value.str));
252         return false;
253
254     case EXPR_FIELD_REF:
255         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
256                 xkb_atom_text(ctx, expr->value.field.element),
257                 xkb_atom_text(ctx, expr->value.field.field));
258         return false;
259
260     case EXPR_INVERT:
261     case EXPR_NOT:
262         ok = ExprResolveBoolean(ctx, expr, set_rtrn);
263         if (ok)
264             *set_rtrn = !*set_rtrn;
265         return ok;
266     case EXPR_ADD:
267     case EXPR_SUBTRACT:
268     case EXPR_MULTIPLY:
269     case EXPR_DIVIDE:
270     case EXPR_ASSIGN:
271     case EXPR_NEGATE:
272     case EXPR_UNARY_PLUS:
273         log_err(ctx, "%s of boolean values not permitted\n",
274                 exprOpText(expr->op));
275         break;
276
277     default:
278         log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
279         break;
280     }
281
282     return false;
283 }
284
285 bool
286 ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr, xkb_keycode_t *kc)
287 {
288     xkb_keycode_t leftRtrn, rightRtrn;
289     ExprDef *left, *right;
290
291     switch (expr->op) {
292     case EXPR_VALUE:
293         if (expr->value_type != EXPR_TYPE_INT) {
294             log_err(ctx,
295                     "Found constant of type %s where an int was expected\n",
296                     exprValueTypeText(expr->value_type));
297             return false;
298         }
299
300         *kc = expr->value.uval;
301         return true;
302
303     case EXPR_ADD:
304     case EXPR_SUBTRACT:
305     case EXPR_MULTIPLY:
306     case EXPR_DIVIDE:
307         left = expr->value.binary.left;
308         right = expr->value.binary.right;
309
310         if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
311             !ExprResolveKeyCode(ctx, right, &rightRtrn))
312             return false;
313
314         switch (expr->op) {
315         case EXPR_ADD:
316             *kc = leftRtrn + rightRtrn;
317             break;
318         case EXPR_SUBTRACT:
319             *kc = leftRtrn - rightRtrn;
320             break;
321         case EXPR_MULTIPLY:
322             *kc = leftRtrn * rightRtrn;
323             break;
324         case EXPR_DIVIDE:
325             if (rightRtrn == 0) {
326                 log_err(ctx, "Cannot divide by zero: %d / %d\n",
327                         leftRtrn, rightRtrn);
328                 return false;
329             }
330
331             *kc = leftRtrn / rightRtrn;
332             break;
333         default:
334             break;
335         }
336
337         return true;
338
339     case EXPR_NEGATE:
340         left = expr->value.child;
341         if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
342             return false;
343
344         *kc = ~leftRtrn;
345         return true;
346
347     case EXPR_UNARY_PLUS:
348         left = expr->value.child;
349         return ExprResolveKeyCode(ctx, left, kc);
350
351     default:
352         log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
353         break;
354     }
355
356     return false;
357 }
358
359 /**
360  * This function returns ... something.  It's a bit of a guess, really.
361  *
362  * If a string is given in value ctx, its first character will be
363  * returned in uval.  If an integer is given in value ctx, it will be
364  * returned in ival.  If a float is given in value ctx, it will be
365  * returned as millimetres (rather than points) in ival.
366  *
367  * If an ident or field reference is given, the lookup function (if given)
368  * will be called.  At the moment, only SimpleLookup use this, and they both
369  * return the results in uval.  And don't support field references.
370  *
371  * Cool.
372  */
373 static int
374 ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
375                          ExprResult *val_rtrn, IdentLookupFunc lookup,
376                          const void *lookupPriv)
377 {
378     int ok = 0;
379     ExprResult leftRtrn, rightRtrn;
380     ExprDef *left, *right;
381
382     switch (expr->op) {
383     case EXPR_VALUE:
384         if (expr->value_type == EXPR_TYPE_STRING) {
385             const char *str;
386             str = xkb_atom_text(ctx, expr->value.str);
387             if (str != NULL)
388                 switch (strlen(str)) {
389                 case 0:
390                     val_rtrn->uval = 0;
391                     return true;
392                 case 1:
393                     val_rtrn->uval = str[0];
394                     return true;
395                 default:
396                     break;
397                 }
398         }
399         if (expr->value_type != EXPR_TYPE_INT) {
400             log_err(ctx,
401                     "Found constant of type %s where an int was expected\n",
402                     exprValueTypeText(expr->value_type));
403             return false;
404         }
405         val_rtrn->ival = expr->value.ival;
406         return true;
407
408     case EXPR_IDENT:
409         if (lookup)
410             ok = lookup(ctx, lookupPriv, expr->value.str,
411                         EXPR_TYPE_INT, val_rtrn);
412         if (!ok)
413             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
414                     xkb_atom_text(ctx, expr->value.str));
415         return ok;
416
417     case EXPR_FIELD_REF:
418         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
419                 xkb_atom_text(ctx, expr->value.field.element),
420                 xkb_atom_text(ctx, expr->value.field.field));
421         return false;
422
423     case EXPR_ADD:
424     case EXPR_SUBTRACT:
425     case EXPR_MULTIPLY:
426     case EXPR_DIVIDE:
427         left = expr->value.binary.left;
428         right = expr->value.binary.right;
429         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
430                                      lookupPriv) &&
431             ExprResolveIntegerLookup(ctx, right, &rightRtrn, lookup,
432                                      lookupPriv)) {
433             switch (expr->op) {
434             case EXPR_ADD:
435                 val_rtrn->ival = leftRtrn.ival + rightRtrn.ival;
436                 break;
437             case EXPR_SUBTRACT:
438                 val_rtrn->ival = leftRtrn.ival - rightRtrn.ival;
439                 break;
440             case EXPR_MULTIPLY:
441                 val_rtrn->ival = leftRtrn.ival * rightRtrn.ival;
442                 break;
443             case EXPR_DIVIDE:
444                 if (rightRtrn.ival == 0) {
445                     log_err(ctx, "Cannot divide by zero: %d / %d\n",
446                             leftRtrn.ival, rightRtrn.ival);
447                     return false;
448                 }
449                 val_rtrn->ival = leftRtrn.ival / rightRtrn.ival;
450                 break;
451             default:
452                 break;
453             }
454             return true;
455         }
456         return false;
457
458     case EXPR_ASSIGN:
459         log_wsgo(ctx, "Assignment operator not implemented yet\n");
460         break;
461
462     case EXPR_NOT:
463         log_err(ctx, "The ! operator cannot be applied to an integer\n");
464         return false;
465
466     case EXPR_INVERT:
467     case EXPR_NEGATE:
468         left = expr->value.child;
469         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
470                                      lookupPriv)) {
471             if (expr->op == EXPR_NEGATE)
472                 val_rtrn->ival = -leftRtrn.ival;
473             else
474                 val_rtrn->ival = ~leftRtrn.ival;
475             return true;
476         }
477         return false;
478
479     case EXPR_UNARY_PLUS:
480         left = expr->value.child;
481         return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
482                                         lookupPriv);
483
484     default:
485         log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
486         break;
487     }
488     return false;
489 }
490
491 int
492 ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr,
493                    ExprResult *val_rtrn)
494 {
495     return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
496 }
497
498 bool
499 ExprResolveGroup(struct xkb_context *ctx, ExprDef *expr,
500                  xkb_group_index_t *group_rtrn)
501 {
502     bool ok;
503     ExprResult result;
504     static const LookupEntry group_names[] = {
505         { "group1", 1 },
506         { "group2", 2 },
507         { "group3", 3 },
508         { "group4", 4 },
509         { "group5", 5 },
510         { "group6", 6 },
511         { "group7", 7 },
512         { "group8", 8 },
513         { NULL, 0 }
514     };
515
516     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
517                                   group_names);
518     if (!ok)
519         return false;
520
521     if (result.uval == 0 || result.uval > XkbNumKbdGroups) {
522         log_err(ctx, "Group index %u is out of range (1..%d)\n",
523                 result.uval, XkbNumKbdGroups);
524         return false;
525     }
526
527     *group_rtrn = result.uval;
528     return true;
529 }
530
531 bool
532 ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
533                  unsigned int *level_rtrn)
534 {
535     bool ok;
536     ExprResult result;
537     static const LookupEntry level_names[] = {
538         { "level1", 1 },
539         { "level2", 2 },
540         { "level3", 3 },
541         { "level4", 4 },
542         { "level5", 5 },
543         { "level6", 6 },
544         { "level7", 7 },
545         { "level8", 8 },
546         { NULL, 0 }
547     };
548
549     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
550                                   level_names);
551     if (!ok)
552         return false;
553
554     if (result.uval < 1 || result.uval > XkbMaxShiftLevel) {
555         log_err(ctx, "Shift level %d is out of range (1..%d)\n",
556                 result.uval, XkbMaxShiftLevel);
557         return false;
558     }
559
560     *level_rtrn = result.uval;
561     return true;
562 }
563
564 bool
565 ExprResolveButton(struct xkb_context *ctx, ExprDef *expr, int *btn_rtrn)
566 {
567     bool ok;
568     ExprResult result;
569     static const LookupEntry button_names[] = {
570         { "button1", 1 },
571         { "button2", 2 },
572         { "button3", 3 },
573         { "button4", 4 },
574         { "button5", 5 },
575         { "default", 0 },
576         { NULL, 0 }
577     };
578
579     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
580                                   button_names);
581     if (ok)
582         *btn_rtrn = result.ival;
583     return ok;
584 }
585
586 bool
587 ExprResolveString(struct xkb_context *ctx, ExprDef *expr,
588                   const char **val_rtrn)
589 {
590     switch (expr->op) {
591     case EXPR_VALUE:
592         if (expr->value_type != EXPR_TYPE_STRING) {
593             log_err(ctx, "Found constant of type %s, expected a string\n",
594                     exprValueTypeText(expr->value_type));
595             return false;
596         }
597
598         *val_rtrn = xkb_atom_text(ctx, expr->value.str);
599         return true;
600
601     case EXPR_IDENT:
602         log_err(ctx, "Identifier \"%s\" of type string not found\n",
603                 xkb_atom_text(ctx, expr->value.str));
604         return false;
605
606     case EXPR_FIELD_REF:
607         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
608                 xkb_atom_text(ctx, expr->value.field.element),
609                 xkb_atom_text(ctx, expr->value.field.field));
610         return false;
611
612     case EXPR_ADD:
613     case EXPR_SUBTRACT:
614     case EXPR_MULTIPLY:
615     case EXPR_DIVIDE:
616     case EXPR_ASSIGN:
617     case EXPR_NEGATE:
618     case EXPR_INVERT:
619     case EXPR_NOT:
620     case EXPR_UNARY_PLUS:
621         log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
622         return false;
623
624     default:
625         log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
626         break;
627     }
628     return false;
629 }
630
631 bool
632 ExprResolveKeyName(struct xkb_context *ctx, ExprDef *expr,
633                    char name[XkbKeyNameLength])
634 {
635     switch (expr->op) {
636     case EXPR_VALUE:
637         if (expr->value_type != EXPR_TYPE_KEYNAME) {
638             log_err(ctx, "Found constant of type %s, expected a key name\n",
639                     exprValueTypeText(expr->value_type));
640             return false;
641         }
642         memcpy(name, expr->value.keyName, XkbKeyNameLength);
643         return true;
644
645     case EXPR_IDENT:
646         log_err(ctx, "Identifier \"%s\" of type string not found\n",
647                 xkb_atom_text(ctx, expr->value.str));
648         return false;
649
650     case EXPR_FIELD_REF:
651         log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
652                 xkb_atom_text(ctx, expr->value.field.element),
653                 xkb_atom_text(ctx, expr->value.field.field));
654         return false;
655
656     case EXPR_ADD:
657     case EXPR_SUBTRACT:
658     case EXPR_MULTIPLY:
659     case EXPR_DIVIDE:
660     case EXPR_ASSIGN:
661     case EXPR_NEGATE:
662     case EXPR_INVERT:
663     case EXPR_NOT:
664     case EXPR_UNARY_PLUS:
665         log_err(ctx, "%s of key name values not permitted\n",
666                 exprOpText(expr->op));
667         return false;
668
669     default:
670         log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
671         break;
672     }
673     return false;
674 }
675
676 /***====================================================================***/
677
678 int
679 ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr,
680                 ExprResult *val_rtrn, const LookupEntry *values)
681 {
682     if (expr->op != EXPR_IDENT) {
683         log_err(ctx, "Found a %s where an enumerated value was expected\n",
684                 exprOpText(expr->op));
685         return false;
686     }
687     if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
688                       val_rtrn)) {
689         int nOut = 0;
690         log_err(ctx, "Illegal identifier %s (expected one of: ",
691                 xkb_atom_text(ctx, expr->value.str));
692         while (values && values->name)
693         {
694             if (nOut != 0)
695                 log_info(ctx, ", %s", values->name);
696             else
697                 log_info(ctx, "%s", values->name);
698             values++;
699             nOut++;
700         }
701         log_info(ctx, ")\n");
702         return false;
703     }
704     return true;
705 }
706
707 static int
708 ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
709                       ExprResult *val_rtrn, IdentLookupFunc lookup,
710                       const void *lookupPriv)
711 {
712     int ok = 0;
713     ExprResult leftRtrn, rightRtrn;
714     ExprDef *left, *right;
715     const char *bogus = NULL;
716
717     switch (expr->op) {
718     case EXPR_VALUE:
719         if (expr->value_type != EXPR_TYPE_INT) {
720             log_err(ctx,
721                     "Found constant of type %s where a mask was expected\n",
722                     exprValueTypeText(expr->value_type));
723             return false;
724         }
725         val_rtrn->ival = expr->value.ival;
726         return true;
727
728     case EXPR_IDENT:
729         ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, val_rtrn);
730         if (!ok)
731             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
732                     xkb_atom_text(ctx, expr->value.str));
733         return ok;
734
735     case EXPR_FIELD_REF:
736         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
737                 xkb_atom_text(ctx, expr->value.field.element),
738                 xkb_atom_text(ctx, expr->value.field.field));
739         return false;
740
741     case EXPR_ARRAY_REF:
742         bogus = "array reference";
743
744     case EXPR_ACTION_DECL:
745         if (bogus == NULL)
746             bogus = "function use";
747         log_err(ctx,
748                 "Unexpected %s in mask expression; Expression Ignored\n",
749                 bogus);
750         return false;
751
752     case EXPR_ADD:
753     case EXPR_SUBTRACT:
754     case EXPR_MULTIPLY:
755     case EXPR_DIVIDE:
756         left = expr->value.binary.left;
757         right = expr->value.binary.right;
758         if (ExprResolveMaskLookup(ctx, left, &leftRtrn, lookup,
759                                   lookupPriv) &&
760             ExprResolveMaskLookup(ctx, right, &rightRtrn, lookup,
761                                   lookupPriv)) {
762             switch (expr->op) {
763             case EXPR_ADD:
764                 val_rtrn->ival = leftRtrn.ival | rightRtrn.ival;
765                 break;
766             case EXPR_SUBTRACT:
767                 val_rtrn->ival = leftRtrn.ival & (~rightRtrn.ival);
768                 break;
769             case EXPR_MULTIPLY:
770             case EXPR_DIVIDE:
771                 log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
772                         (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
773                 return false;
774             default:
775                 break;
776             }
777             return true;
778         }
779         return false;
780
781     case EXPR_ASSIGN:
782         log_wsgo(ctx, "Assignment operator not implemented yet\n");
783         break;
784
785     case EXPR_INVERT:
786         left = expr->value.child;
787         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
788                                      lookupPriv)) {
789             val_rtrn->ival = ~leftRtrn.ival;
790             return true;
791         }
792         return false;
793
794     case EXPR_UNARY_PLUS:
795     case EXPR_NEGATE:
796     case EXPR_NOT:
797         left = expr->value.child;
798         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
799                                      lookupPriv)) {
800             log_err(ctx, "The %s operator cannot be used with a mask\n",
801                     (expr->op == EXPR_NEGATE ? "-" : "!"));
802         }
803         return false;
804
805     default:
806         log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
807         break;
808     }
809     return false;
810 }
811
812 int
813 ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
814                 ExprResult *val_rtrn, const LookupEntry *values)
815 {
816     return ExprResolveMaskLookup(ctx, expr, val_rtrn, SimpleLookup, values);
817 }
818
819 int
820 ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
821                    ExprResult *val_rtrn)
822 {
823     return ExprResolveMaskLookup(ctx, expr, val_rtrn, LookupModMask, NULL);
824 }
825
826 int
827 ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
828                     ExprResult *val_rtrn)
829 {
830     return ExprResolveMaskLookup(keymap->ctx, expr, val_rtrn, LookupVModMask,
831                                  keymap);
832 }
833
834 bool
835 ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
836                   xkb_keysym_t *sym_rtrn)
837 {
838     bool ok = false;
839     ExprResult result;
840
841     if (expr->op == EXPR_IDENT) {
842         const char *str;
843         str = xkb_atom_text(ctx, expr->value.str);
844         *sym_rtrn = xkb_keysym_from_name(str);
845         if (*sym_rtrn != XKB_KEY_NoSymbol)
846             return true;
847     }
848
849     ok = ExprResolveInteger(ctx, expr, &result);
850     if (ok && result.uval < 10)
851         *sym_rtrn = result.uval + '0';
852
853     return ok;
854 }