1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
29 #include "character.h"
32 #include "termhooks.h"
33 #include "blockinput.h"
35 #include "intervals.h"
38 /* The number of elements in keymap vectors. */
39 #define DENSE_TABLE_SIZE (0200)
41 /* Actually allocate storage for these variables */
43 Lisp_Object current_global_map
; /* Current global keymap */
45 Lisp_Object global_map
; /* default global key bindings */
47 Lisp_Object meta_map
; /* The keymap used for globally bound
48 ESC-prefixed default commands */
50 Lisp_Object control_x_map
; /* The keymap used for globally bound
51 C-x-prefixed default commands */
53 /* was MinibufLocalMap */
54 Lisp_Object Vminibuffer_local_map
;
55 /* The keymap used by the minibuf for local
56 bindings when spaces are allowed in the
59 /* was MinibufLocalNSMap */
60 Lisp_Object Vminibuffer_local_ns_map
;
61 /* The keymap used by the minibuf for local
62 bindings when spaces are not encouraged
65 /* keymap used for minibuffers when doing completion */
66 /* was MinibufLocalCompletionMap */
67 Lisp_Object Vminibuffer_local_completion_map
;
69 /* keymap used for minibuffers when doing completion in filenames */
70 Lisp_Object Vminibuffer_local_filename_completion_map
;
72 /* keymap used for minibuffers when doing completion in filenames
74 Lisp_Object Vminibuffer_local_must_match_filename_map
;
76 /* keymap used for minibuffers when doing completion and require a match */
77 /* was MinibufLocalMustMatchMap */
78 Lisp_Object Vminibuffer_local_must_match_map
;
80 /* Alist of minor mode variables and keymaps. */
81 Lisp_Object Vminor_mode_map_alist
;
83 /* Alist of major-mode-specific overrides for
84 minor mode variables and keymaps. */
85 Lisp_Object Vminor_mode_overriding_map_alist
;
87 /* List of emulation mode keymap alists. */
88 Lisp_Object Vemulation_mode_map_alists
;
90 /* Keymap mapping ASCII function key sequences onto their preferred forms.
91 Initialized by the terminal-specific lisp files. See DEFVAR for more
93 Lisp_Object Vfunction_key_map
;
95 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
96 Lisp_Object Vkey_translation_map
;
98 /* A list of all commands given new bindings since a certain time
99 when nil was stored here.
100 This is used to speed up recomputation of menu key equivalents
101 when Emacs starts up. t means don't record anything here. */
102 Lisp_Object Vdefine_key_rebound_commands
;
104 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
106 /* Alist of elements like (DEL . "\d"). */
107 static Lisp_Object exclude_keys
;
109 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
110 static Lisp_Object command_remapping_vector
;
112 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
113 in a string key sequence is equivalent to prefixing with this
115 extern Lisp_Object meta_prefix_char
;
117 extern Lisp_Object Voverriding_local_map
;
119 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
120 static Lisp_Object where_is_cache
;
121 /* Which keymaps are reverse-stored in the cache. */
122 static Lisp_Object where_is_cache_keymaps
;
124 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
125 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
127 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
128 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
129 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
130 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
131 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
132 int, Lisp_Object
, Lisp_Object
*, int, int));
133 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
134 void (*) (Lisp_Object
, Lisp_Object
), int,
135 Lisp_Object
, Lisp_Object
, int *,
137 static void silly_event_symbol_error
P_ ((Lisp_Object
));
139 /* Keymap object support - constructors and predicates. */
141 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
142 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
143 CHARTABLE is a char-table that holds the bindings for all characters
144 without modifiers. All entries in it are initially nil, meaning
145 "command undefined". ALIST is an assoc-list which holds bindings for
146 function keys, mouse events, and any other things that appear in the
147 input stream. Initially, ALIST is nil.
149 The optional arg STRING supplies a menu name for the keymap
150 in case you use it as a menu with `x-popup-menu'. */)
156 tail
= Fcons (string
, Qnil
);
159 return Fcons (Qkeymap
,
160 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
163 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
164 doc
: /* Construct and return a new sparse keymap.
165 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
166 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
167 which binds the function key or mouse event SYMBOL to DEFINITION.
168 Initially the alist is nil.
170 The optional arg STRING supplies a menu name for the keymap
171 in case you use it as a menu with `x-popup-menu'. */)
176 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
177 return Fcons (Qkeymap
, Qnil
);
180 /* This function is used for installing the standard key bindings
181 at initialization time.
185 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
188 initial_define_key (keymap
, key
, defname
)
193 store_in_keymap (keymap
, make_number (key
), intern (defname
));
197 initial_define_lispy_key (keymap
, keyname
, defname
)
202 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
205 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
206 doc
: /* Return t if OBJECT is a keymap.
208 A keymap is a list (keymap . ALIST),
209 or a symbol whose function definition is itself a keymap.
210 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
211 a vector of densely packed bindings for small character codes
212 is also allowed as an element. */)
216 return (KEYMAPP (object
) ? Qt
: Qnil
);
219 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
220 doc
: /* Return the prompt-string of a keymap MAP.
221 If non-nil, the prompt is shown in the echo-area
222 when reading a key-sequence to be looked-up in this keymap. */)
226 map
= get_keymap (map
, 0, 0);
229 Lisp_Object tem
= XCAR (map
);
237 /* Check that OBJECT is a keymap (after dereferencing through any
238 symbols). If it is, return it.
240 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
241 is an autoload form, do the autoload and try again.
242 If AUTOLOAD is nonzero, callers must assume GC is possible.
244 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
245 is zero as well), return Qt.
247 ERROR controls how we respond if OBJECT isn't a keymap.
248 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
250 Note that most of the time, we don't want to pursue autoloads.
251 Functions like Faccessible_keymaps which scan entire keymap trees
252 shouldn't load every autoloaded keymap. I'm not sure about this,
253 but it seems to me that only read_key_sequence, Flookup_key, and
254 Fdefine_key should cause keymaps to be autoloaded.
256 This function can GC when AUTOLOAD is non-zero, because it calls
257 do_autoload which can GC. */
260 get_keymap (object
, error
, autoload
)
269 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
272 tem
= indirect_function (object
);
275 if (EQ (XCAR (tem
), Qkeymap
))
278 /* Should we do an autoload? Autoload forms for keymaps have
279 Qkeymap as their fifth element. */
280 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
285 tail
= Fnth (make_number (4), tem
);
286 if (EQ (tail
, Qkeymap
))
290 struct gcpro gcpro1
, gcpro2
;
292 GCPRO2 (tem
, object
);
293 do_autoload (tem
, object
);
306 wrong_type_argument (Qkeymapp
, object
);
310 /* Return the parent map of KEYMAP, or nil if it has none.
311 We assume that KEYMAP is a valid keymap. */
314 keymap_parent (keymap
, autoload
)
320 keymap
= get_keymap (keymap
, 1, autoload
);
322 /* Skip past the initial element `keymap'. */
323 list
= XCDR (keymap
);
324 for (; CONSP (list
); list
= XCDR (list
))
326 /* See if there is another `keymap'. */
331 return get_keymap (list
, 0, autoload
);
334 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
335 doc
: /* Return the parent keymap of KEYMAP. */)
339 return keymap_parent (keymap
, 1);
342 /* Check whether MAP is one of MAPS parents. */
344 keymap_memberp (map
, maps
)
345 Lisp_Object map
, maps
;
347 if (NILP (map
)) return 0;
348 while (KEYMAPP (maps
) && !EQ (map
, maps
))
349 maps
= keymap_parent (maps
, 0);
350 return (EQ (map
, maps
));
353 /* Set the parent keymap of MAP to PARENT. */
355 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
356 doc
: /* Modify KEYMAP to set its parent map to PARENT.
357 Return PARENT. PARENT should be nil or another keymap. */)
359 Lisp_Object keymap
, parent
;
361 Lisp_Object list
, prev
;
362 struct gcpro gcpro1
, gcpro2
;
365 /* Force a keymap flush for the next call to where-is.
366 Since this can be called from within where-is, we don't set where_is_cache
367 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
368 be changed during where-is, while where_is_cache_keymaps is only used at
369 the very beginning of where-is and can thus be changed here without any
371 This is a very minor correctness (rather than safety) issue. */
372 where_is_cache_keymaps
= Qt
;
374 GCPRO2 (keymap
, parent
);
375 keymap
= get_keymap (keymap
, 1, 1);
379 parent
= get_keymap (parent
, 1, 1);
381 /* Check for cycles. */
382 if (keymap_memberp (keymap
, parent
))
383 error ("Cyclic keymap inheritance");
386 /* Skip past the initial element `keymap'. */
391 /* If there is a parent keymap here, replace it.
392 If we came to the end, add the parent in PREV. */
393 if (!CONSP (list
) || KEYMAPP (list
))
395 /* If we already have the right parent, return now
396 so that we avoid the loops below. */
397 if (EQ (XCDR (prev
), parent
))
398 RETURN_UNGCPRO (parent
);
401 XSETCDR (prev
, parent
);
407 /* Scan through for submaps, and set their parents too. */
409 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
411 /* Stop the scan when we come to the parent. */
412 if (EQ (XCAR (list
), Qkeymap
))
415 /* If this element holds a prefix map, deal with it. */
416 if (CONSP (XCAR (list
))
417 && CONSP (XCDR (XCAR (list
))))
418 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
421 if (VECTORP (XCAR (list
)))
422 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
423 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
424 fix_submap_inheritance (keymap
, make_number (i
),
425 XVECTOR (XCAR (list
))->contents
[i
]);
427 if (CHAR_TABLE_P (XCAR (list
)))
429 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
433 RETURN_UNGCPRO (parent
);
436 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
437 if EVENT is also a prefix in MAP's parent,
438 make sure that SUBMAP inherits that definition as its own parent. */
441 fix_submap_inheritance (map
, event
, submap
)
442 Lisp_Object map
, event
, submap
;
444 Lisp_Object map_parent
, parent_entry
;
446 /* SUBMAP is a cons that we found as a key binding.
447 Discard the other things found in a menu key binding. */
449 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
451 /* If it isn't a keymap now, there's no work to do. */
455 map_parent
= keymap_parent (map
, 0);
456 if (!NILP (map_parent
))
458 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
462 /* If MAP's parent has something other than a keymap,
463 our own submap shadows it completely. */
464 if (!CONSP (parent_entry
))
467 if (! EQ (parent_entry
, submap
))
469 Lisp_Object submap_parent
;
470 submap_parent
= submap
;
475 tem
= keymap_parent (submap_parent
, 0);
479 if (keymap_memberp (tem
, parent_entry
))
480 /* Fset_keymap_parent could create a cycle. */
487 Fset_keymap_parent (submap_parent
, parent_entry
);
491 /* Look up IDX in MAP. IDX may be any sort of event.
492 Note that this does only one level of lookup; IDX must be a single
493 event, not a sequence.
495 If T_OK is non-zero, bindings for Qt are treated as default
496 bindings; any key left unmentioned by other tables and bindings is
497 given the binding of Qt.
499 If T_OK is zero, bindings for Qt are not treated specially.
501 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
504 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
513 /* Qunbound in VAL means we have found no binding yet. */
516 /* If idx is a list (some sort of mouse click, perhaps?),
517 the index we want to use is the car of the list, which
518 ought to be a symbol. */
519 idx
= EVENT_HEAD (idx
);
521 /* If idx is a symbol, it might have modifiers, which need to
522 be put in the canonical order. */
524 idx
= reorder_modifiers (idx
);
525 else if (INTEGERP (idx
))
526 /* Clobber the high bits that can be present on a machine
527 with more than 24 bits of integer. */
528 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
530 /* Handle the special meta -> esc mapping. */
531 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
533 /* See if there is a meta-map. If there's none, there is
534 no binding for IDX, unless a default binding exists in MAP. */
536 Lisp_Object meta_map
;
538 /* A strange value in which Meta is set would cause
539 infinite recursion. Protect against that. */
540 if (XINT (meta_prefix_char
) & CHAR_META
)
541 meta_prefix_char
= make_number (27);
542 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
543 t_ok
, noinherit
, autoload
),
546 if (CONSP (meta_map
))
549 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
552 /* Set IDX to t, so that we only find a default binding. */
555 /* We know there is no binding. */
559 /* t_binding is where we put a default binding that applies,
560 to use in case we do not find a binding specifically
561 for this key sequence. */
564 Lisp_Object t_binding
= Qnil
;
565 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
567 GCPRO4 (map
, tail
, idx
, t_binding
);
569 /* If `t_ok' is 2, both `t' is accepted. */
572 for (tail
= XCDR (map
);
574 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
579 binding
= XCAR (tail
);
580 if (SYMBOLP (binding
))
582 /* If NOINHERIT, stop finding prefix definitions
583 after we pass a second occurrence of the `keymap' symbol. */
584 if (noinherit
&& EQ (binding
, Qkeymap
))
585 RETURN_UNGCPRO (Qnil
);
587 else if (CONSP (binding
))
589 Lisp_Object key
= XCAR (binding
);
592 val
= XCDR (binding
);
593 else if (t_ok
> 1 && EQ (key
, Qt
))
595 t_binding
= XCDR (binding
);
599 else if (VECTORP (binding
))
601 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
602 val
= AREF (binding
, XFASTINT (idx
));
604 else if (CHAR_TABLE_P (binding
))
606 /* Character codes with modifiers
607 are not included in a char-table.
608 All character codes without modifiers are included. */
609 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
611 val
= Faref (binding
, idx
);
612 /* `nil' has a special meaning for char-tables, so
613 we use something else to record an explicitly
620 /* If we found a binding, clean it up and return it. */
621 if (!EQ (val
, Qunbound
))
624 /* A Qt binding is just like an explicit nil binding
625 (i.e. it shadows any parent binding but not bindings in
626 keymaps of lower precedence). */
628 val
= get_keyelt (val
, autoload
);
630 fix_submap_inheritance (map
, idx
, val
);
631 RETURN_UNGCPRO (val
);
636 return get_keyelt (t_binding
, autoload
);
641 map_keymap_item (fun
, args
, key
, val
, data
)
642 map_keymap_function_t fun
;
643 Lisp_Object args
, key
, val
;
646 /* We should maybe try to detect bindings shadowed by previous
647 ones and things like that. */
650 (*fun
) (key
, val
, args
, data
);
654 map_keymap_char_table_item (args
, key
, val
)
655 Lisp_Object args
, key
, val
;
659 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
661 map_keymap_item (fun
, XCDR (args
), key
, val
,
662 XSAVE_VALUE (XCAR (args
))->pointer
);
666 /* Call FUN for every binding in MAP.
667 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA).
668 AUTOLOAD if non-zero means that we can autoload keymaps if necessary. */
670 map_keymap (map
, fun
, args
, data
, autoload
)
671 map_keymap_function_t fun
;
672 Lisp_Object map
, args
;
676 struct gcpro gcpro1
, gcpro2
, gcpro3
;
680 GCPRO3 (map
, args
, tail
);
681 map
= get_keymap (map
, 1, autoload
);
682 for (tail
= (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
683 CONSP (tail
) || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
));
686 Lisp_Object binding
= XCAR (tail
);
689 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
690 else if (VECTORP (binding
))
692 /* Loop over the char values represented in the vector. */
693 int len
= ASIZE (binding
);
695 for (c
= 0; c
< len
; c
++)
697 Lisp_Object character
;
698 XSETFASTINT (character
, c
);
699 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
702 else if (CHAR_TABLE_P (binding
))
704 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
705 Fcons (make_save_value (fun
, 0),
706 Fcons (make_save_value (data
, 0),
714 map_keymap_call (key
, val
, fun
, dummy
)
715 Lisp_Object key
, val
, fun
;
718 call2 (fun
, key
, val
);
721 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
722 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
723 FUNCTION is called with two arguments: the event that is bound, and
724 the definition it is bound to.
726 If KEYMAP has a parent, the parent's bindings are included as well.
727 This works recursively: if the parent has itself a parent, then the
728 grandparent's bindings are also included and so on.
729 usage: (map-keymap FUNCTION KEYMAP) */)
730 (function
, keymap
, sort_first
)
731 Lisp_Object function
, keymap
, sort_first
;
733 if (INTEGERP (function
))
734 /* We have to stop integers early since map_keymap gives them special
736 Fsignal (Qinvalid_function
, Fcons (function
, Qnil
));
737 if (! NILP (sort_first
))
738 return call3 (intern ("map-keymap-internal"), function
, keymap
, Qt
);
740 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
744 /* Given OBJECT which was found in a slot in a keymap,
745 trace indirect definitions to get the actual definition of that slot.
746 An indirect definition is a list of the form
747 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
748 and INDEX is the object to look up in KEYMAP to yield the definition.
750 Also if OBJECT has a menu string as the first element,
751 remove that. Also remove a menu help string as second element.
753 If AUTOLOAD is nonzero, load autoloadable keymaps
754 that are referred to with indirection.
756 This can GC because menu_item_eval_property calls Feval. */
759 get_keyelt (object
, autoload
)
765 if (!(CONSP (object
)))
766 /* This is really the value. */
769 /* If the keymap contents looks like (keymap ...) or (lambda ...)
771 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
774 /* If the keymap contents looks like (menu-item name . DEFN)
775 or (menu-item name DEFN ...) then use DEFN.
776 This is a new format menu item. */
777 else if (EQ (XCAR (object
), Qmenu_item
))
779 if (CONSP (XCDR (object
)))
783 object
= XCDR (XCDR (object
));
786 object
= XCAR (object
);
788 /* If there's a `:filter FILTER', apply FILTER to the
789 menu-item's definition to get the real definition to
791 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
792 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
795 filter
= XCAR (XCDR (tem
));
796 filter
= list2 (filter
, list2 (Qquote
, object
));
797 object
= menu_item_eval_property (filter
);
802 /* Invalid keymap. */
806 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
807 Keymap alist elements like (CHAR MENUSTRING . DEFN)
808 will be used by HierarKey menus. */
809 else if (STRINGP (XCAR (object
)))
811 object
= XCDR (object
);
812 /* Also remove a menu help string, if any,
813 following the menu item name. */
814 if (CONSP (object
) && STRINGP (XCAR (object
)))
815 object
= XCDR (object
);
816 /* Also remove the sublist that caches key equivalences, if any. */
817 if (CONSP (object
) && CONSP (XCAR (object
)))
820 carcar
= XCAR (XCAR (object
));
821 if (NILP (carcar
) || VECTORP (carcar
))
822 object
= XCDR (object
);
826 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
832 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
834 return (!CONSP (map
) ? object
/* Invalid keymap */
835 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
841 store_in_keymap (keymap
, idx
, def
)
843 register Lisp_Object idx
;
846 /* Flush any reverse-map cache. */
847 where_is_cache
= Qnil
;
848 where_is_cache_keymaps
= Qt
;
850 /* If we are preparing to dump, and DEF is a menu element
851 with a menu item indicator, copy it to ensure it is not pure. */
852 if (CONSP (def
) && PURE_P (def
)
853 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
854 def
= Fcons (XCAR (def
), XCDR (def
));
856 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
857 error ("attempt to define a key in a non-keymap");
859 /* If idx is a cons, and the car part is a character, idx must be of
860 the form (FROM-CHAR . TO-CHAR). */
861 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
862 CHECK_CHARACTER_CDR (idx
);
864 /* If idx is a list (some sort of mouse click, perhaps?),
865 the index we want to use is the car of the list, which
866 ought to be a symbol. */
867 idx
= EVENT_HEAD (idx
);
869 /* If idx is a symbol, it might have modifiers, which need to
870 be put in the canonical order. */
872 idx
= reorder_modifiers (idx
);
873 else if (INTEGERP (idx
))
874 /* Clobber the high bits that can be present on a machine
875 with more than 24 bits of integer. */
876 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
878 /* Scan the keymap for a binding of idx. */
882 /* The cons after which we should insert new bindings. If the
883 keymap has a table element, we record its position here, so new
884 bindings will go after it; this way, the table will stay
885 towards the front of the alist and character lookups in dense
886 keymaps will remain fast. Otherwise, this just points at the
887 front of the keymap. */
888 Lisp_Object insertion_point
;
890 insertion_point
= keymap
;
891 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
898 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
901 ASET (elt
, XFASTINT (idx
), def
);
904 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
906 int from
= XFASTINT (XCAR (idx
));
907 int to
= XFASTINT (XCDR (idx
));
909 if (to
>= ASIZE (elt
))
910 to
= ASIZE (elt
) - 1;
911 for (; from
<= to
; from
++)
912 ASET (elt
, from
, def
);
913 if (to
== XFASTINT (XCDR (idx
)))
914 /* We have defined all keys in IDX. */
917 insertion_point
= tail
;
919 else if (CHAR_TABLE_P (elt
))
921 /* Character codes with modifiers
922 are not included in a char-table.
923 All character codes without modifiers are included. */
924 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
927 /* `nil' has a special meaning for char-tables, so
928 we use something else to record an explicitly
930 NILP (def
) ? Qt
: def
);
933 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
935 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
938 insertion_point
= tail
;
940 else if (CONSP (elt
))
942 if (EQ (idx
, XCAR (elt
)))
948 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
950 int from
= XFASTINT (XCAR (idx
));
951 int to
= XFASTINT (XCDR (idx
));
953 if (from
<= XFASTINT (XCAR (elt
))
954 && to
>= XFASTINT (XCAR (elt
)))
962 else if (EQ (elt
, Qkeymap
))
963 /* If we find a 'keymap' symbol in the spine of KEYMAP,
964 then we must have found the start of a second keymap
965 being used as the tail of KEYMAP, and a binding for IDX
966 should be inserted before it. */
973 /* We have scanned the entire keymap, and not found a binding for
974 IDX. Let's add one. */
978 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
980 /* IDX specifies a range of characters, and not all of them
981 were handled yet, which means this keymap doesn't have a
982 char-table. So, we insert a char-table now. */
983 elt
= Fmake_char_table (Qkeymap
, Qnil
);
984 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
987 elt
= Fcons (idx
, def
);
988 CHECK_IMPURE (insertion_point
);
989 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
996 EXFUN (Fcopy_keymap
, 1);
999 copy_keymap_item (elt
)
1002 Lisp_Object res
, tem
;
1009 /* Is this a new format menu item. */
1010 if (EQ (XCAR (tem
), Qmenu_item
))
1012 /* Copy cell with menu-item marker. */
1013 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1017 /* Copy cell with menu-item name. */
1018 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1024 /* Copy cell with binding and if the binding is a keymap,
1026 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1029 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1030 XSETCAR (elt
, Fcopy_keymap (tem
));
1032 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1033 /* Delete cache for key equivalences. */
1034 XSETCDR (elt
, XCDR (tem
));
1039 /* It may be an old fomat menu item.
1040 Skip the optional menu string. */
1041 if (STRINGP (XCAR (tem
)))
1043 /* Copy the cell, since copy-alist didn't go this deep. */
1044 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1046 /* Also skip the optional menu help string. */
1047 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1049 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1053 /* There may also be a list that caches key equivalences.
1054 Just delete it for the new keymap. */
1056 && CONSP (XCAR (tem
))
1057 && (NILP (XCAR (XCAR (tem
)))
1058 || VECTORP (XCAR (XCAR (tem
)))))
1060 XSETCDR (elt
, XCDR (tem
));
1063 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1064 XSETCDR (elt
, Fcopy_keymap (tem
));
1066 else if (EQ (XCAR (tem
), Qkeymap
))
1067 res
= Fcopy_keymap (elt
);
1073 copy_keymap_1 (chartable
, idx
, elt
)
1074 Lisp_Object chartable
, idx
, elt
;
1076 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1079 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1080 doc
: /* Return a copy of the keymap KEYMAP.
1081 The copy starts out with the same definitions of KEYMAP,
1082 but changing either the copy or KEYMAP does not affect the other.
1083 Any key definitions that are subkeymaps are recursively copied.
1084 However, a key definition which is a symbol whose definition is a keymap
1089 register Lisp_Object copy
, tail
;
1090 keymap
= get_keymap (keymap
, 1, 0);
1091 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1092 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1094 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1096 Lisp_Object elt
= XCAR (keymap
);
1097 if (CHAR_TABLE_P (elt
))
1099 elt
= Fcopy_sequence (elt
);
1100 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1102 else if (VECTORP (elt
))
1105 elt
= Fcopy_sequence (elt
);
1106 for (i
= 0; i
< ASIZE (elt
); i
++)
1107 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1109 else if (CONSP (elt
))
1110 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1111 XSETCDR (tail
, Fcons (elt
, Qnil
));
1113 keymap
= XCDR (keymap
);
1115 XSETCDR (tail
, keymap
);
1119 /* Simple Keymap mutators and accessors. */
1121 /* GC is possible in this function if it autoloads a keymap. */
1123 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1124 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1127 KEY is a string or a vector of symbols and characters meaning a
1128 sequence of keystrokes and events. Non-ASCII characters with codes
1129 above 127 (such as ISO Latin-1) can be included if you use a vector.
1130 Using [t] for KEY creates a default definition, which applies to any
1131 event type that has no other definition in this keymap.
1133 DEF is anything that can be a key's definition:
1134 nil (means key is undefined in this keymap),
1135 a command (a Lisp function suitable for interactive calling),
1136 a string (treated as a keyboard macro),
1137 a keymap (to define a prefix key),
1138 a symbol (when the key is looked up, the symbol will stand for its
1139 function definition, which should at that time be one of the above,
1140 or another symbol whose function definition is used, etc.),
1141 a cons (STRING . DEFN), meaning that DEFN is the definition
1142 (DEFN should be a valid definition in its own right),
1143 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP.
1145 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1146 binding is altered. If there is no binding for KEY, the new pair
1147 binding KEY to DEF is added at the front of KEYMAP. */)
1154 register Lisp_Object c
;
1155 register Lisp_Object cmd
;
1159 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1161 GCPRO3 (keymap
, key
, def
);
1162 keymap
= get_keymap (keymap
, 1, 1);
1164 if (!VECTORP (key
) && !STRINGP (key
))
1165 key
= wrong_type_argument (Qarrayp
, key
);
1167 length
= XFASTINT (Flength (key
));
1169 RETURN_UNGCPRO (Qnil
);
1171 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1172 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1174 meta_bit
= VECTORP (key
) ? meta_modifier
: 0x80;
1179 c
= Faref (key
, make_number (idx
));
1183 /* C may be a Lucid style event type list or a cons (FROM .
1184 TO) specifying a range of characters. */
1185 if (lucid_event_type_list_p (c
))
1186 c
= Fevent_convert_list (c
);
1187 else if (CHARACTERP (XCAR (c
)))
1188 CHECK_CHARACTER_CDR (c
);
1192 silly_event_symbol_error (c
);
1195 && (XINT (c
) & meta_bit
)
1198 c
= meta_prefix_char
;
1204 XSETINT (c
, XINT (c
) & ~meta_bit
);
1210 if (!INTEGERP (c
) && !SYMBOLP (c
)
1212 /* If C is a range, it must be a leaf. */
1213 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1214 error ("Key sequence contains invalid event");
1217 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1219 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1221 /* If this key is undefined, make it a prefix. */
1223 cmd
= define_as_prefix (keymap
, c
);
1225 keymap
= get_keymap (cmd
, 0, 1);
1226 if (!CONSP (keymap
))
1227 /* We must use Fkey_description rather than just passing key to
1228 error; key might be a vector, not a string. */
1229 error ("Key sequence %s starts with non-prefix key %s",
1230 SDATA (Fkey_description (key
, Qnil
)),
1231 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1237 /* This function may GC (it calls Fkey_binding). */
1239 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 1, 0,
1240 doc
: /* Return the remapping for command COMMAND in current keymaps.
1241 Returns nil if COMMAND is not remapped (or not a symbol). */)
1243 Lisp_Object command
;
1245 if (!SYMBOLP (command
))
1248 ASET (command_remapping_vector
, 1, command
);
1249 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
);
1252 /* Value is number if KEY is too long; nil if valid but has no definition. */
1253 /* GC is possible in this function if it autoloads a keymap. */
1255 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1256 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1257 nil means undefined. See doc of `define-key' for kinds of definitions.
1259 A number as value means KEY is "too long";
1260 that is, characters or symbols in it except for the last one
1261 fail to be a valid sequence of prefix characters in KEYMAP.
1262 The number is how many characters at the front of KEY
1263 it takes to reach a non-prefix key.
1265 Normally, `lookup-key' ignores bindings for t, which act as default
1266 bindings, used when nothing else in the keymap applies; this makes it
1267 usable as a general function for probing keymaps. However, if the
1268 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1269 recognize the default bindings, just as `read-key-sequence' does. */)
1270 (keymap
, key
, accept_default
)
1273 Lisp_Object accept_default
;
1276 register Lisp_Object cmd
;
1277 register Lisp_Object c
;
1279 int t_ok
= !NILP (accept_default
);
1280 struct gcpro gcpro1
, gcpro2
;
1282 GCPRO2 (keymap
, key
);
1283 keymap
= get_keymap (keymap
, 1, 1);
1285 if (!VECTORP (key
) && !STRINGP (key
))
1286 key
= wrong_type_argument (Qarrayp
, key
);
1288 length
= XFASTINT (Flength (key
));
1290 RETURN_UNGCPRO (keymap
);
1295 c
= Faref (key
, make_number (idx
++));
1297 if (CONSP (c
) && lucid_event_type_list_p (c
))
1298 c
= Fevent_convert_list (c
);
1300 /* Turn the 8th bit of string chars into a meta modifier. */
1301 if (INTEGERP (c
) && XINT (c
) & 0x80 && STRINGP (key
))
1302 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1304 /* Allow string since binding for `menu-bar-select-buffer'
1305 includes the buffer name in the key sequence. */
1306 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1307 error ("Key sequence contains invalid event");
1309 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1311 RETURN_UNGCPRO (cmd
);
1313 keymap
= get_keymap (cmd
, 0, 1);
1314 if (!CONSP (keymap
))
1315 RETURN_UNGCPRO (make_number (idx
));
1321 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1322 Assume that currently it does not define C at all.
1323 Return the keymap. */
1326 define_as_prefix (keymap
, c
)
1327 Lisp_Object keymap
, c
;
1331 cmd
= Fmake_sparse_keymap (Qnil
);
1332 /* If this key is defined as a prefix in an inherited keymap,
1333 make it a prefix in this map, and make its definition
1334 inherit the other prefix definition. */
1335 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1336 store_in_keymap (keymap
, c
, cmd
);
1341 /* Append a key to the end of a key sequence. We always make a vector. */
1344 append_key (key_sequence
, key
)
1345 Lisp_Object key_sequence
, key
;
1347 Lisp_Object args
[2];
1349 args
[0] = key_sequence
;
1351 args
[1] = Fcons (key
, Qnil
);
1352 return Fvconcat (2, args
);
1355 /* Given a event type C which is a symbol,
1356 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1359 silly_event_symbol_error (c
)
1362 Lisp_Object parsed
, base
, name
, assoc
;
1365 parsed
= parse_modifiers (c
);
1366 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1367 base
= XCAR (parsed
);
1368 name
= Fsymbol_name (base
);
1369 /* This alist includes elements such as ("RET" . "\\r"). */
1370 assoc
= Fassoc (name
, exclude_keys
);
1374 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1376 Lisp_Object keystring
;
1377 if (modifiers
& alt_modifier
)
1378 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1379 if (modifiers
& ctrl_modifier
)
1380 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1381 if (modifiers
& hyper_modifier
)
1382 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1383 if (modifiers
& meta_modifier
)
1384 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1385 if (modifiers
& shift_modifier
)
1386 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1387 if (modifiers
& super_modifier
)
1388 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1391 c
= reorder_modifiers (c
);
1392 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1394 error ((modifiers
& ~meta_modifier
1395 ? "To bind the key %s, use [?%s], not [%s]"
1396 : "To bind the key %s, use \"%s\", not [%s]"),
1397 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1398 SDATA (SYMBOL_NAME (c
)));
1402 /* Global, local, and minor mode keymap stuff. */
1404 /* We can't put these variables inside current_minor_maps, since under
1405 some systems, static gets macro-defined to be the empty string.
1407 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1408 static int cmm_size
= 0;
1410 /* Store a pointer to an array of the keymaps of the currently active
1411 minor modes in *buf, and return the number of maps it contains.
1413 This function always returns a pointer to the same buffer, and may
1414 free or reallocate it, so if you want to keep it for a long time or
1415 hand it out to lisp code, copy it. This procedure will be called
1416 for every key sequence read, so the nice lispy approach (return a
1417 new assoclist, list, what have you) for each invocation would
1418 result in a lot of consing over time.
1420 If we used xrealloc/xmalloc and ran out of memory, they would throw
1421 back to the command loop, which would try to read a key sequence,
1422 which would call this function again, resulting in an infinite
1423 loop. Instead, we'll use realloc/malloc and silently truncate the
1424 list, let the key sequence be read, and hope some other piece of
1425 code signals the error. */
1427 current_minor_maps (modeptr
, mapptr
)
1428 Lisp_Object
**modeptr
, **mapptr
;
1431 int list_number
= 0;
1432 Lisp_Object alist
, assoc
, var
, val
;
1433 Lisp_Object emulation_alists
;
1434 Lisp_Object lists
[2];
1436 emulation_alists
= Vemulation_mode_map_alists
;
1437 lists
[0] = Vminor_mode_overriding_map_alist
;
1438 lists
[1] = Vminor_mode_map_alist
;
1440 for (list_number
= 0; list_number
< 2; list_number
++)
1442 if (CONSP (emulation_alists
))
1444 alist
= XCAR (emulation_alists
);
1445 emulation_alists
= XCDR (emulation_alists
);
1446 if (SYMBOLP (alist
))
1447 alist
= find_symbol_value (alist
);
1451 alist
= lists
[list_number
];
1453 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1454 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1455 && (var
= XCAR (assoc
), SYMBOLP (var
))
1456 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1461 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1462 and also an entry in Vminor_mode_map_alist,
1463 ignore the latter. */
1464 if (list_number
== 1)
1466 val
= assq_no_quit (var
, lists
[0]);
1473 int newsize
, allocsize
;
1474 Lisp_Object
*newmodes
, *newmaps
;
1476 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1477 allocsize
= newsize
* sizeof *newmodes
;
1479 /* Use malloc here. See the comment above this function.
1480 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1482 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1487 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1490 cmm_modes
= newmodes
;
1493 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1498 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1505 if (newmodes
== NULL
|| newmaps
== NULL
)
1510 /* Get the keymap definition--or nil if it is not defined. */
1511 temp
= Findirect_function (XCDR (assoc
), Qt
);
1515 cmm_maps
[i
] = temp
;
1521 if (modeptr
) *modeptr
= cmm_modes
;
1522 if (mapptr
) *mapptr
= cmm_maps
;
1526 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1528 doc
: /* Return a list of the currently active keymaps.
1529 OLP if non-nil indicates that we should obey `overriding-local-map' and
1530 `overriding-terminal-local-map'. */)
1534 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1538 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1539 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1540 /* The doc said that overriding-terminal-local-map should
1541 override overriding-local-map. The code used them both,
1542 but it seems clearer to use just one. rms, jan 2005. */
1543 else if (!NILP (Voverriding_local_map
))
1544 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1546 if (NILP (XCDR (keymaps
)))
1552 /* This usually returns the buffer's local map,
1553 but that can be overridden by a `local-map' property. */
1554 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1556 keymaps
= Fcons (local
, keymaps
);
1558 /* Now put all the minor mode keymaps on the list. */
1559 nmaps
= current_minor_maps (0, &maps
);
1561 for (i
= --nmaps
; i
>= 0; i
--)
1562 if (!NILP (maps
[i
]))
1563 keymaps
= Fcons (maps
[i
], keymaps
);
1565 /* This returns nil unless there is a `keymap' property. */
1566 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1568 keymaps
= Fcons (local
, keymaps
);
1574 /* GC is possible in this function if it autoloads a keymap. */
1576 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 3, 0,
1577 doc
: /* Return the binding for command KEY in current keymaps.
1578 KEY is a string or vector, a sequence of keystrokes.
1579 The binding is probably a symbol with a function definition.
1581 Normally, `key-binding' ignores bindings for t, which act as default
1582 bindings, used when nothing else in the keymap applies; this makes it
1583 usable as a general function for probing keymaps. However, if the
1584 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1585 recognize the default bindings, just as `read-key-sequence' does.
1587 Like the normal command loop, `key-binding' will remap the command
1588 resulting from looking up KEY by looking up the command in the
1589 current keymaps. However, if the optional third argument NO-REMAP
1590 is non-nil, `key-binding' returns the unmapped command. */)
1591 (key
, accept_default
, no_remap
)
1592 Lisp_Object key
, accept_default
, no_remap
;
1594 Lisp_Object
*maps
, value
;
1596 struct gcpro gcpro1
;
1600 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1602 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1603 key
, accept_default
);
1604 if (! NILP (value
) && !INTEGERP (value
))
1607 else if (!NILP (Voverriding_local_map
))
1609 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1610 if (! NILP (value
) && !INTEGERP (value
))
1617 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1620 value
= Flookup_key (local
, key
, accept_default
);
1621 if (! NILP (value
) && !INTEGERP (value
))
1625 nmaps
= current_minor_maps (0, &maps
);
1626 /* Note that all these maps are GCPRO'd
1627 in the places where we found them. */
1629 for (i
= 0; i
< nmaps
; i
++)
1630 if (! NILP (maps
[i
]))
1632 value
= Flookup_key (maps
[i
], key
, accept_default
);
1633 if (! NILP (value
) && !INTEGERP (value
))
1637 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1640 value
= Flookup_key (local
, key
, accept_default
);
1641 if (! NILP (value
) && !INTEGERP (value
))
1646 value
= Flookup_key (current_global_map
, key
, accept_default
);
1650 if (NILP (value
) || INTEGERP (value
))
1653 /* If the result of the ordinary keymap lookup is an interactive
1654 command, look for a key binding (ie. remapping) for that command. */
1656 if (NILP (no_remap
) && SYMBOLP (value
))
1659 if (value1
= Fcommand_remapping (value
), !NILP (value1
))
1666 /* GC is possible in this function if it autoloads a keymap. */
1668 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1669 doc
: /* Return the binding for command KEYS in current local keymap only.
1670 KEYS is a string or vector, a sequence of keystrokes.
1671 The binding is probably a symbol with a function definition.
1673 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1674 bindings; see the description of `lookup-key' for more details about this. */)
1675 (keys
, accept_default
)
1676 Lisp_Object keys
, accept_default
;
1678 register Lisp_Object map
;
1679 map
= current_buffer
->keymap
;
1682 return Flookup_key (map
, keys
, accept_default
);
1685 /* GC is possible in this function if it autoloads a keymap. */
1687 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1688 doc
: /* Return the binding for command KEYS in current global keymap only.
1689 KEYS is a string or vector, a sequence of keystrokes.
1690 The binding is probably a symbol with a function definition.
1691 This function's return values are the same as those of `lookup-key'
1694 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1695 bindings; see the description of `lookup-key' for more details about this. */)
1696 (keys
, accept_default
)
1697 Lisp_Object keys
, accept_default
;
1699 return Flookup_key (current_global_map
, keys
, accept_default
);
1702 /* GC is possible in this function if it autoloads a keymap. */
1704 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1705 doc
: /* Find the visible minor mode bindings of KEY.
1706 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1707 the symbol which names the minor mode binding KEY, and BINDING is
1708 KEY's definition in that mode. In particular, if KEY has no
1709 minor-mode bindings, return nil. If the first binding is a
1710 non-prefix, all subsequent bindings will be omitted, since they would
1711 be ignored. Similarly, the list doesn't include non-prefix bindings
1712 that come after prefix bindings.
1714 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1715 bindings; see the description of `lookup-key' for more details about this. */)
1716 (key
, accept_default
)
1717 Lisp_Object key
, accept_default
;
1719 Lisp_Object
*modes
, *maps
;
1721 Lisp_Object binding
;
1723 struct gcpro gcpro1
, gcpro2
;
1725 nmaps
= current_minor_maps (&modes
, &maps
);
1726 /* Note that all these maps are GCPRO'd
1727 in the places where we found them. */
1730 GCPRO2 (key
, binding
);
1732 for (i
= j
= 0; i
< nmaps
; i
++)
1734 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1735 && !INTEGERP (binding
))
1737 if (KEYMAPP (binding
))
1738 maps
[j
++] = Fcons (modes
[i
], binding
);
1740 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1744 return Flist (j
, maps
);
1747 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1748 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1749 A new sparse keymap is stored as COMMAND's function definition and its value.
1750 If a second optional argument MAPVAR is given, the map is stored as
1751 its value instead of as COMMAND's value; but COMMAND is still defined
1753 The third optional argument NAME, if given, supplies a menu name
1754 string for the map. This is required to use the keymap as a menu.
1755 This function returns COMMAND. */)
1756 (command
, mapvar
, name
)
1757 Lisp_Object command
, mapvar
, name
;
1760 map
= Fmake_sparse_keymap (name
);
1761 Ffset (command
, map
);
1765 Fset (command
, map
);
1769 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1770 doc
: /* Select KEYMAP as the global keymap. */)
1774 keymap
= get_keymap (keymap
, 1, 1);
1775 current_global_map
= keymap
;
1780 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1781 doc
: /* Select KEYMAP as the local keymap.
1782 If KEYMAP is nil, that means no local keymap. */)
1787 keymap
= get_keymap (keymap
, 1, 1);
1789 current_buffer
->keymap
= keymap
;
1794 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1795 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1798 return current_buffer
->keymap
;
1801 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1802 doc
: /* Return the current global keymap. */)
1805 return current_global_map
;
1808 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1809 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1813 int nmaps
= current_minor_maps (0, &maps
);
1815 return Flist (nmaps
, maps
);
1818 /* Help functions for describing and documenting keymaps. */
1822 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1823 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1824 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1828 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
1832 /* Look for and break cycles. */
1833 while (!NILP (tem
= Frassq (cmd
, maps
)))
1835 Lisp_Object prefix
= XCAR (tem
);
1836 int lim
= XINT (Flength (XCAR (tem
)));
1837 if (lim
<= XINT (Flength (thisseq
)))
1838 { /* This keymap was already seen with a smaller prefix. */
1840 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
1841 Faref (thisseq
, make_number (i
))))
1844 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1847 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1848 but maybe `cmd' occurs again further down in `maps', so keep
1850 maps
= XCDR (Fmemq (tem
, maps
));
1853 /* If the last key in thisseq is meta-prefix-char,
1854 turn it into a meta-ized keystroke. We know
1855 that the event we're about to append is an
1856 ascii keystroke since we're processing a
1860 int meta_bit
= meta_modifier
;
1861 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1862 tem
= Fcopy_sequence (thisseq
);
1864 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1866 /* This new sequence is the same length as
1867 thisseq, so stick it in the list right
1870 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1874 tem
= append_key (thisseq
, key
);
1875 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1880 accessible_keymaps_char_table (args
, index
, cmd
)
1881 Lisp_Object args
, index
, cmd
;
1883 accessible_keymaps_1 (index
, cmd
,
1887 XINT (XCDR (XCAR (args
))));
1890 /* This function cannot GC. */
1892 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1894 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1895 Returns a list of elements of the form (KEYS . MAP), where the sequence
1896 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1897 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1898 An optional argument PREFIX, if non-nil, should be a key sequence;
1899 then the value includes only maps for prefixes that start with PREFIX. */)
1901 Lisp_Object keymap
, prefix
;
1903 Lisp_Object maps
, tail
;
1906 /* no need for gcpro because we don't autoload any keymaps. */
1909 prefixlen
= XINT (Flength (prefix
));
1913 /* If a prefix was specified, start with the keymap (if any) for
1914 that prefix, so we don't waste time considering other prefixes. */
1916 tem
= Flookup_key (keymap
, prefix
, Qt
);
1917 /* Flookup_key may give us nil, or a number,
1918 if the prefix is not defined in this particular map.
1919 It might even give us a list that isn't a keymap. */
1920 tem
= get_keymap (tem
, 0, 0);
1923 /* Convert PREFIX to a vector now, so that later on
1924 we don't have to deal with the possibility of a string. */
1925 if (STRINGP (prefix
))
1930 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
1931 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
1935 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1936 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1937 c
^= 0200 | meta_modifier
;
1938 ASET (copy
, i_before
, make_number (c
));
1942 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1948 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1949 get_keymap (keymap
, 1, 0)),
1952 /* For each map in the list maps,
1953 look at any other maps it points to,
1954 and stick them at the end if they are not already in the list.
1956 This is a breadth-first traversal, where tail is the queue of
1957 nodes, and maps accumulates a list of all nodes visited. */
1959 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1961 register Lisp_Object thisseq
, thismap
;
1963 /* Does the current sequence end in the meta-prefix-char? */
1966 thisseq
= Fcar (Fcar (tail
));
1967 thismap
= Fcdr (Fcar (tail
));
1968 last
= make_number (XINT (Flength (thisseq
)) - 1);
1969 is_metized
= (XINT (last
) >= 0
1970 /* Don't metize the last char of PREFIX. */
1971 && XINT (last
) >= prefixlen
1972 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1974 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1978 elt
= XCAR (thismap
);
1982 if (CHAR_TABLE_P (elt
))
1984 map_char_table (accessible_keymaps_char_table
, Qnil
,
1985 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1986 Fcons (tail
, thisseq
)));
1988 else if (VECTORP (elt
))
1992 /* Vector keymap. Scan all the elements. */
1993 for (i
= 0; i
< ASIZE (elt
); i
++)
1994 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1995 maps
, tail
, thisseq
, is_metized
);
1998 else if (CONSP (elt
))
1999 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
2000 maps
, tail
, thisseq
,
2001 is_metized
&& INTEGERP (XCAR (elt
)));
2009 Lisp_Object Qsingle_key_description
, Qkey_description
;
2011 /* This function cannot GC. */
2013 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2014 doc
: /* Return a pretty description of key-sequence KEYS.
2015 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2016 Control characters turn into "C-foo" sequences, meta into "M-foo",
2017 spaces are put between sequence elements, etc. */)
2019 Lisp_Object keys
, prefix
;
2024 int size
= XINT (Flength (keys
));
2026 Lisp_Object sep
= build_string (" ");
2031 size
+= XINT (Flength (prefix
));
2033 /* This has one extra element at the end that we don't pass to Fconcat. */
2034 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2036 /* In effect, this computes
2037 (mapconcat 'single-key-description keys " ")
2038 but we shouldn't use mapconcat because it can do GC. */
2042 list
= prefix
, prefix
= Qnil
;
2043 else if (!NILP (keys
))
2044 list
= keys
, keys
= Qnil
;
2049 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2053 return empty_string
;
2054 return Fconcat (len
- 1, args
);
2058 size
= SCHARS (list
);
2059 else if (VECTORP (list
))
2060 size
= XVECTOR (list
)->size
;
2061 else if (CONSP (list
))
2062 size
= XINT (Flength (list
));
2064 wrong_type_argument (Qarrayp
, list
);
2073 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2074 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2075 c
^= 0200 | meta_modifier
;
2076 XSETFASTINT (key
, c
);
2078 else if (VECTORP (list
))
2080 key
= AREF (list
, i
++);
2092 || EQ (key
, meta_prefix_char
)
2093 || (XINT (key
) & meta_modifier
))
2095 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2097 if (EQ (key
, meta_prefix_char
))
2101 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2104 else if (EQ (key
, meta_prefix_char
))
2109 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2117 push_key_description (c
, p
, force_multibyte
)
2118 register unsigned int c
;
2120 int force_multibyte
;
2125 /* Clear all the meaningless bits above the meta bit. */
2126 c
&= meta_modifier
| ~ - meta_modifier
;
2127 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2128 | meta_modifier
| shift_modifier
| super_modifier
);
2130 valid_p
= SINGLE_BYTE_CHAR_P (c2
) || char_valid_p (c2
, 0);
2133 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2134 p
+= sprintf (p
, "[%d]", c
);
2138 if (c
& alt_modifier
)
2144 if ((c
& ctrl_modifier
) != 0
2145 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2149 c
&= ~ctrl_modifier
;
2151 if (c
& hyper_modifier
)
2155 c
-= hyper_modifier
;
2157 if (c
& meta_modifier
)
2163 if (c
& shift_modifier
)
2167 c
-= shift_modifier
;
2169 if (c
& super_modifier
)
2173 c
-= super_modifier
;
2189 else if (c
== Ctl ('M'))
2197 /* `C-' already added above. */
2198 if (c
> 0 && c
<= Ctl ('Z'))
2217 || (NILP (current_buffer
->enable_multibyte_characters
)
2218 && SINGLE_BYTE_CHAR_P (c
)
2219 && !force_multibyte
))
2223 else if (CHARACTERP (make_number (c
)))
2225 if (NILP (current_buffer
->enable_multibyte_characters
)
2226 && ! force_multibyte
)
2227 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2229 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2235 /* The biggest character code uses 22 bits. */
2236 for (bit_offset
= 21; bit_offset
>= 0; bit_offset
-= 3)
2238 if (c
>= (1 << bit_offset
))
2239 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
2246 /* This function cannot GC. */
2248 DEFUN ("single-key-description", Fsingle_key_description
,
2249 Ssingle_key_description
, 1, 2, 0,
2250 doc
: /* Return a pretty description of command character KEY.
2251 Control characters turn into C-whatever, etc.
2252 Optional argument NO-ANGLES non-nil means don't put angle brackets
2253 around function keys and event symbols. */)
2255 Lisp_Object key
, no_angles
;
2257 if (CONSP (key
) && lucid_event_type_list_p (key
))
2258 key
= Fevent_convert_list (key
);
2260 key
= EVENT_HEAD (key
);
2262 if (INTEGERP (key
)) /* Normal character */
2264 char tem
[KEY_DESCRIPTION_SIZE
];
2266 *push_key_description (XUINT (key
), tem
, 1) = 0;
2267 return build_string (tem
);
2269 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2271 if (NILP (no_angles
))
2274 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2275 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2276 return build_string (buffer
);
2279 return Fsymbol_name (key
);
2281 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2282 return Fcopy_sequence (key
);
2284 error ("KEY must be an integer, cons, symbol, or string");
2289 push_text_char_description (c
, p
)
2290 register unsigned int c
;
2302 *p
++ = c
+ 64; /* 'A' - 1 */
2314 /* This function cannot GC. */
2316 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2317 doc
: /* Return a pretty description of file-character CHARACTER.
2318 Control characters turn into "^char", etc. This differs from
2319 `single-key-description' which turns them into "C-char".
2320 Also, this function recognizes the 2**7 bit as the Meta character,
2321 whereas `single-key-description' uses the 2**27 bit for Meta.
2322 See Info node `(elisp)Describing Characters' for examples. */)
2324 Lisp_Object character
;
2326 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2327 unsigned char str
[6];
2330 CHECK_NUMBER (character
);
2332 c
= XINT (character
);
2333 if (!ASCII_CHAR_P (c
))
2335 int len
= CHAR_STRING (c
, str
);
2337 return make_multibyte_string (str
, 1, len
);
2340 *push_text_char_description (c
& 0377, str
) = 0;
2342 return build_string (str
);
2345 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2348 ascii_sequence_p (seq
)
2352 int len
= XINT (Flength (seq
));
2354 for (i
= 0; i
< len
; i
++)
2356 Lisp_Object ii
, elt
;
2358 XSETFASTINT (ii
, i
);
2359 elt
= Faref (seq
, ii
);
2362 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2370 /* where-is - finding a command in a set of keymaps. */
2372 static Lisp_Object
where_is_internal ();
2373 static Lisp_Object
where_is_internal_1 ();
2374 static void where_is_internal_2 ();
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. */
2380 shadow_lookup (shadow
, key
, flag
)
2381 Lisp_Object shadow
, key
, flag
;
2383 Lisp_Object tail
, value
;
2385 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2387 value
= Flookup_key (XCAR (tail
), key
, flag
);
2388 if (NATNUMP (value
))
2390 value
= Flookup_key (XCAR (tail
),
2391 Fsubstring (key
, make_number (0), value
), flag
);
2395 else if (!NILP (value
))
2401 static Lisp_Object Vmouse_events
;
2403 /* This function can GC if Flookup_key autoloads any keymaps. */
2406 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2407 Lisp_Object definition
, keymaps
;
2408 Lisp_Object firstonly
, noindirect
, no_remap
;
2410 Lisp_Object maps
= Qnil
;
2411 Lisp_Object found
, sequences
;
2412 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2413 /* 1 means ignore all menu bindings entirely. */
2414 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2416 /* If this command is remapped, then it has no key bindings
2418 if (NILP (no_remap
) && SYMBOLP (definition
))
2421 if (tem
= Fcommand_remapping (definition
), !NILP (tem
))
2426 while (CONSP (found
))
2430 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2431 found
= XCDR (found
);
2434 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2438 for (; !NILP (maps
); maps
= Fcdr (maps
))
2440 /* Key sequence to reach map, and the map that it reaches */
2441 register Lisp_Object
this, map
, tem
;
2443 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2444 [M-CHAR] sequences, check if last character of the sequence
2445 is the meta-prefix char. */
2449 this = Fcar (Fcar (maps
));
2450 map
= Fcdr (Fcar (maps
));
2451 last
= make_number (XINT (Flength (this)) - 1);
2452 last_is_meta
= (XINT (last
) >= 0
2453 && EQ (Faref (this, last
), meta_prefix_char
));
2455 /* if (nomenus && !ascii_sequence_p (this)) */
2456 if (nomenus
&& XINT (last
) >= 0
2457 && SYMBOLP (tem
= Faref (this, make_number (0)))
2458 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2459 /* If no menu entries should be returned, skip over the
2460 keymaps bound to `menu-bar' and `tool-bar' and other
2461 non-ascii prefixes like `C-down-mouse-2'. */
2468 /* Because the code we want to run on each binding is rather
2469 large, we don't want to have two separate loop bodies for
2470 sparse keymap bindings and tables; we want to iterate one
2471 loop body over both keymap and vector bindings.
2473 For this reason, if Fcar (map) is a vector, we don't
2474 advance map to the next element until i indicates that we
2475 have finished off the vector. */
2476 Lisp_Object elt
, key
, binding
;
2484 /* Set key and binding to the current key and binding, and
2485 advance map and i to the next binding. */
2488 Lisp_Object sequence
;
2490 /* In a vector, look at each element. */
2491 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2493 binding
= AREF (elt
, i
);
2494 XSETFASTINT (key
, i
);
2495 sequence
= where_is_internal_1 (binding
, key
, definition
,
2497 last
, nomenus
, last_is_meta
);
2498 if (!NILP (sequence
))
2499 sequences
= Fcons (sequence
, sequences
);
2502 else if (CHAR_TABLE_P (elt
))
2506 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2507 Qnil
), /* Result accumulator. */
2508 Fcons (Fcons (this, last
),
2509 Fcons (make_number (nomenus
),
2510 make_number (last_is_meta
))));
2511 map_char_table (where_is_internal_2
, Qnil
, elt
, args
);
2512 sequences
= XCDR (XCAR (args
));
2514 else if (CONSP (elt
))
2516 Lisp_Object sequence
;
2519 binding
= XCDR (elt
);
2521 sequence
= where_is_internal_1 (binding
, key
, definition
,
2523 last
, nomenus
, last_is_meta
);
2524 if (!NILP (sequence
))
2525 sequences
= Fcons (sequence
, sequences
);
2529 while (!NILP (sequences
))
2531 Lisp_Object sequence
, remapped
, function
;
2533 sequence
= XCAR (sequences
);
2534 sequences
= XCDR (sequences
);
2536 /* If the current sequence is a command remapping with
2537 format [remap COMMAND], find the key sequences
2538 which run COMMAND, and use those sequences instead. */
2541 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2542 && EQ (AREF (sequence
, 0), Qremap
)
2543 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2545 Lisp_Object remapped1
;
2547 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2548 if (CONSP (remapped1
))
2550 /* Verify that this key binding actually maps to the
2551 remapped command (see below). */
2552 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2554 sequence
= XCAR (remapped1
);
2555 remapped
= XCDR (remapped1
);
2556 goto record_sequence
;
2560 /* Verify that this key binding is not shadowed by another
2561 binding for the same key, before we say it exists.
2563 Mechanism: look for local definition of this key and if
2564 it is defined and does not match what we found then
2567 Either nil or number as value from Flookup_key
2569 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2573 /* Don't annoy user with strings from a menu such as
2574 Select Paste. Change them all to "(any string)",
2575 so that there seems to be only one menu item
2577 if (! NILP (sequence
))
2580 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2582 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2583 build_string ("(any string)"));
2586 /* It is a true unshadowed match. Record it, unless it's already
2587 been seen (as could happen when inheriting keymaps). */
2588 if (NILP (Fmember (sequence
, found
)))
2589 found
= Fcons (sequence
, found
);
2591 /* If firstonly is Qnon_ascii, then we can return the first
2592 binding we find. If firstonly is not Qnon_ascii but not
2593 nil, then we should return the first ascii-only binding
2595 if (EQ (firstonly
, Qnon_ascii
))
2596 RETURN_UNGCPRO (sequence
);
2597 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2598 RETURN_UNGCPRO (sequence
);
2600 if (CONSP (remapped
))
2602 sequence
= XCAR (remapped
);
2603 remapped
= XCDR (remapped
);
2604 goto record_sequence
;
2612 found
= Fnreverse (found
);
2614 /* firstonly may have been t, but we may have gone all the way through
2615 the keymaps without finding an all-ASCII key sequence. So just
2616 return the best we could find. */
2617 if (!NILP (firstonly
))
2618 return Fcar (found
);
2623 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2624 doc
: /* Return list of keys that invoke DEFINITION.
2625 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2626 If KEYMAP is nil, search all the currently active keymaps.
2627 If KEYMAP is a list of keymaps, search only those keymaps.
2629 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2630 rather than a list of all possible key sequences.
2631 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2632 no matter what it is.
2633 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2634 \(or their meta variants) and entirely reject menu bindings.
2636 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2637 to other keymaps or slots. This makes it possible to search for an
2638 indirect definition itself.
2640 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2641 that invoke a command which is remapped to DEFINITION, but include the
2642 remapped command in the returned list. */)
2643 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2644 Lisp_Object definition
, keymap
;
2645 Lisp_Object firstonly
, noindirect
, no_remap
;
2647 Lisp_Object sequences
, keymaps
;
2648 /* 1 means ignore all menu bindings entirely. */
2649 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2652 /* Find the relevant keymaps. */
2653 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2655 else if (!NILP (keymap
))
2656 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2658 keymaps
= Fcurrent_active_maps (Qnil
);
2660 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2661 We don't really need to check `keymap'. */
2662 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2666 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2668 /* Check heuristic-consistency of the cache. */
2669 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2670 where_is_cache
= Qnil
;
2672 if (NILP (where_is_cache
))
2674 /* We need to create the cache. */
2675 Lisp_Object args
[2];
2676 where_is_cache
= Fmake_hash_table (0, args
);
2677 where_is_cache_keymaps
= Qt
;
2679 /* Fill in the cache. */
2680 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2681 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2684 where_is_cache_keymaps
= keymaps
;
2687 /* We want to process definitions from the last to the first.
2688 Instead of consing, copy definitions to a vector and step
2689 over that vector. */
2690 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2691 n
= XINT (Flength (sequences
));
2692 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2693 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2694 defns
[i
++] = XCAR (sequences
);
2696 /* Verify that the key bindings are not shadowed. Note that
2697 the following can GC. */
2698 GCPRO2 (definition
, keymaps
);
2701 for (i
= n
- 1; i
>= 0; --i
)
2702 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2704 if (ascii_sequence_p (defns
[i
]))
2710 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2715 /* Kill the cache so that where_is_internal_1 doesn't think
2716 we're filling it up. */
2717 where_is_cache
= Qnil
;
2718 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2724 /* This is the function that Fwhere_is_internal calls using map_char_table.
2726 (((DEFINITION . NOINDIRECT) . RESULT)
2728 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2729 Since map_char_table doesn't really use the return value from this function,
2730 we the result append to RESULT, the slot in ARGS.
2732 KEY may be a cons (FROM . TO) where both FROM and TO are integers
2733 (i.e. character events).
2735 This function can GC because it calls where_is_internal_1 which can
2739 where_is_internal_2 (args
, key
, binding
)
2740 Lisp_Object args
, key
, binding
;
2742 Lisp_Object definition
, noindirect
, this, last
;
2743 Lisp_Object result
, sequence
;
2744 int nomenus
, last_is_meta
;
2745 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2747 GCPRO3 (args
, key
, binding
);
2748 definition
= XCAR (XCAR (XCAR (args
)));
2749 noindirect
= XCDR (XCAR (XCAR (args
)));
2750 this = XCAR (XCAR (XCDR (args
)));
2751 last
= XCDR (XCAR (XCDR (args
)));
2752 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2753 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2756 if (CONSP (key
) && INTEGERP (XCAR (key
)) && INTEGERP (XCDR (key
)))
2758 /* Try all ASCII characters. Try also non-ASCII characters but
2759 only the first and last one because trying all of them is
2760 extremely memory and time consuming.
2762 Fixme: Perhaps it should be allowed to store a cons directly
2763 in RESULT. -- handa@m17n.org */
2764 int from
= XINT (XCAR (key
)), to
= XINT (XCDR (key
));
2767 for (; from
<= to
; to
--)
2769 k
= make_number (to
);
2770 sequence
= where_is_internal_1 (binding
, k
, definition
, noindirect
,
2771 this, last
, nomenus
, last_is_meta
);
2772 if (!NILP (sequence
))
2773 result
= Fcons (sequence
, result
);
2780 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2781 this, last
, nomenus
, last_is_meta
);
2782 if (!NILP (sequence
))
2783 result
= Fcons (sequence
, Qnil
);
2786 if (! NILP (result
))
2787 nconc2 (XCAR (args
), result
);
2793 /* This function can GC because get_keyelt can. */
2796 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2797 nomenus
, last_is_meta
)
2798 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2799 int nomenus
, last_is_meta
;
2801 Lisp_Object sequence
;
2803 /* Search through indirections unless that's not wanted. */
2804 if (NILP (noindirect
))
2805 binding
= get_keyelt (binding
, 0);
2807 /* End this iteration if this element does not match
2810 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2811 || EQ (binding
, definition
)
2812 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2813 /* Doesn't match. */
2816 /* We have found a match. Construct the key sequence where we found it. */
2817 if (INTEGERP (key
) && last_is_meta
)
2819 sequence
= Fcopy_sequence (this);
2820 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2823 sequence
= append_key (this, key
);
2825 if (!NILP (where_is_cache
))
2827 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2828 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2835 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2837 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2838 doc
: /* Insert the list of all defined keys and their definitions.
2839 The list is inserted in the current buffer, while the bindings are
2840 looked up in BUFFER.
2841 The optional argument PREFIX, if non-nil, should be a key sequence;
2842 then we display only bindings that start with that prefix.
2843 The optional argument MENUS, if non-nil, says to mention menu bindings.
2844 \(Ordinarily these are omitted from the output.) */)
2845 (buffer
, prefix
, menus
)
2846 Lisp_Object buffer
, prefix
, menus
;
2848 Lisp_Object outbuf
, shadow
;
2849 int nomenu
= NILP (menus
);
2850 register Lisp_Object start1
;
2851 struct gcpro gcpro1
;
2853 char *alternate_heading
2855 Keyboard translations:\n\n\
2856 You type Translation\n\
2857 -------- -----------\n";
2862 outbuf
= Fcurrent_buffer ();
2864 /* Report on alternates for keys. */
2865 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2868 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2869 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2871 for (c
= 0; c
< translate_len
; c
++)
2872 if (translate
[c
] != c
)
2874 char buf
[KEY_DESCRIPTION_SIZE
];
2877 if (alternate_heading
)
2879 insert_string (alternate_heading
);
2880 alternate_heading
= 0;
2883 bufend
= push_key_description (translate
[c
], buf
, 1);
2884 insert (buf
, bufend
- buf
);
2885 Findent_to (make_number (16), make_number (1));
2886 bufend
= push_key_description (c
, buf
, 1);
2887 insert (buf
, bufend
- buf
);
2891 /* Insert calls signal_after_change which may GC. */
2892 translate
= SDATA (Vkeyboard_translate_table
);
2898 if (!NILP (Vkey_translation_map
))
2899 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2900 "Key translations", nomenu
, 1, 0, 0);
2903 /* Print the (major mode) local map. */
2905 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2906 start1
= current_kboard
->Voverriding_terminal_local_map
;
2907 else if (!NILP (Voverriding_local_map
))
2908 start1
= Voverriding_local_map
;
2912 describe_map_tree (start1
, 1, shadow
, prefix
,
2913 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
2914 shadow
= Fcons (start1
, shadow
);
2918 /* Print the minor mode and major mode keymaps. */
2920 Lisp_Object
*modes
, *maps
;
2922 /* Temporarily switch to `buffer', so that we can get that buffer's
2923 minor modes correctly. */
2924 Fset_buffer (buffer
);
2926 nmaps
= current_minor_maps (&modes
, &maps
);
2927 Fset_buffer (outbuf
);
2929 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2930 XBUFFER (buffer
), Qkeymap
);
2933 describe_map_tree (start1
, 1, shadow
, prefix
,
2934 "\f\n`keymap' Property Bindings", nomenu
,
2936 shadow
= Fcons (start1
, shadow
);
2939 /* Print the minor mode maps. */
2940 for (i
= 0; i
< nmaps
; i
++)
2942 /* The title for a minor mode keymap
2943 is constructed at run time.
2944 We let describe_map_tree do the actual insertion
2945 because it takes care of other features when doing so. */
2948 if (!SYMBOLP (modes
[i
]))
2951 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
2955 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
2956 SCHARS (SYMBOL_NAME (modes
[i
])));
2957 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
2959 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2960 p
+= sizeof (" Minor Mode Bindings") - 1;
2963 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
2964 title
, nomenu
, 0, 0, 0);
2965 shadow
= Fcons (maps
[i
], shadow
);
2968 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2969 XBUFFER (buffer
), Qlocal_map
);
2972 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
2973 describe_map_tree (start1
, 1, shadow
, prefix
,
2974 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
2976 describe_map_tree (start1
, 1, shadow
, prefix
,
2977 "\f\n`local-map' Property Bindings",
2980 shadow
= Fcons (start1
, shadow
);
2984 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2985 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
2987 /* Print the function-key-map translations under this prefix. */
2988 if (!NILP (Vfunction_key_map
))
2989 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2990 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
2996 /* Insert a description of the key bindings in STARTMAP,
2997 followed by those of all maps reachable through STARTMAP.
2998 If PARTIAL is nonzero, omit certain "uninteresting" commands
2999 (such as `undefined').
3000 If SHADOW is non-nil, it is a list of maps;
3001 don't mention keys which would be shadowed by any of them.
3002 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3003 TITLE, if not 0, is a string to insert at the beginning.
3004 TITLE should not end with a colon or a newline; we supply that.
3005 If NOMENU is not 0, then omit menu-bar commands.
3007 If TRANSL is nonzero, the definitions are actually key translations
3008 so print strings and vectors differently.
3010 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3013 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3014 don't omit it; instead, mention it but say it is shadowed. */
3017 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3018 always_title
, mention_shadow
)
3019 Lisp_Object startmap
, shadow
, prefix
;
3027 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3028 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3035 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3038 GCPRO3 (maps
, seen
, sub_shadows
);
3044 /* Delete from MAPS each element that is for the menu bar. */
3045 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3047 Lisp_Object elt
, prefix
, tem
;
3050 prefix
= Fcar (elt
);
3051 if (XVECTOR (prefix
)->size
>= 1)
3053 tem
= Faref (prefix
, make_number (0));
3054 if (EQ (tem
, Qmenu_bar
))
3055 maps
= Fdelq (elt
, maps
);
3060 if (!NILP (maps
) || always_title
)
3064 insert_string (title
);
3067 insert_string (" Starting With ");
3068 insert1 (Fkey_description (prefix
, Qnil
));
3070 insert_string (":\n");
3072 insert_string (key_heading
);
3076 for (; !NILP (maps
); maps
= Fcdr (maps
))
3078 register Lisp_Object elt
, prefix
, tail
;
3081 prefix
= Fcar (elt
);
3085 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3089 shmap
= XCAR (tail
);
3091 /* If the sequence by which we reach this keymap is zero-length,
3092 then the shadow map for this keymap is just SHADOW. */
3093 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3094 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3096 /* If the sequence by which we reach this keymap actually has
3097 some elements, then the sequence's definition in SHADOW is
3098 what we should use. */
3101 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3102 if (INTEGERP (shmap
))
3106 /* If shmap is not nil and not a keymap,
3107 it completely shadows this map, so don't
3108 describe this map at all. */
3109 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3113 sub_shadows
= Fcons (shmap
, sub_shadows
);
3116 /* Maps we have already listed in this loop shadow this map. */
3117 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3120 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3122 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3125 describe_map (Fcdr (elt
), prefix
,
3126 transl
? describe_translation
: describe_command
,
3127 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3133 insert_string ("\n");
3138 static int previous_description_column
;
3141 describe_command (definition
, args
)
3142 Lisp_Object definition
, args
;
3144 register Lisp_Object tem1
;
3145 int column
= (int) current_column (); /* iftc */
3146 int description_column
;
3148 /* If column 16 is no good, go to col 32;
3149 but don't push beyond that--go to next line instead. */
3153 description_column
= 32;
3155 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3156 description_column
= 32;
3158 description_column
= 16;
3160 Findent_to (make_number (description_column
), make_number (1));
3161 previous_description_column
= description_column
;
3163 if (SYMBOLP (definition
))
3165 tem1
= SYMBOL_NAME (definition
);
3167 insert_string ("\n");
3169 else if (STRINGP (definition
) || VECTORP (definition
))
3170 insert_string ("Keyboard Macro\n");
3171 else if (KEYMAPP (definition
))
3172 insert_string ("Prefix Command\n");
3174 insert_string ("??\n");
3178 describe_translation (definition
, args
)
3179 Lisp_Object definition
, args
;
3181 register Lisp_Object tem1
;
3183 Findent_to (make_number (16), make_number (1));
3185 if (SYMBOLP (definition
))
3187 tem1
= SYMBOL_NAME (definition
);
3189 insert_string ("\n");
3191 else if (STRINGP (definition
) || VECTORP (definition
))
3193 insert1 (Fkey_description (definition
, Qnil
));
3194 insert_string ("\n");
3196 else if (KEYMAPP (definition
))
3197 insert_string ("Prefix Command\n");
3199 insert_string ("??\n");
3202 /* describe_map puts all the usable elements of a sparse keymap
3203 into an array of `struct describe_map_elt',
3204 then sorts them by the events. */
3206 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3208 /* qsort comparison function for sorting `struct describe_map_elt' by
3212 describe_map_compare (aa
, bb
)
3213 const void *aa
, *bb
;
3215 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3216 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3217 return ((XINT (a
->event
) > XINT (b
->event
))
3218 - (XINT (a
->event
) < XINT (b
->event
)));
3219 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3221 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3223 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3224 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3225 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3230 /* Describe the contents of map MAP, assuming that this map itself is
3231 reached by the sequence of prefix keys PREFIX (a string or vector).
3232 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3235 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3236 seen
, nomenu
, mention_shadow
)
3237 register Lisp_Object map
;
3239 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3246 Lisp_Object tail
, definition
, event
;
3248 Lisp_Object suppress
;
3251 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3253 /* These accumulate the values from sparse keymap bindings,
3254 so we can sort them and handle them in order. */
3255 int length_needed
= 0;
3256 struct describe_map_elt
*vect
;
3263 suppress
= intern ("suppress-keymap");
3265 /* This vector gets used to present single keys to Flookup_key. Since
3266 that is done once per keymap element, we don't want to cons up a
3267 fresh vector every time. */
3268 kludge
= Fmake_vector (make_number (1), Qnil
);
3271 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3274 vect
= ((struct describe_map_elt
*)
3275 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3277 GCPRO3 (prefix
, definition
, kludge
);
3279 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3283 if (VECTORP (XCAR (tail
))
3284 || CHAR_TABLE_P (XCAR (tail
)))
3285 describe_vector (XCAR (tail
),
3286 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3287 (int *)0, 0, 1, mention_shadow
);
3288 else if (CONSP (XCAR (tail
)))
3290 int this_shadowed
= 0;
3292 event
= XCAR (XCAR (tail
));
3294 /* Ignore bindings whose "prefix" are not really valid events.
3295 (We get these in the frames and buffers menu.) */
3296 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3299 if (nomenu
&& EQ (event
, Qmenu_bar
))
3302 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3304 /* Don't show undefined commands or suppressed commands. */
3305 if (NILP (definition
)) continue;
3306 if (SYMBOLP (definition
) && partial
)
3308 tem
= Fget (definition
, suppress
);
3313 /* Don't show a command that isn't really visible
3314 because a local definition of the same key shadows it. */
3316 ASET (kludge
, 0, event
);
3319 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3322 /* Avoid generating duplicate entries if the
3323 shadowed binding has the same definition. */
3324 if (mention_shadow
&& !EQ (tem
, definition
))
3331 tem
= Flookup_key (map
, kludge
, Qt
);
3332 if (!EQ (tem
, definition
)) continue;
3334 vect
[slots_used
].event
= event
;
3335 vect
[slots_used
].definition
= definition
;
3336 vect
[slots_used
].shadowed
= this_shadowed
;
3339 else if (EQ (XCAR (tail
), Qkeymap
))
3341 /* The same keymap might be in the structure twice, if we're
3342 using an inherited keymap. So skip anything we've already
3344 tem
= Fassq (tail
, *seen
);
3345 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3347 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3351 /* If we found some sparse map events, sort them. */
3353 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3354 describe_map_compare
);
3356 /* Now output them in sorted order. */
3358 for (i
= 0; i
< slots_used
; i
++)
3360 Lisp_Object start
, end
;
3364 previous_description_column
= 0;
3369 ASET (kludge
, 0, vect
[i
].event
);
3370 start
= vect
[i
].event
;
3373 definition
= vect
[i
].definition
;
3375 /* Find consecutive chars that are identically defined. */
3376 if (INTEGERP (vect
[i
].event
))
3378 while (i
+ 1 < slots_used
3379 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3380 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3381 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3383 end
= vect
[i
].event
;
3386 /* Now START .. END is the range to describe next. */
3388 /* Insert the string to describe the event START. */
3389 insert1 (Fkey_description (kludge
, prefix
));
3391 if (!EQ (start
, end
))
3395 ASET (kludge
, 0, end
);
3396 /* Insert the string to describe the character END. */
3397 insert1 (Fkey_description (kludge
, prefix
));
3400 /* Print a description of the definition of this character.
3401 elt_describer will take care of spacing out far enough
3402 for alignment purposes. */
3403 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3405 if (vect
[i
].shadowed
)
3408 insert_string ("\n (that binding is currently shadowed by another mode)");
3417 describe_vector_princ (elt
, fun
)
3418 Lisp_Object elt
, fun
;
3420 Findent_to (make_number (16), make_number (1));
3425 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3426 doc
: /* Insert a description of contents of VECTOR.
3427 This is text showing the elements of vector matched against indices.
3428 DESCRIBER is the output function used; nil means use `princ'. */)
3430 Lisp_Object vector
, describer
;
3432 int count
= SPECPDL_INDEX ();
3433 if (NILP (describer
))
3434 describer
= intern ("princ");
3435 specbind (Qstandard_output
, Fcurrent_buffer ());
3436 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3437 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3438 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3440 return unbind_to (count
, Qnil
);
3443 /* Insert in the current buffer a description of the contents of VECTOR.
3444 We call ELT_DESCRIBER to insert the description of one value found
3447 ELT_PREFIX describes what "comes before" the keys or indices defined
3448 by this vector. This is a human-readable string whose size
3449 is not necessarily related to the situation.
3451 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3452 leads to this keymap.
3454 If the vector is a chartable, ELT_PREFIX is the vector
3455 of bytes that lead to the character set or portion of a character
3456 set described by this chartable.
3458 If PARTIAL is nonzero, it means do not mention suppressed commands
3459 (that assumes the vector is in a keymap).
3461 SHADOW is a list of keymaps that shadow this map.
3462 If it is non-nil, then we look up the key in those maps
3463 and we don't mention it now if it is defined by any of them.
3465 ENTIRE_MAP is the keymap in which this vector appears.
3466 If the definition in effect in the whole map does not match
3467 the one in this vector, we ignore this one.
3469 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3471 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3474 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3476 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3479 describe_vector (vector
, prefix
, args
, elt_describer
,
3480 partial
, shadow
, entire_map
,
3481 indices
, char_table_depth
, keymap_p
,
3483 register Lisp_Object vector
;
3484 Lisp_Object prefix
, args
;
3485 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3488 Lisp_Object entire_map
;
3490 int char_table_depth
;
3494 Lisp_Object definition
;
3496 Lisp_Object elt_prefix
= Qnil
;
3498 Lisp_Object suppress
;
3501 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3502 /* Range of elements to be handled. */
3504 Lisp_Object character
;
3513 /* Call Fkey_description first, to avoid GC bug for the other string. */
3514 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3517 tem
= Fkey_description (prefix
, Qnil
);
3518 elt_prefix
= concat2 (tem
, build_string (" "));
3523 /* This vector gets used to present single keys to Flookup_key. Since
3524 that is done once per vector element, we don't want to cons up a
3525 fresh vector every time. */
3526 kludge
= Fmake_vector (make_number (1), Qnil
);
3527 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3530 suppress
= intern ("suppress-keymap");
3533 to
= CHAR_TABLE_P (vector
) ? MAX_CHAR
+ 1 : XVECTOR (vector
)->size
;
3535 for (i
= from
; i
< to
; i
++)
3537 int this_shadowed
= 0;
3538 int range_beg
, range_end
;
3545 if (CHAR_TABLE_P (vector
))
3546 val
= char_table_ref_and_range (vector
, i
, &range_beg
, &i
);
3548 val
= AREF (vector
, i
);
3549 definition
= get_keyelt (val
, 0);
3551 if (NILP (definition
)) continue;
3553 /* Don't mention suppressed commands. */
3554 if (SYMBOLP (definition
) && partial
)
3558 tem
= Fget (definition
, suppress
);
3560 if (!NILP (tem
)) continue;
3563 character
= make_number (starting_i
);
3564 ASET (kludge
, 0, character
);
3566 /* If this binding is shadowed by some other map, ignore it. */
3571 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3582 /* Ignore this definition if it is shadowed by an earlier
3583 one in the same keymap. */
3584 if (!NILP (entire_map
))
3588 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3590 if (!EQ (tem
, definition
))
3600 /* Output the prefix that applies to every entry in this map. */
3601 if (!NILP (elt_prefix
))
3602 insert1 (elt_prefix
);
3604 insert1 (Fkey_description (kludge
, prefix
));
3606 /* Find all consecutive characters or rows that have the same
3607 definition. But, for elements of a top level char table, if
3608 they are for charsets, we had better describe one by one even
3609 if they have the same definition. */
3610 if (CHAR_TABLE_P (vector
))
3612 && (val
= char_table_ref_and_range (vector
, i
+ 1,
3613 &range_beg
, &range_end
),
3614 tem2
= get_keyelt (val
, 0),
3616 && !NILP (Fequal (tem2
, definition
)))
3620 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3622 && !NILP (Fequal (tem2
, definition
)))
3625 /* If we have a range of more than one character,
3626 print where the range reaches to. */
3628 if (i
!= starting_i
)
3632 ASET (kludge
, 0, make_number (i
));
3634 if (!NILP (elt_prefix
))
3635 insert1 (elt_prefix
);
3637 insert1 (Fkey_description (kludge
, prefix
));
3640 /* Print a description of the definition of this character.
3641 elt_describer will take care of spacing out far enough
3642 for alignment purposes. */
3643 (*elt_describer
) (definition
, args
);
3648 insert_string (" (binding currently shadowed)");
3653 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3655 if (!NILP (elt_prefix
))
3656 insert1 (elt_prefix
);
3657 insert ("default", 7);
3658 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3664 /* Apropos - finding all symbols whose names match a regexp. */
3665 static Lisp_Object apropos_predicate
;
3666 static Lisp_Object apropos_accumulate
;
3669 apropos_accum (symbol
, string
)
3670 Lisp_Object symbol
, string
;
3672 register Lisp_Object tem
;
3674 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3675 if (!NILP (tem
) && !NILP (apropos_predicate
))
3676 tem
= call1 (apropos_predicate
, symbol
);
3678 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3681 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3682 doc
: /* Show all symbols whose names contain match for REGEXP.
3683 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3684 for each symbol and a symbol is mentioned only if that returns non-nil.
3685 Return list of symbols found. */)
3687 Lisp_Object regexp
, predicate
;
3690 CHECK_STRING (regexp
);
3691 apropos_predicate
= predicate
;
3692 apropos_accumulate
= Qnil
;
3693 map_obarray (Vobarray
, apropos_accum
, regexp
);
3694 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3695 apropos_accumulate
= Qnil
;
3696 apropos_predicate
= Qnil
;
3703 Qkeymap
= intern ("keymap");
3704 staticpro (&Qkeymap
);
3705 staticpro (&apropos_predicate
);
3706 staticpro (&apropos_accumulate
);
3707 apropos_predicate
= Qnil
;
3708 apropos_accumulate
= Qnil
;
3710 /* Now we are ready to set up this property, so we can
3711 create char tables. */
3712 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3714 /* Initialize the keymaps standardly used.
3715 Each one is the value of a Lisp variable, and is also
3716 pointed to by a C variable */
3718 global_map
= Fmake_keymap (Qnil
);
3719 Fset (intern ("global-map"), global_map
);
3721 current_global_map
= global_map
;
3722 staticpro (&global_map
);
3723 staticpro (¤t_global_map
);
3725 meta_map
= Fmake_keymap (Qnil
);
3726 Fset (intern ("esc-map"), meta_map
);
3727 Ffset (intern ("ESC-prefix"), meta_map
);
3729 control_x_map
= Fmake_keymap (Qnil
);
3730 Fset (intern ("ctl-x-map"), control_x_map
);
3731 Ffset (intern ("Control-X-prefix"), control_x_map
);
3734 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3735 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3736 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3737 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3738 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3740 staticpro (&exclude_keys
);
3742 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3743 doc
: /* List of commands given new key bindings recently.
3744 This is used for internal purposes during Emacs startup;
3745 don't alter it yourself. */);
3746 Vdefine_key_rebound_commands
= Qt
;
3748 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3749 doc
: /* Default keymap to use when reading from the minibuffer. */);
3750 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3752 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3753 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3754 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3755 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3757 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3758 doc
: /* Local keymap for minibuffer input with completion. */);
3759 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3760 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3762 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3763 &Vminibuffer_local_filename_completion_map
,
3764 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3765 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3766 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3767 Vminibuffer_local_completion_map
);
3770 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3771 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3772 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3773 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3774 Vminibuffer_local_completion_map
);
3776 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
3777 &Vminibuffer_local_must_match_filename_map
,
3778 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3779 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
3780 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
3781 Vminibuffer_local_must_match_map
);
3783 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3784 doc
: /* Alist of keymaps to use for minor modes.
3785 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3786 key sequences and look up bindings iff VARIABLE's value is non-nil.
3787 If two active keymaps bind the same key, the keymap appearing earlier
3788 in the list takes precedence. */);
3789 Vminor_mode_map_alist
= Qnil
;
3791 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3792 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3793 This variable is an alist just like `minor-mode-map-alist', and it is
3794 used the same way (and before `minor-mode-map-alist'); however,
3795 it is provided for major modes to bind locally. */);
3796 Vminor_mode_overriding_map_alist
= Qnil
;
3798 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3799 doc
: /* List of keymap alists to use for emulations modes.
3800 It is intended for modes or packages using multiple minor-mode keymaps.
3801 Each element is a keymap alist just like `minor-mode-map-alist', or a
3802 symbol with a variable binding which is a keymap alist, and it is used
3803 the same way. The "active" keymaps in each alist are used before
3804 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3805 Vemulation_mode_map_alists
= Qnil
;
3808 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3809 doc
: /* Keymap that translates key sequences to key sequences during input.
3810 This is used mainly for mapping ASCII function key sequences into
3811 real Emacs function key events (symbols).
3813 The `read-key-sequence' function replaces any subsequence bound by
3814 `function-key-map' with its binding. More precisely, when the active
3815 keymaps have no binding for the current key sequence but
3816 `function-key-map' binds a suffix of the sequence to a vector or string,
3817 `read-key-sequence' replaces the matching suffix with its binding, and
3818 continues with the new sequence.
3820 If the binding is a function, it is called with one argument (the prompt)
3821 and its return value (a key sequence) is used.
3823 The events that come from bindings in `function-key-map' are not
3824 themselves looked up in `function-key-map'.
3826 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3827 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3828 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3829 key, typing `ESC O P x' would return [f1 x]. */);
3830 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3832 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3833 doc
: /* Keymap of key translations that can override keymaps.
3834 This keymap works like `function-key-map', but comes after that,
3835 and its non-prefix bindings override ordinary bindings. */);
3836 Vkey_translation_map
= Qnil
;
3838 staticpro (&Vmouse_events
);
3839 Vmouse_events
= Fcons (intern ("menu-bar"),
3840 Fcons (intern ("tool-bar"),
3841 Fcons (intern ("header-line"),
3842 Fcons (intern ("mode-line"),
3843 Fcons (intern ("mouse-1"),
3844 Fcons (intern ("mouse-2"),
3845 Fcons (intern ("mouse-3"),
3846 Fcons (intern ("mouse-4"),
3847 Fcons (intern ("mouse-5"),
3851 Qsingle_key_description
= intern ("single-key-description");
3852 staticpro (&Qsingle_key_description
);
3854 Qkey_description
= intern ("key-description");
3855 staticpro (&Qkey_description
);
3857 Qkeymapp
= intern ("keymapp");
3858 staticpro (&Qkeymapp
);
3860 Qnon_ascii
= intern ("non-ascii");
3861 staticpro (&Qnon_ascii
);
3863 Qmenu_item
= intern ("menu-item");
3864 staticpro (&Qmenu_item
);
3866 Qremap
= intern ("remap");
3867 staticpro (&Qremap
);
3869 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3870 staticpro (&command_remapping_vector
);
3872 where_is_cache_keymaps
= Qt
;
3873 where_is_cache
= Qnil
;
3874 staticpro (&where_is_cache
);
3875 staticpro (&where_is_cache_keymaps
);
3877 defsubr (&Skeymapp
);
3878 defsubr (&Skeymap_parent
);
3879 defsubr (&Skeymap_prompt
);
3880 defsubr (&Sset_keymap_parent
);
3881 defsubr (&Smake_keymap
);
3882 defsubr (&Smake_sparse_keymap
);
3883 defsubr (&Smap_keymap
);
3884 defsubr (&Scopy_keymap
);
3885 defsubr (&Scommand_remapping
);
3886 defsubr (&Skey_binding
);
3887 defsubr (&Slocal_key_binding
);
3888 defsubr (&Sglobal_key_binding
);
3889 defsubr (&Sminor_mode_key_binding
);
3890 defsubr (&Sdefine_key
);
3891 defsubr (&Slookup_key
);
3892 defsubr (&Sdefine_prefix_command
);
3893 defsubr (&Suse_global_map
);
3894 defsubr (&Suse_local_map
);
3895 defsubr (&Scurrent_local_map
);
3896 defsubr (&Scurrent_global_map
);
3897 defsubr (&Scurrent_minor_mode_maps
);
3898 defsubr (&Scurrent_active_maps
);
3899 defsubr (&Saccessible_keymaps
);
3900 defsubr (&Skey_description
);
3901 defsubr (&Sdescribe_vector
);
3902 defsubr (&Ssingle_key_description
);
3903 defsubr (&Stext_char_description
);
3904 defsubr (&Swhere_is_internal
);
3905 defsubr (&Sdescribe_buffer_bindings
);
3906 defsubr (&Sapropos_internal
);
3912 initial_define_key (global_map
, 033, "ESC-prefix");
3913 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
3916 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
3917 (do not change this comment) */