* lisp/emacs-lisp/easy-mmode.el (define-minor-mode): Use mode function
[emacs.git] / src / keymap.c
blobf4dd644aebd3f246834f111cfe63b1429537a529
1 /* Manipulation of keymaps
2 Copyright (C) 1985-1988, 1993-1995, 1998-2014 Free Software
3 Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* Old BUGS:
21 - [M-C-a] != [?\M-\C-a]
22 - [M-f2] != [?\e f2].
23 - (define-key map [menu-bar foo] <bla>) does not always place <bla>
24 at the head of the menu (if `foo' was already bound earlier and
25 then unbound, for example).
26 TODO:
27 - allow many more Meta -> ESC mappings (like Hyper -> C-e for Emacspeak)
28 - Think about the various defaulting that's currently hard-coded in
29 keyboard.c (uppercase->lowercase, char->charset, button-events, ...)
30 and make it more generic. Maybe we should allow mappings of the
31 form (PREDICATE . BINDING) as generalization of the default binding,
32 tho probably a cleaner way to attack this is to allow functional
33 keymaps (i.e. keymaps that are implemented as functions that implement
34 a few different methods like `lookup', `map', ...).
35 - Make [a] equivalent to [?a].
36 BEWARE:
37 - map-keymap should work meaningfully even if entries are added/removed
38 to the keymap while iterating through it:
39 start - removed <= visited <= start + added
42 #include <config.h>
43 #include <stdio.h>
45 #include "lisp.h"
46 #include "commands.h"
47 #include "character.h"
48 #include "buffer.h"
49 #include "charset.h"
50 #include "keyboard.h"
51 #include "frame.h"
52 #include "termhooks.h"
53 #include "blockinput.h"
54 #include "puresize.h"
55 #include "intervals.h"
56 #include "keymap.h"
57 #include "window.h"
59 /* Actually allocate storage for these variables. */
61 Lisp_Object current_global_map; /* Current global keymap. */
63 Lisp_Object global_map; /* Default global key bindings. */
65 Lisp_Object meta_map; /* The keymap used for globally bound
66 ESC-prefixed default commands. */
68 Lisp_Object control_x_map; /* The keymap used for globally bound
69 C-x-prefixed default commands. */
71 /* The keymap used by the minibuf for local
72 bindings when spaces are allowed in the
73 minibuf. */
75 /* The keymap used by the minibuf for local
76 bindings when spaces are not encouraged
77 in the minibuf. */
79 /* Keymap used for minibuffers when doing completion. */
80 /* Keymap used for minibuffers when doing completion and require a match. */
81 static Lisp_Object Qkeymapp, Qnon_ascii;
82 Lisp_Object Qkeymap, Qmenu_item, Qremap;
83 static Lisp_Object QCadvertised_binding;
85 /* Alist of elements like (DEL . "\d"). */
86 static Lisp_Object exclude_keys;
88 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
89 static Lisp_Object command_remapping_vector;
91 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
92 static Lisp_Object where_is_cache;
93 /* Which keymaps are reverse-stored in the cache. */
94 static Lisp_Object where_is_cache_keymaps;
96 static Lisp_Object store_in_keymap (Lisp_Object, Lisp_Object, Lisp_Object);
98 static Lisp_Object define_as_prefix (Lisp_Object, Lisp_Object);
99 static void describe_command (Lisp_Object, Lisp_Object);
100 static void describe_translation (Lisp_Object, Lisp_Object);
101 static void describe_map (Lisp_Object, Lisp_Object,
102 void (*) (Lisp_Object, Lisp_Object),
103 bool, Lisp_Object, Lisp_Object*, bool, bool);
104 static void describe_vector (Lisp_Object, Lisp_Object, Lisp_Object,
105 void (*) (Lisp_Object, Lisp_Object), bool,
106 Lisp_Object, Lisp_Object, bool, bool);
107 static void silly_event_symbol_error (Lisp_Object);
108 static Lisp_Object get_keyelt (Lisp_Object, bool);
110 static void
111 CHECK_VECTOR_OR_CHAR_TABLE (Lisp_Object x)
113 CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x);
116 /* Keymap object support - constructors and predicates. */
118 DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0,
119 doc: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
120 CHARTABLE is a char-table that holds the bindings for all characters
121 without modifiers. All entries in it are initially nil, meaning
122 "command undefined". ALIST is an assoc-list which holds bindings for
123 function keys, mouse events, and any other things that appear in the
124 input stream. Initially, ALIST is nil.
126 The optional arg STRING supplies a menu name for the keymap
127 in case you use it as a menu with `x-popup-menu'. */)
128 (Lisp_Object string)
130 Lisp_Object tail;
131 if (!NILP (string))
132 tail = list1 (string);
133 else
134 tail = Qnil;
135 return Fcons (Qkeymap,
136 Fcons (Fmake_char_table (Qkeymap, Qnil), tail));
139 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
140 doc: /* Construct and return a new sparse keymap.
141 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
142 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
143 which binds the function key or mouse event SYMBOL to DEFINITION.
144 Initially the alist is nil.
146 The optional arg STRING supplies a menu name for the keymap
147 in case you use it as a menu with `x-popup-menu'. */)
148 (Lisp_Object string)
150 if (!NILP (string))
152 if (!NILP (Vpurify_flag))
153 string = Fpurecopy (string);
154 return list2 (Qkeymap, string);
156 return list1 (Qkeymap);
159 /* This function is used for installing the standard key bindings
160 at initialization time.
162 For example:
164 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
166 void
167 initial_define_key (Lisp_Object keymap, int key, const char *defname)
169 store_in_keymap (keymap, make_number (key), intern_c_string (defname));
172 void
173 initial_define_lispy_key (Lisp_Object keymap, const char *keyname, const char *defname)
175 store_in_keymap (keymap, intern_c_string (keyname), intern_c_string (defname));
178 DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0,
179 doc: /* Return t if OBJECT is a keymap.
181 A keymap is a list (keymap . ALIST),
182 or a symbol whose function definition is itself a keymap.
183 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
184 a vector of densely packed bindings for small character codes
185 is also allowed as an element. */)
186 (Lisp_Object object)
188 return (KEYMAPP (object) ? Qt : Qnil);
191 DEFUN ("keymap-prompt", Fkeymap_prompt, Skeymap_prompt, 1, 1, 0,
192 doc: /* Return the prompt-string of a keymap MAP.
193 If non-nil, the prompt is shown in the echo-area
194 when reading a key-sequence to be looked-up in this keymap. */)
195 (Lisp_Object map)
197 map = get_keymap (map, 0, 0);
198 while (CONSP (map))
200 Lisp_Object tem = XCAR (map);
201 if (STRINGP (tem))
202 return tem;
203 else if (KEYMAPP (tem))
205 tem = Fkeymap_prompt (tem);
206 if (!NILP (tem))
207 return tem;
209 map = XCDR (map);
211 return Qnil;
214 /* Check that OBJECT is a keymap (after dereferencing through any
215 symbols). If it is, return it.
217 If AUTOLOAD and if OBJECT is a symbol whose function value
218 is an autoload form, do the autoload and try again.
219 If AUTOLOAD, callers must assume GC is possible.
221 ERROR_IF_NOT_KEYMAP controls how we respond if OBJECT isn't a keymap.
222 If ERROR_IF_NOT_KEYMAP, signal an error; otherwise,
223 just return Qnil.
225 Note that most of the time, we don't want to pursue autoloads.
226 Functions like Faccessible_keymaps which scan entire keymap trees
227 shouldn't load every autoloaded keymap. I'm not sure about this,
228 but it seems to me that only read_key_sequence, Flookup_key, and
229 Fdefine_key should cause keymaps to be autoloaded.
231 This function can GC when AUTOLOAD is true, because it calls
232 Fautoload_do_load which can GC. */
234 Lisp_Object
235 get_keymap (Lisp_Object object, bool error_if_not_keymap, bool autoload)
237 Lisp_Object tem;
239 autoload_retry:
240 if (NILP (object))
241 goto end;
242 if (CONSP (object) && EQ (XCAR (object), Qkeymap))
243 return object;
245 tem = indirect_function (object);
246 if (CONSP (tem))
248 if (EQ (XCAR (tem), Qkeymap))
249 return tem;
251 /* Should we do an autoload? Autoload forms for keymaps have
252 Qkeymap as their fifth element. */
253 if ((autoload || !error_if_not_keymap) && EQ (XCAR (tem), Qautoload)
254 && SYMBOLP (object))
256 Lisp_Object tail;
258 tail = Fnth (make_number (4), tem);
259 if (EQ (tail, Qkeymap))
261 if (autoload)
263 struct gcpro gcpro1, gcpro2;
265 GCPRO2 (tem, object);
266 Fautoload_do_load (tem, object, Qnil);
267 UNGCPRO;
269 goto autoload_retry;
271 else
272 return object;
277 end:
278 if (error_if_not_keymap)
279 wrong_type_argument (Qkeymapp, object);
280 return Qnil;
283 /* Return the parent map of KEYMAP, or nil if it has none.
284 We assume that KEYMAP is a valid keymap. */
286 static Lisp_Object
287 keymap_parent (Lisp_Object keymap, bool autoload)
289 Lisp_Object list;
291 keymap = get_keymap (keymap, 1, autoload);
293 /* Skip past the initial element `keymap'. */
294 list = XCDR (keymap);
295 for (; CONSP (list); list = XCDR (list))
297 /* See if there is another `keymap'. */
298 if (KEYMAPP (list))
299 return list;
302 return get_keymap (list, 0, autoload);
305 DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
306 doc: /* Return the parent keymap of KEYMAP.
307 If KEYMAP has no parent, return nil. */)
308 (Lisp_Object keymap)
310 return keymap_parent (keymap, 1);
313 /* Check whether MAP is one of MAPS parents. */
314 static bool
315 keymap_memberp (Lisp_Object map, Lisp_Object maps)
317 if (NILP (map)) return 0;
318 while (KEYMAPP (maps) && !EQ (map, maps))
319 maps = keymap_parent (maps, 0);
320 return (EQ (map, maps));
323 /* Set the parent keymap of MAP to PARENT. */
325 DEFUN ("set-keymap-parent", Fset_keymap_parent, Sset_keymap_parent, 2, 2, 0,
326 doc: /* Modify KEYMAP to set its parent map to PARENT.
327 Return PARENT. PARENT should be nil or another keymap. */)
328 (Lisp_Object keymap, Lisp_Object parent)
330 Lisp_Object list, prev;
331 struct gcpro gcpro1, gcpro2;
333 /* Flush any reverse-map cache. */
334 where_is_cache = Qnil; where_is_cache_keymaps = Qt;
336 GCPRO2 (keymap, parent);
337 keymap = get_keymap (keymap, 1, 1);
339 if (!NILP (parent))
341 parent = get_keymap (parent, 1, 0);
343 /* Check for cycles. */
344 if (keymap_memberp (keymap, parent))
345 error ("Cyclic keymap inheritance");
348 /* Skip past the initial element `keymap'. */
349 prev = keymap;
350 while (1)
352 list = XCDR (prev);
353 /* If there is a parent keymap here, replace it.
354 If we came to the end, add the parent in PREV. */
355 if (!CONSP (list) || KEYMAPP (list))
357 CHECK_IMPURE (prev);
358 XSETCDR (prev, parent);
359 RETURN_UNGCPRO (parent);
361 prev = list;
366 /* Look up IDX in MAP. IDX may be any sort of event.
367 Note that this does only one level of lookup; IDX must be a single
368 event, not a sequence.
370 MAP must be a keymap or a list of keymaps.
372 If T_OK, bindings for Qt are treated as default
373 bindings; any key left unmentioned by other tables and bindings is
374 given the binding of Qt.
376 If not T_OK, bindings for Qt are not treated specially.
378 If NOINHERIT, don't accept a subkeymap found in an inherited keymap.
380 Return Qunbound if no binding was found (and return Qnil if a nil
381 binding was found). */
383 static Lisp_Object
384 access_keymap_1 (Lisp_Object map, Lisp_Object idx,
385 bool t_ok, bool noinherit, bool autoload)
387 /* If idx is a list (some sort of mouse click, perhaps?),
388 the index we want to use is the car of the list, which
389 ought to be a symbol. */
390 idx = EVENT_HEAD (idx);
392 /* If idx is a symbol, it might have modifiers, which need to
393 be put in the canonical order. */
394 if (SYMBOLP (idx))
395 idx = reorder_modifiers (idx);
396 else if (INTEGERP (idx))
397 /* Clobber the high bits that can be present on a machine
398 with more than 24 bits of integer. */
399 XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
401 /* Handle the special meta -> esc mapping. */
402 if (INTEGERP (idx) && XFASTINT (idx) & meta_modifier)
404 /* See if there is a meta-map. If there's none, there is
405 no binding for IDX, unless a default binding exists in MAP. */
406 struct gcpro gcpro1;
407 Lisp_Object event_meta_binding, event_meta_map;
408 GCPRO1 (map);
409 /* A strange value in which Meta is set would cause
410 infinite recursion. Protect against that. */
411 if (XINT (meta_prefix_char) & CHAR_META)
412 meta_prefix_char = make_number (27);
413 event_meta_binding = access_keymap_1 (map, meta_prefix_char, t_ok,
414 noinherit, autoload);
415 event_meta_map = get_keymap (event_meta_binding, 0, autoload);
416 UNGCPRO;
417 if (CONSP (event_meta_map))
419 map = event_meta_map;
420 idx = make_number (XFASTINT (idx) & ~meta_modifier);
422 else if (t_ok)
423 /* Set IDX to t, so that we only find a default binding. */
424 idx = Qt;
425 else
426 /* An explicit nil binding, or no binding at all. */
427 return NILP (event_meta_binding) ? Qnil : Qunbound;
430 /* t_binding is where we put a default binding that applies,
431 to use in case we do not find a binding specifically
432 for this key sequence. */
434 Lisp_Object tail;
435 Lisp_Object t_binding = Qunbound;
436 Lisp_Object retval = Qunbound;
437 Lisp_Object retval_tail = Qnil;
438 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
440 GCPRO4 (tail, idx, t_binding, retval);
442 for (tail = (CONSP (map) && EQ (Qkeymap, XCAR (map))) ? XCDR (map) : map;
443 (CONSP (tail)
444 || (tail = get_keymap (tail, 0, autoload), CONSP (tail)));
445 tail = XCDR (tail))
447 /* Qunbound in VAL means we have found no binding. */
448 Lisp_Object val = Qunbound;
449 Lisp_Object binding = XCAR (tail);
450 Lisp_Object submap = get_keymap (binding, 0, autoload);
452 if (EQ (binding, Qkeymap))
454 if (noinherit || NILP (retval))
455 /* If NOINHERIT, stop here, the rest is inherited. */
456 break;
457 else if (!EQ (retval, Qunbound))
459 Lisp_Object parent_entry;
460 eassert (KEYMAPP (retval));
461 parent_entry
462 = get_keymap (access_keymap_1 (tail, idx,
463 t_ok, 0, autoload),
464 0, autoload);
465 if (KEYMAPP (parent_entry))
467 if (CONSP (retval_tail))
468 XSETCDR (retval_tail, parent_entry);
469 else
471 retval_tail = Fcons (retval, parent_entry);
472 retval = Fcons (Qkeymap, retval_tail);
475 break;
478 else if (CONSP (submap))
480 val = access_keymap_1 (submap, idx, t_ok, noinherit, autoload);
482 else if (CONSP (binding))
484 Lisp_Object key = XCAR (binding);
486 if (EQ (key, idx))
487 val = XCDR (binding);
488 else if (t_ok && EQ (key, Qt))
490 t_binding = XCDR (binding);
491 t_ok = 0;
494 else if (VECTORP (binding))
496 if (INTEGERP (idx) && XFASTINT (idx) < ASIZE (binding))
497 val = AREF (binding, XFASTINT (idx));
499 else if (CHAR_TABLE_P (binding))
501 /* Character codes with modifiers
502 are not included in a char-table.
503 All character codes without modifiers are included. */
504 if (INTEGERP (idx) && (XFASTINT (idx) & CHAR_MODIFIER_MASK) == 0)
506 val = Faref (binding, idx);
507 /* `nil' has a special meaning for char-tables, so
508 we use something else to record an explicitly
509 unbound entry. */
510 if (NILP (val))
511 val = Qunbound;
515 /* If we found a binding, clean it up and return it. */
516 if (!EQ (val, Qunbound))
518 if (EQ (val, Qt))
519 /* A Qt binding is just like an explicit nil binding
520 (i.e. it shadows any parent binding but not bindings in
521 keymaps of lower precedence). */
522 val = Qnil;
524 val = get_keyelt (val, autoload);
526 if (!KEYMAPP (val))
528 if (NILP (retval) || EQ (retval, Qunbound))
529 retval = val;
530 if (!NILP (val))
531 break; /* Shadows everything that follows. */
533 else if (NILP (retval) || EQ (retval, Qunbound))
534 retval = val;
535 else if (CONSP (retval_tail))
537 XSETCDR (retval_tail, list1 (val));
538 retval_tail = XCDR (retval_tail);
540 else
542 retval_tail = list1 (val);
543 retval = Fcons (Qkeymap, Fcons (retval, retval_tail));
546 QUIT;
548 UNGCPRO;
549 return EQ (Qunbound, retval) ? get_keyelt (t_binding, autoload) : retval;
553 Lisp_Object
554 access_keymap (Lisp_Object map, Lisp_Object idx,
555 bool t_ok, bool noinherit, bool autoload)
557 Lisp_Object val = access_keymap_1 (map, idx, t_ok, noinherit, autoload);
558 return EQ (val, Qunbound) ? Qnil : val;
561 static void
562 map_keymap_item (map_keymap_function_t fun, Lisp_Object args, Lisp_Object key, Lisp_Object val, void *data)
564 if (EQ (val, Qt))
565 val = Qnil;
566 (*fun) (key, val, args, data);
569 static void
570 map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
572 if (!NILP (val))
574 map_keymap_function_t fun
575 = (map_keymap_function_t) XSAVE_FUNCPOINTER (args, 0);
576 /* If the key is a range, make a copy since map_char_table modifies
577 it in place. */
578 if (CONSP (key))
579 key = Fcons (XCAR (key), XCDR (key));
580 map_keymap_item (fun, XSAVE_OBJECT (args, 2), key,
581 val, XSAVE_POINTER (args, 1));
585 /* Call FUN for every binding in MAP and stop at (and return) the parent.
586 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA). */
587 static Lisp_Object
588 map_keymap_internal (Lisp_Object map,
589 map_keymap_function_t fun,
590 Lisp_Object args,
591 void *data)
593 struct gcpro gcpro1, gcpro2, gcpro3;
594 Lisp_Object tail
595 = (CONSP (map) && EQ (Qkeymap, XCAR (map))) ? XCDR (map) : map;
597 GCPRO3 (map, args, tail);
598 for (; CONSP (tail) && !EQ (Qkeymap, XCAR (tail)); tail = XCDR (tail))
600 Lisp_Object binding = XCAR (tail);
602 if (KEYMAPP (binding)) /* An embedded parent. */
603 break;
604 else if (CONSP (binding))
605 map_keymap_item (fun, args, XCAR (binding), XCDR (binding), data);
606 else if (VECTORP (binding))
608 /* Loop over the char values represented in the vector. */
609 int len = ASIZE (binding);
610 int c;
611 for (c = 0; c < len; c++)
613 Lisp_Object character;
614 XSETFASTINT (character, c);
615 map_keymap_item (fun, args, character, AREF (binding, c), data);
618 else if (CHAR_TABLE_P (binding))
619 map_char_table (map_keymap_char_table_item, Qnil, binding,
620 make_save_funcptr_ptr_obj ((voidfuncptr) fun, data,
621 args));
623 UNGCPRO;
624 return tail;
627 static void
628 map_keymap_call (Lisp_Object key, Lisp_Object val, Lisp_Object fun, void *dummy)
630 call2 (fun, key, val);
633 /* Same as map_keymap_internal, but traverses parent keymaps as well.
634 AUTOLOAD indicates that autoloaded keymaps should be loaded. */
635 void
636 map_keymap (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args,
637 void *data, bool autoload)
639 struct gcpro gcpro1;
640 GCPRO1 (args);
641 map = get_keymap (map, 1, autoload);
642 while (CONSP (map))
644 if (KEYMAPP (XCAR (map)))
646 map_keymap (XCAR (map), fun, args, data, autoload);
647 map = XCDR (map);
649 else
650 map = map_keymap_internal (map, fun, args, data);
651 if (!CONSP (map))
652 map = get_keymap (map, 0, autoload);
654 UNGCPRO;
657 static Lisp_Object Qkeymap_canonicalize;
659 /* Same as map_keymap, but does it right, properly eliminating duplicate
660 bindings due to inheritance. */
661 void
662 map_keymap_canonical (Lisp_Object map, map_keymap_function_t fun, Lisp_Object args, void *data)
664 struct gcpro gcpro1;
665 GCPRO1 (args);
666 /* map_keymap_canonical may be used from redisplay (e.g. when building menus)
667 so be careful to ignore errors and to inhibit redisplay. */
668 map = safe_call1 (Qkeymap_canonicalize, map);
669 /* No need to use `map_keymap' here because canonical map has no parent. */
670 map_keymap_internal (map, fun, args, data);
671 UNGCPRO;
674 DEFUN ("map-keymap-internal", Fmap_keymap_internal, Smap_keymap_internal, 2, 2, 0,
675 doc: /* Call FUNCTION once for each event binding in KEYMAP.
676 FUNCTION is called with two arguments: the event that is bound, and
677 the definition it is bound to. The event may be a character range.
678 If KEYMAP has a parent, this function returns it without processing it. */)
679 (Lisp_Object function, Lisp_Object keymap)
681 struct gcpro gcpro1;
682 GCPRO1 (function);
683 keymap = get_keymap (keymap, 1, 1);
684 keymap = map_keymap_internal (keymap, map_keymap_call, function, NULL);
685 UNGCPRO;
686 return keymap;
689 DEFUN ("map-keymap", Fmap_keymap, Smap_keymap, 2, 3, 0,
690 doc: /* Call FUNCTION once for each event binding in KEYMAP.
691 FUNCTION is called with two arguments: the event that is bound, and
692 the definition it is bound to. The event may be a character range.
694 If KEYMAP has a parent, the parent's bindings are included as well.
695 This works recursively: if the parent has itself a parent, then the
696 grandparent's bindings are also included and so on.
697 usage: (map-keymap FUNCTION KEYMAP) */)
698 (Lisp_Object function, Lisp_Object keymap, Lisp_Object sort_first)
700 if (! NILP (sort_first))
701 return call2 (intern ("map-keymap-sorted"), function, keymap);
703 map_keymap (keymap, map_keymap_call, function, NULL, 1);
704 return Qnil;
707 /* Given OBJECT which was found in a slot in a keymap,
708 trace indirect definitions to get the actual definition of that slot.
709 An indirect definition is a list of the form
710 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
711 and INDEX is the object to look up in KEYMAP to yield the definition.
713 Also if OBJECT has a menu string as the first element,
714 remove that. Also remove a menu help string as second element.
716 If AUTOLOAD, load autoloadable keymaps
717 that are referred to with indirection.
719 This can GC because menu_item_eval_property calls Feval. */
721 static Lisp_Object
722 get_keyelt (Lisp_Object object, bool autoload)
724 while (1)
726 if (!(CONSP (object)))
727 /* This is really the value. */
728 return object;
730 /* If the keymap contents looks like (menu-item name . DEFN)
731 or (menu-item name DEFN ...) then use DEFN.
732 This is a new format menu item. */
733 else if (EQ (XCAR (object), Qmenu_item))
735 if (CONSP (XCDR (object)))
737 Lisp_Object tem;
739 object = XCDR (XCDR (object));
740 tem = object;
741 if (CONSP (object))
742 object = XCAR (object);
744 /* If there's a `:filter FILTER', apply FILTER to the
745 menu-item's definition to get the real definition to
746 use. */
747 for (; CONSP (tem) && CONSP (XCDR (tem)); tem = XCDR (tem))
748 if (EQ (XCAR (tem), QCfilter) && autoload)
750 Lisp_Object filter;
751 filter = XCAR (XCDR (tem));
752 filter = list2 (filter, list2 (Qquote, object));
753 object = menu_item_eval_property (filter);
754 break;
757 else
758 /* Invalid keymap. */
759 return object;
762 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
763 Keymap alist elements like (CHAR MENUSTRING . DEFN)
764 will be used by HierarKey menus. */
765 else if (STRINGP (XCAR (object)))
766 object = XCDR (object);
768 else
769 return object;
773 static Lisp_Object
774 store_in_keymap (Lisp_Object keymap, register Lisp_Object idx, Lisp_Object def)
776 /* Flush any reverse-map cache. */
777 where_is_cache = Qnil;
778 where_is_cache_keymaps = Qt;
780 if (EQ (idx, Qkeymap))
781 error ("`keymap' is reserved for embedded parent maps");
783 /* If we are preparing to dump, and DEF is a menu element
784 with a menu item indicator, copy it to ensure it is not pure. */
785 if (CONSP (def) && PURE_P (def)
786 && (EQ (XCAR (def), Qmenu_item) || STRINGP (XCAR (def))))
787 def = Fcons (XCAR (def), XCDR (def));
789 if (!CONSP (keymap) || !EQ (XCAR (keymap), Qkeymap))
790 error ("attempt to define a key in a non-keymap");
792 /* If idx is a cons, and the car part is a character, idx must be of
793 the form (FROM-CHAR . TO-CHAR). */
794 if (CONSP (idx) && CHARACTERP (XCAR (idx)))
795 CHECK_CHARACTER_CDR (idx);
796 else
797 /* If idx is a list (some sort of mouse click, perhaps?),
798 the index we want to use is the car of the list, which
799 ought to be a symbol. */
800 idx = EVENT_HEAD (idx);
802 /* If idx is a symbol, it might have modifiers, which need to
803 be put in the canonical order. */
804 if (SYMBOLP (idx))
805 idx = reorder_modifiers (idx);
806 else if (INTEGERP (idx))
807 /* Clobber the high bits that can be present on a machine
808 with more than 24 bits of integer. */
809 XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
811 /* Scan the keymap for a binding of idx. */
813 Lisp_Object tail;
815 /* The cons after which we should insert new bindings. If the
816 keymap has a table element, we record its position here, so new
817 bindings will go after it; this way, the table will stay
818 towards the front of the alist and character lookups in dense
819 keymaps will remain fast. Otherwise, this just points at the
820 front of the keymap. */
821 Lisp_Object insertion_point;
823 insertion_point = keymap;
824 for (tail = XCDR (keymap); CONSP (tail); tail = XCDR (tail))
826 Lisp_Object elt;
828 elt = XCAR (tail);
829 if (VECTORP (elt))
831 if (NATNUMP (idx) && XFASTINT (idx) < ASIZE (elt))
833 CHECK_IMPURE (elt);
834 ASET (elt, XFASTINT (idx), def);
835 return def;
837 else if (CONSP (idx) && CHARACTERP (XCAR (idx)))
839 int from = XFASTINT (XCAR (idx));
840 int to = XFASTINT (XCDR (idx));
842 if (to >= ASIZE (elt))
843 to = ASIZE (elt) - 1;
844 for (; from <= to; from++)
845 ASET (elt, from, def);
846 if (to == XFASTINT (XCDR (idx)))
847 /* We have defined all keys in IDX. */
848 return def;
850 insertion_point = tail;
852 else if (CHAR_TABLE_P (elt))
854 /* Character codes with modifiers
855 are not included in a char-table.
856 All character codes without modifiers are included. */
857 if (NATNUMP (idx) && !(XFASTINT (idx) & CHAR_MODIFIER_MASK))
859 Faset (elt, idx,
860 /* `nil' has a special meaning for char-tables, so
861 we use something else to record an explicitly
862 unbound entry. */
863 NILP (def) ? Qt : def);
864 return def;
866 else if (CONSP (idx) && CHARACTERP (XCAR (idx)))
868 Fset_char_table_range (elt, idx, NILP (def) ? Qt : def);
869 return def;
871 insertion_point = tail;
873 else if (CONSP (elt))
875 if (EQ (Qkeymap, XCAR (elt)))
876 { /* A sub keymap. This might be due to a lookup that found
877 two matching bindings (maybe because of a sub keymap).
878 It almost never happens (since the second binding normally
879 only happens in the inherited part of the keymap), but
880 if it does, we want to update the sub-keymap since the
881 main one might be temporary (built by access_keymap). */
882 tail = insertion_point = elt;
884 else if (EQ (idx, XCAR (elt)))
886 CHECK_IMPURE (elt);
887 XSETCDR (elt, def);
888 return def;
890 else if (CONSP (idx) && CHARACTERP (XCAR (idx)))
892 int from = XFASTINT (XCAR (idx));
893 int to = XFASTINT (XCDR (idx));
895 if (from <= XFASTINT (XCAR (elt))
896 && to >= XFASTINT (XCAR (elt)))
898 XSETCDR (elt, def);
899 if (from == to)
900 return def;
904 else if (EQ (elt, Qkeymap))
905 /* If we find a 'keymap' symbol in the spine of KEYMAP,
906 then we must have found the start of a second keymap
907 being used as the tail of KEYMAP, and a binding for IDX
908 should be inserted before it. */
909 goto keymap_end;
911 QUIT;
914 keymap_end:
915 /* We have scanned the entire keymap, and not found a binding for
916 IDX. Let's add one. */
918 Lisp_Object elt;
920 if (CONSP (idx) && CHARACTERP (XCAR (idx)))
922 /* IDX specifies a range of characters, and not all of them
923 were handled yet, which means this keymap doesn't have a
924 char-table. So, we insert a char-table now. */
925 elt = Fmake_char_table (Qkeymap, Qnil);
926 Fset_char_table_range (elt, idx, NILP (def) ? Qt : def);
928 else
929 elt = Fcons (idx, def);
930 CHECK_IMPURE (insertion_point);
931 XSETCDR (insertion_point, Fcons (elt, XCDR (insertion_point)));
935 return def;
938 static Lisp_Object
939 copy_keymap_item (Lisp_Object elt)
941 Lisp_Object res, tem;
943 if (!CONSP (elt))
944 return elt;
946 res = tem = elt;
948 /* Is this a new format menu item. */
949 if (EQ (XCAR (tem), Qmenu_item))
951 /* Copy cell with menu-item marker. */
952 res = elt = Fcons (XCAR (tem), XCDR (tem));
953 tem = XCDR (elt);
954 if (CONSP (tem))
956 /* Copy cell with menu-item name. */
957 XSETCDR (elt, Fcons (XCAR (tem), XCDR (tem)));
958 elt = XCDR (elt);
959 tem = XCDR (elt);
961 if (CONSP (tem))
963 /* Copy cell with binding and if the binding is a keymap,
964 copy that. */
965 XSETCDR (elt, Fcons (XCAR (tem), XCDR (tem)));
966 elt = XCDR (elt);
967 tem = XCAR (elt);
968 if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
969 XSETCAR (elt, Fcopy_keymap (tem));
970 tem = XCDR (elt);
973 else
975 /* It may be an old format menu item.
976 Skip the optional menu string. */
977 if (STRINGP (XCAR (tem)))
979 /* Copy the cell, since copy-alist didn't go this deep. */
980 res = elt = Fcons (XCAR (tem), XCDR (tem));
981 tem = XCDR (elt);
982 /* Also skip the optional menu help string. */
983 if (CONSP (tem) && STRINGP (XCAR (tem)))
985 XSETCDR (elt, Fcons (XCAR (tem), XCDR (tem)));
986 elt = XCDR (elt);
987 tem = XCDR (elt);
989 if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
990 XSETCDR (elt, Fcopy_keymap (tem));
992 else if (EQ (XCAR (tem), Qkeymap))
993 res = Fcopy_keymap (elt);
995 return res;
998 static void
999 copy_keymap_1 (Lisp_Object chartable, Lisp_Object idx, Lisp_Object elt)
1001 Fset_char_table_range (chartable, idx, copy_keymap_item (elt));
1004 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
1005 doc: /* Return a copy of the keymap KEYMAP.
1006 The copy starts out with the same definitions of KEYMAP,
1007 but changing either the copy or KEYMAP does not affect the other.
1008 Any key definitions that are subkeymaps are recursively copied.
1009 However, a key definition which is a symbol whose definition is a keymap
1010 is not copied. */)
1011 (Lisp_Object keymap)
1013 Lisp_Object copy, tail;
1014 keymap = get_keymap (keymap, 1, 0);
1015 copy = tail = list1 (Qkeymap);
1016 keymap = XCDR (keymap); /* Skip the `keymap' symbol. */
1018 while (CONSP (keymap) && !EQ (XCAR (keymap), Qkeymap))
1020 Lisp_Object elt = XCAR (keymap);
1021 if (CHAR_TABLE_P (elt))
1023 elt = Fcopy_sequence (elt);
1024 map_char_table (copy_keymap_1, Qnil, elt, elt);
1026 else if (VECTORP (elt))
1028 int i;
1029 elt = Fcopy_sequence (elt);
1030 for (i = 0; i < ASIZE (elt); i++)
1031 ASET (elt, i, copy_keymap_item (AREF (elt, i)));
1033 else if (CONSP (elt))
1035 if (EQ (XCAR (elt), Qkeymap))
1036 /* This is a sub keymap. */
1037 elt = Fcopy_keymap (elt);
1038 else
1039 elt = Fcons (XCAR (elt), copy_keymap_item (XCDR (elt)));
1041 XSETCDR (tail, list1 (elt));
1042 tail = XCDR (tail);
1043 keymap = XCDR (keymap);
1045 XSETCDR (tail, keymap);
1046 return copy;
1049 /* Simple Keymap mutators and accessors. */
1051 /* GC is possible in this function if it autoloads a keymap. */
1053 DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
1054 doc: /* In KEYMAP, define key sequence KEY as DEF.
1055 KEYMAP is a keymap.
1057 KEY is a string or a vector of symbols and characters, representing a
1058 sequence of keystrokes and events. Non-ASCII characters with codes
1059 above 127 (such as ISO Latin-1) can be represented by vectors.
1060 Two types of vector have special meanings:
1061 [remap COMMAND] remaps any key binding for COMMAND.
1062 [t] creates a default definition, which applies to any event with no
1063 other definition in KEYMAP.
1065 DEF is anything that can be a key's definition:
1066 nil (means key is undefined in this keymap),
1067 a command (a Lisp function suitable for interactive calling),
1068 a string (treated as a keyboard macro),
1069 a keymap (to define a prefix key),
1070 a symbol (when the key is looked up, the symbol will stand for its
1071 function definition, which should at that time be one of the above,
1072 or another symbol whose function definition is used, etc.),
1073 a cons (STRING . DEFN), meaning that DEFN is the definition
1074 (DEFN should be a valid definition in its own right),
1075 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
1076 or an extended menu item definition.
1077 (See info node `(elisp)Extended Menu Items'.)
1079 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1080 binding is altered. If there is no binding for KEY, the new pair
1081 binding KEY to DEF is added at the front of KEYMAP. */)
1082 (Lisp_Object keymap, Lisp_Object key, Lisp_Object def)
1084 ptrdiff_t idx;
1085 Lisp_Object c;
1086 Lisp_Object cmd;
1087 bool metized = 0;
1088 int meta_bit;
1089 ptrdiff_t length;
1090 struct gcpro gcpro1, gcpro2, gcpro3;
1092 GCPRO3 (keymap, key, def);
1093 keymap = get_keymap (keymap, 1, 1);
1095 length = CHECK_VECTOR_OR_STRING (key);
1096 if (length == 0)
1097 RETURN_UNGCPRO (Qnil);
1099 if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt))
1100 Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands);
1102 meta_bit = (VECTORP (key) || (STRINGP (key) && STRING_MULTIBYTE (key))
1103 ? meta_modifier : 0x80);
1105 if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, 0)))
1106 { /* DEF is apparently an XEmacs-style keyboard macro. */
1107 Lisp_Object tmp = Fmake_vector (make_number (ASIZE (def)), Qnil);
1108 ptrdiff_t i = ASIZE (def);
1109 while (--i >= 0)
1111 Lisp_Object defi = AREF (def, i);
1112 if (CONSP (defi) && lucid_event_type_list_p (defi))
1113 defi = Fevent_convert_list (defi);
1114 ASET (tmp, i, defi);
1116 def = tmp;
1119 idx = 0;
1120 while (1)
1122 c = Faref (key, make_number (idx));
1124 if (CONSP (c))
1126 /* C may be a Lucid style event type list or a cons (FROM .
1127 TO) specifying a range of characters. */
1128 if (lucid_event_type_list_p (c))
1129 c = Fevent_convert_list (c);
1130 else if (CHARACTERP (XCAR (c)))
1131 CHECK_CHARACTER_CDR (c);
1134 if (SYMBOLP (c))
1135 silly_event_symbol_error (c);
1137 if (INTEGERP (c)
1138 && (XINT (c) & meta_bit)
1139 && !metized)
1141 c = meta_prefix_char;
1142 metized = 1;
1144 else
1146 if (INTEGERP (c))
1147 XSETINT (c, XINT (c) & ~meta_bit);
1149 metized = 0;
1150 idx++;
1153 if (!INTEGERP (c) && !SYMBOLP (c)
1154 && (!CONSP (c)
1155 /* If C is a range, it must be a leaf. */
1156 || (INTEGERP (XCAR (c)) && idx != length)))
1157 message_with_string ("Key sequence contains invalid event %s", c, 1);
1159 if (idx == length)
1160 RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
1162 cmd = access_keymap (keymap, c, 0, 1, 1);
1164 /* If this key is undefined, make it a prefix. */
1165 if (NILP (cmd))
1166 cmd = define_as_prefix (keymap, c);
1168 keymap = get_keymap (cmd, 0, 1);
1169 if (!CONSP (keymap))
1171 const char *trailing_esc = ((EQ (c, meta_prefix_char) && metized)
1172 ? (idx == 0 ? "ESC" : " ESC")
1173 : "");
1175 /* We must use Fkey_description rather than just passing key to
1176 error; key might be a vector, not a string. */
1177 error ("Key sequence %s starts with non-prefix key %s%s",
1178 SDATA (Fkey_description (key, Qnil)),
1179 SDATA (Fkey_description (Fsubstring (key, make_number (0),
1180 make_number (idx)),
1181 Qnil)),
1182 trailing_esc);
1187 /* This function may GC (it calls Fkey_binding). */
1189 DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 3, 0,
1190 doc: /* Return the remapping for command COMMAND.
1191 Returns nil if COMMAND is not remapped (or not a symbol).
1193 If the optional argument POSITION is non-nil, it specifies a mouse
1194 position as returned by `event-start' and `event-end', and the
1195 remapping occurs in the keymaps associated with it. It can also be a
1196 number or marker, in which case the keymap properties at the specified
1197 buffer position instead of point are used. The KEYMAPS argument is
1198 ignored if POSITION is non-nil.
1200 If the optional argument KEYMAPS is non-nil, it should be a list of
1201 keymaps to search for command remapping. Otherwise, search for the
1202 remapping in all currently active keymaps. */)
1203 (Lisp_Object command, Lisp_Object position, Lisp_Object keymaps)
1205 if (!SYMBOLP (command))
1206 return Qnil;
1208 ASET (command_remapping_vector, 1, command);
1210 if (NILP (keymaps))
1211 command = Fkey_binding (command_remapping_vector, Qnil, Qt, position);
1212 else
1213 command = Flookup_key (Fcons (Qkeymap, keymaps),
1214 command_remapping_vector, Qnil);
1215 return INTEGERP (command) ? Qnil : command;
1218 /* Value is number if KEY is too long; nil if valid but has no definition. */
1219 /* GC is possible in this function. */
1221 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
1222 doc: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1223 A value of nil means undefined. See doc of `define-key'
1224 for kinds of definitions.
1226 A number as value means KEY is "too long";
1227 that is, characters or symbols in it except for the last one
1228 fail to be a valid sequence of prefix characters in KEYMAP.
1229 The number is how many characters at the front of KEY
1230 it takes to reach a non-prefix key.
1232 Normally, `lookup-key' ignores bindings for t, which act as default
1233 bindings, used when nothing else in the keymap applies; this makes it
1234 usable as a general function for probing keymaps. However, if the
1235 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1236 recognize the default bindings, just as `read-key-sequence' does. */)
1237 (Lisp_Object keymap, Lisp_Object key, Lisp_Object accept_default)
1239 ptrdiff_t idx;
1240 Lisp_Object cmd;
1241 Lisp_Object c;
1242 ptrdiff_t length;
1243 bool t_ok = !NILP (accept_default);
1244 struct gcpro gcpro1, gcpro2;
1246 GCPRO2 (keymap, key);
1247 keymap = get_keymap (keymap, 1, 1);
1249 length = CHECK_VECTOR_OR_STRING (key);
1250 if (length == 0)
1251 RETURN_UNGCPRO (keymap);
1253 idx = 0;
1254 while (1)
1256 c = Faref (key, make_number (idx++));
1258 if (CONSP (c) && lucid_event_type_list_p (c))
1259 c = Fevent_convert_list (c);
1261 /* Turn the 8th bit of string chars into a meta modifier. */
1262 if (STRINGP (key) && XINT (c) & 0x80 && !STRING_MULTIBYTE (key))
1263 XSETINT (c, (XINT (c) | meta_modifier) & ~0x80);
1265 /* Allow string since binding for `menu-bar-select-buffer'
1266 includes the buffer name in the key sequence. */
1267 if (!INTEGERP (c) && !SYMBOLP (c) && !CONSP (c) && !STRINGP (c))
1268 message_with_string ("Key sequence contains invalid event %s", c, 1);
1270 cmd = access_keymap (keymap, c, t_ok, 0, 1);
1271 if (idx == length)
1272 RETURN_UNGCPRO (cmd);
1274 keymap = get_keymap (cmd, 0, 1);
1275 if (!CONSP (keymap))
1276 RETURN_UNGCPRO (make_number (idx));
1278 QUIT;
1282 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1283 Assume that currently it does not define C at all.
1284 Return the keymap. */
1286 static Lisp_Object
1287 define_as_prefix (Lisp_Object keymap, Lisp_Object c)
1289 Lisp_Object cmd;
1291 cmd = Fmake_sparse_keymap (Qnil);
1292 store_in_keymap (keymap, c, cmd);
1294 return cmd;
1297 /* Append a key to the end of a key sequence. We always make a vector. */
1299 static Lisp_Object
1300 append_key (Lisp_Object key_sequence, Lisp_Object key)
1302 Lisp_Object args[2];
1304 args[0] = key_sequence;
1305 args[1] = list1 (key);
1306 return Fvconcat (2, args);
1309 /* Given a event type C which is a symbol,
1310 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1312 static void
1313 silly_event_symbol_error (Lisp_Object c)
1315 Lisp_Object parsed, base, name, assoc;
1316 int modifiers;
1318 parsed = parse_modifiers (c);
1319 modifiers = XFASTINT (XCAR (XCDR (parsed)));
1320 base = XCAR (parsed);
1321 name = Fsymbol_name (base);
1322 /* This alist includes elements such as ("RET" . "\\r"). */
1323 assoc = Fassoc (name, exclude_keys);
1325 if (! NILP (assoc))
1327 char new_mods[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1328 char *p = new_mods;
1329 Lisp_Object keystring;
1330 if (modifiers & alt_modifier)
1331 { *p++ = '\\'; *p++ = 'A'; *p++ = '-'; }
1332 if (modifiers & ctrl_modifier)
1333 { *p++ = '\\'; *p++ = 'C'; *p++ = '-'; }
1334 if (modifiers & hyper_modifier)
1335 { *p++ = '\\'; *p++ = 'H'; *p++ = '-'; }
1336 if (modifiers & meta_modifier)
1337 { *p++ = '\\'; *p++ = 'M'; *p++ = '-'; }
1338 if (modifiers & shift_modifier)
1339 { *p++ = '\\'; *p++ = 'S'; *p++ = '-'; }
1340 if (modifiers & super_modifier)
1341 { *p++ = '\\'; *p++ = 's'; *p++ = '-'; }
1342 *p = 0;
1344 c = reorder_modifiers (c);
1345 keystring = concat2 (build_string (new_mods), XCDR (assoc));
1347 error ("To bind the key %s, use [?%s], not [%s]",
1348 SDATA (SYMBOL_NAME (c)), SDATA (keystring),
1349 SDATA (SYMBOL_NAME (c)));
1353 /* Global, local, and minor mode keymap stuff. */
1355 /* We can't put these variables inside current_minor_maps, since under
1356 some systems, static gets macro-defined to be the empty string.
1357 Ickypoo. */
1358 static Lisp_Object *cmm_modes = NULL, *cmm_maps = NULL;
1359 static ptrdiff_t cmm_size = 0;
1361 /* Store a pointer to an array of the currently active minor modes in
1362 *modeptr, a pointer to an array of the keymaps of the currently
1363 active minor modes in *mapptr, and return the number of maps
1364 *mapptr contains.
1366 This function always returns a pointer to the same buffer, and may
1367 free or reallocate it, so if you want to keep it for a long time or
1368 hand it out to lisp code, copy it. This procedure will be called
1369 for every key sequence read, so the nice lispy approach (return a
1370 new assoclist, list, what have you) for each invocation would
1371 result in a lot of consing over time.
1373 If we used xrealloc/xmalloc and ran out of memory, they would throw
1374 back to the command loop, which would try to read a key sequence,
1375 which would call this function again, resulting in an infinite
1376 loop. Instead, we'll use realloc/malloc and silently truncate the
1377 list, let the key sequence be read, and hope some other piece of
1378 code signals the error. */
1379 ptrdiff_t
1380 current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
1382 ptrdiff_t i = 0;
1383 int list_number = 0;
1384 Lisp_Object alist, assoc, var, val;
1385 Lisp_Object emulation_alists;
1386 Lisp_Object lists[2];
1388 emulation_alists = Vemulation_mode_map_alists;
1389 lists[0] = Vminor_mode_overriding_map_alist;
1390 lists[1] = Vminor_mode_map_alist;
1392 for (list_number = 0; list_number < 2; list_number++)
1394 if (CONSP (emulation_alists))
1396 alist = XCAR (emulation_alists);
1397 emulation_alists = XCDR (emulation_alists);
1398 if (SYMBOLP (alist))
1399 alist = find_symbol_value (alist);
1400 list_number = -1;
1402 else
1403 alist = lists[list_number];
1405 for ( ; CONSP (alist); alist = XCDR (alist))
1406 if ((assoc = XCAR (alist), CONSP (assoc))
1407 && (var = XCAR (assoc), SYMBOLP (var))
1408 && (val = find_symbol_value (var), !EQ (val, Qunbound))
1409 && !NILP (val))
1411 Lisp_Object temp;
1413 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1414 and also an entry in Vminor_mode_map_alist,
1415 ignore the latter. */
1416 if (list_number == 1)
1418 val = assq_no_quit (var, lists[0]);
1419 if (!NILP (val))
1420 continue;
1423 if (i >= cmm_size)
1425 ptrdiff_t newsize, allocsize;
1426 Lisp_Object *newmodes, *newmaps;
1428 /* Check for size calculation overflow. Other code
1429 (e.g., read_key_sequence) adds 3 to the count
1430 later, so subtract 3 from the limit here. */
1431 if (min (PTRDIFF_MAX, SIZE_MAX) / (2 * sizeof *newmodes) - 3
1432 < cmm_size)
1433 break;
1435 newsize = cmm_size == 0 ? 30 : cmm_size * 2;
1436 allocsize = newsize * sizeof *newmodes;
1438 /* Use malloc here. See the comment above this function.
1439 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1440 block_input ();
1441 newmodes = malloc (allocsize);
1442 if (newmodes)
1444 if (cmm_modes)
1446 memcpy (newmodes, cmm_modes,
1447 cmm_size * sizeof cmm_modes[0]);
1448 free (cmm_modes);
1450 cmm_modes = newmodes;
1453 newmaps = malloc (allocsize);
1454 if (newmaps)
1456 if (cmm_maps)
1458 memcpy (newmaps, cmm_maps,
1459 cmm_size * sizeof cmm_maps[0]);
1460 free (cmm_maps);
1462 cmm_maps = newmaps;
1464 unblock_input ();
1466 if (newmodes == NULL || newmaps == NULL)
1467 break;
1468 cmm_size = newsize;
1471 /* Get the keymap definition--or nil if it is not defined. */
1472 temp = Findirect_function (XCDR (assoc), Qt);
1473 if (!NILP (temp))
1475 cmm_modes[i] = var;
1476 cmm_maps [i] = temp;
1477 i++;
1482 if (modeptr) *modeptr = cmm_modes;
1483 if (mapptr) *mapptr = cmm_maps;
1484 return i;
1487 /* Return the offset of POSITION, a click position, in the style of
1488 the respective argument of Fkey_binding. */
1489 static ptrdiff_t
1490 click_position (Lisp_Object position)
1492 EMACS_INT pos = (INTEGERP (position) ? XINT (position)
1493 : MARKERP (position) ? marker_position (position)
1494 : PT);
1495 if (! (BEGV <= pos && pos <= ZV))
1496 args_out_of_range (Fcurrent_buffer (), position);
1497 return pos;
1500 DEFUN ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps,
1501 0, 2, 0,
1502 doc: /* Return a list of the currently active keymaps.
1503 OLP if non-nil indicates that we should obey `overriding-local-map' and
1504 `overriding-terminal-local-map'. POSITION can specify a click position
1505 like in the respective argument of `key-binding'. */)
1506 (Lisp_Object olp, Lisp_Object position)
1508 ptrdiff_t count = SPECPDL_INDEX ();
1510 Lisp_Object keymaps = list1 (current_global_map);
1512 /* If a mouse click position is given, our variables are based on
1513 the buffer clicked on, not the current buffer. So we may have to
1514 switch the buffer here. */
1516 if (CONSP (position))
1518 Lisp_Object window;
1520 window = POSN_WINDOW (position);
1522 if (WINDOWP (window)
1523 && BUFFERP (XWINDOW (window)->contents)
1524 && XBUFFER (XWINDOW (window)->contents) != current_buffer)
1526 /* Arrange to go back to the original buffer once we're done
1527 processing the key sequence. We don't use
1528 save_excursion_{save,restore} here, in analogy to
1529 `read-key-sequence' to avoid saving point. Maybe this
1530 would not be a problem here, but it is easier to keep
1531 things the same.
1533 record_unwind_current_buffer ();
1534 set_buffer_internal (XBUFFER (XWINDOW (window)->contents));
1538 if (!NILP (olp)
1539 /* The doc said that overriding-terminal-local-map should
1540 override overriding-local-map. The code used them both,
1541 but it seems clearer to use just one. rms, jan 2005. */
1542 && NILP (KVAR (current_kboard, Voverriding_terminal_local_map))
1543 && !NILP (Voverriding_local_map))
1544 keymaps = Fcons (Voverriding_local_map, keymaps);
1546 if (NILP (XCDR (keymaps)))
1548 Lisp_Object *maps;
1549 int nmaps, i;
1550 ptrdiff_t pt = click_position (position);
1551 /* This usually returns the buffer's local map,
1552 but that can be overridden by a `local-map' property. */
1553 Lisp_Object local_map = get_local_map (pt, current_buffer, Qlocal_map);
1554 /* This returns nil unless there is a `keymap' property. */
1555 Lisp_Object keymap = get_local_map (pt, current_buffer, Qkeymap);
1556 Lisp_Object otlp = KVAR (current_kboard, Voverriding_terminal_local_map);
1558 if (CONSP (position))
1560 Lisp_Object string = POSN_STRING (position);
1562 /* For a mouse click, get the local text-property keymap
1563 of the place clicked on, rather than point. */
1565 if (POSN_INBUFFER_P (position))
1567 Lisp_Object pos;
1569 pos = POSN_BUFFER_POSN (position);
1570 if (INTEGERP (pos)
1571 && XINT (pos) >= BEG && XINT (pos) <= Z)
1573 local_map = get_local_map (XINT (pos),
1574 current_buffer, Qlocal_map);
1576 keymap = get_local_map (XINT (pos),
1577 current_buffer, Qkeymap);
1581 /* If on a mode line string with a local keymap,
1582 or for a click on a string, i.e. overlay string or a
1583 string displayed via the `display' property,
1584 consider `local-map' and `keymap' properties of
1585 that string. */
1587 if (CONSP (string) && STRINGP (XCAR (string)))
1589 Lisp_Object pos, map;
1591 pos = XCDR (string);
1592 string = XCAR (string);
1593 if (INTEGERP (pos)
1594 && XINT (pos) >= 0
1595 && XINT (pos) < SCHARS (string))
1597 map = Fget_text_property (pos, Qlocal_map, string);
1598 if (!NILP (map))
1599 local_map = map;
1601 map = Fget_text_property (pos, Qkeymap, string);
1602 if (!NILP (map))
1603 keymap = map;
1609 if (!NILP (local_map))
1610 keymaps = Fcons (local_map, keymaps);
1612 /* Now put all the minor mode keymaps on the list. */
1613 nmaps = current_minor_maps (0, &maps);
1615 for (i = --nmaps; i >= 0; i--)
1616 if (!NILP (maps[i]))
1617 keymaps = Fcons (maps[i], keymaps);
1619 if (!NILP (keymap))
1620 keymaps = Fcons (keymap, keymaps);
1622 if (!NILP (olp) && !NILP (otlp))
1623 keymaps = Fcons (otlp, keymaps);
1626 unbind_to (count, Qnil);
1628 return keymaps;
1631 /* GC is possible in this function if it autoloads a keymap. */
1633 DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 4, 0,
1634 doc: /* Return the binding for command KEY in current keymaps.
1635 KEY is a string or vector, a sequence of keystrokes.
1636 The binding is probably a symbol with a function definition.
1638 Normally, `key-binding' ignores bindings for t, which act as default
1639 bindings, used when nothing else in the keymap applies; this makes it
1640 usable as a general function for probing keymaps. However, if the
1641 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1642 recognize the default bindings, just as `read-key-sequence' does.
1644 Like the normal command loop, `key-binding' will remap the command
1645 resulting from looking up KEY by looking up the command in the
1646 current keymaps. However, if the optional third argument NO-REMAP
1647 is non-nil, `key-binding' returns the unmapped command.
1649 If KEY is a key sequence initiated with the mouse, the used keymaps
1650 will depend on the clicked mouse position with regard to the buffer
1651 and possible local keymaps on strings.
1653 If the optional argument POSITION is non-nil, it specifies a mouse
1654 position as returned by `event-start' and `event-end', and the lookup
1655 occurs in the keymaps associated with it instead of KEY. It can also
1656 be a number or marker, in which case the keymap properties at the
1657 specified buffer position instead of point are used.
1659 (Lisp_Object key, Lisp_Object accept_default, Lisp_Object no_remap, Lisp_Object position)
1661 Lisp_Object value;
1663 if (NILP (position) && VECTORP (key))
1665 Lisp_Object event
1666 /* mouse events may have a symbolic prefix indicating the
1667 scrollbar or mode line */
1668 = AREF (key, SYMBOLP (AREF (key, 0)) && ASIZE (key) > 1 ? 1 : 0);
1670 /* We are not interested in locations without event data */
1672 if (EVENT_HAS_PARAMETERS (event) && CONSP (XCDR (event)))
1674 Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (event));
1675 if (EQ (kind, Qmouse_click))
1676 position = EVENT_START (event);
1680 value = Flookup_key (Fcons (Qkeymap, Fcurrent_active_maps (Qt, position)),
1681 key, accept_default);
1683 if (NILP (value) || INTEGERP (value))
1684 return Qnil;
1686 /* If the result of the ordinary keymap lookup is an interactive
1687 command, look for a key binding (ie. remapping) for that command. */
1689 if (NILP (no_remap) && SYMBOLP (value))
1691 Lisp_Object value1;
1692 if (value1 = Fcommand_remapping (value, position, Qnil), !NILP (value1))
1693 value = value1;
1696 return value;
1699 /* GC is possible in this function if it autoloads a keymap. */
1701 DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
1702 doc: /* Return the binding for command KEYS in current local keymap only.
1703 KEYS is a string or vector, a sequence of keystrokes.
1704 The binding is probably a symbol with a function definition.
1706 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1707 bindings; see the description of `lookup-key' for more details about this. */)
1708 (Lisp_Object keys, Lisp_Object accept_default)
1710 register Lisp_Object map;
1711 map = BVAR (current_buffer, keymap);
1712 if (NILP (map))
1713 return Qnil;
1714 return Flookup_key (map, keys, accept_default);
1717 /* GC is possible in this function if it autoloads a keymap. */
1719 DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
1720 doc: /* Return the binding for command KEYS in current global keymap only.
1721 KEYS is a string or vector, a sequence of keystrokes.
1722 The binding is probably a symbol with a function definition.
1723 This function's return values are the same as those of `lookup-key'
1724 \(which see).
1726 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1727 bindings; see the description of `lookup-key' for more details about this. */)
1728 (Lisp_Object keys, Lisp_Object accept_default)
1730 return Flookup_key (current_global_map, keys, accept_default);
1733 /* GC is possible in this function if it autoloads a keymap. */
1735 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
1736 doc: /* Find the visible minor mode bindings of KEY.
1737 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1738 the symbol which names the minor mode binding KEY, and BINDING is
1739 KEY's definition in that mode. In particular, if KEY has no
1740 minor-mode bindings, return nil. If the first binding is a
1741 non-prefix, all subsequent bindings will be omitted, since they would
1742 be ignored. Similarly, the list doesn't include non-prefix bindings
1743 that come after prefix bindings.
1745 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1746 bindings; see the description of `lookup-key' for more details about this. */)
1747 (Lisp_Object key, Lisp_Object accept_default)
1749 Lisp_Object *modes, *maps;
1750 int nmaps;
1751 Lisp_Object binding;
1752 int i, j;
1753 struct gcpro gcpro1, gcpro2;
1755 nmaps = current_minor_maps (&modes, &maps);
1756 /* Note that all these maps are GCPRO'd
1757 in the places where we found them. */
1759 binding = Qnil;
1760 GCPRO2 (key, binding);
1762 for (i = j = 0; i < nmaps; i++)
1763 if (!NILP (maps[i])
1764 && !NILP (binding = Flookup_key (maps[i], key, accept_default))
1765 && !INTEGERP (binding))
1767 if (KEYMAPP (binding))
1768 maps[j++] = Fcons (modes[i], binding);
1769 else if (j == 0)
1770 RETURN_UNGCPRO (list1 (Fcons (modes[i], binding)));
1773 UNGCPRO;
1774 return Flist (j, maps);
1777 DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 3, 0,
1778 doc: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1779 A new sparse keymap is stored as COMMAND's function definition and its value.
1780 If a second optional argument MAPVAR is given, the map is stored as
1781 its value instead of as COMMAND's value; but COMMAND is still defined
1782 as a function.
1783 The third optional argument NAME, if given, supplies a menu name
1784 string for the map. This is required to use the keymap as a menu.
1785 This function returns COMMAND. */)
1786 (Lisp_Object command, Lisp_Object mapvar, Lisp_Object name)
1788 Lisp_Object map;
1789 map = Fmake_sparse_keymap (name);
1790 Ffset (command, map);
1791 if (!NILP (mapvar))
1792 Fset (mapvar, map);
1793 else
1794 Fset (command, map);
1795 return command;
1798 DEFUN ("use-global-map", Fuse_global_map, Suse_global_map, 1, 1, 0,
1799 doc: /* Select KEYMAP as the global keymap. */)
1800 (Lisp_Object keymap)
1802 keymap = get_keymap (keymap, 1, 1);
1803 current_global_map = keymap;
1805 return Qnil;
1808 DEFUN ("use-local-map", Fuse_local_map, Suse_local_map, 1, 1, 0,
1809 doc: /* Select KEYMAP as the local keymap.
1810 If KEYMAP is nil, that means no local keymap. */)
1811 (Lisp_Object keymap)
1813 if (!NILP (keymap))
1814 keymap = get_keymap (keymap, 1, 1);
1816 bset_keymap (current_buffer, keymap);
1818 return Qnil;
1821 DEFUN ("current-local-map", Fcurrent_local_map, Scurrent_local_map, 0, 0, 0,
1822 doc: /* Return current buffer's local keymap, or nil if it has none.
1823 Normally the local keymap is set by the major mode with `use-local-map'. */)
1824 (void)
1826 return BVAR (current_buffer, keymap);
1829 DEFUN ("current-global-map", Fcurrent_global_map, Scurrent_global_map, 0, 0, 0,
1830 doc: /* Return the current global keymap. */)
1831 (void)
1833 return current_global_map;
1836 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_maps, 0, 0, 0,
1837 doc: /* Return a list of keymaps for the minor modes of the current buffer. */)
1838 (void)
1840 Lisp_Object *maps;
1841 int nmaps = current_minor_maps (0, &maps);
1843 return Flist (nmaps, maps);
1846 /* Help functions for describing and documenting keymaps. */
1848 struct accessible_keymaps_data {
1849 Lisp_Object maps, tail, thisseq;
1850 /* Does the current sequence end in the meta-prefix-char? */
1851 bool is_metized;
1854 static void
1855 accessible_keymaps_1 (Lisp_Object key, Lisp_Object cmd, Lisp_Object args, void *data)
1856 /* Use void * data to be compatible with map_keymap_function_t. */
1858 struct accessible_keymaps_data *d = data; /* Cast! */
1859 Lisp_Object maps = d->maps;
1860 Lisp_Object tail = d->tail;
1861 Lisp_Object thisseq = d->thisseq;
1862 bool is_metized = d->is_metized && INTEGERP (key);
1863 Lisp_Object tem;
1865 cmd = get_keymap (get_keyelt (cmd, 0), 0, 0);
1866 if (NILP (cmd))
1867 return;
1869 /* Look for and break cycles. */
1870 while (!NILP (tem = Frassq (cmd, maps)))
1872 Lisp_Object prefix = XCAR (tem);
1873 ptrdiff_t lim = XINT (Flength (XCAR (tem)));
1874 if (lim <= XINT (Flength (thisseq)))
1875 { /* This keymap was already seen with a smaller prefix. */
1876 ptrdiff_t i = 0;
1877 while (i < lim && EQ (Faref (prefix, make_number (i)),
1878 Faref (thisseq, make_number (i))))
1879 i++;
1880 if (i >= lim)
1881 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1882 return;
1884 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1885 but maybe `cmd' occurs again further down in `maps', so keep
1886 looking. */
1887 maps = XCDR (Fmemq (tem, maps));
1890 /* If the last key in thisseq is meta-prefix-char,
1891 turn it into a meta-ized keystroke. We know
1892 that the event we're about to append is an
1893 ascii keystroke since we're processing a
1894 keymap table. */
1895 if (is_metized)
1897 int meta_bit = meta_modifier;
1898 Lisp_Object last = make_number (XINT (Flength (thisseq)) - 1);
1899 tem = Fcopy_sequence (thisseq);
1901 Faset (tem, last, make_number (XINT (key) | meta_bit));
1903 /* This new sequence is the same length as
1904 thisseq, so stick it in the list right
1905 after this one. */
1906 XSETCDR (tail,
1907 Fcons (Fcons (tem, cmd), XCDR (tail)));
1909 else
1911 tem = append_key (thisseq, key);
1912 nconc2 (tail, list1 (Fcons (tem, cmd)));
1916 /* This function cannot GC. */
1918 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
1919 1, 2, 0,
1920 doc: /* Find all keymaps accessible via prefix characters from KEYMAP.
1921 Returns a list of elements of the form (KEYS . MAP), where the sequence
1922 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1923 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1924 An optional argument PREFIX, if non-nil, should be a key sequence;
1925 then the value includes only maps for prefixes that start with PREFIX. */)
1926 (Lisp_Object keymap, Lisp_Object prefix)
1928 Lisp_Object maps, tail;
1929 EMACS_INT prefixlen = XFASTINT (Flength (prefix));
1931 /* no need for gcpro because we don't autoload any keymaps. */
1933 if (!NILP (prefix))
1935 /* If a prefix was specified, start with the keymap (if any) for
1936 that prefix, so we don't waste time considering other prefixes. */
1937 Lisp_Object tem;
1938 tem = Flookup_key (keymap, prefix, Qt);
1939 /* Flookup_key may give us nil, or a number,
1940 if the prefix is not defined in this particular map.
1941 It might even give us a list that isn't a keymap. */
1942 tem = get_keymap (tem, 0, 0);
1943 /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
1944 want to return it. */
1945 if (!NILP (tem))
1947 /* Convert PREFIX to a vector now, so that later on
1948 we don't have to deal with the possibility of a string. */
1949 if (STRINGP (prefix))
1951 int i, i_byte, c;
1952 Lisp_Object copy;
1954 copy = Fmake_vector (make_number (SCHARS (prefix)), Qnil);
1955 for (i = 0, i_byte = 0; i < SCHARS (prefix);)
1957 int i_before = i;
1959 FETCH_STRING_CHAR_ADVANCE (c, prefix, i, i_byte);
1960 if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
1961 c ^= 0200 | meta_modifier;
1962 ASET (copy, i_before, make_number (c));
1964 prefix = copy;
1966 maps = list1 (Fcons (prefix, tem));
1968 else
1969 return Qnil;
1971 else
1972 maps = list1 (Fcons (zero_vector, get_keymap (keymap, 1, 0)));
1974 /* For each map in the list maps,
1975 look at any other maps it points to,
1976 and stick them at the end if they are not already in the list.
1978 This is a breadth-first traversal, where tail is the queue of
1979 nodes, and maps accumulates a list of all nodes visited. */
1981 for (tail = maps; CONSP (tail); tail = XCDR (tail))
1983 struct accessible_keymaps_data data;
1984 register Lisp_Object thismap = Fcdr (XCAR (tail));
1985 Lisp_Object last;
1987 data.thisseq = Fcar (XCAR (tail));
1988 data.maps = maps;
1989 data.tail = tail;
1990 last = make_number (XINT (Flength (data.thisseq)) - 1);
1991 /* Does the current sequence end in the meta-prefix-char? */
1992 data.is_metized = (XINT (last) >= 0
1993 /* Don't metize the last char of PREFIX. */
1994 && XINT (last) >= prefixlen
1995 && EQ (Faref (data.thisseq, last), meta_prefix_char));
1997 /* Since we can't run lisp code, we can't scan autoloaded maps. */
1998 if (CONSP (thismap))
1999 map_keymap (thismap, accessible_keymaps_1, Qnil, &data, 0);
2001 return maps;
2003 static Lisp_Object Qsingle_key_description, Qkey_description;
2005 /* This function cannot GC. */
2007 DEFUN ("key-description", Fkey_description, Skey_description, 1, 2, 0,
2008 doc: /* Return a pretty description of key-sequence KEYS.
2009 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2010 For example, [?\C-x ?l] is converted into the string \"C-x l\".
2012 For an approximate inverse of this, see `kbd'. */)
2013 (Lisp_Object keys, Lisp_Object prefix)
2015 ptrdiff_t len = 0;
2016 EMACS_INT i;
2017 ptrdiff_t i_byte;
2018 Lisp_Object *args;
2019 EMACS_INT size = XINT (Flength (keys));
2020 Lisp_Object list;
2021 Lisp_Object sep = build_string (" ");
2022 Lisp_Object key;
2023 Lisp_Object result;
2024 bool add_meta = 0;
2025 USE_SAFE_ALLOCA;
2027 if (!NILP (prefix))
2028 size += XINT (Flength (prefix));
2030 /* This has one extra element at the end that we don't pass to Fconcat. */
2031 if (min (PTRDIFF_MAX, SIZE_MAX) / word_size / 4 < size)
2032 memory_full (SIZE_MAX);
2033 SAFE_ALLOCA_LISP (args, size * 4);
2035 /* In effect, this computes
2036 (mapconcat 'single-key-description keys " ")
2037 but we shouldn't use mapconcat because it can do GC. */
2039 next_list:
2040 if (!NILP (prefix))
2041 list = prefix, prefix = Qnil;
2042 else if (!NILP (keys))
2043 list = keys, keys = Qnil;
2044 else
2046 if (add_meta)
2048 args[len] = Fsingle_key_description (meta_prefix_char, Qnil);
2049 result = Fconcat (len + 1, args);
2051 else if (len == 0)
2052 result = empty_unibyte_string;
2053 else
2054 result = Fconcat (len - 1, args);
2055 SAFE_FREE ();
2056 return result;
2059 if (STRINGP (list))
2060 size = SCHARS (list);
2061 else if (VECTORP (list))
2062 size = ASIZE (list);
2063 else if (CONSP (list))
2064 size = XINT (Flength (list));
2065 else
2066 wrong_type_argument (Qarrayp, list);
2068 i = i_byte = 0;
2070 while (i < size)
2072 if (STRINGP (list))
2074 int c;
2075 FETCH_STRING_CHAR_ADVANCE (c, list, i, i_byte);
2076 if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
2077 c ^= 0200 | meta_modifier;
2078 XSETFASTINT (key, c);
2080 else if (VECTORP (list))
2082 key = AREF (list, i); i++;
2084 else
2086 key = XCAR (list);
2087 list = XCDR (list);
2088 i++;
2091 if (add_meta)
2093 if (!INTEGERP (key)
2094 || EQ (key, meta_prefix_char)
2095 || (XINT (key) & meta_modifier))
2097 args[len++] = Fsingle_key_description (meta_prefix_char, Qnil);
2098 args[len++] = sep;
2099 if (EQ (key, meta_prefix_char))
2100 continue;
2102 else
2103 XSETINT (key, XINT (key) | meta_modifier);
2104 add_meta = 0;
2106 else if (EQ (key, meta_prefix_char))
2108 add_meta = 1;
2109 continue;
2111 args[len++] = Fsingle_key_description (key, Qnil);
2112 args[len++] = sep;
2114 goto next_list;
2118 char *
2119 push_key_description (EMACS_INT ch, char *p)
2121 int c, c2;
2122 bool tab_as_ci;
2124 /* Clear all the meaningless bits above the meta bit. */
2125 c = ch & (meta_modifier | ~ - meta_modifier);
2126 c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier
2127 | meta_modifier | shift_modifier | super_modifier);
2129 if (! CHARACTERP (make_number (c2)))
2131 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2132 p += sprintf (p, "[%d]", c);
2133 return p;
2136 tab_as_ci = (c2 == '\t' && (c & meta_modifier));
2138 if (c & alt_modifier)
2140 *p++ = 'A';
2141 *p++ = '-';
2142 c -= alt_modifier;
2144 if ((c & ctrl_modifier) != 0
2145 || (c2 < ' ' && c2 != 27 && c2 != '\t' && c2 != Ctl ('M'))
2146 || tab_as_ci)
2148 *p++ = 'C';
2149 *p++ = '-';
2150 c &= ~ctrl_modifier;
2152 if (c & hyper_modifier)
2154 *p++ = 'H';
2155 *p++ = '-';
2156 c -= hyper_modifier;
2158 if (c & meta_modifier)
2160 *p++ = 'M';
2161 *p++ = '-';
2162 c -= meta_modifier;
2164 if (c & shift_modifier)
2166 *p++ = 'S';
2167 *p++ = '-';
2168 c -= shift_modifier;
2170 if (c & super_modifier)
2172 *p++ = 's';
2173 *p++ = '-';
2174 c -= super_modifier;
2176 if (c < 040)
2178 if (c == 033)
2180 *p++ = 'E';
2181 *p++ = 'S';
2182 *p++ = 'C';
2184 else if (tab_as_ci)
2186 *p++ = 'i';
2188 else if (c == '\t')
2190 *p++ = 'T';
2191 *p++ = 'A';
2192 *p++ = 'B';
2194 else if (c == Ctl ('M'))
2196 *p++ = 'R';
2197 *p++ = 'E';
2198 *p++ = 'T';
2200 else
2202 /* `C-' already added above. */
2203 if (c > 0 && c <= Ctl ('Z'))
2204 *p++ = c + 0140;
2205 else
2206 *p++ = c + 0100;
2209 else if (c == 0177)
2211 *p++ = 'D';
2212 *p++ = 'E';
2213 *p++ = 'L';
2215 else if (c == ' ')
2217 *p++ = 'S';
2218 *p++ = 'P';
2219 *p++ = 'C';
2221 else if (c < 128)
2222 *p++ = c;
2223 else
2225 /* Now we are sure that C is a valid character code. */
2226 p += CHAR_STRING (c, (unsigned char *) p);
2229 return p;
2232 /* This function cannot GC. */
2234 DEFUN ("single-key-description", Fsingle_key_description,
2235 Ssingle_key_description, 1, 2, 0,
2236 doc: /* Return a pretty description of command character KEY.
2237 Control characters turn into C-whatever, etc.
2238 Optional argument NO-ANGLES non-nil means don't put angle brackets
2239 around function keys and event symbols. */)
2240 (Lisp_Object key, Lisp_Object no_angles)
2242 if (CONSP (key) && lucid_event_type_list_p (key))
2243 key = Fevent_convert_list (key);
2245 if (CONSP (key) && INTEGERP (XCAR (key)) && INTEGERP (XCDR (key)))
2246 /* An interval from a map-char-table. */
2247 return concat3 (Fsingle_key_description (XCAR (key), no_angles),
2248 build_string (".."),
2249 Fsingle_key_description (XCDR (key), no_angles));
2251 key = EVENT_HEAD (key);
2253 if (INTEGERP (key)) /* Normal character. */
2255 char tem[KEY_DESCRIPTION_SIZE];
2256 char *p = push_key_description (XINT (key), tem);
2257 *p = 0;
2258 return make_specified_string (tem, -1, p - tem, 1);
2260 else if (SYMBOLP (key)) /* Function key or event-symbol. */
2262 if (NILP (no_angles))
2264 Lisp_Object result;
2265 USE_SAFE_ALLOCA;
2266 char *buffer = SAFE_ALLOCA (sizeof "<>"
2267 + SBYTES (SYMBOL_NAME (key)));
2268 esprintf (buffer, "<%s>", SDATA (SYMBOL_NAME (key)));
2269 result = build_string (buffer);
2270 SAFE_FREE ();
2271 return result;
2273 else
2274 return Fsymbol_name (key);
2276 else if (STRINGP (key)) /* Buffer names in the menubar. */
2277 return Fcopy_sequence (key);
2278 else
2279 error ("KEY must be an integer, cons, symbol, or string");
2282 static char *
2283 push_text_char_description (register unsigned int c, register char *p)
2285 if (c >= 0200)
2287 *p++ = 'M';
2288 *p++ = '-';
2289 c -= 0200;
2291 if (c < 040)
2293 *p++ = '^';
2294 *p++ = c + 64; /* 'A' - 1 */
2296 else if (c == 0177)
2298 *p++ = '^';
2299 *p++ = '?';
2301 else
2302 *p++ = c;
2303 return p;
2306 /* This function cannot GC. */
2308 DEFUN ("text-char-description", Ftext_char_description, Stext_char_description, 1, 1, 0,
2309 doc: /* Return a pretty description of file-character CHARACTER.
2310 Control characters turn into "^char", etc. This differs from
2311 `single-key-description' which turns them into "C-char".
2312 Also, this function recognizes the 2**7 bit as the Meta character,
2313 whereas `single-key-description' uses the 2**27 bit for Meta.
2314 See Info node `(elisp)Describing Characters' for examples. */)
2315 (Lisp_Object character)
2317 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2318 char str[6];
2319 int c;
2321 CHECK_CHARACTER (character);
2323 c = XINT (character);
2324 if (!ASCII_CHAR_P (c))
2326 int len = CHAR_STRING (c, (unsigned char *) str);
2328 return make_multibyte_string (str, 1, len);
2331 *push_text_char_description (c & 0377, str) = 0;
2333 return build_string (str);
2336 static int where_is_preferred_modifier;
2338 /* Return 0 if SEQ uses non-preferred modifiers or non-char events.
2339 Else, return 2 if SEQ uses the where_is_preferred_modifier,
2340 and 1 otherwise. */
2341 static int
2342 preferred_sequence_p (Lisp_Object seq)
2344 EMACS_INT i;
2345 EMACS_INT len = XFASTINT (Flength (seq));
2346 int result = 1;
2348 for (i = 0; i < len; i++)
2350 Lisp_Object ii, elt;
2352 XSETFASTINT (ii, i);
2353 elt = Faref (seq, ii);
2355 if (!INTEGERP (elt))
2356 return 0;
2357 else
2359 int modifiers = XINT (elt) & (CHAR_MODIFIER_MASK & ~CHAR_META);
2360 if (modifiers == where_is_preferred_modifier)
2361 result = 2;
2362 else if (modifiers)
2363 return 0;
2367 return result;
2371 /* where-is - finding a command in a set of keymaps. */
2373 static void where_is_internal_1 (Lisp_Object key, Lisp_Object binding,
2374 Lisp_Object args, void *data);
2376 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2377 Returns the first non-nil binding found in any of those maps.
2378 If REMAP is true, pass the result of the lookup through command
2379 remapping before returning it. */
2381 static Lisp_Object
2382 shadow_lookup (Lisp_Object shadow, Lisp_Object key, Lisp_Object flag,
2383 bool remap)
2385 Lisp_Object tail, value;
2387 for (tail = shadow; CONSP (tail); tail = XCDR (tail))
2389 value = Flookup_key (XCAR (tail), key, flag);
2390 if (NATNUMP (value))
2392 value = Flookup_key (XCAR (tail),
2393 Fsubstring (key, make_number (0), value), flag);
2394 if (!NILP (value))
2395 return Qnil;
2397 else if (!NILP (value))
2399 Lisp_Object remapping;
2400 if (remap && SYMBOLP (value)
2401 && (remapping = Fcommand_remapping (value, Qnil, shadow),
2402 !NILP (remapping)))
2403 return remapping;
2404 else
2405 return value;
2408 return Qnil;
2411 static Lisp_Object Vmouse_events;
2413 struct where_is_internal_data {
2414 Lisp_Object definition, this, last;
2415 bool last_is_meta, noindirect;
2416 Lisp_Object sequences;
2419 /* This function can't GC, AFAIK. */
2420 /* Return the list of bindings found. This list is ordered "longest
2421 to shortest". It may include bindings that are actually shadowed
2422 by others, as well as duplicate bindings and remapping bindings.
2423 The list returned is potentially shared with where_is_cache, so
2424 be careful not to modify it via side-effects. */
2426 static Lisp_Object
2427 where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
2428 bool noindirect, bool nomenus)
2430 Lisp_Object maps = Qnil;
2431 Lisp_Object found;
2432 struct where_is_internal_data data;
2434 /* Only important use of caching is for the menubar
2435 (i.e. where-is-internal called with (def nil t nil nil)). */
2436 if (nomenus && !noindirect)
2438 /* Check heuristic-consistency of the cache. */
2439 if (NILP (Fequal (keymaps, where_is_cache_keymaps)))
2440 where_is_cache = Qnil;
2442 if (NILP (where_is_cache))
2444 /* We need to create the cache. */
2445 Lisp_Object args[2];
2446 where_is_cache = Fmake_hash_table (0, args);
2447 where_is_cache_keymaps = Qt;
2449 else
2450 /* We can reuse the cache. */
2451 return Fgethash (definition, where_is_cache, Qnil);
2453 else
2454 /* Kill the cache so that where_is_internal_1 doesn't think
2455 we're filling it up. */
2456 where_is_cache = Qnil;
2458 found = keymaps;
2459 while (CONSP (found))
2461 maps =
2462 nconc2 (maps,
2463 Faccessible_keymaps (get_keymap (XCAR (found), 1, 0), Qnil));
2464 found = XCDR (found);
2467 data.sequences = Qnil;
2468 for (; CONSP (maps); maps = XCDR (maps))
2470 /* Key sequence to reach map, and the map that it reaches */
2471 register Lisp_Object this, map, tem;
2473 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2474 [M-CHAR] sequences, check if last character of the sequence
2475 is the meta-prefix char. */
2476 Lisp_Object last;
2477 bool last_is_meta;
2479 this = Fcar (XCAR (maps));
2480 map = Fcdr (XCAR (maps));
2481 last = make_number (XINT (Flength (this)) - 1);
2482 last_is_meta = (XINT (last) >= 0
2483 && EQ (Faref (this, last), meta_prefix_char));
2485 /* if (nomenus && !preferred_sequence_p (this)) */
2486 if (nomenus && XINT (last) >= 0
2487 && SYMBOLP (tem = Faref (this, make_number (0)))
2488 && !NILP (Fmemq (XCAR (parse_modifiers (tem)), Vmouse_events)))
2489 /* If no menu entries should be returned, skip over the
2490 keymaps bound to `menu-bar' and `tool-bar' and other
2491 non-ascii prefixes like `C-down-mouse-2'. */
2492 continue;
2494 QUIT;
2496 data.definition = definition;
2497 data.noindirect = noindirect;
2498 data.this = this;
2499 data.last = last;
2500 data.last_is_meta = last_is_meta;
2502 if (CONSP (map))
2503 map_keymap (map, where_is_internal_1, Qnil, &data, 0);
2506 if (nomenus && !noindirect)
2507 { /* Remember for which keymaps this cache was built.
2508 We do it here (late) because we want to keep where_is_cache_keymaps
2509 set to t while the cache isn't fully filled. */
2510 where_is_cache_keymaps = keymaps;
2511 /* During cache-filling, data.sequences is not filled by
2512 where_is_internal_1. */
2513 return Fgethash (definition, where_is_cache, Qnil);
2515 else
2516 return data.sequences;
2519 /* This function can GC if Flookup_key autoloads any keymaps. */
2521 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
2522 doc: /* Return list of keys that invoke DEFINITION.
2523 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2524 If KEYMAP is nil, search all the currently active keymaps, except
2525 for `overriding-local-map' (which is ignored).
2526 If KEYMAP is a list of keymaps, search only those keymaps.
2528 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2529 rather than a list of all possible key sequences.
2530 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2531 no matter what it is.
2532 If FIRSTONLY has another non-nil value, prefer bindings
2533 that use the modifier key specified in `where-is-preferred-modifier'
2534 \(or their meta variants) and entirely reject menu bindings.
2536 If optional 4th arg NOINDIRECT is non-nil, don't extract the commands inside
2537 menu-items. This makes it possible to search for a menu-item itself.
2539 The optional 5th arg NO-REMAP alters how command remapping is handled:
2541 - If another command OTHER-COMMAND is remapped to DEFINITION, normally
2542 search for the bindings of OTHER-COMMAND and include them in the
2543 returned list. But if NO-REMAP is non-nil, include the vector
2544 [remap OTHER-COMMAND] in the returned list instead, without
2545 searching for those other bindings.
2547 - If DEFINITION is remapped to OTHER-COMMAND, normally return the
2548 bindings for OTHER-COMMAND. But if NO-REMAP is non-nil, return the
2549 bindings for DEFINITION instead, ignoring its remapping. */)
2550 (Lisp_Object definition, Lisp_Object keymap, Lisp_Object firstonly, Lisp_Object noindirect, Lisp_Object no_remap)
2552 /* The keymaps in which to search. */
2553 Lisp_Object keymaps;
2554 /* Potentially relevant bindings in "shortest to longest" order. */
2555 Lisp_Object sequences = Qnil;
2556 /* Actually relevant bindings. */
2557 Lisp_Object found = Qnil;
2558 /* 1 means ignore all menu bindings entirely. */
2559 bool nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
2560 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
2561 /* List of sequences found via remapping. Keep them in a separate
2562 variable, so as to push them later, since we prefer
2563 non-remapped binding. */
2564 Lisp_Object remapped_sequences = Qnil;
2565 /* Whether or not we're handling remapped sequences. This is needed
2566 because remapping is not done recursively by Fcommand_remapping: you
2567 can't remap a remapped command. */
2568 bool remapped = 0;
2569 Lisp_Object tem = Qnil;
2571 /* Refresh the C version of the modifier preference. */
2572 where_is_preferred_modifier
2573 = parse_solitary_modifier (Vwhere_is_preferred_modifier);
2575 /* Find the relevant keymaps. */
2576 if (CONSP (keymap) && KEYMAPP (XCAR (keymap)))
2577 keymaps = keymap;
2578 else if (!NILP (keymap))
2579 keymaps = list2 (keymap, current_global_map);
2580 else
2581 keymaps = Fcurrent_active_maps (Qnil, Qnil);
2583 GCPRO6 (definition, keymaps, found, sequences, remapped_sequences, tem);
2585 tem = Fcommand_remapping (definition, Qnil, keymaps);
2586 /* If `definition' is remapped to tem', then OT1H no key will run
2587 that command (since they will run `tem' instead), so we should
2588 return nil; but OTOH all keys bound to `definition' (or to `tem')
2589 will run the same command.
2590 So for menu-shortcut purposes, we want to find all the keys bound (maybe
2591 via remapping) to `tem'. But for the purpose of finding the keys that
2592 run `definition', then we'd want to just return nil.
2593 We choose to make it work right for menu-shortcuts, since it's the most
2594 common use.
2595 Known bugs: if you remap switch-to-buffer to toto, C-h f switch-to-buffer
2596 will tell you that switch-to-buffer is bound to C-x b even though C-x b
2597 will run toto instead. And if `toto' is itself remapped to forward-char,
2598 then C-h f toto will tell you that it's bound to C-f even though C-f does
2599 not run toto and it won't tell you that C-x b does run toto. */
2600 if (NILP (no_remap) && !NILP (tem))
2601 definition = tem;
2603 if (SYMBOLP (definition)
2604 && !NILP (firstonly)
2605 && !NILP (tem = Fget (definition, QCadvertised_binding)))
2607 /* We have a list of advertised bindings. */
2608 while (CONSP (tem))
2609 if (EQ (shadow_lookup (keymaps, XCAR (tem), Qnil, 0), definition))
2610 RETURN_UNGCPRO (XCAR (tem));
2611 else
2612 tem = XCDR (tem);
2613 if (EQ (shadow_lookup (keymaps, tem, Qnil, 0), definition))
2614 RETURN_UNGCPRO (tem);
2617 sequences = Freverse (where_is_internal (definition, keymaps,
2618 !NILP (noindirect), nomenus));
2620 while (CONSP (sequences)
2621 /* If we're at the end of the `sequences' list and we haven't
2622 considered remapped sequences yet, copy them over and
2623 process them. */
2624 || (!remapped && (sequences = remapped_sequences,
2625 remapped = 1,
2626 CONSP (sequences))))
2628 Lisp_Object sequence, function;
2630 sequence = XCAR (sequences);
2631 sequences = XCDR (sequences);
2633 /* Verify that this key binding is not shadowed by another
2634 binding for the same key, before we say it exists.
2636 Mechanism: look for local definition of this key and if
2637 it is defined and does not match what we found then
2638 ignore this key.
2640 Either nil or number as value from Flookup_key
2641 means undefined. */
2642 if (NILP (Fequal (shadow_lookup (keymaps, sequence, Qnil, remapped),
2643 definition)))
2644 continue;
2646 /* If the current sequence is a command remapping with
2647 format [remap COMMAND], find the key sequences
2648 which run COMMAND, and use those sequences instead. */
2649 if (NILP (no_remap) && !remapped
2650 && VECTORP (sequence) && ASIZE (sequence) == 2
2651 && EQ (AREF (sequence, 0), Qremap)
2652 && (function = AREF (sequence, 1), SYMBOLP (function)))
2654 Lisp_Object seqs = where_is_internal (function, keymaps,
2655 !NILP (noindirect), nomenus);
2656 remapped_sequences = nconc2 (Freverse (seqs), remapped_sequences);
2657 continue;
2660 /* Don't annoy user with strings from a menu such as the
2661 entries from the "Edit => Paste from Kill Menu".
2662 Change them all to "(any string)", so that there
2663 seems to be only one menu item to report. */
2664 if (! NILP (sequence))
2666 Lisp_Object tem1;
2667 tem1 = Faref (sequence, make_number (ASIZE (sequence) - 1));
2668 if (STRINGP (tem1))
2669 Faset (sequence, make_number (ASIZE (sequence) - 1),
2670 build_string ("(any string)"));
2673 /* It is a true unshadowed match. Record it, unless it's already
2674 been seen (as could happen when inheriting keymaps). */
2675 if (NILP (Fmember (sequence, found)))
2676 found = Fcons (sequence, found);
2678 /* If firstonly is Qnon_ascii, then we can return the first
2679 binding we find. If firstonly is not Qnon_ascii but not
2680 nil, then we should return the first ascii-only binding
2681 we find. */
2682 if (EQ (firstonly, Qnon_ascii))
2683 RETURN_UNGCPRO (sequence);
2684 else if (!NILP (firstonly)
2685 && 2 == preferred_sequence_p (sequence))
2686 RETURN_UNGCPRO (sequence);
2689 UNGCPRO;
2691 found = Fnreverse (found);
2693 /* firstonly may have been t, but we may have gone all the way through
2694 the keymaps without finding an all-ASCII key sequence. So just
2695 return the best we could find. */
2696 if (NILP (firstonly))
2697 return found;
2698 else if (where_is_preferred_modifier == 0)
2699 return Fcar (found);
2700 else
2701 { /* Maybe we did not find a preferred_modifier binding, but we did find
2702 some ASCII binding. */
2703 Lisp_Object bindings = found;
2704 while (CONSP (bindings))
2705 if (preferred_sequence_p (XCAR (bindings)))
2706 return XCAR (bindings);
2707 else
2708 bindings = XCDR (bindings);
2709 return Fcar (found);
2713 /* This function can GC because get_keyelt can. */
2715 static void
2716 where_is_internal_1 (Lisp_Object key, Lisp_Object binding, Lisp_Object args, void *data)
2718 struct where_is_internal_data *d = data; /* Cast! */
2719 Lisp_Object definition = d->definition;
2720 bool noindirect = d->noindirect;
2721 Lisp_Object this = d->this;
2722 Lisp_Object last = d->last;
2723 bool last_is_meta = d->last_is_meta;
2724 Lisp_Object sequence;
2726 /* Search through indirections unless that's not wanted. */
2727 if (!noindirect)
2728 binding = get_keyelt (binding, 0);
2730 /* End this iteration if this element does not match
2731 the target. */
2733 if (!(!NILP (where_is_cache) /* everything "matches" during cache-fill. */
2734 || EQ (binding, definition)
2735 || (CONSP (definition) && !NILP (Fequal (binding, definition)))))
2736 /* Doesn't match. */
2737 return;
2739 /* We have found a match. Construct the key sequence where we found it. */
2740 if (INTEGERP (key) && last_is_meta)
2742 sequence = Fcopy_sequence (this);
2743 Faset (sequence, last, make_number (XINT (key) | meta_modifier));
2745 else
2747 if (CONSP (key))
2748 key = Fcons (XCAR (key), XCDR (key));
2749 sequence = append_key (this, key);
2752 if (!NILP (where_is_cache))
2754 Lisp_Object sequences = Fgethash (binding, where_is_cache, Qnil);
2755 Fputhash (binding, Fcons (sequence, sequences), where_is_cache);
2757 else
2758 d->sequences = Fcons (sequence, d->sequences);
2761 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2763 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings, Sdescribe_buffer_bindings, 1, 3, 0,
2764 doc: /* Insert the list of all defined keys and their definitions.
2765 The list is inserted in the current buffer, while the bindings are
2766 looked up in BUFFER.
2767 The optional argument PREFIX, if non-nil, should be a key sequence;
2768 then we display only bindings that start with that prefix.
2769 The optional argument MENUS, if non-nil, says to mention menu bindings.
2770 \(Ordinarily these are omitted from the output.) */)
2771 (Lisp_Object buffer, Lisp_Object prefix, Lisp_Object menus)
2773 Lisp_Object outbuf, shadow;
2774 bool nomenu = NILP (menus);
2775 Lisp_Object start1;
2776 struct gcpro gcpro1;
2778 const char *alternate_heading
2779 = "\
2780 Keyboard translations:\n\n\
2781 You type Translation\n\
2782 -------- -----------\n";
2784 CHECK_BUFFER (buffer);
2786 shadow = Qnil;
2787 GCPRO1 (shadow);
2789 outbuf = Fcurrent_buffer ();
2791 /* Report on alternates for keys. */
2792 if (STRINGP (KVAR (current_kboard, Vkeyboard_translate_table)) && !NILP (prefix))
2794 int c;
2795 const unsigned char *translate = SDATA (KVAR (current_kboard, Vkeyboard_translate_table));
2796 int translate_len = SCHARS (KVAR (current_kboard, Vkeyboard_translate_table));
2798 for (c = 0; c < translate_len; c++)
2799 if (translate[c] != c)
2801 char buf[KEY_DESCRIPTION_SIZE];
2802 char *bufend;
2804 if (alternate_heading)
2806 insert_string (alternate_heading);
2807 alternate_heading = 0;
2810 bufend = push_key_description (translate[c], buf);
2811 insert (buf, bufend - buf);
2812 Findent_to (make_number (16), make_number (1));
2813 bufend = push_key_description (c, buf);
2814 insert (buf, bufend - buf);
2816 insert ("\n", 1);
2818 /* Insert calls signal_after_change which may GC. */
2819 translate = SDATA (KVAR (current_kboard, Vkeyboard_translate_table));
2822 insert ("\n", 1);
2825 if (!NILP (Vkey_translation_map))
2826 describe_map_tree (Vkey_translation_map, 0, Qnil, prefix,
2827 "Key translations", nomenu, 1, 0, 0);
2830 /* Print the (major mode) local map. */
2831 start1 = Qnil;
2832 if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
2833 start1 = KVAR (current_kboard, Voverriding_terminal_local_map);
2835 if (!NILP (start1))
2837 describe_map_tree (start1, 1, shadow, prefix,
2838 "\f\nOverriding Bindings", nomenu, 0, 0, 0);
2839 shadow = Fcons (start1, shadow);
2840 start1 = Qnil;
2842 else if (!NILP (Voverriding_local_map))
2843 start1 = Voverriding_local_map;
2845 if (!NILP (start1))
2847 describe_map_tree (start1, 1, shadow, prefix,
2848 "\f\nOverriding Bindings", nomenu, 0, 0, 0);
2849 shadow = Fcons (start1, shadow);
2851 else
2853 /* Print the minor mode and major mode keymaps. */
2854 int i, nmaps;
2855 Lisp_Object *modes, *maps;
2857 /* Temporarily switch to `buffer', so that we can get that buffer's
2858 minor modes correctly. */
2859 Fset_buffer (buffer);
2861 nmaps = current_minor_maps (&modes, &maps);
2862 Fset_buffer (outbuf);
2864 start1 = get_local_map (BUF_PT (XBUFFER (buffer)),
2865 XBUFFER (buffer), Qkeymap);
2866 if (!NILP (start1))
2868 describe_map_tree (start1, 1, shadow, prefix,
2869 "\f\n`keymap' Property Bindings", nomenu,
2870 0, 0, 0);
2871 shadow = Fcons (start1, shadow);
2874 /* Print the minor mode maps. */
2875 for (i = 0; i < nmaps; i++)
2877 /* The title for a minor mode keymap
2878 is constructed at run time.
2879 We let describe_map_tree do the actual insertion
2880 because it takes care of other features when doing so. */
2881 char *title, *p;
2883 if (!SYMBOLP (modes[i]))
2884 emacs_abort ();
2886 p = title = alloca (42 + SCHARS (SYMBOL_NAME (modes[i])));
2887 *p++ = '\f';
2888 *p++ = '\n';
2889 *p++ = '`';
2890 memcpy (p, SDATA (SYMBOL_NAME (modes[i])),
2891 SCHARS (SYMBOL_NAME (modes[i])));
2892 p += SCHARS (SYMBOL_NAME (modes[i]));
2893 *p++ = '\'';
2894 memcpy (p, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
2895 p += strlen (" Minor Mode Bindings");
2896 *p = 0;
2898 describe_map_tree (maps[i], 1, shadow, prefix,
2899 title, nomenu, 0, 0, 0);
2900 shadow = Fcons (maps[i], shadow);
2903 start1 = get_local_map (BUF_PT (XBUFFER (buffer)),
2904 XBUFFER (buffer), Qlocal_map);
2905 if (!NILP (start1))
2907 if (EQ (start1, BVAR (XBUFFER (buffer), keymap)))
2908 describe_map_tree (start1, 1, shadow, prefix,
2909 "\f\nMajor Mode Bindings", nomenu, 0, 0, 0);
2910 else
2911 describe_map_tree (start1, 1, shadow, prefix,
2912 "\f\n`local-map' Property Bindings",
2913 nomenu, 0, 0, 0);
2915 shadow = Fcons (start1, shadow);
2919 describe_map_tree (current_global_map, 1, shadow, prefix,
2920 "\f\nGlobal Bindings", nomenu, 0, 1, 0);
2922 /* Print the function-key-map translations under this prefix. */
2923 if (!NILP (KVAR (current_kboard, Vlocal_function_key_map)))
2924 describe_map_tree (KVAR (current_kboard, Vlocal_function_key_map), 0, Qnil, prefix,
2925 "\f\nFunction key map translations", nomenu, 1, 0, 0);
2927 /* Print the input-decode-map translations under this prefix. */
2928 if (!NILP (KVAR (current_kboard, Vinput_decode_map)))
2929 describe_map_tree (KVAR (current_kboard, Vinput_decode_map), 0, Qnil, prefix,
2930 "\f\nInput decoding map translations", nomenu, 1, 0, 0);
2932 UNGCPRO;
2933 return Qnil;
2936 /* Insert a description of the key bindings in STARTMAP,
2937 followed by those of all maps reachable through STARTMAP.
2938 If PARTIAL, omit certain "uninteresting" commands
2939 (such as `undefined').
2940 If SHADOW is non-nil, it is a list of maps;
2941 don't mention keys which would be shadowed by any of them.
2942 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2943 TITLE, if not 0, is a string to insert at the beginning.
2944 TITLE should not end with a colon or a newline; we supply that.
2945 If NOMENU, then omit menu-bar commands.
2947 If TRANSL, the definitions are actually key translations
2948 so print strings and vectors differently.
2950 If ALWAYS_TITLE, print the title even if there are no maps
2951 to look through.
2953 If MENTION_SHADOW, then when something is shadowed by SHADOW,
2954 don't omit it; instead, mention it but say it is shadowed.
2956 Any inserted text ends in two newlines (used by `help-make-xrefs'). */
2958 void
2959 describe_map_tree (Lisp_Object startmap, bool partial, Lisp_Object shadow,
2960 Lisp_Object prefix, const char *title, bool nomenu,
2961 bool transl, bool always_title, bool mention_shadow)
2963 Lisp_Object maps, orig_maps, seen, sub_shadows;
2964 struct gcpro gcpro1, gcpro2, gcpro3;
2965 bool something = 0;
2966 const char *key_heading
2967 = "\
2968 key binding\n\
2969 --- -------\n";
2971 orig_maps = maps = Faccessible_keymaps (startmap, prefix);
2972 seen = Qnil;
2973 sub_shadows = Qnil;
2974 GCPRO3 (maps, seen, sub_shadows);
2976 if (nomenu)
2978 Lisp_Object list;
2980 /* Delete from MAPS each element that is for the menu bar. */
2981 for (list = maps; CONSP (list); list = XCDR (list))
2983 Lisp_Object elt, elt_prefix, tem;
2985 elt = XCAR (list);
2986 elt_prefix = Fcar (elt);
2987 if (ASIZE (elt_prefix) >= 1)
2989 tem = Faref (elt_prefix, make_number (0));
2990 if (EQ (tem, Qmenu_bar))
2991 maps = Fdelq (elt, maps);
2996 if (!NILP (maps) || always_title)
2998 if (title)
3000 insert_string (title);
3001 if (!NILP (prefix))
3003 insert_string (" Starting With ");
3004 insert1 (Fkey_description (prefix, Qnil));
3006 insert_string (":\n");
3008 insert_string (key_heading);
3009 something = 1;
3012 for (; CONSP (maps); maps = XCDR (maps))
3014 register Lisp_Object elt, elt_prefix, tail;
3016 elt = XCAR (maps);
3017 elt_prefix = Fcar (elt);
3019 sub_shadows = Qnil;
3021 for (tail = shadow; CONSP (tail); tail = XCDR (tail))
3023 Lisp_Object shmap;
3025 shmap = XCAR (tail);
3027 /* If the sequence by which we reach this keymap is zero-length,
3028 then the shadow map for this keymap is just SHADOW. */
3029 if ((STRINGP (elt_prefix) && SCHARS (elt_prefix) == 0)
3030 || (VECTORP (elt_prefix) && ASIZE (elt_prefix) == 0))
3032 /* If the sequence by which we reach this keymap actually has
3033 some elements, then the sequence's definition in SHADOW is
3034 what we should use. */
3035 else
3037 shmap = Flookup_key (shmap, Fcar (elt), Qt);
3038 if (INTEGERP (shmap))
3039 shmap = Qnil;
3042 /* If shmap is not nil and not a keymap,
3043 it completely shadows this map, so don't
3044 describe this map at all. */
3045 if (!NILP (shmap) && !KEYMAPP (shmap))
3046 goto skip;
3048 if (!NILP (shmap))
3049 sub_shadows = Fcons (shmap, sub_shadows);
3052 /* Maps we have already listed in this loop shadow this map. */
3053 for (tail = orig_maps; !EQ (tail, maps); tail = XCDR (tail))
3055 Lisp_Object tem;
3056 tem = Fequal (Fcar (XCAR (tail)), elt_prefix);
3057 if (!NILP (tem))
3058 sub_shadows = Fcons (XCDR (XCAR (tail)), sub_shadows);
3061 describe_map (Fcdr (elt), elt_prefix,
3062 transl ? describe_translation : describe_command,
3063 partial, sub_shadows, &seen, nomenu, mention_shadow);
3065 skip: ;
3068 if (something)
3069 insert_string ("\n");
3071 UNGCPRO;
3074 static int previous_description_column;
3076 static void
3077 describe_command (Lisp_Object definition, Lisp_Object args)
3079 register Lisp_Object tem1;
3080 ptrdiff_t column = current_column ();
3081 int description_column;
3083 /* If column 16 is no good, go to col 32;
3084 but don't push beyond that--go to next line instead. */
3085 if (column > 30)
3087 insert_char ('\n');
3088 description_column = 32;
3090 else if (column > 14 || (column > 10 && previous_description_column == 32))
3091 description_column = 32;
3092 else
3093 description_column = 16;
3095 Findent_to (make_number (description_column), make_number (1));
3096 previous_description_column = description_column;
3098 if (SYMBOLP (definition))
3100 tem1 = SYMBOL_NAME (definition);
3101 insert1 (tem1);
3102 insert_string ("\n");
3104 else if (STRINGP (definition) || VECTORP (definition))
3105 insert_string ("Keyboard Macro\n");
3106 else if (KEYMAPP (definition))
3107 insert_string ("Prefix Command\n");
3108 else
3109 insert_string ("??\n");
3112 static void
3113 describe_translation (Lisp_Object definition, Lisp_Object args)
3115 register Lisp_Object tem1;
3117 Findent_to (make_number (16), make_number (1));
3119 if (SYMBOLP (definition))
3121 tem1 = SYMBOL_NAME (definition);
3122 insert1 (tem1);
3123 insert_string ("\n");
3125 else if (STRINGP (definition) || VECTORP (definition))
3127 insert1 (Fkey_description (definition, Qnil));
3128 insert_string ("\n");
3130 else if (KEYMAPP (definition))
3131 insert_string ("Prefix Command\n");
3132 else
3133 insert_string ("??\n");
3136 /* describe_map puts all the usable elements of a sparse keymap
3137 into an array of `struct describe_map_elt',
3138 then sorts them by the events. */
3140 struct describe_map_elt
3142 Lisp_Object event;
3143 Lisp_Object definition;
3144 bool shadowed;
3147 /* qsort comparison function for sorting `struct describe_map_elt' by
3148 the event field. */
3150 static int
3151 describe_map_compare (const void *aa, const void *bb)
3153 const struct describe_map_elt *a = aa, *b = bb;
3154 if (INTEGERP (a->event) && INTEGERP (b->event))
3155 return ((XINT (a->event) > XINT (b->event))
3156 - (XINT (a->event) < XINT (b->event)));
3157 if (!INTEGERP (a->event) && INTEGERP (b->event))
3158 return 1;
3159 if (INTEGERP (a->event) && !INTEGERP (b->event))
3160 return -1;
3161 if (SYMBOLP (a->event) && SYMBOLP (b->event))
3162 return (!NILP (Fstring_lessp (a->event, b->event)) ? -1
3163 : !NILP (Fstring_lessp (b->event, a->event)) ? 1
3164 : 0);
3165 return 0;
3168 /* Describe the contents of map MAP, assuming that this map itself is
3169 reached by the sequence of prefix keys PREFIX (a string or vector).
3170 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3172 static void
3173 describe_map (Lisp_Object map, Lisp_Object prefix,
3174 void (*elt_describer) (Lisp_Object, Lisp_Object),
3175 bool partial, Lisp_Object shadow,
3176 Lisp_Object *seen, bool nomenu, bool mention_shadow)
3178 Lisp_Object tail, definition, event;
3179 Lisp_Object tem;
3180 Lisp_Object suppress;
3181 Lisp_Object kludge;
3182 bool first = 1;
3183 struct gcpro gcpro1, gcpro2, gcpro3;
3185 /* These accumulate the values from sparse keymap bindings,
3186 so we can sort them and handle them in order. */
3187 int length_needed = 0;
3188 struct describe_map_elt *vect;
3189 int slots_used = 0;
3190 int i;
3192 suppress = Qnil;
3194 if (partial)
3195 suppress = intern ("suppress-keymap");
3197 /* This vector gets used to present single keys to Flookup_key. Since
3198 that is done once per keymap element, we don't want to cons up a
3199 fresh vector every time. */
3200 kludge = Fmake_vector (make_number (1), Qnil);
3201 definition = Qnil;
3203 GCPRO3 (prefix, definition, kludge);
3205 map = call1 (Qkeymap_canonicalize, map);
3207 for (tail = map; CONSP (tail); tail = XCDR (tail))
3208 length_needed++;
3210 vect = alloca (length_needed * sizeof *vect);
3212 for (tail = map; CONSP (tail); tail = XCDR (tail))
3214 QUIT;
3216 if (VECTORP (XCAR (tail))
3217 || CHAR_TABLE_P (XCAR (tail)))
3218 describe_vector (XCAR (tail),
3219 prefix, Qnil, elt_describer, partial, shadow, map,
3220 1, mention_shadow);
3221 else if (CONSP (XCAR (tail)))
3223 bool this_shadowed = 0;
3225 event = XCAR (XCAR (tail));
3227 /* Ignore bindings whose "prefix" are not really valid events.
3228 (We get these in the frames and buffers menu.) */
3229 if (!(SYMBOLP (event) || INTEGERP (event)))
3230 continue;
3232 if (nomenu && EQ (event, Qmenu_bar))
3233 continue;
3235 definition = get_keyelt (XCDR (XCAR (tail)), 0);
3237 /* Don't show undefined commands or suppressed commands. */
3238 if (NILP (definition)) continue;
3239 if (SYMBOLP (definition) && partial)
3241 tem = Fget (definition, suppress);
3242 if (!NILP (tem))
3243 continue;
3246 /* Don't show a command that isn't really visible
3247 because a local definition of the same key shadows it. */
3249 ASET (kludge, 0, event);
3250 if (!NILP (shadow))
3252 tem = shadow_lookup (shadow, kludge, Qt, 0);
3253 if (!NILP (tem))
3255 /* If both bindings are keymaps, this key is a prefix key,
3256 so don't say it is shadowed. */
3257 if (KEYMAPP (definition) && KEYMAPP (tem))
3259 /* Avoid generating duplicate entries if the
3260 shadowed binding has the same definition. */
3261 else if (mention_shadow && !EQ (tem, definition))
3262 this_shadowed = 1;
3263 else
3264 continue;
3268 tem = Flookup_key (map, kludge, Qt);
3269 if (!EQ (tem, definition)) continue;
3271 vect[slots_used].event = event;
3272 vect[slots_used].definition = definition;
3273 vect[slots_used].shadowed = this_shadowed;
3274 slots_used++;
3276 else if (EQ (XCAR (tail), Qkeymap))
3278 /* The same keymap might be in the structure twice, if we're
3279 using an inherited keymap. So skip anything we've already
3280 encountered. */
3281 tem = Fassq (tail, *seen);
3282 if (CONSP (tem) && !NILP (Fequal (XCAR (tem), prefix)))
3283 break;
3284 *seen = Fcons (Fcons (tail, prefix), *seen);
3288 /* If we found some sparse map events, sort them. */
3290 qsort (vect, slots_used, sizeof (struct describe_map_elt),
3291 describe_map_compare);
3293 /* Now output them in sorted order. */
3295 for (i = 0; i < slots_used; i++)
3297 Lisp_Object start, end;
3299 if (first)
3301 previous_description_column = 0;
3302 insert ("\n", 1);
3303 first = 0;
3306 ASET (kludge, 0, vect[i].event);
3307 start = vect[i].event;
3308 end = start;
3310 definition = vect[i].definition;
3312 /* Find consecutive chars that are identically defined. */
3313 if (INTEGERP (vect[i].event))
3315 while (i + 1 < slots_used
3316 && EQ (vect[i+1].event, make_number (XINT (vect[i].event) + 1))
3317 && !NILP (Fequal (vect[i + 1].definition, definition))
3318 && vect[i].shadowed == vect[i + 1].shadowed)
3319 i++;
3320 end = vect[i].event;
3323 /* Now START .. END is the range to describe next. */
3325 /* Insert the string to describe the event START. */
3326 insert1 (Fkey_description (kludge, prefix));
3328 if (!EQ (start, end))
3330 insert (" .. ", 4);
3332 ASET (kludge, 0, end);
3333 /* Insert the string to describe the character END. */
3334 insert1 (Fkey_description (kludge, prefix));
3337 /* Print a description of the definition of this character.
3338 elt_describer will take care of spacing out far enough
3339 for alignment purposes. */
3340 (*elt_describer) (vect[i].definition, Qnil);
3342 if (vect[i].shadowed)
3344 ptrdiff_t pt = max (PT - 1, BEG);
3346 SET_PT (pt);
3347 insert_string ("\n (that binding is currently shadowed by another mode)");
3348 pt = min (PT + 1, Z);
3349 SET_PT (pt);
3353 UNGCPRO;
3356 static void
3357 describe_vector_princ (Lisp_Object elt, Lisp_Object fun)
3359 Findent_to (make_number (16), make_number (1));
3360 call1 (fun, elt);
3361 Fterpri (Qnil);
3364 DEFUN ("describe-vector", Fdescribe_vector, Sdescribe_vector, 1, 2, 0,
3365 doc: /* Insert a description of contents of VECTOR.
3366 This is text showing the elements of vector matched against indices.
3367 DESCRIBER is the output function used; nil means use `princ'. */)
3368 (Lisp_Object vector, Lisp_Object describer)
3370 ptrdiff_t count = SPECPDL_INDEX ();
3371 if (NILP (describer))
3372 describer = intern ("princ");
3373 specbind (Qstandard_output, Fcurrent_buffer ());
3374 CHECK_VECTOR_OR_CHAR_TABLE (vector);
3375 describe_vector (vector, Qnil, describer, describe_vector_princ, 0,
3376 Qnil, Qnil, 0, 0);
3378 return unbind_to (count, Qnil);
3381 /* Insert in the current buffer a description of the contents of VECTOR.
3382 We call ELT_DESCRIBER to insert the description of one value found
3383 in VECTOR.
3385 ELT_PREFIX describes what "comes before" the keys or indices defined
3386 by this vector. This is a human-readable string whose size
3387 is not necessarily related to the situation.
3389 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3390 leads to this keymap.
3392 If the vector is a chartable, ELT_PREFIX is the vector
3393 of bytes that lead to the character set or portion of a character
3394 set described by this chartable.
3396 If PARTIAL, it means do not mention suppressed commands
3397 (that assumes the vector is in a keymap).
3399 SHADOW is a list of keymaps that shadow this map.
3400 If it is non-nil, then we look up the key in those maps
3401 and we don't mention it now if it is defined by any of them.
3403 ENTIRE_MAP is the keymap in which this vector appears.
3404 If the definition in effect in the whole map does not match
3405 the one in this vector, we ignore this one.
3407 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3409 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3411 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3413 static void
3414 describe_vector (Lisp_Object vector, Lisp_Object prefix, Lisp_Object args,
3415 void (*elt_describer) (Lisp_Object, Lisp_Object),
3416 bool partial, Lisp_Object shadow, Lisp_Object entire_map,
3417 bool keymap_p, bool mention_shadow)
3419 Lisp_Object definition;
3420 Lisp_Object tem2;
3421 Lisp_Object elt_prefix = Qnil;
3422 int i;
3423 Lisp_Object suppress;
3424 Lisp_Object kludge;
3425 bool first = 1;
3426 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
3427 /* Range of elements to be handled. */
3428 int from, to, stop;
3429 Lisp_Object character;
3430 int starting_i;
3432 suppress = Qnil;
3434 definition = Qnil;
3436 if (!keymap_p)
3438 /* Call Fkey_description first, to avoid GC bug for the other string. */
3439 if (!NILP (prefix) && XFASTINT (Flength (prefix)) > 0)
3441 Lisp_Object tem;
3442 tem = Fkey_description (prefix, Qnil);
3443 elt_prefix = concat2 (tem, build_string (" "));
3445 prefix = Qnil;
3448 /* This vector gets used to present single keys to Flookup_key. Since
3449 that is done once per vector element, we don't want to cons up a
3450 fresh vector every time. */
3451 kludge = Fmake_vector (make_number (1), Qnil);
3452 GCPRO4 (elt_prefix, prefix, definition, kludge);
3454 if (partial)
3455 suppress = intern ("suppress-keymap");
3457 from = 0;
3458 if (CHAR_TABLE_P (vector))
3459 stop = MAX_5_BYTE_CHAR + 1, to = MAX_CHAR + 1;
3460 else
3461 stop = to = ASIZE (vector);
3463 for (i = from; ; i++)
3465 bool this_shadowed = 0;
3466 int range_beg, range_end;
3467 Lisp_Object val;
3469 QUIT;
3471 if (i == stop)
3473 if (i == to)
3474 break;
3475 stop = to;
3478 starting_i = i;
3480 if (CHAR_TABLE_P (vector))
3482 range_beg = i;
3483 i = stop - 1;
3484 val = char_table_ref_and_range (vector, range_beg, &range_beg, &i);
3486 else
3487 val = AREF (vector, i);
3488 definition = get_keyelt (val, 0);
3490 if (NILP (definition)) continue;
3492 /* Don't mention suppressed commands. */
3493 if (SYMBOLP (definition) && partial)
3495 Lisp_Object tem;
3497 tem = Fget (definition, suppress);
3499 if (!NILP (tem)) continue;
3502 character = make_number (starting_i);
3503 ASET (kludge, 0, character);
3505 /* If this binding is shadowed by some other map, ignore it. */
3506 if (!NILP (shadow))
3508 Lisp_Object tem;
3510 tem = shadow_lookup (shadow, kludge, Qt, 0);
3512 if (!NILP (tem))
3514 if (mention_shadow)
3515 this_shadowed = 1;
3516 else
3517 continue;
3521 /* Ignore this definition if it is shadowed by an earlier
3522 one in the same keymap. */
3523 if (!NILP (entire_map))
3525 Lisp_Object tem;
3527 tem = Flookup_key (entire_map, kludge, Qt);
3529 if (!EQ (tem, definition))
3530 continue;
3533 if (first)
3535 insert ("\n", 1);
3536 first = 0;
3539 /* Output the prefix that applies to every entry in this map. */
3540 if (!NILP (elt_prefix))
3541 insert1 (elt_prefix);
3543 insert1 (Fkey_description (kludge, prefix));
3545 /* Find all consecutive characters or rows that have the same
3546 definition. But, VECTOR is a char-table, we had better put a
3547 boundary between normal characters (-#x3FFF7F) and 8-bit
3548 characters (#x3FFF80-). */
3549 if (CHAR_TABLE_P (vector))
3551 while (i + 1 < stop
3552 && (range_beg = i + 1, range_end = stop - 1,
3553 val = char_table_ref_and_range (vector, range_beg,
3554 &range_beg, &range_end),
3555 tem2 = get_keyelt (val, 0),
3556 !NILP (tem2))
3557 && !NILP (Fequal (tem2, definition)))
3558 i = range_end;
3560 else
3561 while (i + 1 < stop
3562 && (tem2 = get_keyelt (AREF (vector, i + 1), 0),
3563 !NILP (tem2))
3564 && !NILP (Fequal (tem2, definition)))
3565 i++;
3567 /* If we have a range of more than one character,
3568 print where the range reaches to. */
3570 if (i != starting_i)
3572 insert (" .. ", 4);
3574 ASET (kludge, 0, make_number (i));
3576 if (!NILP (elt_prefix))
3577 insert1 (elt_prefix);
3579 insert1 (Fkey_description (kludge, prefix));
3582 /* Print a description of the definition of this character.
3583 elt_describer will take care of spacing out far enough
3584 for alignment purposes. */
3585 (*elt_describer) (definition, args);
3587 if (this_shadowed)
3589 SET_PT (PT - 1);
3590 insert_string (" (binding currently shadowed)");
3591 SET_PT (PT + 1);
3595 if (CHAR_TABLE_P (vector) && ! NILP (XCHAR_TABLE (vector)->defalt))
3597 if (!NILP (elt_prefix))
3598 insert1 (elt_prefix);
3599 insert ("default", 7);
3600 (*elt_describer) (XCHAR_TABLE (vector)->defalt, args);
3603 UNGCPRO;
3606 /* Apropos - finding all symbols whose names match a regexp. */
3607 static Lisp_Object apropos_predicate;
3608 static Lisp_Object apropos_accumulate;
3610 static void
3611 apropos_accum (Lisp_Object symbol, Lisp_Object string)
3613 register Lisp_Object tem;
3615 tem = Fstring_match (string, Fsymbol_name (symbol), Qnil);
3616 if (!NILP (tem) && !NILP (apropos_predicate))
3617 tem = call1 (apropos_predicate, symbol);
3618 if (!NILP (tem))
3619 apropos_accumulate = Fcons (symbol, apropos_accumulate);
3622 DEFUN ("apropos-internal", Fapropos_internal, Sapropos_internal, 1, 2, 0,
3623 doc: /* Show all symbols whose names contain match for REGEXP.
3624 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3625 for each symbol and a symbol is mentioned only if that returns non-nil.
3626 Return list of symbols found. */)
3627 (Lisp_Object regexp, Lisp_Object predicate)
3629 Lisp_Object tem;
3630 CHECK_STRING (regexp);
3631 apropos_predicate = predicate;
3632 apropos_accumulate = Qnil;
3633 map_obarray (Vobarray, apropos_accum, regexp);
3634 tem = Fsort (apropos_accumulate, Qstring_lessp);
3635 apropos_accumulate = Qnil;
3636 apropos_predicate = Qnil;
3637 return tem;
3640 void
3641 syms_of_keymap (void)
3643 DEFSYM (Qkeymap, "keymap");
3644 staticpro (&apropos_predicate);
3645 staticpro (&apropos_accumulate);
3646 apropos_predicate = Qnil;
3647 apropos_accumulate = Qnil;
3649 DEFSYM (Qkeymap_canonicalize, "keymap-canonicalize");
3651 /* Now we are ready to set up this property, so we can
3652 create char tables. */
3653 Fput (Qkeymap, Qchar_table_extra_slots, make_number (0));
3655 /* Initialize the keymaps standardly used.
3656 Each one is the value of a Lisp variable, and is also
3657 pointed to by a C variable */
3659 global_map = Fmake_keymap (Qnil);
3660 Fset (intern_c_string ("global-map"), global_map);
3662 current_global_map = global_map;
3663 staticpro (&global_map);
3664 staticpro (&current_global_map);
3666 meta_map = Fmake_keymap (Qnil);
3667 Fset (intern_c_string ("esc-map"), meta_map);
3668 Ffset (intern_c_string ("ESC-prefix"), meta_map);
3670 control_x_map = Fmake_keymap (Qnil);
3671 Fset (intern_c_string ("ctl-x-map"), control_x_map);
3672 Ffset (intern_c_string ("Control-X-prefix"), control_x_map);
3674 exclude_keys = listn (CONSTYPE_PURE, 5,
3675 pure_cons (build_pure_c_string ("DEL"), build_pure_c_string ("\\d")),
3676 pure_cons (build_pure_c_string ("TAB"), build_pure_c_string ("\\t")),
3677 pure_cons (build_pure_c_string ("RET"), build_pure_c_string ("\\r")),
3678 pure_cons (build_pure_c_string ("ESC"), build_pure_c_string ("\\e")),
3679 pure_cons (build_pure_c_string ("SPC"), build_pure_c_string (" ")));
3680 staticpro (&exclude_keys);
3682 DEFVAR_LISP ("define-key-rebound-commands", Vdefine_key_rebound_commands,
3683 doc: /* List of commands given new key bindings recently.
3684 This is used for internal purposes during Emacs startup;
3685 don't alter it yourself. */);
3686 Vdefine_key_rebound_commands = Qt;
3688 DEFVAR_LISP ("minibuffer-local-map", Vminibuffer_local_map,
3689 doc: /* Default keymap to use when reading from the minibuffer. */);
3690 Vminibuffer_local_map = Fmake_sparse_keymap (Qnil);
3692 DEFVAR_LISP ("minibuffer-local-ns-map", Vminibuffer_local_ns_map,
3693 doc: /* Local keymap for the minibuffer when spaces are not allowed. */);
3694 Vminibuffer_local_ns_map = Fmake_sparse_keymap (Qnil);
3695 Fset_keymap_parent (Vminibuffer_local_ns_map, Vminibuffer_local_map);
3698 DEFVAR_LISP ("minor-mode-map-alist", Vminor_mode_map_alist,
3699 doc: /* Alist of keymaps to use for minor modes.
3700 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3701 key sequences and look up bindings if VARIABLE's value is non-nil.
3702 If two active keymaps bind the same key, the keymap appearing earlier
3703 in the list takes precedence. */);
3704 Vminor_mode_map_alist = Qnil;
3706 DEFVAR_LISP ("minor-mode-overriding-map-alist", Vminor_mode_overriding_map_alist,
3707 doc: /* Alist of keymaps to use for minor modes, in current major mode.
3708 This variable is an alist just like `minor-mode-map-alist', and it is
3709 used the same way (and before `minor-mode-map-alist'); however,
3710 it is provided for major modes to bind locally. */);
3711 Vminor_mode_overriding_map_alist = Qnil;
3713 DEFVAR_LISP ("emulation-mode-map-alists", Vemulation_mode_map_alists,
3714 doc: /* List of keymap alists to use for emulation modes.
3715 It is intended for modes or packages using multiple minor-mode keymaps.
3716 Each element is a keymap alist just like `minor-mode-map-alist', or a
3717 symbol with a variable binding which is a keymap alist, and it is used
3718 the same way. The "active" keymaps in each alist are used before
3719 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3720 Vemulation_mode_map_alists = Qnil;
3722 DEFVAR_LISP ("where-is-preferred-modifier", Vwhere_is_preferred_modifier,
3723 doc: /* Preferred modifier key to use for `where-is'.
3724 When a single binding is requested, `where-is' will return one that
3725 uses this modifier key if possible. If nil, or if no such binding
3726 exists, bindings using keys without modifiers (or only with meta) will
3727 be preferred. */);
3728 Vwhere_is_preferred_modifier = Qnil;
3729 where_is_preferred_modifier = 0;
3731 staticpro (&Vmouse_events);
3732 Vmouse_events = listn (CONSTYPE_PURE, 9,
3733 intern_c_string ("menu-bar"),
3734 intern_c_string ("tool-bar"),
3735 intern_c_string ("header-line"),
3736 intern_c_string ("mode-line"),
3737 intern_c_string ("mouse-1"),
3738 intern_c_string ("mouse-2"),
3739 intern_c_string ("mouse-3"),
3740 intern_c_string ("mouse-4"),
3741 intern_c_string ("mouse-5"));
3743 DEFSYM (Qsingle_key_description, "single-key-description");
3744 DEFSYM (Qkey_description, "key-description");
3745 DEFSYM (Qkeymapp, "keymapp");
3746 DEFSYM (Qnon_ascii, "non-ascii");
3747 DEFSYM (Qmenu_item, "menu-item");
3748 DEFSYM (Qremap, "remap");
3749 DEFSYM (QCadvertised_binding, ":advertised-binding");
3751 command_remapping_vector = Fmake_vector (make_number (2), Qremap);
3752 staticpro (&command_remapping_vector);
3754 where_is_cache_keymaps = Qt;
3755 where_is_cache = Qnil;
3756 staticpro (&where_is_cache);
3757 staticpro (&where_is_cache_keymaps);
3759 defsubr (&Skeymapp);
3760 defsubr (&Skeymap_parent);
3761 defsubr (&Skeymap_prompt);
3762 defsubr (&Sset_keymap_parent);
3763 defsubr (&Smake_keymap);
3764 defsubr (&Smake_sparse_keymap);
3765 defsubr (&Smap_keymap_internal);
3766 defsubr (&Smap_keymap);
3767 defsubr (&Scopy_keymap);
3768 defsubr (&Scommand_remapping);
3769 defsubr (&Skey_binding);
3770 defsubr (&Slocal_key_binding);
3771 defsubr (&Sglobal_key_binding);
3772 defsubr (&Sminor_mode_key_binding);
3773 defsubr (&Sdefine_key);
3774 defsubr (&Slookup_key);
3775 defsubr (&Sdefine_prefix_command);
3776 defsubr (&Suse_global_map);
3777 defsubr (&Suse_local_map);
3778 defsubr (&Scurrent_local_map);
3779 defsubr (&Scurrent_global_map);
3780 defsubr (&Scurrent_minor_mode_maps);
3781 defsubr (&Scurrent_active_maps);
3782 defsubr (&Saccessible_keymaps);
3783 defsubr (&Skey_description);
3784 defsubr (&Sdescribe_vector);
3785 defsubr (&Ssingle_key_description);
3786 defsubr (&Stext_char_description);
3787 defsubr (&Swhere_is_internal);
3788 defsubr (&Sdescribe_buffer_bindings);
3789 defsubr (&Sapropos_internal);
3792 void
3793 keys_of_keymap (void)
3795 initial_define_key (global_map, 033, "ESC-prefix");
3796 initial_define_key (global_map, Ctl ('X'), "Control-X-prefix");