src/xkbcomp/action.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 /*
  28  * Copyright © 2012 Intel Corporation
  29  * Copyright © 2012 Ran Benita <ran234@gmail.com>
  30  *
  31  * Permission is hereby granted, free of charge, to any person obtaining a
  32  * copy of this software and associated documentation files (the "Software"),
  33  * to deal in the Software without restriction, including without limitation
  34  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  35  * and/or sell copies of the Software, and to permit persons to whom the
  36  * Software is furnished to do so, subject to the following conditions:
  37  *
  38  * The above copyright notice and this permission notice (including the next
  39  * paragraph) shall be included in all copies or substantial portions of the
  40  * Software.
  41  *
  42  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  43  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  44  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  45  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  46  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  47  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  48  * DEALINGS IN THE SOFTWARE.
  49  *
  50  * Author: Daniel Stone <daniel@fooishbar.org>
  51  *         Ran Benita <ran234@gmail.com>
  52  */
  53
  54 #include "xkbcomp-priv.h"
  55 #include "text.h"
  56 #include "expr.h"
  57 #include "action.h"
  58
  59 static const ExprBoolean constTrue = {
  60     .expr = {
  61         .common = { .type = STMT_EXPR, .next = NULL },
  62         .op = EXPR_VALUE,
  63         .value_type = EXPR_TYPE_BOOLEAN,
  64     },
  65     .set = true,
  66 };
  67
  68 static const ExprBoolean constFalse = {
  69     .expr = {
  70         .common = { .type = STMT_EXPR, .next = NULL },
  71         .op = EXPR_VALUE,
  72         .value_type = EXPR_TYPE_BOOLEAN,
  73     },
  74     .set = false,
  75 };
  76
  77 enum action_field {
  78     ACTION_FIELD_CLEAR_LOCKS,
  79     ACTION_FIELD_LATCH_TO_LOCK,
  80     ACTION_FIELD_GEN_KEY_EVENT,
  81     ACTION_FIELD_REPORT,
  82     ACTION_FIELD_DEFAULT,
  83     ACTION_FIELD_AFFECT,
  84     ACTION_FIELD_INCREMENT,
  85     ACTION_FIELD_MODIFIERS,
  86     ACTION_FIELD_GROUP,
  87     ACTION_FIELD_X,
  88     ACTION_FIELD_Y,
  89     ACTION_FIELD_ACCEL,
  90     ACTION_FIELD_BUTTON,
  91     ACTION_FIELD_VALUE,
  92     ACTION_FIELD_CONTROLS,
  93     ACTION_FIELD_TYPE,
  94     ACTION_FIELD_COUNT,
  95     ACTION_FIELD_SCREEN,
  96     ACTION_FIELD_SAME,
  97     ACTION_FIELD_DATA,
  98     ACTION_FIELD_DEVICE,
  99     ACTION_FIELD_KEYCODE,
 100     ACTION_FIELD_MODS_TO_CLEAR,
 101 };
 102
 103 ActionsInfo *
 104 NewActionsInfo(void)
 105 {
 106     unsigned type;
 107     ActionsInfo *info;
 108
 109     info = calloc(1, sizeof(*info));
 110     if (!info)
 111         return NULL;
 112
 113     for (type = 0; type < _ACTION_TYPE_NUM_ENTRIES; type++)
 114         info->actions[type].type = type;
 115
 116     /* Apply some "factory defaults". */
 117
 118     /* Increment default button. */
 119     info->actions[ACTION_TYPE_PTR_DEFAULT].dflt.flags = 0;
 120     info->actions[ACTION_TYPE_PTR_DEFAULT].dflt.value = 1;
 121
 122     return info;
 123 }
 124
 125 void
 126 FreeActionsInfo(ActionsInfo *info)
 127 {
 128     free(info);
 129 }
 130
 131 static const LookupEntry fieldStrings[] = {
 132     { "clearLocks",       ACTION_FIELD_CLEAR_LOCKS   },
 133     { "latchToLock",      ACTION_FIELD_LATCH_TO_LOCK },
 134     { "genKeyEvent",      ACTION_FIELD_GEN_KEY_EVENT },
 135     { "generateKeyEvent", ACTION_FIELD_GEN_KEY_EVENT },
 136     { "report",           ACTION_FIELD_REPORT        },
 137     { "default",          ACTION_FIELD_DEFAULT       },
 138     { "affect",           ACTION_FIELD_AFFECT        },
 139     { "increment",        ACTION_FIELD_INCREMENT     },
 140     { "modifiers",        ACTION_FIELD_MODIFIERS     },
 141     { "mods",             ACTION_FIELD_MODIFIERS     },
 142     { "group",            ACTION_FIELD_GROUP         },
 143     { "x",                ACTION_FIELD_X             },
 144     { "y",                ACTION_FIELD_Y             },
 145     { "accel",            ACTION_FIELD_ACCEL         },
 146     { "accelerate",       ACTION_FIELD_ACCEL         },
 147     { "repeat",           ACTION_FIELD_ACCEL         },
 148     { "button",           ACTION_FIELD_BUTTON        },
 149     { "value",            ACTION_FIELD_VALUE         },
 150     { "controls",         ACTION_FIELD_CONTROLS      },
 151     { "ctrls",            ACTION_FIELD_CONTROLS      },
 152     { "type",             ACTION_FIELD_TYPE          },
 153     { "count",            ACTION_FIELD_COUNT         },
 154     { "screen",           ACTION_FIELD_SCREEN        },
 155     { "same",             ACTION_FIELD_SAME          },
 156     { "sameServer",       ACTION_FIELD_SAME          },
 157     { "data",             ACTION_FIELD_DATA          },
 158     { "device",           ACTION_FIELD_DEVICE        },
 159     { "dev",              ACTION_FIELD_DEVICE        },
 160     { "key",              ACTION_FIELD_KEYCODE       },
 161     { "keycode",          ACTION_FIELD_KEYCODE       },
 162     { "kc",               ACTION_FIELD_KEYCODE       },
 163     { "clearmods",        ACTION_FIELD_MODS_TO_CLEAR },
 164     { "clearmodifiers",   ACTION_FIELD_MODS_TO_CLEAR },
 165     { NULL,               0                          }
 166 };
 167
 168 static bool
 169 stringToAction(const char *str, unsigned *type_rtrn)
 170 {
 171     return LookupString(actionTypeNames, str, type_rtrn);
 172 }
 173
 174 static bool
 175 stringToField(const char *str, enum action_field *field_rtrn)
 176 {
 177     return LookupString(fieldStrings, str, field_rtrn);
 178 }
 179
 180 static const char *
 181 fieldText(enum action_field field)
 182 {
 183     return LookupValue(fieldStrings, field);
 184 }
 185
 186 /***====================================================================***/
 187
 188 static inline bool
 189 ReportMismatch(struct xkb_context *ctx, enum xkb_action_type action,
 190                enum action_field field, const char *type)
 191 {
 192     log_err(ctx,
 193             "Value of %s field must be of type %s; "
 194             "Action %s definition ignored\n",
 195             fieldText(field), type, ActionTypeText(action));
 196     return false;
 197 }
 198
 199 static inline bool
 200 ReportIllegal(struct xkb_context *ctx, enum xkb_action_type action,
 201               enum action_field field)
 202 {
 203     log_err(ctx,
 204             "Field %s is not defined for an action of type %s; "
 205             "Action definition ignored\n",
 206             fieldText(field), ActionTypeText(action));
 207     return false;
 208 }
 209
 210 static inline bool
 211 ReportActionNotArray(struct xkb_context *ctx, enum xkb_action_type action,
 212                      enum action_field field)
 213 {
 214     log_err(ctx,
 215             "The %s field in the %s action is not an array; "
 216             "Action definition ignored\n",
 217             fieldText(field), ActionTypeText(action));
 218     return false;
 219 }
 220
 221 static bool
 222 HandleNoAction(struct xkb_keymap *keymap, union xkb_action *action,
 223                enum action_field field, const ExprDef *array_ndx,
 224                const ExprDef *value)
 225
 226 {
 227     return true;
 228 }
 229
 230 static bool
 231 CheckLatchLockFlags(struct xkb_context *ctx, enum xkb_action_type action,
 232                     enum action_field field, const ExprDef *array_ndx,
 233                     const ExprDef *value, enum xkb_action_flags *flags_inout)
 234 {
 235     enum xkb_action_flags tmp;
 236     bool result;
 237
 238     if (array_ndx)
 239         return ReportActionNotArray(ctx, action, field);
 240
 241     if (field == ACTION_FIELD_CLEAR_LOCKS)
 242         tmp = ACTION_LOCK_CLEAR;
 243     else if (field == ACTION_FIELD_LATCH_TO_LOCK)
 244         tmp = ACTION_LATCH_TO_LOCK;
 245     else
 246         return false;           /* WSGO! */
 247
 248     if (!ExprResolveBoolean(ctx, value, &result))
 249         return ReportMismatch(ctx, action, field, "boolean");
 250
 251     if (result)
 252         *flags_inout |= tmp;
 253     else
 254         *flags_inout &= ~tmp;
 255
 256     return true;
 257 }
 258
 259 static bool
 260 CheckModifierField(struct xkb_keymap *keymap, enum xkb_action_type action,
 261                    const ExprDef *array_ndx, const ExprDef *value,
 262                    enum xkb_action_flags *flags_inout, xkb_mod_mask_t *mods_rtrn)
 263 {
 264     if (array_ndx)
 265         return ReportActionNotArray(keymap->ctx, action, ACTION_FIELD_MODIFIERS);
 266
 267     if (value->expr.op == EXPR_IDENT) {
 268         const char *valStr;
 269         valStr = xkb_atom_text(keymap->ctx, value->ident.ident);
 270         if (valStr && (istreq(valStr, "usemodmapmods") ||
 271                        istreq(valStr, "modmapmods"))) {
 272             *mods_rtrn = 0;
 273             *flags_inout |= ACTION_MODS_LOOKUP_MODMAP;
 274             return true;
 275         }
 276     }
 277
 278     if (!ExprResolveModMask(keymap, value, MOD_BOTH, mods_rtrn))
 279         return ReportMismatch(keymap->ctx, action,
 280                               ACTION_FIELD_MODIFIERS, "modifier mask");
 281
 282     *flags_inout &= ~ACTION_MODS_LOOKUP_MODMAP;
 283     return true;
 284 }
 285
 286 static bool
 287 HandleSetLatchMods(struct xkb_keymap *keymap, union xkb_action *action,
 288                    enum action_field field, const ExprDef *array_ndx,
 289                    const ExprDef *value)
 290 {
 291     struct xkb_mod_action *act = &action->mods;
 292
 293     if (field == ACTION_FIELD_CLEAR_LOCKS ||
 294         field == ACTION_FIELD_LATCH_TO_LOCK)
 295         return CheckLatchLockFlags(keymap->ctx, action->type, field, array_ndx,
 296                                    value, &act->flags);
 297     else if (field == ACTION_FIELD_MODIFIERS)
 298         return CheckModifierField(keymap, action->type, array_ndx, value,
 299                                   &act->flags, &act->mods.mods);
 300
 301     return ReportIllegal(keymap->ctx, action->type, field);
 302 }
 303
 304 static const LookupEntry lockWhich[] = {
 305     { "both", 0 },
 306     { "lock", ACTION_LOCK_NO_UNLOCK },
 307     { "neither", (ACTION_LOCK_NO_LOCK | ACTION_LOCK_NO_UNLOCK) },
 308     { "unlock", ACTION_LOCK_NO_LOCK },
 309     { NULL, 0 }
 310 };
 311
 312 static bool
 313 CheckAffectField(struct xkb_context *ctx, enum xkb_action_type action,
 314                  const ExprDef *array_ndx, const ExprDef *value,
 315                  enum xkb_action_flags *flags_inout)
 316 {
 317     enum xkb_action_flags flags;
 318
 319     if (array_ndx)
 320         return ReportActionNotArray(ctx, action, ACTION_FIELD_AFFECT);
 321
 322     if (!ExprResolveEnum(ctx, value, &flags, lockWhich))
 323         return ReportMismatch(ctx, action, ACTION_FIELD_AFFECT,
 324                               "lock, unlock, both, neither");
 325
 326     *flags_inout &= ~(ACTION_LOCK_NO_LOCK | ACTION_LOCK_NO_UNLOCK);
 327     *flags_inout |= flags;
 328     return true;
 329 }
 330
 331 static bool
 332 HandleLockMods(struct xkb_keymap *keymap, union xkb_action *action,
 333                enum action_field field, const ExprDef *array_ndx,
 334                const ExprDef *value)
 335 {
 336     struct xkb_mod_action *act = &action->mods;
 337
 338     if (field == ACTION_FIELD_MODIFIERS)
 339         return CheckModifierField(keymap, action->type, array_ndx, value,
 340                                   &act->flags, &act->mods.mods);
 341     else if (field == ACTION_FIELD_AFFECT)
 342         return CheckAffectField(keymap->ctx, action->type, array_ndx, value,
 343                                 &act->flags);
 344
 345     return ReportIllegal(keymap->ctx, action->type, field);
 346 }
 347
 348 static bool
 349 CheckGroupField(struct xkb_context *ctx, unsigned action,
 350                 const ExprDef *array_ndx, const ExprDef *value,
 351                 enum xkb_action_flags *flags_inout, int32_t *group_rtrn)
 352 {
 353     const ExprDef *spec;
 354     xkb_layout_index_t idx;
 355     enum xkb_action_flags flags = *flags_inout;
 356
 357     if (array_ndx)
 358         return ReportActionNotArray(ctx, action, ACTION_FIELD_GROUP);
 359
 360     if (value->expr.op == EXPR_NEGATE || value->expr.op == EXPR_UNARY_PLUS) {
 361         flags &= ~ACTION_ABSOLUTE_SWITCH;
 362         spec = value->unary.child;
 363     }
 364     else {
 365         flags |= ACTION_ABSOLUTE_SWITCH;
 366         spec = value;
 367     }
 368
 369     if (!ExprResolveGroup(ctx, spec, &idx))
 370         return ReportMismatch(ctx, action, ACTION_FIELD_GROUP,
 371                               "integer (range 1..8)");
 372
 373     /* +n, -n are relative, n is absolute. */
 374     if (value->expr.op == EXPR_NEGATE || value->expr.op == EXPR_UNARY_PLUS) {
 375         *group_rtrn = (int32_t) idx;
 376         if (value->expr.op == EXPR_NEGATE)
 377             *group_rtrn = -*group_rtrn;
 378     }
 379     else {
 380         *group_rtrn = (int32_t) (idx - 1);
 381     }
 382     *flags_inout = flags;
 383     return true;
 384 }
 385
 386 static bool
 387 HandleSetLatchGroup(struct xkb_keymap *keymap, union xkb_action *action,
 388                     enum action_field field, const ExprDef *array_ndx,
 389                     const ExprDef *value)
 390 {
 391     struct xkb_group_action *act = &action->group;
 392
 393     if (field == ACTION_FIELD_CLEAR_LOCKS ||
 394         field == ACTION_FIELD_LATCH_TO_LOCK)
 395         return CheckLatchLockFlags(keymap->ctx, action->type, field, array_ndx,
 396                                    value, &act->flags);
 397     else if (field == ACTION_FIELD_GROUP)
 398         return CheckGroupField(keymap->ctx, action->type, array_ndx, value,
 399                                &act->flags, &act->group);
 400
 401     return ReportIllegal(keymap->ctx, action->type, field);
 402 }
 403
 404 static bool
 405 HandleLockGroup(struct xkb_keymap *keymap, union xkb_action *action,
 406                 enum action_field field, const ExprDef *array_ndx,
 407                 const ExprDef *value)
 408 {
 409     struct xkb_group_action *act = &action->group;
 410
 411     if (field == ACTION_FIELD_GROUP)
 412         return CheckGroupField(keymap->ctx, action->type, array_ndx, value,
 413                                &act->flags, &act->group);
 414
 415     return ReportIllegal(keymap->ctx, action->type, field);
 416 }
 417
 418 static bool
 419 HandleMovePtr(struct xkb_keymap *keymap, union xkb_action *action,
 420               enum action_field field, const ExprDef *array_ndx,
 421               const ExprDef *value)
 422 {
 423     struct xkb_pointer_action *act = &action->ptr;
 424
 425     if (field == ACTION_FIELD_X || field == ACTION_FIELD_Y) {
 426         int val;
 427         const bool absolute = (value->expr.op != EXPR_NEGATE &&
 428                                value->expr.op != EXPR_UNARY_PLUS);
 429
 430         if (array_ndx)
 431             return ReportActionNotArray(keymap->ctx, action->type, field);
 432
 433         if (!ExprResolveInteger(keymap->ctx, value, &val))
 434             return ReportMismatch(keymap->ctx, action->type, field, "integer");
 435
 436         if (val < INT16_MIN || val > INT16_MAX) {
 437             log_err(keymap->ctx,
 438                     "The %s field in the %s action must be in range %d..%d; "
 439                     "Action definition ignored\n",
 440                     fieldText(field), ActionTypeText(action->type),
 441                     INT16_MIN, INT16_MAX);
 442             return false;
 443         }
 444
 445         if (field == ACTION_FIELD_X) {
 446             if (absolute)
 447                 act->flags |= ACTION_ABSOLUTE_X;
 448             act->x = (int16_t) val;
 449         }
 450         else {
 451             if (absolute)
 452                 act->flags |= ACTION_ABSOLUTE_Y;
 453             act->y = (int16_t) val;
 454         }
 455
 456         return true;
 457     }
 458     else if (field == ACTION_FIELD_ACCEL) {
 459         bool set;
 460
 461         if (array_ndx)
 462             return ReportActionNotArray(keymap->ctx, action->type, field);
 463
 464         if (!ExprResolveBoolean(keymap->ctx, value, &set))
 465             return ReportMismatch(keymap->ctx, action->type, field, "boolean");
 466
 467         if (set)
 468             act->flags &= ~ACTION_NO_ACCEL;
 469         else
 470             act->flags |= ACTION_NO_ACCEL;
 471     }
 472
 473     return ReportIllegal(keymap->ctx, action->type, field);
 474 }
 475
 476 static bool
 477 HandlePtrBtn(struct xkb_keymap *keymap, union xkb_action *action,
 478              enum action_field field, const ExprDef *array_ndx,
 479              const ExprDef *value)
 480 {
 481     struct xkb_pointer_button_action *act = &action->btn;
 482
 483     if (field == ACTION_FIELD_BUTTON) {
 484         int btn;
 485
 486         if (array_ndx)
 487             return ReportActionNotArray(keymap->ctx, action->type, field);
 488
 489         if (!ExprResolveButton(keymap->ctx, value, &btn))
 490             return ReportMismatch(keymap->ctx, action->type, field,
 491                                   "integer (range 1..5)");
 492
 493         if (btn < 0 || btn > 5) {
 494             log_err(keymap->ctx,
 495                     "Button must specify default or be in the range 1..5; "
 496                     "Illegal button value %d ignored\n", btn);
 497             return false;
 498         }
 499
 500         act->button = btn;
 501         return true;
 502     }
 503     else if (action->type == ACTION_TYPE_PTR_LOCK &&
 504              field == ACTION_FIELD_AFFECT) {
 505         return CheckAffectField(keymap->ctx, action->type, array_ndx, value,
 506                                 &act->flags);
 507     }
 508     else if (field == ACTION_FIELD_COUNT) {
 509         int val;
 510
 511         if (array_ndx)
 512             return ReportActionNotArray(keymap->ctx, action->type, field);
 513
 514         if (!ExprResolveInteger(keymap->ctx, value, &val))
 515             return ReportMismatch(keymap->ctx, action->type, field, "integer");
 516
 517         if (val < 0 || val > 255) {
 518             log_err(keymap->ctx,
 519                     "The count field must have a value in the range 0..255; "
 520                     "Illegal count %d ignored\n", val);
 521             return false;
 522         }
 523
 524         act->count = (uint8_t) val;
 525         return true;
 526     }
 527
 528     return ReportIllegal(keymap->ctx, action->type, field);
 529 }
 530
 531 static const LookupEntry ptrDflts[] = {
 532     { "dfltbtn", 1 },
 533     { "defaultbutton", 1 },
 534     { "button", 1 },
 535     { NULL, 0 }
 536 };
 537
 538 static bool
 539 HandleSetPtrDflt(struct xkb_keymap *keymap, union xkb_action *action,
 540                  enum action_field field, const ExprDef *array_ndx,
 541                  const ExprDef *value)
 542 {
 543     struct xkb_pointer_default_action *act = &action->dflt;
 544
 545     if (field == ACTION_FIELD_AFFECT) {
 546         unsigned int val;
 547
 548         if (array_ndx)
 549             return ReportActionNotArray(keymap->ctx, action->type, field);
 550
 551         if (!ExprResolveEnum(keymap->ctx, value, &val, ptrDflts))
 552             return ReportMismatch(keymap->ctx, action->type, field,
 553                                   "pointer component");
 554         return true;
 555     }
 556     else if (field == ACTION_FIELD_BUTTON || field == ACTION_FIELD_VALUE) {
 557         const ExprDef *button;
 558         int btn;
 559
 560         if (array_ndx)
 561             return ReportActionNotArray(keymap->ctx, action->type, field);
 562
 563         if (value->expr.op == EXPR_NEGATE ||
 564             value->expr.op == EXPR_UNARY_PLUS) {
 565             act->flags &= ~ACTION_ABSOLUTE_SWITCH;
 566             button = value->unary.child;
 567         }
 568         else {
 569             act->flags |= ACTION_ABSOLUTE_SWITCH;
 570             button = value;
 571         }
 572
 573         if (!ExprResolveButton(keymap->ctx, button, &btn))
 574             return ReportMismatch(keymap->ctx, action->type, field,
 575                                   "integer (range 1..5)");
 576
 577         if (btn < 0 || btn > 5) {
 578             log_err(keymap->ctx,
 579                     "New default button value must be in the range 1..5; "
 580                     "Illegal default button value %d ignored\n", btn);
 581             return false;
 582         }
 583         if (btn == 0) {
 584             log_err(keymap->ctx,
 585                     "Cannot set default pointer button to \"default\"; "
 586                     "Illegal default button setting ignored\n");
 587             return false;
 588         }
 589
 590         act->value = (value->expr.op == EXPR_NEGATE ? -btn: btn);
 591         return true;
 592     }
 593
 594     return ReportIllegal(keymap->ctx, action->type, field);
 595 }
 596
 597 static bool
 598 HandleSwitchScreen(struct xkb_keymap *keymap, union xkb_action *action,
 599                    enum action_field field, const ExprDef *array_ndx,
 600                    const ExprDef *value)
 601 {
 602     struct xkb_switch_screen_action *act = &action->screen;
 603
 604     if (field == ACTION_FIELD_SCREEN) {
 605         const ExprDef *scrn;
 606         int val;
 607
 608         if (array_ndx)
 609             return ReportActionNotArray(keymap->ctx, action->type, field);
 610
 611         if (value->expr.op == EXPR_NEGATE ||
 612             value->expr.op == EXPR_UNARY_PLUS) {
 613             act->flags &= ~ACTION_ABSOLUTE_SWITCH;
 614             scrn = value->unary.child;
 615         }
 616         else {
 617             act->flags |= ACTION_ABSOLUTE_SWITCH;
 618             scrn = value;
 619         }
 620
 621         if (!ExprResolveInteger(keymap->ctx, scrn, &val))
 622             return ReportMismatch(keymap->ctx, action->type, field,
 623                                   "integer (0..255)");
 624
 625         if (val < 0 || val > 255) {
 626             log_err(keymap->ctx,
 627                     "Screen index must be in the range 1..255; "
 628                     "Illegal screen value %d ignored\n", val);
 629             return false;
 630         }
 631
 632         act->screen = (value->expr.op == EXPR_NEGATE ? -val : val);
 633         return true;
 634     }
 635     else if (field == ACTION_FIELD_SAME) {
 636         bool set;
 637
 638         if (array_ndx)
 639             return ReportActionNotArray(keymap->ctx, action->type, field);
 640
 641         if (!ExprResolveBoolean(keymap->ctx, value, &set))
 642             return ReportMismatch(keymap->ctx, action->type, field, "boolean");
 643
 644         if (set)
 645             act->flags &= ~ACTION_SAME_SCREEN;
 646         else
 647             act->flags |= ACTION_SAME_SCREEN;
 648
 649         return true;
 650     }
 651
 652     return ReportIllegal(keymap->ctx, action->type, field);
 653 }
 654
 655 static bool
 656 HandleSetLockControls(struct xkb_keymap *keymap, union xkb_action *action,
 657                       enum action_field field, const ExprDef *array_ndx,
 658                       const ExprDef *value)
 659 {
 660     struct xkb_controls_action *act = &action->ctrls;
 661
 662     if (field == ACTION_FIELD_CONTROLS) {
 663         unsigned int mask;
 664
 665         if (array_ndx)
 666             return ReportActionNotArray(keymap->ctx, action->type, field);
 667
 668         if (!ExprResolveMask(keymap->ctx, value, &mask, ctrlMaskNames))
 669             return ReportMismatch(keymap->ctx, action->type, field,
 670                                   "controls mask");
 671
 672         act->ctrls = mask;
 673         return true;
 674     }
 675     else if (field == ACTION_FIELD_AFFECT) {
 676         return CheckAffectField(keymap->ctx, action->type, array_ndx, value,
 677                                 &act->flags);
 678     }
 679
 680     return ReportIllegal(keymap->ctx, action->type, field);
 681 }
 682
 683 static bool
 684 HandlePrivate(struct xkb_keymap *keymap, union xkb_action *action,
 685               enum action_field field, const ExprDef *array_ndx,
 686               const ExprDef *value)
 687 {
 688     struct xkb_private_action *act = &action->priv;
 689
 690     if (field == ACTION_FIELD_TYPE) {
 691         int type;
 692
 693         if (array_ndx)
 694             return ReportActionNotArray(keymap->ctx, action->type, field);
 695
 696         if (!ExprResolveInteger(keymap->ctx, value, &type))
 697             return ReportMismatch(keymap->ctx, ACTION_TYPE_PRIVATE, field, "integer");
 698
 699         if (type < 0 || type > 255) {
 700             log_err(keymap->ctx,
 701                     "Private action type must be in the range 0..255; "
 702                     "Illegal type %d ignored\n", type);
 703             return false;
 704         }
 705
 706         /*
 707          * It's possible for someone to write something like this:
 708          *      actions = [ Private(type=3,data[0]=1,data[1]=3,data[2]=3) ]
 709          * where the type refers to some existing action type, e.g. LockMods.
 710          * This assumes that this action's struct is laid out in memory
 711          * exactly as described in the XKB specification and libraries.
 712          * We, however, have changed these structs in various ways, so this
 713          * assumption is no longer true. Since this is a lousy "feature", we
 714          * make actions like these no-ops for now.
 715          */
 716         if (type < ACTION_TYPE_PRIVATE) {
 717             log_info(keymap->ctx,
 718                      "Private actions of type %s are not supported; Ignored\n",
 719                      ActionTypeText(type));
 720             act->type = ACTION_TYPE_NONE;
 721         }
 722         else {
 723             act->type = (enum xkb_action_type) type;
 724         }
 725
 726         return true;
 727     }
 728     else if (field == ACTION_FIELD_DATA) {
 729         if (array_ndx == NULL) {
 730             xkb_atom_t val;
 731             const char *str;
 732             size_t len;
 733
 734             if (!ExprResolveString(keymap->ctx, value, &val))
 735                 return ReportMismatch(keymap->ctx, action->type, field, "string");
 736
 737             str = xkb_atom_text(keymap->ctx, val);
 738             len = strlen(str);
 739             if (len < 1 || len > 7) {
 740                 log_warn(keymap->ctx,
 741                          "A private action has 7 data bytes; "
 742                          "Illegal data ignored\n");
 743                 return false;
 744             }
 745
 746             strncpy((char *) act->data, str, sizeof(act->data));
 747             return true;
 748         }
 749         else {
 750             int ndx, datum;
 751
 752             if (!ExprResolveInteger(keymap->ctx, array_ndx, &ndx)) {
 753                 log_err(keymap->ctx,
 754                         "Array subscript must be integer; "
 755                         "Illegal subscript ignored\n");
 756                 return false;
 757             }
 758
 759             if (ndx < 0 || (size_t) ndx >= sizeof(act->data)) {
 760                 log_err(keymap->ctx,
 761                         "The data for a private action is %lu bytes long; "
 762                         "Attempt to use data[%d] ignored\n",
 763                         (unsigned long) sizeof(act->data), ndx);
 764                 return false;
 765             }
 766
 767             if (!ExprResolveInteger(keymap->ctx, value, &datum))
 768                 return ReportMismatch(keymap->ctx, act->type, field, "integer");
 769
 770             if (datum < 0 || datum > 255) {
 771                 log_err(keymap->ctx,
 772                         "All data for a private action must be 0..255; "
 773                         "Illegal datum %d ignored\n", datum);
 774                 return false;
 775             }
 776
 777             act->data[ndx] = (uint8_t) datum;
 778             return true;
 779         }
 780     }
 781
 782     return ReportIllegal(keymap->ctx, ACTION_TYPE_NONE, field);
 783 }
 784
 785 typedef bool (*actionHandler)(struct xkb_keymap *keymap,
 786                               union xkb_action *action,
 787                               enum action_field field,
 788                               const ExprDef *array_ndx,
 789                               const ExprDef *value);
 790
 791 static const actionHandler handleAction[_ACTION_TYPE_NUM_ENTRIES] = {
 792     [ACTION_TYPE_NONE] = HandleNoAction,
 793     [ACTION_TYPE_MOD_SET] = HandleSetLatchMods,
 794     [ACTION_TYPE_MOD_LATCH] = HandleSetLatchMods,
 795     [ACTION_TYPE_MOD_LOCK] = HandleLockMods,
 796     [ACTION_TYPE_GROUP_SET] = HandleSetLatchGroup,
 797     [ACTION_TYPE_GROUP_LATCH] = HandleSetLatchGroup,
 798     [ACTION_TYPE_GROUP_LOCK] = HandleLockGroup,
 799     [ACTION_TYPE_PTR_MOVE] = HandleMovePtr,
 800     [ACTION_TYPE_PTR_BUTTON] = HandlePtrBtn,
 801     [ACTION_TYPE_PTR_LOCK] = HandlePtrBtn,
 802     [ACTION_TYPE_PTR_DEFAULT] = HandleSetPtrDflt,
 803     [ACTION_TYPE_TERMINATE] = HandleNoAction,
 804     [ACTION_TYPE_SWITCH_VT] = HandleSwitchScreen,
 805     [ACTION_TYPE_CTRL_SET] = HandleSetLockControls,
 806     [ACTION_TYPE_CTRL_LOCK] = HandleSetLockControls,
 807     [ACTION_TYPE_PRIVATE] = HandlePrivate,
 808 };
 809
 810 /***====================================================================***/
 811
 812 bool
 813 HandleActionDef(ExprDef *def, struct xkb_keymap *keymap,
 814                 union xkb_action *action, ActionsInfo *info)
 815 {
 816     ExprDef *arg;
 817     const char *str;
 818     unsigned handler_type;
 819
 820     if (def->expr.op != EXPR_ACTION_DECL) {
 821         log_err(keymap->ctx, "Expected an action definition, found %s\n",
 822                 expr_op_type_to_string(def->expr.op));
 823         return false;
 824     }
 825
 826     str = xkb_atom_text(keymap->ctx, def->action.name);
 827     if (!stringToAction(str, &handler_type)) {
 828         log_err(keymap->ctx, "Unknown action %s\n", str);
 829         return false;
 830     }
 831
 832     /*
 833      * Get the default values for this action type, as modified by
 834      * statements such as:
 835      *     latchMods.clearLocks = True;
 836      */
 837     *action = info->actions[handler_type];
 838
 839     /*
 840      * Now change the action properties as specified for this
 841      * particular instance, e.g. "modifiers" and "clearLocks" in:
 842      *     SetMods(modifiers=Alt,clearLocks);
 843      */
 844     for (arg = def->action.args; arg != NULL;
 845          arg = (ExprDef *) arg->common.next) {
 846         const ExprDef *value;
 847         ExprDef *field, *arrayRtrn;
 848         const char *elemRtrn, *fieldRtrn;
 849         enum action_field fieldNdx;
 850
 851         if (arg->expr.op == EXPR_ASSIGN) {
 852             field = arg->binary.left;
 853             value = arg->binary.right;
 854         }
 855         else if (arg->expr.op == EXPR_NOT || arg->expr.op == EXPR_INVERT) {
 856             field = arg->unary.child;
 857             value = (const ExprDef *) &constFalse;
 858         }
 859         else {
 860             field = arg;
 861             value = (const ExprDef *) &constTrue;
 862         }
 863
 864         if (!ExprResolveLhs(keymap->ctx, field, &elemRtrn, &fieldRtrn,
 865                             &arrayRtrn))
 866             return false;
 867
 868         if (elemRtrn) {
 869             log_err(keymap->ctx,
 870                     "Cannot change defaults in an action definition; "
 871                     "Ignoring attempt to change %s.%s\n",
 872                     elemRtrn, fieldRtrn);
 873             return false;
 874         }
 875
 876         if (!stringToField(fieldRtrn, &fieldNdx)) {
 877             log_err(keymap->ctx, "Unknown field name %s\n", fieldRtrn);
 878             return false;
 879         }
 880
 881         if (!handleAction[handler_type](keymap, action, fieldNdx, arrayRtrn,
 882                                         value))
 883             return false;
 884     }
 885
 886     return true;
 887 }
 888
 889 bool
 890 SetActionField(struct xkb_keymap *keymap, const char *elem, const char *field,
 891                ExprDef *array_ndx, ExprDef *value, ActionsInfo *info)
 892 {
 893     unsigned action;
 894     enum action_field action_field;
 895
 896     if (!stringToAction(elem, &action))
 897         return false;
 898
 899     if (!stringToField(field, &action_field)) {
 900         log_err(keymap->ctx, "\"%s\" is not a legal field name\n", field);
 901         return false;
 902     }
 903
 904     return handleAction[action](keymap, &info->actions[action],
 905                                 action_field, array_ndx, value);
 906 }