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