Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 934:c925bacdda60

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2002-07-29 09:21:12 by michaels] 2002-07-17 Marcus Crestani <crestani@informatik.uni-tuebingen.de> Markus Kaltenbach <makalten@informatik.uni-tuebingen.de> Mike Sperber <mike@xemacs.org> configure flag to turn these changes on: --use-kkcc First we added a dumpable flag to lrecord_implementation. It shows, if the object is dumpable and should be processed by the dumper. * lrecord.h (struct lrecord_implementation): added dumpable flag (MAKE_LRECORD_IMPLEMENTATION): fitted the different makro definitions to the new lrecord_implementation and their calls. Then we changed mark_object, that it no longer needs a mark method for those types that have pdump descritions. * alloc.c: (mark_object): If the object has a description, the new mark algorithm is called, and the object is marked according to its description. Otherwise it uses the mark method like before. These procedures mark objects according to their descriptions. They are modeled on the corresponding pdumper procedures. (mark_with_description): (get_indirect_count): (structure_size): (mark_struct_contents): These procedures still call mark_object, this is needed while there are Lisp_Objects without descriptions left. We added pdump descriptions for many Lisp_Objects: * extents.c: extent_auxiliary_description * database.c: database_description * gui.c: gui_item_description * scrollbar.c: scrollbar_instance_description * toolbar.c: toolbar_button_description * event-stream.c: command_builder_description * mule-charset.c: charset_description * device-msw.c: devmode_description * dialog-msw.c: mswindows_dialog_id_description * eldap.c: ldap_description * postgresql.c: pgconn_description pgresult_description * tooltalk.c: tooltalk_message_description tooltalk_pattern_description * ui-gtk.c: emacs_ffi_description emacs_gtk_object_description * events.c: * events.h: * event-stream.c: * event-Xt.c: * event-gtk.c: * event-tty.c: To write a pdump description for Lisp_Event, we converted every struct in the union event to a Lisp_Object. So we created nine new Lisp_Objects: Lisp_Key_Data, Lisp_Button_Data, Lisp_Motion_Data, Lisp_Process_Data, Lisp_Timeout_Data, Lisp_Eval_Data, Lisp_Misc_User_Data, Lisp_Magic_Data, Lisp_Magic_Eval_Data. We also wrote makro selectors and mutators for the fields of the new designed Lisp_Event and added everywhere these new abstractions. We implemented XD_UNION support in (mark_with_description), so we can describe exspecially console/device specific data with XD_UNION. To describe with XD_UNION, we added a field to these objects, which holds the variant type of the object. This field is initialized in the appendant constructor. The variant is an integer, it has also to be described in an description, if XD_UNION is used. XD_UNION is used in following descriptions: * console.c: console_description (get_console_variant): returns the variant (create_console): added variant initialization * console.h (console_variant): the different console types * console-impl.h (struct console): added enum console_variant contype * device.c: device_description (Fmake_device): added variant initialization * device-impl.h (struct device): added enum console_variant devtype * objects.c: image_instance_description font_instance_description (Fmake_color_instance): added variant initialization (Fmake_font_instance): added variant initialization * objects-impl.h (struct Lisp_Color_Instance): added color_instance_type * objects-impl.h (struct Lisp_Font_Instance): added font_instance_type * process.c: process_description (make_process_internal): added variant initialization * process.h (process_variant): the different process types
author michaels
date Mon, 29 Jul 2002 09:21:25 +0000
parents 79c6ff3eef26
children 0dc7756a58c4
comparison
equal deleted inserted replaced
933:f6bc42928b34 934:c925bacdda60
279 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) }, 279 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) },
280 { XD_END } 280 { XD_END }
281 }; 281 };
282 282
283 /* No need for keymap_equal #### Why not? */ 283 /* No need for keymap_equal #### Why not? */
284 #ifdef USE_KKCC
285 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap,
286 1, /*dumpable-flag*/
287 mark_keymap, print_keymap, 0, 0, 0,
288 keymap_description,
289 Lisp_Keymap);
290 #else /* not USE_KKCC */
284 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap, 291 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap,
285 mark_keymap, print_keymap, 0, 0, 0, 292 mark_keymap, print_keymap, 0, 0, 0,
286 keymap_description, 293 keymap_description,
287 Lisp_Keymap); 294 Lisp_Keymap);
295 #endif /* not USE_KKCC */
288 296
289 /************************************************************************/ 297 /************************************************************************/
290 /* Traversing keymaps and their parents */ 298 /* Traversing keymaps and their parents */
291 /************************************************************************/ 299 /************************************************************************/
292 300
426 if (modifiers & XEMACS_MOD_META) frob = Fcons (Qmeta, frob); 434 if (modifiers & XEMACS_MOD_META) frob = Fcons (Qmeta, frob);
427 return frob; 435 return frob;
428 } 436 }
429 437
430 static Lisp_Object 438 static Lisp_Object
439 #ifdef USE_KKCC
440 make_key_description (const Lisp_Key_Data *key, int prettify)
441 {
442 Lisp_Object keysym = KEY_DATA_KEYSYM(key);
443 int modifiers = KEY_DATA_MODIFIERS (key);
444 #else /* not USE_KKCC */
431 make_key_description (const struct key_data *key, int prettify) 445 make_key_description (const struct key_data *key, int prettify)
432 { 446 {
433 Lisp_Object keysym = key->keysym; 447 Lisp_Object keysym = key->keysym;
434 int modifiers = key->modifiers; 448 int modifiers = key->modifiers;
435 449 #endif /* not USE_KKCC */
436 if (prettify && CHARP (keysym)) 450 if (prettify && CHARP (keysym))
437 { 451 {
438 /* This is a little slow, but (control a) is prettier than (control 65). 452 /* This is a little slow, but (control a) is prettier than (control 65).
439 It's now ok to do this for digit-chars too, since we've fixed the 453 It's now ok to do this for digit-chars too, since we've fixed the
440 bug where \9 read as the integer 9 instead of as the symbol with 454 bug where \9 read as the integer 9 instead of as the symbol with
454 /* Low-level keymap-store functions */ 468 /* Low-level keymap-store functions */
455 /************************************************************************/ 469 /************************************************************************/
456 470
457 static Lisp_Object 471 static Lisp_Object
458 raw_lookup_key (Lisp_Object keymap, 472 raw_lookup_key (Lisp_Object keymap,
473 #ifdef USE_KKCC
474 const Lisp_Key_Data *raw_keys, int raw_keys_count,
475 #else /* not USE_KKCC */
459 const struct key_data *raw_keys, int raw_keys_count, 476 const struct key_data *raw_keys, int raw_keys_count,
477 #endif /* not USE_KKCC */
460 int keys_so_far, int accept_default); 478 int keys_so_far, int accept_default);
461 479
462 /* Relies on caller to gc-protect args */ 480 /* Relies on caller to gc-protect args */
463 static Lisp_Object 481 static Lisp_Object
464 keymap_lookup_directly (Lisp_Object keymap, 482 keymap_lookup_directly (Lisp_Object keymap,
638 } 656 }
639 657
640 658
641 /* Relies on caller to gc-protect keymap, keysym, value */ 659 /* Relies on caller to gc-protect keymap, keysym, value */
642 static void 660 static void
661 #ifdef USE_KKCC
662 keymap_store (Lisp_Object keymap, const Lisp_Key_Data *key,
663 #else /* not USE_KKCC */
643 keymap_store (Lisp_Object keymap, const struct key_data *key, 664 keymap_store (Lisp_Object keymap, const struct key_data *key,
665 #endif /* not USE_KKCC */
644 Lisp_Object value) 666 Lisp_Object value)
645 { 667 {
668 #ifdef USE_KKCC
669 Lisp_Object keysym = KEY_DATA_KEYSYM (key);
670 int modifiers = KEY_DATA_MODIFIERS (key);
671 #else /* not USE_KKCC */
646 Lisp_Object keysym = key->keysym; 672 Lisp_Object keysym = key->keysym;
647 int modifiers = key->modifiers; 673 int modifiers = key->modifiers;
674 #endif /* not USE_KKCC */
648 Lisp_Keymap *k = XKEYMAP (keymap); 675 Lisp_Keymap *k = XKEYMAP (keymap);
649 676
650 modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 677 modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3
651 | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5); 678 | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5);
652 assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META 679 assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META
1052 } 1079 }
1053 /* If the contents are (KEYMAP . ELEMENT), go indirect. */ 1080 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
1054 if (!NILP (map)) 1081 if (!NILP (map))
1055 { 1082 {
1056 Lisp_Object idx = Fcdr (object); 1083 Lisp_Object idx = Fcdr (object);
1084 #ifdef USE_KKCC
1085 Lisp_Key_Data indirection;
1086 #else /* not USE_KKCC */
1057 struct key_data indirection; 1087 struct key_data indirection;
1088 #endif /* not USE_KKCC */
1058 if (CHARP (idx)) 1089 if (CHARP (idx))
1059 { 1090 {
1091 #ifdef USE_KKCC
1092 Lisp_Object event = Fmake_event (Qnil, Qnil);
1093 struct gcpro gcpro1;
1094 GCPRO1 (event);
1095 XSET_EVENT_TYPE (event, empty_event);
1096 character_to_event (XCHAR (idx), XEVENT (event),
1097 XCONSOLE (Vselected_console), 0, 0);
1098 indirection = *XKEY_DATA (XEVENT_DATA (event));
1099 #else /* not USE_KKCC */
1060 Lisp_Event event; 1100 Lisp_Event event;
1061 event.event_type = empty_event; 1101 event.event_type = empty_event;
1062 character_to_event (XCHAR (idx), &event, 1102 character_to_event (XCHAR (idx), &event,
1063 XCONSOLE (Vselected_console), 0, 0); 1103 XCONSOLE (Vselected_console), 0, 0);
1064 indirection = event.event.key; 1104 indirection = event.event.key;
1105 #endif /* not USE_KKCC */
1065 } 1106 }
1066 else if (CONSP (idx)) 1107 else if (CONSP (idx))
1067 { 1108 {
1068 if (!INTP (XCDR (idx))) 1109 if (!INTP (XCDR (idx)))
1069 return Qnil; 1110 return Qnil;
1071 indirection.modifiers = (unsigned char) XINT (XCDR (idx)); 1112 indirection.modifiers = (unsigned char) XINT (XCDR (idx));
1072 } 1113 }
1073 else if (SYMBOLP (idx)) 1114 else if (SYMBOLP (idx))
1074 { 1115 {
1075 indirection.keysym = idx; 1116 indirection.keysym = idx;
1117 #ifdef USE_KKCC
1118 SET_KEY_DATA_MODIFIERS (&indirection, XINT (XCDR (idx)));
1119 #else /* not USE_KKCC */
1076 indirection.modifiers = 0; 1120 indirection.modifiers = 0;
1121 #endif /* not USE_KKCC */
1077 } 1122 }
1078 else 1123 else
1079 { 1124 {
1080 /* Random junk */ 1125 /* Random junk */
1081 return Qnil; 1126 return Qnil;
1097 return object; 1142 return object;
1098 } 1143 }
1099 } 1144 }
1100 1145
1101 static Lisp_Object 1146 static Lisp_Object
1147 #ifdef USE_KKCC
1148 keymap_lookup_1 (Lisp_Object keymap, const Lisp_Key_Data *key,
1149 #else /* not USE_KKCC */
1102 keymap_lookup_1 (Lisp_Object keymap, const struct key_data *key, 1150 keymap_lookup_1 (Lisp_Object keymap, const struct key_data *key,
1151 #endif /* not USE_KKCC */
1103 int accept_default) 1152 int accept_default)
1104 { 1153 {
1105 /* This function can GC */ 1154 /* This function can GC */
1155 #ifdef USE_KKCC
1156 return get_keyelt (keymap_lookup_directly (keymap,
1157 KEY_DATA_KEYSYM (key),
1158 KEY_DATA_MODIFIERS (key)),
1159 accept_default);
1160 #else /* not USE_KKCC */
1106 return get_keyelt (keymap_lookup_directly (keymap, 1161 return get_keyelt (keymap_lookup_directly (keymap,
1107 key->keysym, key->modifiers), 1162 key->keysym, key->modifiers),
1108 accept_default); 1163 accept_default);
1164 #endif /* not USE_KKCC */
1109 } 1165 }
1110 1166
1111 1167
1112 /************************************************************************/ 1168 /************************************************************************/
1113 /* Copying keymaps */ 1169 /* Copying keymaps */
1396 -- integers are converted into the equivalent characters. 1452 -- integers are converted into the equivalent characters.
1397 -- one-character strings are converted into the equivalent characters. 1453 -- one-character strings are converted into the equivalent characters.
1398 */ 1454 */
1399 1455
1400 static void 1456 static void
1457 #ifdef USE_KKCC
1458 define_key_parser (Lisp_Object spec, Lisp_Key_Data *returned_value)
1459 #else /* not USE_KKCC */
1401 define_key_parser (Lisp_Object spec, struct key_data *returned_value) 1460 define_key_parser (Lisp_Object spec, struct key_data *returned_value)
1461 #endif /* not USE_KKCC */
1402 { 1462 {
1403 if (CHAR_OR_CHAR_INTP (spec)) 1463 if (CHAR_OR_CHAR_INTP (spec))
1404 { 1464 {
1465 #ifdef USE_KKCC
1466 Lisp_Object event = Fmake_event (Qnil, Qnil);
1467 struct gcpro gcpro1;
1468 GCPRO1 (event);
1469 XSET_EVENT_TYPE (event, empty_event);
1470 character_to_event (XCHAR_OR_CHAR_INT (spec), XEVENT (event),
1471 XCONSOLE (Vselected_console), 0, 0);
1472 SET_KEY_DATA_KEYSYM (returned_value, XKEY_DATA_KEYSYM (XEVENT_DATA (event)));
1473 SET_KEY_DATA_MODIFIERS (returned_value,
1474 XKEY_DATA_MODIFIERS (XEVENT_DATA (event)));
1475 #else /* not USE_KKCC */
1405 Lisp_Event event; 1476 Lisp_Event event;
1406 event.event_type = empty_event; 1477 event.event_type = empty_event;
1407 character_to_event (XCHAR_OR_CHAR_INT (spec), &event, 1478 character_to_event (XCHAR_OR_CHAR_INT (spec), &event,
1408 XCONSOLE (Vselected_console), 0, 0); 1479 XCONSOLE (Vselected_console), 0, 0);
1409 returned_value->keysym = event.event.key.keysym; 1480 returned_value->keysym = event.event.key.keysym;
1410 returned_value->modifiers = event.event.key.modifiers; 1481 returned_value->modifiers = event.event.key.modifiers;
1482 #endif /* not USE_KKCC */
1411 } 1483 }
1412 else if (EVENTP (spec)) 1484 else if (EVENTP (spec))
1413 { 1485 {
1486 #ifdef USE_KKCC
1487 switch (XEVENT_TYPE (spec))
1488 #else /* not USE_KKCC */
1414 switch (XEVENT (spec)->event_type) 1489 switch (XEVENT (spec)->event_type)
1490 #endif /* not USE_KKCC */
1415 { 1491 {
1416 case key_press_event: 1492 case key_press_event:
1417 { 1493 {
1494 #ifdef USE_KKCC
1495 SET_KEY_DATA_KEYSYM (returned_value, XKEY_DATA_KEYSYM (XEVENT_DATA (spec)));
1496 SET_KEY_DATA_MODIFIERS (returned_value, XKEY_DATA_MODIFIERS (XEVENT_DATA (spec)));
1497 #else /* not USE_KKCC */
1418 returned_value->keysym = XEVENT (spec)->event.key.keysym; 1498 returned_value->keysym = XEVENT (spec)->event.key.keysym;
1419 returned_value->modifiers = XEVENT (spec)->event.key.modifiers; 1499 returned_value->modifiers = XEVENT (spec)->event.key.modifiers;
1500 #endif /* not USE_KKCC */
1420 break; 1501 break;
1421 } 1502 }
1422 case button_press_event: 1503 case button_press_event:
1423 case button_release_event: 1504 case button_release_event:
1424 { 1505 {
1506 #ifdef USE_KKCC
1507 int down = (XEVENT_TYPE (spec) == button_press_event);
1508 switch (XBUTTON_DATA_BUTTON (XEVENT_DATA (spec)))
1509 {
1510 case 1:
1511 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton1 : Qbutton1up));
1512 break;
1513 case 2:
1514 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton2 : Qbutton2up));
1515 break;
1516 case 3:
1517 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton3 : Qbutton3up));
1518 break;
1519 case 4:
1520 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton4 : Qbutton4up));
1521 break;
1522 case 5:
1523 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton5 : Qbutton5up));
1524 break;
1525 case 6:
1526 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton6 : Qbutton6up));
1527 break;
1528 case 7:
1529 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton7 : Qbutton7up));
1530 break;
1531 default:
1532 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton0 : Qbutton0up));
1533 break;
1534 }
1535 SET_KEY_DATA_MODIFIERS (returned_value, XBUTTON_DATA_MODIFIERS (XEVENT_DATA (spec)));
1536 #else /* not USE_KKCC */
1425 int down = (XEVENT (spec)->event_type == button_press_event); 1537 int down = (XEVENT (spec)->event_type == button_press_event);
1426 switch (XEVENT (spec)->event.button.button) 1538 switch (XEVENT (spec)->event.button.button)
1427 { 1539 {
1428 case 1: 1540 case 1:
1429 returned_value->keysym = (down ? Qbutton1 : Qbutton1up); break; 1541 returned_value->keysym = (down ? Qbutton1 : Qbutton1up); break;
1441 returned_value->keysym = (down ? Qbutton7 : Qbutton7up); break; 1553 returned_value->keysym = (down ? Qbutton7 : Qbutton7up); break;
1442 default: 1554 default:
1443 returned_value->keysym = (down ? Qbutton0 : Qbutton0up); break; 1555 returned_value->keysym = (down ? Qbutton0 : Qbutton0up); break;
1444 } 1556 }
1445 returned_value->modifiers = XEVENT (spec)->event.button.modifiers; 1557 returned_value->modifiers = XEVENT (spec)->event.button.modifiers;
1558 #endif /* not USE_KKCC */
1446 break; 1559 break;
1447 } 1560 }
1448 default: 1561 default:
1449 wtaerror ("unable to bind this type of event", spec); 1562 wtaerror ("unable to bind this type of event", spec);
1450 } 1563 }
1453 { 1566 {
1454 /* Be nice, allow = to mean (=) */ 1567 /* Be nice, allow = to mean (=) */
1455 if (bucky_sym_to_bucky_bit (spec) != 0) 1568 if (bucky_sym_to_bucky_bit (spec) != 0)
1456 invalid_argument ("Key is a modifier name", spec); 1569 invalid_argument ("Key is a modifier name", spec);
1457 define_key_check_and_coerce_keysym (spec, &spec, 0); 1570 define_key_check_and_coerce_keysym (spec, &spec, 0);
1571 #ifdef USE_KKCC
1572 SET_KEY_DATA_KEYSYM (returned_value, spec);
1573 SET_KEY_DATA_MODIFIERS (returned_value, 0);
1574 #else /* not USE_KKCC */
1458 returned_value->keysym = spec; 1575 returned_value->keysym = spec;
1459 returned_value->modifiers = 0; 1576 returned_value->modifiers = 0;
1577 #endif /* not USE_KKCC */
1460 } 1578 }
1461 else if (CONSP (spec)) 1579 else if (CONSP (spec))
1462 { 1580 {
1463 int modifiers = 0; 1581 int modifiers = 0;
1464 Lisp_Object keysym = Qnil; 1582 Lisp_Object keysym = Qnil;
1489 if (!NILP (rest)) 1607 if (!NILP (rest))
1490 signal_error (Qlist_formation_error, 1608 signal_error (Qlist_formation_error,
1491 "List must be nil-terminated", spec); 1609 "List must be nil-terminated", spec);
1492 1610
1493 define_key_check_and_coerce_keysym (spec, &keysym, modifiers); 1611 define_key_check_and_coerce_keysym (spec, &keysym, modifiers);
1612 #ifdef USE_KKCC
1613 SET_KEY_DATA_KEYSYM(returned_value, keysym);
1614 SET_KEY_DATA_MODIFIERS (returned_value, modifiers);
1615 #else /* not USE_KKCC */
1494 returned_value->keysym = keysym; 1616 returned_value->keysym = keysym;
1495 returned_value->modifiers = modifiers; 1617 returned_value->modifiers = modifiers;
1618 #endif /* not USE_KKCC */
1496 } 1619 }
1497 else 1620 else
1498 { 1621 {
1499 invalid_argument ("Unknown key-sequence specifier", 1622 invalid_argument ("Unknown key-sequence specifier",
1500 spec); 1623 spec);
1504 /* Used by character-to-event */ 1627 /* Used by character-to-event */
1505 void 1628 void
1506 key_desc_list_to_event (Lisp_Object list, Lisp_Object event, 1629 key_desc_list_to_event (Lisp_Object list, Lisp_Object event,
1507 int allow_menu_events) 1630 int allow_menu_events)
1508 { 1631 {
1632 #ifdef USE_KKCC
1633 Lisp_Key_Data raw_key;
1634 #else /* not USE_KKCC */
1509 struct key_data raw_key; 1635 struct key_data raw_key;
1636 #endif /* not USE_KKCC */
1510 1637
1511 if (allow_menu_events && 1638 if (allow_menu_events &&
1512 CONSP (list) && 1639 CONSP (list) &&
1513 /* #### where the hell does this come from? */ 1640 /* #### where the hell does this come from? */
1514 EQ (XCAR (list), Qmenu_selection)) 1641 EQ (XCAR (list), Qmenu_selection))
1519 arg = Fcar (Fcdr (list)); 1646 arg = Fcar (Fcdr (list));
1520 if (SYMBOLP (arg)) 1647 if (SYMBOLP (arg))
1521 fn = Qcall_interactively; 1648 fn = Qcall_interactively;
1522 else 1649 else
1523 fn = Qeval; 1650 fn = Qeval;
1651 #ifdef USE_KKCC
1652 XSET_EVENT_TYPE (event, misc_user_event);
1653 XSET_EVENT_CHANNEL (event, wrap_frame (selected_frame));
1654 XSET_MISC_USER_DATA_FUNCTION (XEVENT_DATA (event), fn);
1655 XSET_MISC_USER_DATA_OBJECT (XEVENT_DATA (event), arg);
1656 #else /* not USE_KKCC */
1524 XEVENT (event)->channel = wrap_frame (selected_frame ()); 1657 XEVENT (event)->channel = wrap_frame (selected_frame ());
1525 XEVENT (event)->event_type = misc_user_event; 1658 XEVENT (event)->event_type = misc_user_event;
1526 XEVENT (event)->event.eval.function = fn; 1659 XEVENT (event)->event.eval.function = fn;
1527 XEVENT (event)->event.eval.object = arg; 1660 XEVENT (event)->event.eval.object = arg;
1661 #endif /* not USE_KKCC */
1528 return; 1662 return;
1529 } 1663 }
1530 1664
1531 define_key_parser (list, &raw_key); 1665 define_key_parser (list, &raw_key);
1532 1666
1539 EQ (raw_key.keysym, Qbutton6) || EQ (raw_key.keysym, Qbutton6up) || 1673 EQ (raw_key.keysym, Qbutton6) || EQ (raw_key.keysym, Qbutton6up) ||
1540 EQ (raw_key.keysym, Qbutton7) || EQ (raw_key.keysym, Qbutton7up)) 1674 EQ (raw_key.keysym, Qbutton7) || EQ (raw_key.keysym, Qbutton7up))
1541 invalid_operation ("Mouse-clicks can't appear in saved keyboard macros", 1675 invalid_operation ("Mouse-clicks can't appear in saved keyboard macros",
1542 Qunbound); 1676 Qunbound);
1543 1677
1678 #ifdef USE_KKCC
1679 XSET_EVENT_CHANNEL (event, Vselected_console);
1680 XSET_EVENT_TYPE (event, key_press_event);
1681 XSET_KEY_DATA_KEYSYM (XEVENT_DATA (event), raw_key.keysym);
1682 XSET_KEY_DATA_MODIFIERS (XEVENT_DATA (event), KEY_DATA_MODIFIERS (&raw_key));
1683 #else /* not USE_KKCC */
1544 XEVENT (event)->channel = Vselected_console; 1684 XEVENT (event)->channel = Vselected_console;
1545 XEVENT (event)->event_type = key_press_event; 1685 XEVENT (event)->event_type = key_press_event;
1546 XEVENT (event)->event.key.keysym = raw_key.keysym; 1686 XEVENT (event)->event.key.keysym = raw_key.keysym;
1547 XEVENT (event)->event.key.modifiers = raw_key.modifiers; 1687 XEVENT (event)->event.key.modifiers = raw_key.modifiers;
1688 #endif /* not USE_KKCC */
1548 } 1689 }
1549 1690
1550 1691
1551 int 1692 int
1552 event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier) 1693 event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier)
1587 1728
1588 ch1 = event_to_character (event, 0, 0, 0); 1729 ch1 = event_to_character (event, 0, 0, 0);
1589 ch2 = event_to_character (XEVENT (event2), 0, 0, 0); 1730 ch2 = event_to_character (XEVENT (event2), 0, 0, 0);
1590 retval = (ch1 >= 0 && ch2 >= 0 && ch1 == ch2); 1731 retval = (ch1 >= 0 && ch2 >= 0 && ch1 == ch2);
1591 } 1732 }
1733 #ifdef USE_KKCC
1734 else if (EQ (XKEY_DATA_KEYSYM (EVENT_DATA (event)), XKEY_DATA_KEYSYM (XEVENT_DATA (event2))) &&
1735 XKEY_DATA_MODIFIERS (EVENT_DATA (event)) == XKEY_DATA_MODIFIERS (XEVENT_DATA (event2)))
1736 #else /* not USE_KKCC */
1592 else if (EQ (event->event.key.keysym, XEVENT (event2)->event.key.keysym) && 1737 else if (EQ (event->event.key.keysym, XEVENT (event2)->event.key.keysym) &&
1593 event->event.key.modifiers == XEVENT (event2)->event.key.modifiers) 1738 event->event.key.modifiers == XEVENT (event2)->event.key.modifiers)
1739 #endif /* not USE_KKCC */
1594 retval = 1; 1740 retval = 1;
1595 else 1741 else
1596 retval = 0; 1742 retval = 0;
1597 Fdeallocate_event (event2); 1743 Fdeallocate_event (event2);
1598 UNGCPRO; 1744 UNGCPRO;
1599 return retval; 1745 return retval;
1600 } 1746 }
1601 1747
1602 static int 1748 static int
1749 #ifdef USE_KKCC
1750 meta_prefix_char_p (const Lisp_Key_Data *key)
1751 #else /* not USE_KKCC */
1603 meta_prefix_char_p (const struct key_data *key) 1752 meta_prefix_char_p (const struct key_data *key)
1604 { 1753 #endif /* not USE_KKCC */
1754 {
1755 #ifdef USE_KKCC
1756 Lisp_Object event = Fmake_event (Qnil, Qnil);
1757 struct gcpro gcpro1;
1758 GCPRO1 (event);
1759
1760 XSET_EVENT_TYPE (event, key_press_event);
1761 XSET_EVENT_CHANNEL (event, Vselected_console);
1762 XSET_KEY_DATA_KEYSYM (XEVENT_DATA (event), KEY_DATA_KEYSYM (key));
1763 XSET_KEY_DATA_MODIFIERS (XEVENT_DATA (event), KEY_DATA_MODIFIERS (key));
1764 return event_matches_key_specifier_p (XEVENT(event), Vmeta_prefix_char);
1765 #else /* not USE_KKCC */
1605 Lisp_Event event; 1766 Lisp_Event event;
1606 1767
1607 event.event_type = key_press_event; 1768 event.event_type = key_press_event;
1608 event.channel = Vselected_console; 1769 event.channel = Vselected_console;
1609 event.event.key.keysym = key->keysym; 1770 event.event.key.keysym = key->keysym;
1610 event.event.key.modifiers = key->modifiers; 1771 event.event.key.modifiers = key->modifiers;
1611 return event_matches_key_specifier_p (&event, Vmeta_prefix_char); 1772 return event_matches_key_specifier_p (&event, Vmeta_prefix_char);
1773 #endif /* not USE_KKCC */
1612 } 1774 }
1613 1775
1614 DEFUN ("event-matches-key-specifier-p", Fevent_matches_key_specifier_p, 2, 2, 0, /* 1776 DEFUN ("event-matches-key-specifier-p", Fevent_matches_key_specifier_p, 2, 2, 0, /*
1615 Return non-nil if EVENT matches KEY-SPECIFIER. 1777 Return non-nil if EVENT matches KEY-SPECIFIER.
1616 This can be useful, e.g., to determine if the user pressed `help-char' or 1778 This can be useful, e.g., to determine if the user pressed `help-char' or
1620 { 1782 {
1621 CHECK_LIVE_EVENT (event); 1783 CHECK_LIVE_EVENT (event);
1622 return (event_matches_key_specifier_p (XEVENT (event), key_specifier) 1784 return (event_matches_key_specifier_p (XEVENT (event), key_specifier)
1623 ? Qt : Qnil); 1785 ? Qt : Qnil);
1624 } 1786 }
1625 1787 #ifdef USE_KKCC
1788 #define MACROLET(k,m) do { \
1789 SET_KEY_DATA_KEYSYM(returned_value, k); \
1790 SET_KEY_DATA_MODIFIERS(returned_value, m); \
1791 RETURN_SANS_WARNINGS; \
1792 } while (0)
1793 #else /* not USE_KKCC */
1626 #define MACROLET(k,m) do { \ 1794 #define MACROLET(k,m) do { \
1627 returned_value->keysym = (k); \ 1795 returned_value->keysym = (k); \
1628 returned_value->modifiers = (m); \ 1796 returned_value->modifiers = (m); \
1629 RETURN_SANS_WARNINGS; \ 1797 RETURN_SANS_WARNINGS; \
1630 } while (0) 1798 } while (0)
1631 1799 #endif /* not USE_KKCC */
1632 /* ASCII grunge. 1800 /* ASCII grunge.
1633 Given a keysym, return another keysym/modifier pair which could be 1801 Given a keysym, return another keysym/modifier pair which could be
1634 considered the same key in an ASCII world. Backspace returns ^H, for 1802 considered the same key in an ASCII world. Backspace returns ^H, for
1635 example. 1803 example.
1636 */ 1804 */
1637 static void 1805 static void
1806 #ifdef USE_KKCC
1807 define_key_alternate_name (Lisp_Key_Data *key,
1808 Lisp_Key_Data *returned_value)
1809 #else /* not USE_KKCC */
1638 define_key_alternate_name (struct key_data *key, 1810 define_key_alternate_name (struct key_data *key,
1639 struct key_data *returned_value) 1811 struct key_data *returned_value)
1640 { 1812 #endif /* not USE_KKCC */
1813 {
1814 #ifdef USE_KKCC
1815 Lisp_Object keysym = KEY_DATA_KEYSYM (key);
1816 int modifiers = KEY_DATA_MODIFIERS (key);
1817 #else /* not USE_KKCC */
1641 Lisp_Object keysym = key->keysym; 1818 Lisp_Object keysym = key->keysym;
1642 int modifiers = key->modifiers; 1819 int modifiers = key->modifiers;
1820 #endif /* not USE_KKCC */
1643 int modifiers_sans_control = (modifiers & (~XEMACS_MOD_CONTROL)); 1821 int modifiers_sans_control = (modifiers & (~XEMACS_MOD_CONTROL));
1644 int modifiers_sans_meta = (modifiers & (~XEMACS_MOD_META)); 1822 int modifiers_sans_meta = (modifiers & (~XEMACS_MOD_META));
1823 #ifdef USE_KKCC
1824 SET_KEY_DATA_KEYSYM (returned_value, Qnil); /* By default, no "alternate" key */
1825 SET_KEY_DATA_MODIFIERS (returned_value, 0);
1826 #else /* not USE_KKCC */
1645 returned_value->keysym = Qnil; /* By default, no "alternate" key */ 1827 returned_value->keysym = Qnil; /* By default, no "alternate" key */
1646 returned_value->modifiers = 0; 1828 returned_value->modifiers = 0;
1829 #endif /* not USE_KKCC */
1647 if (modifiers_sans_meta == XEMACS_MOD_CONTROL) 1830 if (modifiers_sans_meta == XEMACS_MOD_CONTROL)
1648 { 1831 {
1649 if (EQ (keysym, QKspace)) 1832 if (EQ (keysym, QKspace))
1650 MACROLET (make_char ('@'), modifiers); 1833 MACROLET (make_char ('@'), modifiers);
1651 else if (!CHARP (keysym)) 1834 else if (!CHARP (keysym))
1692 { 1875 {
1693 /* This function can GC */ 1876 /* This function can GC */
1694 Lisp_Object new_keys; 1877 Lisp_Object new_keys;
1695 int i; 1878 int i;
1696 Lisp_Object mpc_binding; 1879 Lisp_Object mpc_binding;
1880 #ifdef USE_KKCC
1881 Lisp_Key_Data meta_key;
1882 #else /* not USE_KKCC */
1697 struct key_data meta_key; 1883 struct key_data meta_key;
1698 1884 #endif /* not USE_KKCC */
1699 if (NILP (Vmeta_prefix_char) || 1885 if (NILP (Vmeta_prefix_char) ||
1700 (INTP (Vmeta_prefix_char) && !CHAR_INTP (Vmeta_prefix_char))) 1886 (INTP (Vmeta_prefix_char) && !CHAR_INTP (Vmeta_prefix_char)))
1701 return; 1887 return;
1702 1888
1703 define_key_parser (Vmeta_prefix_char, &meta_key); 1889 define_key_parser (Vmeta_prefix_char, &meta_key);
1894 2080
1895 idx = 0; 2081 idx = 0;
1896 while (1) 2082 while (1)
1897 { 2083 {
1898 Lisp_Object c; 2084 Lisp_Object c;
2085 #ifdef USE_KKCC
2086 Lisp_Key_Data raw_key1;
2087 Lisp_Key_Data raw_key2;
2088 #else /* not USE_KKCC */
1899 struct key_data raw_key1; 2089 struct key_data raw_key1;
1900 struct key_data raw_key2; 2090 struct key_data raw_key2;
1901 2091 #endif /* not USE_KKCC */
1902 if (STRINGP (keys)) 2092 if (STRINGP (keys))
1903 c = make_char (string_ichar (keys, idx)); 2093 c = make_char (string_ichar (keys, idx));
1904 else 2094 else
1905 c = XVECTOR_DATA (keys) [idx]; 2095 c = XVECTOR_DATA (keys) [idx];
1906 2096
2010 to make where-is-internal really fly. */ 2200 to make where-is-internal really fly. */
2011 2201
2012 struct raw_lookup_key_mapper_closure 2202 struct raw_lookup_key_mapper_closure
2013 { 2203 {
2014 int remaining; 2204 int remaining;
2205 #ifdef USE_KKCC
2206 const Lisp_Key_Data *raw_keys;
2207 #else /* not USE_KKCC */
2015 const struct key_data *raw_keys; 2208 const struct key_data *raw_keys;
2209 #endif /* not USE_KKCC */
2016 int raw_keys_count; 2210 int raw_keys_count;
2017 int keys_so_far; 2211 int keys_so_far;
2018 int accept_default; 2212 int accept_default;
2019 }; 2213 };
2020 2214
2021 static Lisp_Object raw_lookup_key_mapper (Lisp_Object k, void *); 2215 static Lisp_Object raw_lookup_key_mapper (Lisp_Object k, void *);
2022 2216
2023 /* Caller should gc-protect args (keymaps may autoload) */ 2217 /* Caller should gc-protect args (keymaps may autoload) */
2024 static Lisp_Object 2218 static Lisp_Object
2025 raw_lookup_key (Lisp_Object keymap, 2219 raw_lookup_key (Lisp_Object keymap,
2220 #ifdef USE_KKCC
2221 const Lisp_Key_Data *raw_keys, int raw_keys_count,
2222 #else /* not USE_KKCC */
2026 const struct key_data *raw_keys, int raw_keys_count, 2223 const struct key_data *raw_keys, int raw_keys_count,
2224 #endif /* not USE_KKCC */
2027 int keys_so_far, int accept_default) 2225 int keys_so_far, int accept_default)
2028 { 2226 {
2029 /* This function can GC */ 2227 /* This function can GC */
2030 struct raw_lookup_key_mapper_closure c; 2228 struct raw_lookup_key_mapper_closure c;
2031 c.remaining = raw_keys_count - 1; 2229 c.remaining = raw_keys_count - 1;
2044 struct raw_lookup_key_mapper_closure *c = 2242 struct raw_lookup_key_mapper_closure *c =
2045 (struct raw_lookup_key_mapper_closure *) arg; 2243 (struct raw_lookup_key_mapper_closure *) arg;
2046 int accept_default = c->accept_default; 2244 int accept_default = c->accept_default;
2047 int remaining = c->remaining; 2245 int remaining = c->remaining;
2048 int keys_so_far = c->keys_so_far; 2246 int keys_so_far = c->keys_so_far;
2247 #ifdef USE_KKCC
2248 const Lisp_Key_Data *raw_keys = c->raw_keys;
2249 #else /* not USE_KKCC */
2049 const struct key_data *raw_keys = c->raw_keys; 2250 const struct key_data *raw_keys = c->raw_keys;
2251 #endif /* not USE_KKCC */
2050 Lisp_Object cmd; 2252 Lisp_Object cmd;
2051 2253
2052 if (! meta_prefix_char_p (&(raw_keys[0]))) 2254 if (! meta_prefix_char_p (&(raw_keys[0])))
2053 { 2255 {
2054 /* Normal case: every case except the meta-hack (see below). */ 2256 /* Normal case: every case except the meta-hack (see below). */
2097 if (!NILP (cmd)) 2299 if (!NILP (cmd))
2098 cmd = raw_lookup_key (cmd, raw_keys + 1, remaining, 2300 cmd = raw_lookup_key (cmd, raw_keys + 1, remaining,
2099 keys_so_far + 1, accept_default); 2301 keys_so_far + 1, accept_default);
2100 else if ((raw_keys[1].modifiers & XEMACS_MOD_META) == 0) 2302 else if ((raw_keys[1].modifiers & XEMACS_MOD_META) == 0)
2101 { 2303 {
2304 #ifdef USE_KKCC
2305 Lisp_Key_Data metified;
2306 #else /* not USE_KKCC */
2102 struct key_data metified; 2307 struct key_data metified;
2308 #endif /* not USE_KKCC */
2103 metified.keysym = raw_keys[1].keysym; 2309 metified.keysym = raw_keys[1].keysym;
2104 metified.modifiers = raw_keys[1].modifiers | 2310 metified.modifiers = raw_keys[1].modifiers |
2105 (unsigned char) XEMACS_MOD_META; 2311 (unsigned char) XEMACS_MOD_META;
2106 2312
2107 /* Search for meta-next-char sequence directly */ 2313 /* Search for meta-next-char sequence directly */
2129 static Lisp_Object 2335 static Lisp_Object
2130 lookup_keys (Lisp_Object keymap, int nkeys, Lisp_Object *keys, 2336 lookup_keys (Lisp_Object keymap, int nkeys, Lisp_Object *keys,
2131 int accept_default) 2337 int accept_default)
2132 { 2338 {
2133 /* This function can GC */ 2339 /* This function can GC */
2340 #ifdef USE_KKCC
2341 Lisp_Key_Data kkk[20];
2342 Lisp_Key_Data *raw_keys;
2343 #else /* not USE_KKCC */
2134 struct key_data kkk[20]; 2344 struct key_data kkk[20];
2135 struct key_data *raw_keys; 2345 struct key_data *raw_keys;
2346 #endif /* not USE_KKCC */
2136 int i; 2347 int i;
2137 2348
2138 if (nkeys == 0) 2349 if (nkeys == 0)
2139 return Qnil; 2350 return Qnil;
2140 2351
2141 if (nkeys < countof (kkk)) 2352 if (nkeys < countof (kkk))
2142 raw_keys = kkk; 2353 raw_keys = kkk;
2143 else 2354 else
2355 #ifdef USE_KKCC
2356 raw_keys = alloca_array (Lisp_Key_Data, nkeys);
2357 #else /* not USE_KKCC */
2144 raw_keys = alloca_array (struct key_data, nkeys); 2358 raw_keys = alloca_array (struct key_data, nkeys);
2359 #endif /* not USE_KKCC */
2145 2360
2146 for (i = 0; i < nkeys; i++) 2361 for (i = 0; i < nkeys; i++)
2147 { 2362 {
2148 define_key_parser (keys[i], &(raw_keys[i])); 2363 define_key_parser (keys[i], &(raw_keys[i]));
2149 } 2364 }
2153 static Lisp_Object 2368 static Lisp_Object
2154 lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[], 2369 lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[],
2155 int accept_default) 2370 int accept_default)
2156 { 2371 {
2157 /* This function can GC */ 2372 /* This function can GC */
2373 #ifdef USE_KKCC
2374 Lisp_Key_Data kkk[20];
2375 #else /* not USE_KKCC */
2158 struct key_data kkk[20]; 2376 struct key_data kkk[20];
2377 #endif /* not USE_KKCC */
2159 Lisp_Object event; 2378 Lisp_Object event;
2160 2379
2161 int nkeys; 2380 int nkeys;
2381 #ifdef USE_KKCC
2382 Lisp_Key_Data *raw_keys;
2383 #else /* not USE_KKCC */
2162 struct key_data *raw_keys; 2384 struct key_data *raw_keys;
2385 #endif /* not USE_KKCC */
2163 Lisp_Object tem = Qnil; 2386 Lisp_Object tem = Qnil;
2164 struct gcpro gcpro1, gcpro2; 2387 struct gcpro gcpro1, gcpro2;
2165 int iii; 2388 int iii;
2166 2389
2167 CHECK_LIVE_EVENT (event_head); 2390 CHECK_LIVE_EVENT (event_head);
2169 nkeys = event_chain_count (event_head); 2392 nkeys = event_chain_count (event_head);
2170 2393
2171 if (nkeys < countof (kkk)) 2394 if (nkeys < countof (kkk))
2172 raw_keys = kkk; 2395 raw_keys = kkk;
2173 else 2396 else
2397 #ifdef USE_KKCC
2398 raw_keys = alloca_array (Lisp_Key_Data, nkeys);
2399 #else /* not USE_KKCC */
2174 raw_keys = alloca_array (struct key_data, nkeys); 2400 raw_keys = alloca_array (struct key_data, nkeys);
2401 #endif /* not USE_KKCC */
2175 2402
2176 nkeys = 0; 2403 nkeys = 0;
2177 EVENT_CHAIN_LOOP (event, event_head) 2404 EVENT_CHAIN_LOOP (event, event_head)
2178 define_key_parser (event, &(raw_keys[nkeys++])); 2405 define_key_parser (event, &(raw_keys[nkeys++]));
2179 GCPRO2 (keymaps[0], event_head); 2406 GCPRO2 (keymaps[0], event_head);
2218 return lookup_keys (keymap, 1, &keys, !NILP (accept_default)); 2445 return lookup_keys (keymap, 1, &keys, !NILP (accept_default));
2219 else if (STRINGP (keys)) 2446 else if (STRINGP (keys))
2220 { 2447 {
2221 int length = string_char_length (keys); 2448 int length = string_char_length (keys);
2222 int i; 2449 int i;
2450 #ifdef USE_KKCC
2451 Lisp_Key_Data *raw_keys = alloca_array (Lisp_Key_Data, length);
2452 #else /* not USE_KKCC */
2223 struct key_data *raw_keys = alloca_array (struct key_data, length); 2453 struct key_data *raw_keys = alloca_array (struct key_data, length);
2454 #endif /* not USE_KKCC */
2224 if (length == 0) 2455 if (length == 0)
2225 return Qnil; 2456 return Qnil;
2226 2457
2227 for (i = 0; i < length; i++) 2458 for (i = 0; i < length; i++)
2228 { 2459 {
2797 outside of this file doesn't need to know about. 3028 outside of this file doesn't need to know about.
2798 */ 3029 */
2799 3030
2800 struct map_keymap_unsorted_closure 3031 struct map_keymap_unsorted_closure
2801 { 3032 {
3033 #ifdef USE_KKCC
3034 void (*fn) (const Lisp_Key_Data *, Lisp_Object binding, void *arg);
3035 #else /* not USE_KKCC */
2802 void (*fn) (const struct key_data *, Lisp_Object binding, void *arg); 3036 void (*fn) (const struct key_data *, Lisp_Object binding, void *arg);
3037 #endif /* not USE_KKCC */
2803 void *arg; 3038 void *arg;
2804 int modifiers; 3039 int modifiers;
2805 }; 3040 };
2806 3041
2807 /* used by map_keymap() */ 3042 /* used by map_keymap() */
2825 map_keymap_unsorted_closure); 3060 map_keymap_unsorted_closure);
2826 closure->modifiers = omod; 3061 closure->modifiers = omod;
2827 } 3062 }
2828 else 3063 else
2829 { 3064 {
3065 #ifdef USE_KKCC
3066 Lisp_Key_Data key;
3067 #else /* not USE_KKCC */
2830 struct key_data key; 3068 struct key_data key;
3069 #endif /* not USE_KKCC */
2831 key.keysym = keysym; 3070 key.keysym = keysym;
2832 key.modifiers = modifiers; 3071 key.modifiers = modifiers;
2833 ((*closure->fn) (&key, value, closure->arg)); 3072 ((*closure->fn) (&key, value, closure->arg));
2834 } 3073 }
2835 return 0; 3074 return 0;
2932 3171
2933 /* used by map_keymap() */ 3172 /* used by map_keymap() */
2934 static void 3173 static void
2935 map_keymap_sorted (Lisp_Object keymap_table, 3174 map_keymap_sorted (Lisp_Object keymap_table,
2936 int modifiers, 3175 int modifiers,
3176 #ifdef USE_KKCC
3177 void (*function) (const Lisp_Key_Data *key,
3178 #else /* not USE_KKCC */
2937 void (*function) (const struct key_data *key, 3179 void (*function) (const struct key_data *key,
3180 #endif /* not USE_KKCC */
2938 Lisp_Object binding, 3181 Lisp_Object binding,
2939 void *map_keymap_sorted_closure), 3182 void *map_keymap_sorted_closure),
2940 void *map_keymap_sorted_closure) 3183 void *map_keymap_sorted_closure)
2941 { 3184 {
2942 /* This function can GC */ 3185 /* This function can GC */
2965 (modifiers | sub_bits), 3208 (modifiers | sub_bits),
2966 function, 3209 function,
2967 map_keymap_sorted_closure); 3210 map_keymap_sorted_closure);
2968 else 3211 else
2969 { 3212 {
3213 #ifdef USE_KKCC
3214 Lisp_Key_Data k;
3215 #else /* not USE_KKCC */
2970 struct key_data k; 3216 struct key_data k;
3217 #endif /* not USE_KKCC */
2971 k.keysym = keysym; 3218 k.keysym = keysym;
2972 k.modifiers = modifiers; 3219 k.modifiers = modifiers;
2973 ((*function) (&k, binding, map_keymap_sorted_closure)); 3220 ((*function) (&k, binding, map_keymap_sorted_closure));
2974 } 3221 }
2975 } 3222 }
2977 } 3224 }
2978 3225
2979 3226
2980 /* used by Fmap_keymap() */ 3227 /* used by Fmap_keymap() */
2981 static void 3228 static void
3229 #ifdef USE_KKCC
3230 map_keymap_mapper (const Lisp_Key_Data *key,
3231 #else /* not USE_KKCC */
2982 map_keymap_mapper (const struct key_data *key, 3232 map_keymap_mapper (const struct key_data *key,
3233 #endif /* not USE_KKCC */
2983 Lisp_Object binding, 3234 Lisp_Object binding,
2984 void *function) 3235 void *function)
2985 { 3236 {
2986 /* This function can GC */ 3237 /* This function can GC */
2987 Lisp_Object fn; 3238 Lisp_Object fn;
2990 } 3241 }
2991 3242
2992 3243
2993 static void 3244 static void
2994 map_keymap (Lisp_Object keymap_table, int sort_first, 3245 map_keymap (Lisp_Object keymap_table, int sort_first,
3246 #ifdef USE_KKCC
3247 void (*function) (const Lisp_Key_Data *key,
3248 #else /* not USE_KKCC */
2995 void (*function) (const struct key_data *key, 3249 void (*function) (const struct key_data *key,
3250 #endif /* not USE_KKCC */
2996 Lisp_Object binding, 3251 Lisp_Object binding,
2997 void *fn_arg), 3252 void *fn_arg),
2998 void *fn_arg) 3253 void *fn_arg)
2999 { 3254 {
3000 /* This function can GC */ 3255 /* This function can GC */
3089 Lisp_Object thisseq = Fcar (Fcar (closure->tail)); 3344 Lisp_Object thisseq = Fcar (Fcar (closure->tail));
3090 Lisp_Object cmd = get_keyelt (contents, 1); 3345 Lisp_Object cmd = get_keyelt (contents, 1);
3091 Lisp_Object vec; 3346 Lisp_Object vec;
3092 int j; 3347 int j;
3093 int len; 3348 int len;
3349 #ifdef USE_KKCC
3350 Lisp_Key_Data key;
3351 #else /* not USE_KKCC */
3094 struct key_data key; 3352 struct key_data key;
3353 #endif /* not USE_KKCC */
3095 key.keysym = keysym; 3354 key.keysym = keysym;
3096 key.modifiers = modifiers; 3355 key.modifiers = modifiers;
3097 3356
3098 if (NILP (cmd)) 3357 if (NILP (cmd))
3099 abort (); 3358 abort ();
3177 keymap = def; 3436 keymap = def;
3178 p = make_vector (len, Qnil); 3437 p = make_vector (len, Qnil);
3179 NGCPRO1 (p); 3438 NGCPRO1 (p);
3180 for (iii = 0; iii < len; iii++) 3439 for (iii = 0; iii < len; iii++)
3181 { 3440 {
3441 #ifdef USE_KKCC
3442 Lisp_Key_Data key;
3443 #else /* not USE_KKCC */
3182 struct key_data key; 3444 struct key_data key;
3445 #endif /* not USE_KKCC */
3183 define_key_parser (Faref (prefix, make_int (iii)), &key); 3446 define_key_parser (Faref (prefix, make_int (iii)), &key);
3184 XVECTOR_DATA (p)[iii] = make_key_description (&key, 1); 3447 XVECTOR_DATA (p)[iii] = make_key_description (&key, 1);
3185 } 3448 }
3186 NUNGCPRO; 3449 NUNGCPRO;
3187 prefix = p; 3450 prefix = p;
3273 DECLARE_EISTRING_MALLOC (buf); 3536 DECLARE_EISTRING_MALLOC (buf);
3274 Lisp_Object str; 3537 Lisp_Object str;
3275 3538
3276 if (!EVENTP (key)) 3539 if (!EVENTP (key))
3277 { 3540 {
3541 #ifdef USE_KKCC
3542 Lisp_Object event = Fmake_event (Qnil, Qnil);
3543 XSET_EVENT_TYPE (event, empty_event);
3544 CHECK_CHAR_COERCE_INT (key);
3545 character_to_event (XCHAR (key), XEVENT(event),
3546 XCONSOLE (Vselected_console), 0, 1);
3547 format_event_object (buf, event, 1);
3548 }
3549 else
3550 format_event_object (buf, key, 1);
3551 #else /* not USE_KKCC */
3278 Lisp_Event event; 3552 Lisp_Event event;
3279 event.event_type = empty_event; 3553 event.event_type = empty_event;
3280 CHECK_CHAR_COERCE_INT (key); 3554 CHECK_CHAR_COERCE_INT (key);
3281 character_to_event (XCHAR (key), &event, 3555 character_to_event (XCHAR (key), &event,
3282 XCONSOLE (Vselected_console), 0, 1); 3556 XCONSOLE (Vselected_console), 0, 1);
3283 format_event_object (buf, &event, 1); 3557 format_event_object (buf, &event, 1);
3284 } 3558 }
3285 else 3559 else
3286 format_event_object (buf, XEVENT (key), 1); 3560 format_event_object (buf, XEVENT (key), 1);
3561 #endif /* not USE_KKCC */
3287 str = eimake_string (buf); 3562 str = eimake_string (buf);
3288 eifree (buf); 3563 eifree (buf);
3289 return str; 3564 return str;
3290 } 3565 }
3291 3566
3505 where_is_internal (definition, maps, nmaps, Qt, buffer); 3780 where_is_internal (definition, maps, nmaps, Qt, buffer);
3506 } 3781 }
3507 3782
3508 3783
3509 static Lisp_Object 3784 static Lisp_Object
3785 #ifdef USE_KKCC
3786 raw_keys_to_keys (Lisp_Key_Data *keys, int count)
3787 #else /* not USE_KKCC */
3510 raw_keys_to_keys (struct key_data *keys, int count) 3788 raw_keys_to_keys (struct key_data *keys, int count)
3789 #endif /* not USE_KKCC */
3511 { 3790 {
3512 Lisp_Object result = make_vector (count, Qnil); 3791 Lisp_Object result = make_vector (count, Qnil);
3513 while (count--) 3792 while (count--)
3514 XVECTOR_DATA (result) [count] = make_key_description (&(keys[count]), 1); 3793 XVECTOR_DATA (result) [count] = make_key_description (&(keys[count]), 1);
3515 return result; 3794 return result;
3516 } 3795 }
3517 3796
3518 3797
3519 static void 3798 static void
3799 #ifdef USE_KKCC
3800 format_raw_keys (Lisp_Key_Data *keys, int count, Eistring *buf)
3801 #else /* not USE_KKCC */
3520 format_raw_keys (struct key_data *keys, int count, Eistring *buf) 3802 format_raw_keys (struct key_data *keys, int count, Eistring *buf)
3803 #endif /* not USE_KKCC */
3521 { 3804 {
3522 int i; 3805 int i;
3806 #ifdef USE_KKCC
3807 Lisp_Object event = Fmake_event (Qnil, Qnil);
3808 XSET_EVENT_TYPE (event, key_press_event);
3809 XSET_EVENT_CHANNEL (event, Vselected_console);
3810 #else /* not USE_KKCC */
3523 Lisp_Event event; 3811 Lisp_Event event;
3524 event.event_type = key_press_event; 3812 event.event_type = key_press_event;
3525 event.channel = Vselected_console; 3813 event.channel = Vselected_console;
3814 #endif /* not USE_KKCC */
3526 for (i = 0; i < count; i++) 3815 for (i = 0; i < count; i++)
3527 { 3816 {
3817 #ifdef USE_KKCC
3818 XSET_KEY_DATA_KEYSYM (XEVENT_DATA (event), keys[i].keysym);
3819 XSET_KEY_DATA_MODIFIERS (XEVENT_DATA (event), KEY_DATA_MODIFIERS (&keys[i]));
3820 format_event_object (buf, event, 1);
3821 #else /* not USE_KKCC */
3528 event.event.key.keysym = keys[i].keysym; 3822 event.event.key.keysym = keys[i].keysym;
3529 event.event.key.modifiers = keys[i].modifiers; 3823 event.event.key.modifiers = keys[i].modifiers;
3530 format_event_object (buf, &event, 1); 3824 format_event_object (buf, &event, 1);
3825 #endif /* not USE_KKCC */
3531 if (i < count - 1) 3826 if (i < count - 1)
3532 eicat_c (buf, " "); 3827 eicat_c (buf, " ");
3533 } 3828 }
3534 } 3829 }
3535 3830
3561 int shadow_count; 3856 int shadow_count;
3562 int firstonly; 3857 int firstonly;
3563 int keys_count; 3858 int keys_count;
3564 int modifiers_so_far; 3859 int modifiers_so_far;
3565 Eistring *target_buffer; 3860 Eistring *target_buffer;
3861 #ifdef USE_KKCC
3862 Lisp_Key_Data *keys_so_far;
3863 #else /* not USE_KKCC */
3566 struct key_data *keys_so_far; 3864 struct key_data *keys_so_far;
3865 #endif /* not USE_KKCC */
3567 int keys_so_far_total_size; 3866 int keys_so_far_total_size;
3568 int keys_so_far_malloced; 3867 int keys_so_far_malloced;
3569 }; 3868 };
3570 3869
3571 static Lisp_Object where_is_recursive_mapper (Lisp_Object map, void *arg); 3870 static Lisp_Object where_is_recursive_mapper (Lisp_Object map, void *arg);
3590 { 3889 {
3591 /* One or more keys in this map match the definition we're looking for. 3890 /* One or more keys in this map match the definition we're looking for.
3592 Verify that these bindings aren't shadowed by other bindings 3891 Verify that these bindings aren't shadowed by other bindings
3593 in the shadow maps. Either nil or number as value from 3892 in the shadow maps. Either nil or number as value from
3594 raw_lookup_key() means undefined. */ 3893 raw_lookup_key() means undefined. */
3894 #ifdef USE_KKCC
3895 Lisp_Key_Data *so_far = c->keys_so_far;
3896 #else /* not USE_KKCC */
3595 struct key_data *so_far = c->keys_so_far; 3897 struct key_data *so_far = c->keys_so_far;
3898 #endif /* not USE_KKCC */
3596 3899
3597 for (;;) /* loop over all keys that match */ 3900 for (;;) /* loop over all keys that match */
3598 { 3901 {
3599 Lisp_Object k = CONSP (keys) ? XCAR (keys) : keys; 3902 Lisp_Object k = CONSP (keys) ? XCAR (keys) : keys;
3600 int i; 3903 int i;
3601 3904
3602 so_far [keys_count].keysym = k; 3905 so_far [keys_count].keysym = k;
3906 #ifdef USE_KKCC
3907 SET_KEY_DATA_MODIFIERS (&so_far [keys_count], modifiers_so_far);
3908 #else /* not USE_KKCC */
3603 so_far [keys_count].modifiers = modifiers_so_far; 3909 so_far [keys_count].modifiers = modifiers_so_far;
3910 #endif /* not USE_KKCC */
3604 3911
3605 /* now loop over all shadow maps */ 3912 /* now loop over all shadow maps */
3606 for (i = 0; i < c->shadow_count; i++) 3913 for (i = 0; i < c->shadow_count; i++)
3607 { 3914 {
3608 Lisp_Object shadowed = raw_lookup_key (c->shadow[i], 3915 Lisp_Object shadowed = raw_lookup_key (c->shadow[i],
3679 bucky = MODIFIER_HASH_KEY_BITS (key); 3986 bucky = MODIFIER_HASH_KEY_BITS (key);
3680 if (bucky != 0) 3987 if (bucky != 0)
3681 lower_modifiers = (modifiers_so_far | bucky); 3988 lower_modifiers = (modifiers_so_far | bucky);
3682 else 3989 else
3683 { 3990 {
3991 #ifdef USE_KKCC
3992 Lisp_Key_Data *so_far = c->keys_so_far;
3993 #else /* not USE_KKCC */
3684 struct key_data *so_far = c->keys_so_far; 3994 struct key_data *so_far = c->keys_so_far;
3995 #endif /* not USE_KKCC */
3685 lower_modifiers = 0; 3996 lower_modifiers = 0;
3686 so_far [lower_keys_count].keysym = key; 3997 so_far [lower_keys_count].keysym = key;
3998 #ifdef USE_KKCC
3999 SET_KEY_DATA_MODIFIERS (&so_far [lower_keys_count], modifiers_so_far);
4000 #else /* not USE_KKCC */
3687 so_far [lower_keys_count].modifiers = modifiers_so_far; 4001 so_far [lower_keys_count].modifiers = modifiers_so_far;
4002 #endif /* not USE_KKCC */
3688 lower_keys_count++; 4003 lower_keys_count++;
3689 } 4004 }
3690 4005
3691 if (lower_keys_count >= c->keys_so_far_total_size) 4006 if (lower_keys_count >= c->keys_so_far_total_size)
3692 { 4007 {
3693 int size = lower_keys_count + 50; 4008 int size = lower_keys_count + 50;
3694 if (! c->keys_so_far_malloced) 4009 if (! c->keys_so_far_malloced)
3695 { 4010 {
4011 #ifdef USE_KKCC
4012 Lisp_Key_Data *new = xnew_array (Lisp_Key_Data, size);
4013 #else /* not USE_KKCC */
3696 struct key_data *new = xnew_array (struct key_data, size); 4014 struct key_data *new = xnew_array (struct key_data, size);
4015 #endif /* not USE_KKCC */
3697 memcpy ((void *)new, (const void *)c->keys_so_far, 4016 memcpy ((void *)new, (const void *)c->keys_so_far,
4017 #ifdef USE_KKCC
4018 c->keys_so_far_total_size * sizeof (Lisp_Key_Data));
4019 #else /* not USE_KKCC */
3698 c->keys_so_far_total_size * sizeof (struct key_data)); 4020 c->keys_so_far_total_size * sizeof (struct key_data));
4021 #endif /* not USE_KKCC */
3699 } 4022 }
3700 else 4023 else
4024 #ifdef USE_KKCC
4025 XREALLOC_ARRAY (c->keys_so_far, Lisp_Key_Data, size);
4026 #else /* not USE_KKCC */
3701 XREALLOC_ARRAY (c->keys_so_far, struct key_data, size); 4027 XREALLOC_ARRAY (c->keys_so_far, struct key_data, size);
4028 #endif /* not USE_KKCC */
3702 4029
3703 c->keys_so_far_total_size = size; 4030 c->keys_so_far_total_size = size;
3704 c->keys_so_far_malloced = 1; 4031 c->keys_so_far_malloced = 1;
3705 } 4032 }
3706 4033
3730 Lisp_Object firstonly, Eistring *target_buffer) 4057 Lisp_Object firstonly, Eistring *target_buffer)
3731 { 4058 {
3732 /* This function can GC */ 4059 /* This function can GC */
3733 Lisp_Object result = Qnil; 4060 Lisp_Object result = Qnil;
3734 int i; 4061 int i;
4062 #ifdef USE_KKCC
4063 Lisp_Key_Data raw[20];
4064 #else /* not USE_KKCC */
3735 struct key_data raw[20]; 4065 struct key_data raw[20];
4066 #endif /* not USE_KKCC */
3736 struct where_is_closure c; 4067 struct where_is_closure c;
3737 4068
3738 c.definition = definition; 4069 c.definition = definition;
3739 c.shadow = maps; 4070 c.shadow = maps;
3740 c.firstonly = !NILP (firstonly); 4071 c.firstonly = !NILP (firstonly);
3945 int mice_only_p; /* whether we are to display only button bindings */ 4276 int mice_only_p; /* whether we are to display only button bindings */
3946 }; 4277 };
3947 4278
3948 struct describe_map_shadow_closure 4279 struct describe_map_shadow_closure
3949 { 4280 {
4281 #ifdef USE_KKCC
4282 const Lisp_Key_Data *raw_key;
4283 #else /* not USE_KKCC */
3950 const struct key_data *raw_key; 4284 const struct key_data *raw_key;
4285 #endif /* not USE_KKCC */
3951 Lisp_Object self; 4286 Lisp_Object self;
3952 }; 4287 };
3953 4288
3954 static Lisp_Object 4289 static Lisp_Object
3955 describe_map_mapper_shadow_search (Lisp_Object map, void *arg) 4290 describe_map_mapper_shadow_search (Lisp_Object map, void *arg)
3958 (struct describe_map_shadow_closure *) arg; 4293 (struct describe_map_shadow_closure *) arg;
3959 4294
3960 if (EQ (map, c->self)) 4295 if (EQ (map, c->self))
3961 return Qzero; /* Not shadowed; terminate search */ 4296 return Qzero; /* Not shadowed; terminate search */
3962 4297
4298 #ifdef USE_KKCC
4299 return !NILP (keymap_lookup_directly (map,
4300 KEY_DATA_KEYSYM (c->raw_key),
4301 KEY_DATA_MODIFIERS (c->raw_key)))
4302 #else /* not USE_KKCC */
3963 return !NILP (keymap_lookup_directly (map, 4303 return !NILP (keymap_lookup_directly (map,
3964 c->raw_key->keysym, 4304 c->raw_key->keysym,
3965 c->raw_key->modifiers)) 4305 c->raw_key->modifiers))
4306 #endif /* not USE_KKCC */
3966 ? Qt : Qnil; 4307 ? Qt : Qnil;
3967 } 4308 }
3968 4309
3969 4310
3970 static Lisp_Object 4311 static Lisp_Object
3971 keymap_lookup_inherited_mapper (Lisp_Object km, void *arg) 4312 keymap_lookup_inherited_mapper (Lisp_Object km, void *arg)
3972 { 4313 {
4314 #ifdef USE_KKCC
4315 Lisp_Key_Data *k = (Lisp_Key_Data *) arg;
4316 return keymap_lookup_directly (km, KEY_DATA_KEYSYM (k), KEY_DATA_MODIFIERS (k));
4317 #else /* not USE_KKCC */
3973 struct key_data *k = (struct key_data *) arg; 4318 struct key_data *k = (struct key_data *) arg;
3974 return keymap_lookup_directly (km, k->keysym, k->modifiers); 4319 return keymap_lookup_directly (km, k->keysym, k->modifiers);
4320 #endif /* not USE_KKCC */
3975 } 4321 }
3976 4322
3977 4323
3978 static void 4324 static void
4325 #ifdef USE_KKCC
4326 describe_map_mapper (const Lisp_Key_Data *key,
4327 #else /* not USE_KKCC */
3979 describe_map_mapper (const struct key_data *key, 4328 describe_map_mapper (const struct key_data *key,
4329 #endif /* not USE_KKCC */
3980 Lisp_Object binding, 4330 Lisp_Object binding,
3981 void *describe_map_closure) 4331 void *describe_map_closure)
3982 { 4332 {
3983 /* This function can GC */ 4333 /* This function can GC */
3984 struct describe_map_closure *closure = 4334 struct describe_map_closure *closure =
3985 (struct describe_map_closure *) describe_map_closure; 4335 (struct describe_map_closure *) describe_map_closure;
4336 #ifdef USE_KKCC
4337 Lisp_Object keysym = KEY_DATA_KEYSYM (key);
4338 int modifiers = KEY_DATA_MODIFIERS (key);
4339 #else /* not USE_KKCC */
3986 Lisp_Object keysym = key->keysym; 4340 Lisp_Object keysym = key->keysym;
3987 int modifiers = key->modifiers; 4341 int modifiers = key->modifiers;
4342 #endif /* not USE_KKCC */
3988 4343
3989 /* Don't mention suppressed commands. */ 4344 /* Don't mention suppressed commands. */
3990 if (SYMBOLP (binding) 4345 if (SYMBOLP (binding)
3991 && !NILP (closure->partial) 4346 && !NILP (closure->partial)
3992 && !NILP (Fget (binding, closure->partial, Qnil))) 4347 && !NILP (Fget (binding, closure->partial, Qnil)))