Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 5125:b5df3737028a ben-lisp-object

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge
author Ben Wing <ben@xemacs.org>
date Wed, 24 Feb 2010 01:58:04 -0600
parents 623d57b7fbe8 ae48681c47fa
children 2a462149bd6a
comparison
equal deleted inserted replaced
5124:623d57b7fbe8 5125:b5df3737028a
1 /* Manipulation of keymaps 1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1991-1995 Free Software Foundation, Inc. 2 Copyright (C) 1985, 1991-1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Board of Trustees, University of Illinois. 3 Copyright (C) 1995 Board of Trustees, University of Illinois.
4 Copyright (C) 1995 Sun Microsystems, Inc. 4 Copyright (C) 1995 Sun Microsystems, Inc.
5 Copyright (C) 2001, 2002 Ben Wing. 5 Copyright (C) 2001, 2002, 2010 Ben Wing.
6 Totally redesigned by jwz in 1991. 6 Totally redesigned by jwz in 1991.
7 7
8 This file is part of XEmacs. 8 This file is part of XEmacs.
9 9
10 XEmacs is free software; you can redistribute it and/or modify it 10 XEmacs is free software; you can redistribute it and/or modify it
147 */ 147 */
148 148
149 struct Lisp_Keymap 149 struct Lisp_Keymap
150 { 150 {
151 LISP_OBJECT_HEADER header; 151 LISP_OBJECT_HEADER header;
152 Lisp_Object parents; /* Keymaps to be searched after this one. 152 #define MARKED_SLOT(x) Lisp_Object x;
153 An ordered list */ 153 #include "keymap-slots.h"
154 Lisp_Object prompt; /* Qnil or a string to print in the minibuffer
155 when reading from this keymap */
156 Lisp_Object table; /* The contents of this keymap */
157 Lisp_Object inverse_table; /* The inverse mapping of the above */
158 Lisp_Object default_binding; /* Use this if no other binding is found
159 (this overrides parent maps and the
160 normal global-map lookup). */
161 Lisp_Object sub_maps_cache; /* Cache of directly inferior keymaps;
162 This holds an alist, of the key and the
163 maps, or the modifier bit and the map.
164 If this is the symbol t, then the cache
165 needs to be recomputed. */
166 Lisp_Object name; /* Just for debugging convenience */
167 }; 154 };
168 155
169 #define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier) 156 #define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier)
170 #define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0) 157 #define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0)
171 158
215 int mice_only_p, 202 int mice_only_p,
216 Lisp_Object buffer); 203 Lisp_Object buffer);
217 static Lisp_Object keymap_submaps (Lisp_Object keymap); 204 static Lisp_Object keymap_submaps (Lisp_Object keymap);
218 205
219 Lisp_Object Qcontrol, Qctrl, Qmeta, Qsuper, Qhyper, Qalt, Qshift; 206 Lisp_Object Qcontrol, Qctrl, Qmeta, Qsuper, Qhyper, Qalt, Qshift;
220 Lisp_Object Qbutton0; 207
221 Lisp_Object Qbutton1, Qbutton2, Qbutton3, Qbutton4, Qbutton5; 208 #define INCLUDE_BUTTON_ZERO
222 Lisp_Object Qbutton6, Qbutton7, Qbutton8, Qbutton9, Qbutton10; 209 #define FROB(num) \
223 Lisp_Object Qbutton11, Qbutton12, Qbutton13, Qbutton14, Qbutton15; 210 Lisp_Object Qbutton##num; \
224 Lisp_Object Qbutton16, Qbutton17, Qbutton18, Qbutton19, Qbutton20; 211 Lisp_Object Qbutton##num##up;
225 Lisp_Object Qbutton21, Qbutton22, Qbutton23, Qbutton24, Qbutton25; 212 #include "keymap-buttons.h"
226 Lisp_Object Qbutton26;
227 Lisp_Object Qbutton0up;
228 Lisp_Object Qbutton1up, Qbutton2up, Qbutton3up, Qbutton4up, Qbutton5up;
229 Lisp_Object Qbutton6up, Qbutton7up, Qbutton8up, Qbutton9up, Qbutton10up;
230 Lisp_Object Qbutton11up, Qbutton12up, Qbutton13up, Qbutton14up, Qbutton15up;
231 Lisp_Object Qbutton16up, Qbutton17up, Qbutton18up, Qbutton19up, Qbutton20up;
232 Lisp_Object Qbutton21up, Qbutton22up, Qbutton23up, Qbutton24up, Qbutton25up;
233 Lisp_Object Qbutton26up;
234 213
235 Lisp_Object Qmenu_selection; 214 Lisp_Object Qmenu_selection;
215
236 /* Emacs compatibility */ 216 /* Emacs compatibility */
237 Lisp_Object Qdown_mouse_1, Qmouse_1; 217 #define FROB(num) \
238 Lisp_Object Qdown_mouse_2, Qmouse_2; 218 Lisp_Object Qmouse_##num; \
239 Lisp_Object Qdown_mouse_3, Qmouse_3; 219 Lisp_Object Qdown_mouse_##num;
240 Lisp_Object Qdown_mouse_4, Qmouse_4; 220 #include "keymap-buttons.h"
241 Lisp_Object Qdown_mouse_5, Qmouse_5;
242 Lisp_Object Qdown_mouse_6, Qmouse_6;
243 Lisp_Object Qdown_mouse_7, Qmouse_7;
244 Lisp_Object Qdown_mouse_8, Qmouse_8;
245 Lisp_Object Qdown_mouse_9, Qmouse_9;
246 Lisp_Object Qdown_mouse_10, Qmouse_10;
247 Lisp_Object Qdown_mouse_11, Qmouse_11;
248 Lisp_Object Qdown_mouse_12, Qmouse_12;
249 Lisp_Object Qdown_mouse_13, Qmouse_13;
250 Lisp_Object Qdown_mouse_14, Qmouse_14;
251 Lisp_Object Qdown_mouse_15, Qmouse_15;
252 Lisp_Object Qdown_mouse_16, Qmouse_16;
253 Lisp_Object Qdown_mouse_17, Qmouse_17;
254 Lisp_Object Qdown_mouse_18, Qmouse_18;
255 Lisp_Object Qdown_mouse_19, Qmouse_19;
256 Lisp_Object Qdown_mouse_20, Qmouse_20;
257 Lisp_Object Qdown_mouse_21, Qmouse_21;
258 Lisp_Object Qdown_mouse_22, Qmouse_22;
259 Lisp_Object Qdown_mouse_23, Qmouse_23;
260 Lisp_Object Qdown_mouse_24, Qmouse_24;
261 Lisp_Object Qdown_mouse_25, Qmouse_25;
262 Lisp_Object Qdown_mouse_26, Qmouse_26;
263 221
264 /* Kludge kludge kludge */ 222 /* Kludge kludge kludge */
265 Lisp_Object QLFD, QTAB, QRET, QESC, QDEL, QSPC, QBS; 223 Lisp_Object QLFD, QTAB, QRET, QESC, QDEL, QSPC, QBS;
266 224
267 225
268 /************************************************************************/ 226 /************************************************************************/
269 /* The keymap Lisp object */ 227 /* The keymap Lisp object */
270 /************************************************************************/ 228 /************************************************************************/
271 229
230 /* Keymaps are equal if Faces are equal if all of their display attributes are equal. We
231 don't compare names or doc-strings, because that would make equal
232 be eq.
233
234 This isn't concerned with "unspecified" attributes, that's what
235 #'face-differs-from-default-p is for. */
236 static int
237 keymap_equal (Lisp_Object obj1, Lisp_Object obj2, int depth,
238 int UNUSED (foldcase))
239 {
240 Lisp_Keymap *k1 = XKEYMAP (obj1);
241 Lisp_Keymap *k2 = XKEYMAP (obj2);
242
243 depth++;
244
245 return
246 (
247 #define MARKED_SLOT(x) \
248 internal_equal (k1->x, k2->x, depth) &&
249 #define MARKED_SLOT_NOCOMPARE(x)
250 #include "keymap-slots.h"
251 1
252 );
253 }
254
255 static Hashcode
256 keymap_hash (Lisp_Object obj, int depth)
257 {
258 Lisp_Keymap *k = XKEYMAP (obj);
259 Hashcode hash = 0xCAFEBABE; /* why not? */
260
261 depth++;
262
263 #define MARKED_SLOT(x) \
264 hash = HASH2 (hash, internal_hash (k->x, depth));
265 #define MARKED_SLOT_NOCOMPARE(x)
266 #include "keymap-slots.h"
267
268 return hash;
269 }
270
272 static Lisp_Object 271 static Lisp_Object
273 mark_keymap (Lisp_Object obj) 272 mark_keymap (Lisp_Object obj)
274 { 273 {
275 Lisp_Keymap *keymap = XKEYMAP (obj); 274 Lisp_Keymap *keymap = XKEYMAP (obj);
276 mark_object (keymap->parents); 275 #define MARKED_SLOT(x) mark_object (keymap->x);
277 mark_object (keymap->prompt); 276 #include "keymap-slots.h"
278 mark_object (keymap->inverse_table); 277 return Qnil;
279 mark_object (keymap->sub_maps_cache);
280 mark_object (keymap->default_binding);
281 mark_object (keymap->name);
282 return keymap->table;
283 } 278 }
284 279
285 static void 280 static void
286 print_keymap (Lisp_Object obj, Lisp_Object printcharfun, 281 print_keymap (Lisp_Object obj, Lisp_Object printcharfun,
287 int UNUSED (escapeflag)) 282 int UNUSED (escapeflag))
288 { 283 {
289 /* This function can GC */ 284 /* This function can GC */
290 Lisp_Keymap *keymap = XKEYMAP (obj); 285 Lisp_Keymap *keymap = XKEYMAP (obj);
291 if (print_readably) 286 if (print_readably)
292 printing_unreadable_object ("#<keymap 0x%x>", keymap->header.uid); 287 printing_unreadable_lcrecord (obj, 0);
293 write_c_string (printcharfun, "#<keymap "); 288 write_ascstring (printcharfun, "#<keymap ");
294 if (!NILP (keymap->name)) 289 if (!NILP (keymap->name))
295 { 290 {
296 write_fmt_string_lisp (printcharfun, "%S ", 1, keymap->name); 291 write_fmt_string_lisp (printcharfun, "%S ", 1, keymap->name);
297 } 292 }
298 write_fmt_string (printcharfun, "size %ld 0x%x>", 293 write_fmt_string (printcharfun, "size %ld 0x%x>",
299 (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid); 294 (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid);
300 } 295 }
301 296
302 static const struct memory_description keymap_description[] = { 297 static const struct memory_description keymap_description[] = {
303 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, parents) }, 298 #define MARKED_SLOT(x) { XD_LISP_OBJECT, offsetof (Lisp_Keymap, x) },
304 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, prompt) }, 299 #include "keymap-slots.h"
305 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, table) },
306 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, inverse_table) },
307 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, default_binding) },
308 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, sub_maps_cache) },
309 { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) },
310 { XD_END } 300 { XD_END }
311 }; 301 };
312 302
313 /* No need for keymap_equal #### Why not? */
314 DEFINE_DUMPABLE_LISP_OBJECT ("keymap", keymap, 303 DEFINE_DUMPABLE_LISP_OBJECT ("keymap", keymap,
315 mark_keymap, print_keymap, 0, 0, 0, 304 mark_keymap, print_keymap, 0,
305 keymap_equal, keymap_hash,
316 keymap_description, 306 keymap_description,
317 Lisp_Keymap); 307 Lisp_Keymap);
318 308
319 /************************************************************************/ 309 /************************************************************************/
320 /* Traversing keymaps and their parents */ 310 /* Traversing keymaps and their parents */
471 */ 461 */
472 /* !!#### I'm not sure how correct this is. */ 462 /* !!#### I'm not sure how correct this is. */
473 Ibyte str [1 + MAX_ICHAR_LEN]; 463 Ibyte str [1 + MAX_ICHAR_LEN];
474 Bytecount count = set_itext_ichar (str, XCHAR (keysym)); 464 Bytecount count = set_itext_ichar (str, XCHAR (keysym));
475 str[count] = 0; 465 str[count] = 0;
476 keysym = intern_int (str); 466 keysym = intern_istring (str);
477 } 467 }
478 return control_meta_superify (keysym, modifiers); 468 return control_meta_superify (keysym, modifiers);
479 } 469 }
480 470
481 471
493 keymap_lookup_directly (Lisp_Object keymap, 483 keymap_lookup_directly (Lisp_Object keymap,
494 Lisp_Object keysym, int modifiers) 484 Lisp_Object keysym, int modifiers)
495 { 485 {
496 Lisp_Keymap *k; 486 Lisp_Keymap *k;
497 487
498 modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 488 modifiers &= ~(
499 | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5 | XEMACS_MOD_BUTTON6 489 #define FROB(num) XEMACS_MOD_BUTTON##num |
500 | XEMACS_MOD_BUTTON7 | XEMACS_MOD_BUTTON8 | XEMACS_MOD_BUTTON9 490 #include "keymap-buttons.h"
501 | XEMACS_MOD_BUTTON10 | XEMACS_MOD_BUTTON11 | XEMACS_MOD_BUTTON12 491 0);
502 | XEMACS_MOD_BUTTON13 | XEMACS_MOD_BUTTON14 | XEMACS_MOD_BUTTON15
503 | XEMACS_MOD_BUTTON16 | XEMACS_MOD_BUTTON17 | XEMACS_MOD_BUTTON18
504 | XEMACS_MOD_BUTTON19 | XEMACS_MOD_BUTTON20 | XEMACS_MOD_BUTTON21
505 | XEMACS_MOD_BUTTON22 | XEMACS_MOD_BUTTON23 | XEMACS_MOD_BUTTON24
506 | XEMACS_MOD_BUTTON25 | XEMACS_MOD_BUTTON26);
507 if ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER 492 if ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER
508 | XEMACS_MOD_HYPER | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT)) 493 | XEMACS_MOD_HYPER | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT))
509 != 0) 494 != 0)
510 ABORT (); 495 ABORT ();
511 496
681 { 666 {
682 Lisp_Object keysym = KEY_DATA_KEYSYM (key); 667 Lisp_Object keysym = KEY_DATA_KEYSYM (key);
683 int modifiers = KEY_DATA_MODIFIERS (key); 668 int modifiers = KEY_DATA_MODIFIERS (key);
684 Lisp_Keymap *k = XKEYMAP (keymap); 669 Lisp_Keymap *k = XKEYMAP (keymap);
685 670
686 modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 671 modifiers &= ~(
687 | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5 | XEMACS_MOD_BUTTON6 672 #define FROB(num) XEMACS_MOD_BUTTON##num |
688 | XEMACS_MOD_BUTTON7 | XEMACS_MOD_BUTTON8 | XEMACS_MOD_BUTTON9 673 #include "keymap-buttons.h"
689 | XEMACS_MOD_BUTTON10 | XEMACS_MOD_BUTTON11 | XEMACS_MOD_BUTTON12 674 0);
690 | XEMACS_MOD_BUTTON13 | XEMACS_MOD_BUTTON14 | XEMACS_MOD_BUTTON15
691 | XEMACS_MOD_BUTTON16 | XEMACS_MOD_BUTTON17 | XEMACS_MOD_BUTTON18
692 | XEMACS_MOD_BUTTON19 | XEMACS_MOD_BUTTON20 | XEMACS_MOD_BUTTON21
693 | XEMACS_MOD_BUTTON22 | XEMACS_MOD_BUTTON23 | XEMACS_MOD_BUTTON24
694 | XEMACS_MOD_BUTTON25 | XEMACS_MOD_BUTTON26);
695 assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META 675 assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META
696 | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER 676 | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER
697 | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT)) == 0); 677 | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT)) == 0);
698 678
699 /* If the keysym is a one-character symbol, use the char code instead. */ 679 /* If the keysym is a one-character symbol, use the char code instead. */
798 make_keymap (Elemcount size) 778 make_keymap (Elemcount size)
799 { 779 {
800 Lisp_Object obj = ALLOC_LISP_OBJECT (keymap); 780 Lisp_Object obj = ALLOC_LISP_OBJECT (keymap);
801 Lisp_Keymap *keymap = XKEYMAP (obj); 781 Lisp_Keymap *keymap = XKEYMAP (obj);
802 782
803 keymap->parents = Qnil; 783 #define MARKED_SLOT(x) keymap->x = Qnil;
804 keymap->prompt = Qnil; 784 #include "keymap-slots.h"
805 keymap->table = Qnil;
806 keymap->inverse_table = Qnil;
807 keymap->default_binding = Qnil;
808 keymap->sub_maps_cache = Qnil; /* No possible submaps */
809 keymap->name = Qnil;
810 785
811 if (size != 0) /* hack for copy-keymap */ 786 if (size != 0) /* hack for copy-keymap */
812 { 787 {
813 keymap->table = 788 keymap->table =
814 make_lisp_hash_table (size, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); 789 make_lisp_hash_table (size, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
1401 else if (EQ (*keysym, QSPC)) 1376 else if (EQ (*keysym, QSPC))
1402 *keysym = QKspace; 1377 *keysym = QKspace;
1403 else if (EQ (*keysym, QBS)) 1378 else if (EQ (*keysym, QBS))
1404 *keysym = QKbackspace; 1379 *keysym = QKbackspace;
1405 /* Emacs compatibility */ 1380 /* Emacs compatibility */
1406 else if (EQ(*keysym, Qdown_mouse_1)) 1381 #define FROB(num) \
1407 *keysym = Qbutton1; 1382 else if (EQ(*keysym, Qdown_mouse_##num)) \
1408 else if (EQ(*keysym, Qdown_mouse_2)) 1383 *keysym = Qbutton##num; \
1409 *keysym = Qbutton2; 1384 else if (EQ(*keysym, Qmouse_##num)) \
1410 else if (EQ(*keysym, Qdown_mouse_3)) 1385 *keysym = Qbutton##num##up;
1411 *keysym = Qbutton3; 1386 #include "keymap-buttons.h"
1412 else if (EQ(*keysym, Qdown_mouse_4))
1413 *keysym = Qbutton4;
1414 else if (EQ(*keysym, Qdown_mouse_5))
1415 *keysym = Qbutton5;
1416 else if (EQ(*keysym, Qdown_mouse_6))
1417 *keysym = Qbutton6;
1418 else if (EQ(*keysym, Qdown_mouse_7))
1419 *keysym = Qbutton7;
1420 else if (EQ(*keysym, Qdown_mouse_8))
1421 *keysym = Qbutton8;
1422 else if (EQ(*keysym, Qdown_mouse_9))
1423 *keysym = Qbutton9;
1424 else if (EQ(*keysym, Qdown_mouse_10))
1425 *keysym = Qbutton10;
1426 else if (EQ(*keysym, Qdown_mouse_11))
1427 *keysym = Qbutton11;
1428 else if (EQ(*keysym, Qdown_mouse_12))
1429 *keysym = Qbutton12;
1430 else if (EQ(*keysym, Qdown_mouse_13))
1431 *keysym = Qbutton13;
1432 else if (EQ(*keysym, Qdown_mouse_14))
1433 *keysym = Qbutton14;
1434 else if (EQ(*keysym, Qdown_mouse_15))
1435 *keysym = Qbutton15;
1436 else if (EQ(*keysym, Qdown_mouse_16))
1437 *keysym = Qbutton16;
1438 else if (EQ(*keysym, Qdown_mouse_17))
1439 *keysym = Qbutton17;
1440 else if (EQ(*keysym, Qdown_mouse_18))
1441 *keysym = Qbutton18;
1442 else if (EQ(*keysym, Qdown_mouse_19))
1443 *keysym = Qbutton19;
1444 else if (EQ(*keysym, Qdown_mouse_20))
1445 *keysym = Qbutton20;
1446 else if (EQ(*keysym, Qdown_mouse_21))
1447 *keysym = Qbutton21;
1448 else if (EQ(*keysym, Qdown_mouse_22))
1449 *keysym = Qbutton22;
1450 else if (EQ(*keysym, Qdown_mouse_23))
1451 *keysym = Qbutton23;
1452 else if (EQ(*keysym, Qdown_mouse_24))
1453 *keysym = Qbutton24;
1454 else if (EQ(*keysym, Qdown_mouse_25))
1455 *keysym = Qbutton25;
1456 else if (EQ(*keysym, Qdown_mouse_26))
1457 *keysym = Qbutton26;
1458 else if (EQ(*keysym, Qmouse_1))
1459 *keysym = Qbutton1up;
1460 else if (EQ(*keysym, Qmouse_2))
1461 *keysym = Qbutton2up;
1462 else if (EQ(*keysym, Qmouse_3))
1463 *keysym = Qbutton3up;
1464 else if (EQ(*keysym, Qmouse_4))
1465 *keysym = Qbutton4up;
1466 else if (EQ(*keysym, Qmouse_5))
1467 *keysym = Qbutton5up;
1468 else if (EQ(*keysym, Qmouse_6))
1469 *keysym = Qbutton6up;
1470 else if (EQ(*keysym, Qmouse_7))
1471 *keysym = Qbutton7up;
1472 else if (EQ(*keysym, Qmouse_8))
1473 *keysym = Qbutton8up;
1474 else if (EQ(*keysym, Qmouse_9))
1475 *keysym = Qbutton9up;
1476 else if (EQ(*keysym, Qmouse_10))
1477 *keysym = Qbutton10up;
1478 else if (EQ(*keysym, Qmouse_11))
1479 *keysym = Qbutton11up;
1480 else if (EQ(*keysym, Qmouse_12))
1481 *keysym = Qbutton12up;
1482 else if (EQ(*keysym, Qmouse_13))
1483 *keysym = Qbutton13up;
1484 else if (EQ(*keysym, Qmouse_14))
1485 *keysym = Qbutton14up;
1486 else if (EQ(*keysym, Qmouse_15))
1487 *keysym = Qbutton15up;
1488 else if (EQ(*keysym, Qmouse_16))
1489 *keysym = Qbutton16up;
1490 else if (EQ(*keysym, Qmouse_17))
1491 *keysym = Qbutton17up;
1492 else if (EQ(*keysym, Qmouse_18))
1493 *keysym = Qbutton18up;
1494 else if (EQ(*keysym, Qmouse_19))
1495 *keysym = Qbutton19up;
1496 else if (EQ(*keysym, Qmouse_20))
1497 *keysym = Qbutton20up;
1498 else if (EQ(*keysym, Qmouse_21))
1499 *keysym = Qbutton21up;
1500 else if (EQ(*keysym, Qmouse_22))
1501 *keysym = Qbutton22up;
1502 else if (EQ(*keysym, Qmouse_23))
1503 *keysym = Qbutton23up;
1504 else if (EQ(*keysym, Qmouse_24))
1505 *keysym = Qbutton24up;
1506 else if (EQ(*keysym, Qmouse_25))
1507 *keysym = Qbutton25up;
1508 else if (EQ(*keysym, Qmouse_26))
1509 *keysym = Qbutton26up;
1510 } 1387 }
1511 } 1388 }
1512 1389
1513 1390
1514 /* Given any kind of key-specifier, return a keysym and modifier mask. 1391 /* Given any kind of key-specifier, return a keysym and modifier mask.
1547 case button_release_event: 1424 case button_release_event:
1548 { 1425 {
1549 int down = (XEVENT_TYPE (spec) == button_press_event); 1426 int down = (XEVENT_TYPE (spec) == button_press_event);
1550 switch (XEVENT_BUTTON_BUTTON (spec)) 1427 switch (XEVENT_BUTTON_BUTTON (spec))
1551 { 1428 {
1552 case 1: 1429 #define FROB(num) \
1553 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton1 : Qbutton1up)); 1430 case num: \
1431 SET_KEY_DATA_KEYSYM (returned_value, \
1432 (down ? Qbutton##num : \
1433 Qbutton##num##up)); \
1554 break; 1434 break;
1555 case 2: 1435 #include "keymap-buttons.h"
1556 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton2 : Qbutton2up));
1557 break;
1558 case 3:
1559 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton3 : Qbutton3up));
1560 break;
1561 case 4:
1562 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton4 : Qbutton4up));
1563 break;
1564 case 5:
1565 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton5 : Qbutton5up));
1566 break;
1567 case 6:
1568 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton6 : Qbutton6up));
1569 break;
1570 case 7:
1571 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton7 : Qbutton7up));
1572 break;
1573 case 8:
1574 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton8 : Qbutton8up));
1575 break;
1576 case 9:
1577 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton9 : Qbutton9up));
1578 break;
1579 case 10:
1580 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton10 : Qbutton10up));
1581 break;
1582 case 11:
1583 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton11 : Qbutton11up));
1584 break;
1585 case 12:
1586 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton12 : Qbutton12up));
1587 break;
1588 case 13:
1589 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton13 : Qbutton13up));
1590 break;
1591 case 14:
1592 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton14 : Qbutton14up));
1593 break;
1594 case 15:
1595 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton15 : Qbutton15up));
1596 break;
1597 case 16:
1598 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton16 : Qbutton16up));
1599 break;
1600 case 17:
1601 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton17 : Qbutton17up));
1602 break;
1603 case 18:
1604 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton18 : Qbutton18up));
1605 break;
1606 case 19:
1607 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton19 : Qbutton19up));
1608 break;
1609 case 20:
1610 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton20 : Qbutton20up));
1611 break;
1612 case 21:
1613 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton21 : Qbutton21up));
1614 break;
1615 case 22:
1616 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton22 : Qbutton22up));
1617 break;
1618 case 23:
1619 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton23 : Qbutton23up));
1620 break;
1621 case 24:
1622 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton24 : Qbutton24up));
1623 break;
1624 case 25:
1625 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton25 : Qbutton25up));
1626 break;
1627 case 26:
1628 SET_KEY_DATA_KEYSYM(returned_value, (down ? Qbutton26 : Qbutton26up));
1629 break;
1630 default: 1436 default:
1631 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton0 : Qbutton0up)); 1437 SET_KEY_DATA_KEYSYM (returned_value, (down ? Qbutton0 :
1438 Qbutton0up));
1632 break; 1439 break;
1633 } 1440 }
1634 SET_KEY_DATA_MODIFIERS (returned_value, XEVENT_BUTTON_MODIFIERS (spec)); 1441 SET_KEY_DATA_MODIFIERS (returned_value,
1442 XEVENT_BUTTON_MODIFIERS (spec));
1635 break; 1443 break;
1636 } 1444 }
1637 default: 1445 default:
1638 wtaerror ("unable to bind this type of event", spec); 1446 wtaerror ("unable to bind this type of event", spec);
1639 } 1447 }
1717 return; 1525 return;
1718 } 1526 }
1719 1527
1720 define_key_parser (list, &raw_key); 1528 define_key_parser (list, &raw_key);
1721 1529
1722 if (EQ (raw_key.keysym, Qbutton0) || EQ (raw_key.keysym, Qbutton0up) || 1530 if (
1723 EQ (raw_key.keysym, Qbutton1) || EQ (raw_key.keysym, Qbutton1up) || 1531 #define INCLUDE_BUTTON_ZERO
1724 EQ (raw_key.keysym, Qbutton2) || EQ (raw_key.keysym, Qbutton2up) || 1532 #define FROB(num) \
1725 EQ (raw_key.keysym, Qbutton3) || EQ (raw_key.keysym, Qbutton3up) || 1533 EQ (raw_key.keysym, Qbutton##num) || \
1726 EQ (raw_key.keysym, Qbutton4) || EQ (raw_key.keysym, Qbutton4up) || 1534 EQ (raw_key.keysym, Qbutton##num##up) ||
1727 EQ (raw_key.keysym, Qbutton5) || EQ (raw_key.keysym, Qbutton5up) || 1535 #include "keymap-buttons.h"
1728 EQ (raw_key.keysym, Qbutton6) || EQ (raw_key.keysym, Qbutton6up) || 1536 0)
1729 EQ (raw_key.keysym, Qbutton7) || EQ (raw_key.keysym, Qbutton7up) ||
1730 EQ (raw_key.keysym, Qbutton8) || EQ (raw_key.keysym, Qbutton8up) ||
1731 EQ (raw_key.keysym, Qbutton9) || EQ (raw_key.keysym, Qbutton9up) ||
1732 EQ (raw_key.keysym, Qbutton10) || EQ (raw_key.keysym, Qbutton10up) ||
1733 EQ (raw_key.keysym, Qbutton11) || EQ (raw_key.keysym, Qbutton11up) ||
1734 EQ (raw_key.keysym, Qbutton12) || EQ (raw_key.keysym, Qbutton12up) ||
1735 EQ (raw_key.keysym, Qbutton13) || EQ (raw_key.keysym, Qbutton13up) ||
1736 EQ (raw_key.keysym, Qbutton14) || EQ (raw_key.keysym, Qbutton14up) ||
1737 EQ (raw_key.keysym, Qbutton15) || EQ (raw_key.keysym, Qbutton15up) ||
1738 EQ (raw_key.keysym, Qbutton16) || EQ (raw_key.keysym, Qbutton16up) ||
1739 EQ (raw_key.keysym, Qbutton17) || EQ (raw_key.keysym, Qbutton17up) ||
1740 EQ (raw_key.keysym, Qbutton18) || EQ (raw_key.keysym, Qbutton18up) ||
1741 EQ (raw_key.keysym, Qbutton19) || EQ (raw_key.keysym, Qbutton19up) ||
1742 EQ (raw_key.keysym, Qbutton20) || EQ (raw_key.keysym, Qbutton20up) ||
1743 EQ (raw_key.keysym, Qbutton21) || EQ (raw_key.keysym, Qbutton21up) ||
1744 EQ (raw_key.keysym, Qbutton22) || EQ (raw_key.keysym, Qbutton22up) ||
1745 EQ (raw_key.keysym, Qbutton23) || EQ (raw_key.keysym, Qbutton23up) ||
1746 EQ (raw_key.keysym, Qbutton24) || EQ (raw_key.keysym, Qbutton24up) ||
1747 EQ (raw_key.keysym, Qbutton25) || EQ (raw_key.keysym, Qbutton25up) ||
1748 EQ (raw_key.keysym, Qbutton26) || EQ (raw_key.keysym, Qbutton26up))
1749 invalid_operation ("Mouse-clicks can't appear in saved keyboard macros", 1537 invalid_operation ("Mouse-clicks can't appear in saved keyboard macros",
1750 Qunbound); 1538 Qunbound);
1751 1539
1752 XSET_EVENT_CHANNEL (event, Vselected_console); 1540 XSET_EVENT_CHANNEL (event, Vselected_console);
1753 XSET_EVENT_TYPE (event, key_press_event); 1541 XSET_EVENT_TYPE (event, key_press_event);
1955 } 1743 }
1956 1744
1957 if (EQ (keys, new_keys)) 1745 if (EQ (keys, new_keys))
1958 signal_ferror_with_frob (Qinvalid_operation, mpc_binding, 1746 signal_ferror_with_frob (Qinvalid_operation, mpc_binding,
1959 "can't bind %s: %s has a non-keymap binding", 1747 "can't bind %s: %s has a non-keymap binding",
1960 (char *) XSTRING_DATA (Fkey_description (keys)), 1748 (CIbyte *) XSTRING_DATA (Fkey_description (keys)),
1961 (char *) XSTRING_DATA (Fsingle_key_description 1749 (CIbyte *) XSTRING_DATA (Fsingle_key_description
1962 (Vmeta_prefix_char))); 1750 (Vmeta_prefix_char)));
1963 else 1751 else
1964 signal_ferror_with_frob (Qinvalid_operation, mpc_binding, 1752 signal_ferror_with_frob (Qinvalid_operation, mpc_binding,
1965 "can't bind %s: %s %s has a non-keymap binding", 1753 "can't bind %s: %s %s has a non-keymap binding",
1966 (char *) XSTRING_DATA (Fkey_description (keys)), 1754 (CIbyte *) XSTRING_DATA (Fkey_description (keys)),
1967 (char *) XSTRING_DATA (Fkey_description 1755 (CIbyte *) XSTRING_DATA (Fkey_description
1968 (new_keys)), 1756 (new_keys)),
1969 (char *) XSTRING_DATA (Fsingle_key_description 1757 (CIbyte *) XSTRING_DATA (Fsingle_key_description
1970 (Vmeta_prefix_char))); 1758 (Vmeta_prefix_char)));
1971 } 1759 }
1972 1760
1973 DEFUN ("define-key", Fdefine_key, 3, 3, 0, /* 1761 DEFUN ("define-key", Fdefine_key, 3, 3, 0, /*
1974 Define key sequence KEYS, in KEYMAP, as DEF. 1762 Define key sequence KEYS, in KEYMAP, as DEF.
1975 KEYMAP is a keymap object. 1763 KEYMAP is a keymap object.
3229 Lisp_Object binding, 3017 Lisp_Object binding,
3230 void *function) 3018 void *function)
3231 { 3019 {
3232 /* This function can GC */ 3020 /* This function can GC */
3233 Lisp_Object fn; 3021 Lisp_Object fn;
3234 fn = VOID_TO_LISP (function); 3022 fn = GET_LISP_FROM_VOID (function);
3235 call2 (fn, make_key_description (key, 1), binding); 3023 call2 (fn, make_key_description (key, 1), binding);
3236 } 3024 }
3237 3025
3238 3026
3239 static void 3027 static void
3289 keymap = tmp; 3077 keymap = tmp;
3290 } 3078 }
3291 GCPRO2 (function, keymap); 3079 GCPRO2 (function, keymap);
3292 keymap = get_keymap (keymap, 1, 1); 3080 keymap = get_keymap (keymap, 1, 1);
3293 map_keymap (XKEYMAP (keymap)->table, !NILP (sort_first), 3081 map_keymap (XKEYMAP (keymap)->table, !NILP (sort_first),
3294 map_keymap_mapper, LISP_TO_VOID (function)); 3082 map_keymap_mapper, STORE_LISP_IN_VOID (function));
3295 UNGCPRO; 3083 UNGCPRO;
3296 return Qnil; 3084 return Qnil;
3297 } 3085 }
3298 3086
3299 3087
3492 3280
3493 if (i == 0) 3281 if (i == 0)
3494 string = s2; 3282 string = s2;
3495 else 3283 else
3496 { 3284 {
3497 /* if (NILP (sep)) Lisp_Object sep = build_string (" ") */; 3285 /* if (NILP (sep)) Lisp_Object sep = build_ascstring (" ") */;
3498 string = concat2 (string, concat2 (Vsingle_space_string, s2)); 3286 string = concat2 (string, concat2 (Vsingle_space_string, s2));
3499 } 3287 }
3500 } 3288 }
3501 return string; 3289 return string;
3502 } 3290 }
3650 { 3438 {
3651 p += set_itext_ichar (p, c); 3439 p += set_itext_ichar (p, c);
3652 } 3440 }
3653 3441
3654 *p = 0; 3442 *p = 0;
3655 return build_string ((char *) buf); 3443 return build_istring (buf);
3656 } 3444 }
3657 3445
3658 3446
3659 /************************************************************************/ 3447 /************************************************************************/
3660 /* where-is (mapping bindings to keys) */ 3448 /* where-is (mapping bindings to keys) */
3946 if (! c->keys_so_far_malloced) 3734 if (! c->keys_so_far_malloced)
3947 { 3735 {
3948 Lisp_Key_Data *new_ = xnew_array (Lisp_Key_Data, size); 3736 Lisp_Key_Data *new_ = xnew_array (Lisp_Key_Data, size);
3949 memcpy ((void *)new_, (const void *)c->keys_so_far, 3737 memcpy ((void *)new_, (const void *)c->keys_so_far,
3950 c->keys_so_far_total_size * sizeof (Lisp_Key_Data)); 3738 c->keys_so_far_total_size * sizeof (Lisp_Key_Data));
3951 xfree (c->keys_so_far, Lisp_Key_Data); 3739 xfree (c->keys_so_far);
3952 c->keys_so_far = new_; 3740 c->keys_so_far = new_;
3953 } 3741 }
3954 else 3742 else
3955 XREALLOC_ARRAY (c->keys_so_far, Lisp_Key_Data, size); 3743 XREALLOC_ARRAY (c->keys_so_far, Lisp_Key_Data, size);
3956 3744
4022 3810
4023 if (NILP (firstonly)) 3811 if (NILP (firstonly))
4024 result = Fnreverse (result); 3812 result = Fnreverse (result);
4025 3813
4026 if (c.keys_so_far_malloced) 3814 if (c.keys_so_far_malloced)
4027 xfree (c.keys_so_far, Lisp_Key_Data *); 3815 xfree (c.keys_so_far);
4028 return result; 3816 return result;
4029 } 3817 }
4030 3818
4031 3819
4032 /************************************************************************/ 3820 /************************************************************************/
4145 struct gcpro gcpro1; 3933 struct gcpro gcpro1;
4146 GCPRO1 (definition); 3934 GCPRO1 (definition);
4147 3935
4148 Findent_to (make_int (16), make_int (3), buffer); 3936 Findent_to (make_int (16), make_int (3), buffer);
4149 if (keymapp) 3937 if (keymapp)
4150 buffer_insert_c_string (XBUFFER (buffer), "<< "); 3938 buffer_insert_ascstring (XBUFFER (buffer), "<< ");
4151 3939
4152 if (SYMBOLP (definition)) 3940 if (SYMBOLP (definition))
4153 { 3941 {
4154 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (definition)); 3942 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (definition));
4155 } 3943 }
4156 else if (STRINGP (definition) || VECTORP (definition)) 3944 else if (STRINGP (definition) || VECTORP (definition))
4157 { 3945 {
4158 buffer_insert_c_string (XBUFFER (buffer), "Kbd Macro: "); 3946 buffer_insert_ascstring (XBUFFER (buffer), "Kbd Macro: ");
4159 buffer_insert1 (XBUFFER (buffer), Fkey_description (definition)); 3947 buffer_insert1 (XBUFFER (buffer), Fkey_description (definition));
4160 } 3948 }
4161 else if (COMPILED_FUNCTIONP (definition)) 3949 else if (COMPILED_FUNCTIONP (definition))
4162 buffer_insert_c_string (XBUFFER (buffer), "Anonymous Compiled Function"); 3950 buffer_insert_ascstring (XBUFFER (buffer), "Anonymous Compiled Function");
4163 else if (CONSP (definition) && EQ (XCAR (definition), Qlambda)) 3951 else if (CONSP (definition) && EQ (XCAR (definition), Qlambda))
4164 buffer_insert_c_string (XBUFFER (buffer), "Anonymous Lambda"); 3952 buffer_insert_ascstring (XBUFFER (buffer), "Anonymous Lambda");
4165 else if (KEYMAPP (definition)) 3953 else if (KEYMAPP (definition))
4166 { 3954 {
4167 Lisp_Object name = XKEYMAP (definition)->name; 3955 Lisp_Object name = XKEYMAP (definition)->name;
4168 if (STRINGP (name) || (SYMBOLP (name) && !NILP (name))) 3956 if (STRINGP (name) || (SYMBOLP (name) && !NILP (name)))
4169 { 3957 {
4170 buffer_insert_c_string (XBUFFER (buffer), "Prefix command "); 3958 buffer_insert_ascstring (XBUFFER (buffer), "Prefix command ");
4171 if (SYMBOLP (name) 3959 if (SYMBOLP (name)
4172 && EQ (find_symbol_value (name), definition)) 3960 && EQ (find_symbol_value (name), definition))
4173 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (name)); 3961 buffer_insert1 (XBUFFER (buffer), Fsymbol_name (name));
4174 else 3962 else
4175 { 3963 {
4176 buffer_insert1 (XBUFFER (buffer), Fprin1_to_string (name, Qnil)); 3964 buffer_insert1 (XBUFFER (buffer), Fprin1_to_string (name, Qnil));
4177 } 3965 }
4178 } 3966 }
4179 else 3967 else
4180 buffer_insert_c_string (XBUFFER (buffer), "Prefix Command"); 3968 buffer_insert_ascstring (XBUFFER (buffer), "Prefix Command");
4181 } 3969 }
4182 else 3970 else
4183 buffer_insert_c_string (XBUFFER (buffer), "??"); 3971 buffer_insert_ascstring (XBUFFER (buffer), "??");
4184 3972
4185 if (keymapp) 3973 if (keymapp)
4186 buffer_insert_c_string (XBUFFER (buffer), " >>"); 3974 buffer_insert_ascstring (XBUFFER (buffer), " >>");
4187 buffer_insert_c_string (XBUFFER (buffer), "\n"); 3975 buffer_insert_ascstring (XBUFFER (buffer), "\n");
4188 UNGCPRO; 3976 UNGCPRO;
4189 } 3977 }
4190 3978
4191 struct describe_map_closure 3979 struct describe_map_closure
4192 { 3980 {
4247 return; 4035 return;
4248 4036
4249 /* If we're only supposed to display mouse bindings and this isn't one, 4037 /* If we're only supposed to display mouse bindings and this isn't one,
4250 then bug out. */ 4038 then bug out. */
4251 if (closure->mice_only_p && 4039 if (closure->mice_only_p &&
4252 (! (EQ (keysym, Qbutton0) || 4040 (! (
4253 EQ (keysym, Qbutton1) || 4041 #define INCLUDE_BUTTON_ZERO
4254 EQ (keysym, Qbutton2) || 4042 #define FROB(num) EQ (keysym, Qbutton##num) || \
4255 EQ (keysym, Qbutton3) || 4043 EQ (keysym, Qbutton##num##up) ||
4256 EQ (keysym, Qbutton4) || 4044 #include "keymap-buttons.h"
4257 EQ (keysym, Qbutton5) || 4045 0)))
4258 EQ (keysym, Qbutton6) ||
4259 EQ (keysym, Qbutton7) ||
4260 EQ (keysym, Qbutton8) ||
4261 EQ (keysym, Qbutton9) ||
4262 EQ (keysym, Qbutton10) ||
4263 EQ (keysym, Qbutton11) ||
4264 EQ (keysym, Qbutton12) ||
4265 EQ (keysym, Qbutton13) ||
4266 EQ (keysym, Qbutton14) ||
4267 EQ (keysym, Qbutton15) ||
4268 EQ (keysym, Qbutton16) ||
4269 EQ (keysym, Qbutton17) ||
4270 EQ (keysym, Qbutton18) ||
4271 EQ (keysym, Qbutton19) ||
4272 EQ (keysym, Qbutton20) ||
4273 EQ (keysym, Qbutton21) ||
4274 EQ (keysym, Qbutton22) ||
4275 EQ (keysym, Qbutton23) ||
4276 EQ (keysym, Qbutton24) ||
4277 EQ (keysym, Qbutton25) ||
4278 EQ (keysym, Qbutton26) ||
4279 EQ (keysym, Qbutton0up) ||
4280 EQ (keysym, Qbutton1up) ||
4281 EQ (keysym, Qbutton2up) ||
4282 EQ (keysym, Qbutton3up) ||
4283 EQ (keysym, Qbutton4up) ||
4284 EQ (keysym, Qbutton5up) ||
4285 EQ (keysym, Qbutton6up) ||
4286 EQ (keysym, Qbutton7up) ||
4287 EQ (keysym, Qbutton8up) ||
4288 EQ (keysym, Qbutton9up) ||
4289 EQ (keysym, Qbutton10up) ||
4290 EQ (keysym, Qbutton11up) ||
4291 EQ (keysym, Qbutton12up) ||
4292 EQ (keysym, Qbutton13up) ||
4293 EQ (keysym, Qbutton14up) ||
4294 EQ (keysym, Qbutton15up) ||
4295 EQ (keysym, Qbutton16up) ||
4296 EQ (keysym, Qbutton17up) ||
4297 EQ (keysym, Qbutton18up) ||
4298 EQ (keysym, Qbutton19up) ||
4299 EQ (keysym, Qbutton20up) ||
4300 EQ (keysym, Qbutton21up) ||
4301 EQ (keysym, Qbutton22up) ||
4302 EQ (keysym, Qbutton23up) ||
4303 EQ (keysym, Qbutton24up) ||
4304 EQ (keysym, Qbutton25up) ||
4305 EQ (keysym, Qbutton26up))))
4306 return; 4046 return;
4307 4047
4308 /* If this command in this map is shadowed by some other map, ignore it. */ 4048 /* If this command in this map is shadowed by some other map, ignore it. */
4309 { 4049 {
4310 Lisp_Object tail; 4050 Lisp_Object tail;
4465 describe_map_parent_mapper, &describe_map_closure); 4205 describe_map_parent_mapper, &describe_map_closure);
4466 4206
4467 if (!NILP (list)) 4207 if (!NILP (list))
4468 { 4208 {
4469 list = list_sort (list, Qnil, describe_map_sort_predicate); 4209 list = list_sort (list, Qnil, describe_map_sort_predicate);
4470 buffer_insert_c_string (buf, "\n"); 4210 buffer_insert_ascstring (buf, "\n");
4471 while (!NILP (list)) 4211 while (!NILP (list))
4472 { 4212 {
4473 Lisp_Object elt = XCAR (XCAR (list)); 4213 Lisp_Object elt = XCAR (XCAR (list));
4474 Lisp_Object keysym = XCAR (elt); 4214 Lisp_Object keysym = XCAR (elt);
4475 int modifiers = XINT (XCDR (elt)); 4215 int modifiers = XINT (XCDR (elt));
4476 4216
4477 if (!NILP (elt_prefix)) 4217 if (!NILP (elt_prefix))
4478 buffer_insert_lisp_string (buf, elt_prefix); 4218 buffer_insert_lisp_string (buf, elt_prefix);
4479 4219
4480 if (modifiers & XEMACS_MOD_META) 4220 if (modifiers & XEMACS_MOD_META)
4481 buffer_insert_c_string (buf, "M-"); 4221 buffer_insert_ascstring (buf, "M-");
4482 if (modifiers & XEMACS_MOD_CONTROL) 4222 if (modifiers & XEMACS_MOD_CONTROL)
4483 buffer_insert_c_string (buf, "C-"); 4223 buffer_insert_ascstring (buf, "C-");
4484 if (modifiers & XEMACS_MOD_SUPER) 4224 if (modifiers & XEMACS_MOD_SUPER)
4485 buffer_insert_c_string (buf, "S-"); 4225 buffer_insert_ascstring (buf, "S-");
4486 if (modifiers & XEMACS_MOD_HYPER) 4226 if (modifiers & XEMACS_MOD_HYPER)
4487 buffer_insert_c_string (buf, "H-"); 4227 buffer_insert_ascstring (buf, "H-");
4488 if (modifiers & XEMACS_MOD_ALT) 4228 if (modifiers & XEMACS_MOD_ALT)
4489 buffer_insert_c_string (buf, "Alt-"); 4229 buffer_insert_ascstring (buf, "Alt-");
4490 if (modifiers & XEMACS_MOD_SHIFT) 4230 if (modifiers & XEMACS_MOD_SHIFT)
4491 buffer_insert_c_string (buf, "Sh-"); 4231 buffer_insert_ascstring (buf, "Sh-");
4492 if (SYMBOLP (keysym)) 4232 if (SYMBOLP (keysym))
4493 { 4233 {
4494 Lisp_Object code = Fget (keysym, Qcharacter_of_keysym, Qnil); 4234 Lisp_Object code = Fget (keysym, Qcharacter_of_keysym, Qnil);
4495 Ichar c = (CHAR_OR_CHAR_INTP (code) 4235 Ichar c = (CHAR_OR_CHAR_INTP (code)
4496 ? XCHAR_OR_CHAR_INT (code) : (Ichar) -1); 4236 ? XCHAR_OR_CHAR_INT (code) : (Ichar) -1);
4497 /* Calling Fsingle_key_description() would cons more */ 4237 /* Calling Fsingle_key_description() would cons more */
4498 #if 0 /* This is bogus */ 4238 #if 0 /* This is bogus */
4499 if (EQ (keysym, QKlinefeed)) 4239 if (EQ (keysym, QKlinefeed))
4500 buffer_insert_c_string (buf, "LFD"); 4240 buffer_insert_ascstring (buf, "LFD");
4501 else if (EQ (keysym, QKtab)) 4241 else if (EQ (keysym, QKtab))
4502 buffer_insert_c_string (buf, "TAB"); 4242 buffer_insert_ascstring (buf, "TAB");
4503 else if (EQ (keysym, QKreturn)) 4243 else if (EQ (keysym, QKreturn))
4504 buffer_insert_c_string (buf, "RET"); 4244 buffer_insert_ascstring (buf, "RET");
4505 else if (EQ (keysym, QKescape)) 4245 else if (EQ (keysym, QKescape))
4506 buffer_insert_c_string (buf, "ESC"); 4246 buffer_insert_ascstring (buf, "ESC");
4507 else if (EQ (keysym, QKdelete)) 4247 else if (EQ (keysym, QKdelete))
4508 buffer_insert_c_string (buf, "DEL"); 4248 buffer_insert_ascstring (buf, "DEL");
4509 else if (EQ (keysym, QKspace)) 4249 else if (EQ (keysym, QKspace))
4510 buffer_insert_c_string (buf, "SPC"); 4250 buffer_insert_ascstring (buf, "SPC");
4511 else if (EQ (keysym, QKbackspace)) 4251 else if (EQ (keysym, QKbackspace))
4512 buffer_insert_c_string (buf, "BS"); 4252 buffer_insert_ascstring (buf, "BS");
4513 else 4253 else
4514 #endif 4254 #endif
4515 if (c >= printable_min) 4255 if (c >= printable_min)
4516 buffer_insert_emacs_char (buf, c); 4256 buffer_insert_emacs_char (buf, c);
4517 else buffer_insert1 (buf, Fsymbol_name (keysym)); 4257 else buffer_insert1 (buf, Fsymbol_name (keysym));
4518 } 4258 }
4519 else if (CHARP (keysym)) 4259 else if (CHARP (keysym))
4520 buffer_insert_emacs_char (buf, XCHAR (keysym)); 4260 buffer_insert_emacs_char (buf, XCHAR (keysym));
4521 else 4261 else
4522 buffer_insert_c_string (buf, "---bad keysym---"); 4262 buffer_insert_ascstring (buf, "---bad keysym---");
4523 4263
4524 if (elided) 4264 if (elided)
4525 elided = 0; 4265 elided = 0;
4526 else 4266 else
4527 { 4267 {
4533 list = XCDR (list); 4273 list = XCDR (list);
4534 } 4274 }
4535 if (k != 0) 4275 if (k != 0)
4536 { 4276 {
4537 if (k == 1) 4277 if (k == 1)
4538 buffer_insert_c_string (buf, ", "); 4278 buffer_insert_ascstring (buf, ", ");
4539 else 4279 else
4540 buffer_insert_c_string (buf, " .. "); 4280 buffer_insert_ascstring (buf, " .. ");
4541 elided = 1; 4281 elided = 1;
4542 continue; 4282 continue;
4543 } 4283 }
4544 } 4284 }
4545 4285
4604 DEFSYMBOL (Qmeta); 4344 DEFSYMBOL (Qmeta);
4605 DEFSYMBOL (Qsuper); 4345 DEFSYMBOL (Qsuper);
4606 DEFSYMBOL (Qhyper); 4346 DEFSYMBOL (Qhyper);
4607 DEFSYMBOL (Qalt); 4347 DEFSYMBOL (Qalt);
4608 DEFSYMBOL (Qshift); 4348 DEFSYMBOL (Qshift);
4609 DEFSYMBOL (Qbutton0); 4349 #define INCLUDE_BUTTON_ZERO
4610 DEFSYMBOL (Qbutton1); 4350 #define FROB(num) \
4611 DEFSYMBOL (Qbutton2); 4351 DEFSYMBOL (Qbutton##num); \
4612 DEFSYMBOL (Qbutton3); 4352 DEFSYMBOL (Qbutton##num##up);
4613 DEFSYMBOL (Qbutton4); 4353 #include "keymap-buttons.h"
4614 DEFSYMBOL (Qbutton5); 4354 #define FROB(num) \
4615 DEFSYMBOL (Qbutton6); 4355 DEFSYMBOL (Qmouse_##num); \
4616 DEFSYMBOL (Qbutton7); 4356 DEFSYMBOL (Qdown_mouse_##num);
4617 DEFSYMBOL (Qbutton8); 4357 #include "keymap-buttons.h"
4618 DEFSYMBOL (Qbutton9);
4619 DEFSYMBOL (Qbutton10);
4620 DEFSYMBOL (Qbutton11);
4621 DEFSYMBOL (Qbutton12);
4622 DEFSYMBOL (Qbutton13);
4623 DEFSYMBOL (Qbutton14);
4624 DEFSYMBOL (Qbutton15);
4625 DEFSYMBOL (Qbutton16);
4626 DEFSYMBOL (Qbutton17);
4627 DEFSYMBOL (Qbutton18);
4628 DEFSYMBOL (Qbutton19);
4629 DEFSYMBOL (Qbutton20);
4630 DEFSYMBOL (Qbutton21);
4631 DEFSYMBOL (Qbutton22);
4632 DEFSYMBOL (Qbutton23);
4633 DEFSYMBOL (Qbutton24);
4634 DEFSYMBOL (Qbutton25);
4635 DEFSYMBOL (Qbutton26);
4636 DEFSYMBOL (Qbutton0up);
4637 DEFSYMBOL (Qbutton1up);
4638 DEFSYMBOL (Qbutton2up);
4639 DEFSYMBOL (Qbutton3up);
4640 DEFSYMBOL (Qbutton4up);
4641 DEFSYMBOL (Qbutton5up);
4642 DEFSYMBOL (Qbutton6up);
4643 DEFSYMBOL (Qbutton7up);
4644 DEFSYMBOL (Qbutton8up);
4645 DEFSYMBOL (Qbutton9up);
4646 DEFSYMBOL (Qbutton10up);
4647 DEFSYMBOL (Qbutton11up);
4648 DEFSYMBOL (Qbutton12up);
4649 DEFSYMBOL (Qbutton13up);
4650 DEFSYMBOL (Qbutton14up);
4651 DEFSYMBOL (Qbutton15up);
4652 DEFSYMBOL (Qbutton16up);
4653 DEFSYMBOL (Qbutton17up);
4654 DEFSYMBOL (Qbutton18up);
4655 DEFSYMBOL (Qbutton19up);
4656 DEFSYMBOL (Qbutton20up);
4657 DEFSYMBOL (Qbutton21up);
4658 DEFSYMBOL (Qbutton22up);
4659 DEFSYMBOL (Qbutton23up);
4660 DEFSYMBOL (Qbutton24up);
4661 DEFSYMBOL (Qbutton25up);
4662 DEFSYMBOL (Qbutton26up);
4663 DEFSYMBOL (Qmouse_1);
4664 DEFSYMBOL (Qmouse_2);
4665 DEFSYMBOL (Qmouse_3);
4666 DEFSYMBOL (Qmouse_4);
4667 DEFSYMBOL (Qmouse_5);
4668 DEFSYMBOL (Qmouse_6);
4669 DEFSYMBOL (Qmouse_7);
4670 DEFSYMBOL (Qmouse_8);
4671 DEFSYMBOL (Qmouse_9);
4672 DEFSYMBOL (Qmouse_10);
4673 DEFSYMBOL (Qmouse_11);
4674 DEFSYMBOL (Qmouse_12);
4675 DEFSYMBOL (Qmouse_13);
4676 DEFSYMBOL (Qmouse_14);
4677 DEFSYMBOL (Qmouse_15);
4678 DEFSYMBOL (Qmouse_16);
4679 DEFSYMBOL (Qmouse_17);
4680 DEFSYMBOL (Qmouse_18);
4681 DEFSYMBOL (Qmouse_19);
4682 DEFSYMBOL (Qmouse_20);
4683 DEFSYMBOL (Qmouse_21);
4684 DEFSYMBOL (Qmouse_22);
4685 DEFSYMBOL (Qmouse_23);
4686 DEFSYMBOL (Qmouse_24);
4687 DEFSYMBOL (Qmouse_25);
4688 DEFSYMBOL (Qmouse_26);
4689 DEFSYMBOL (Qdown_mouse_1);
4690 DEFSYMBOL (Qdown_mouse_2);
4691 DEFSYMBOL (Qdown_mouse_3);
4692 DEFSYMBOL (Qdown_mouse_4);
4693 DEFSYMBOL (Qdown_mouse_5);
4694 DEFSYMBOL (Qdown_mouse_6);
4695 DEFSYMBOL (Qdown_mouse_7);
4696 DEFSYMBOL (Qdown_mouse_8);
4697 DEFSYMBOL (Qdown_mouse_9);
4698 DEFSYMBOL (Qdown_mouse_10);
4699 DEFSYMBOL (Qdown_mouse_11);
4700 DEFSYMBOL (Qdown_mouse_12);
4701 DEFSYMBOL (Qdown_mouse_13);
4702 DEFSYMBOL (Qdown_mouse_14);
4703 DEFSYMBOL (Qdown_mouse_15);
4704 DEFSYMBOL (Qdown_mouse_16);
4705 DEFSYMBOL (Qdown_mouse_17);
4706 DEFSYMBOL (Qdown_mouse_18);
4707 DEFSYMBOL (Qdown_mouse_19);
4708 DEFSYMBOL (Qdown_mouse_20);
4709 DEFSYMBOL (Qdown_mouse_21);
4710 DEFSYMBOL (Qdown_mouse_22);
4711 DEFSYMBOL (Qdown_mouse_23);
4712 DEFSYMBOL (Qdown_mouse_24);
4713 DEFSYMBOL (Qdown_mouse_25);
4714 DEFSYMBOL (Qdown_mouse_26);
4715 DEFSYMBOL (Qmenu_selection); 4358 DEFSYMBOL (Qmenu_selection);
4716 DEFSYMBOL (QLFD); 4359 DEFSYMBOL (QLFD);
4717 DEFSYMBOL (QTAB); 4360 DEFSYMBOL (QTAB);
4718 DEFSYMBOL (QRET); 4361 DEFSYMBOL (QRET);
4719 DEFSYMBOL (QESC); 4362 DEFSYMBOL (QESC);