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 xsignal1 (Qinvalid_function
, function
);
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 CHECK_VECTOR_OR_STRING (key
);
1166 length
= XFASTINT (Flength (key
));
1168 RETURN_UNGCPRO (Qnil
);
1170 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1171 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1173 meta_bit
= VECTORP (key
) ? meta_modifier
: 0x80;
1175 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, make_number (0))))
1176 { /* DEF is apparently an XEmacs-style keyboard macro. */
1177 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1178 int i
= ASIZE (def
);
1181 Lisp_Object c
= AREF (def
, i
);
1182 if (CONSP (c
) && lucid_event_type_list_p (c
))
1183 c
= Fevent_convert_list (c
);
1192 c
= Faref (key
, make_number (idx
));
1196 /* C may be a Lucid style event type list or a cons (FROM .
1197 TO) specifying a range of characters. */
1198 if (lucid_event_type_list_p (c
))
1199 c
= Fevent_convert_list (c
);
1200 else if (CHARACTERP (XCAR (c
)))
1201 CHECK_CHARACTER_CDR (c
);
1205 silly_event_symbol_error (c
);
1208 && (XINT (c
) & meta_bit
)
1211 c
= meta_prefix_char
;
1217 XSETINT (c
, XINT (c
) & ~meta_bit
);
1223 if (!INTEGERP (c
) && !SYMBOLP (c
)
1225 /* If C is a range, it must be a leaf. */
1226 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1227 error ("Key sequence contains invalid event");
1230 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1232 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1234 /* If this key is undefined, make it a prefix. */
1236 cmd
= define_as_prefix (keymap
, c
);
1238 keymap
= get_keymap (cmd
, 0, 1);
1239 if (!CONSP (keymap
))
1240 /* We must use Fkey_description rather than just passing key to
1241 error; key might be a vector, not a string. */
1242 error ("Key sequence %s starts with non-prefix key %s",
1243 SDATA (Fkey_description (key
, Qnil
)),
1244 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1250 /* This function may GC (it calls Fkey_binding). */
1252 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 1, 0,
1253 doc
: /* Return the remapping for command COMMAND in current keymaps.
1254 Returns nil if COMMAND is not remapped (or not a symbol). */)
1256 Lisp_Object command
;
1258 if (!SYMBOLP (command
))
1261 ASET (command_remapping_vector
, 1, command
);
1262 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
);
1265 /* Value is number if KEY is too long; nil if valid but has no definition. */
1266 /* GC is possible in this function if it autoloads a keymap. */
1268 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1269 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1270 nil means undefined. See doc of `define-key' for kinds of definitions.
1272 A number as value means KEY is "too long";
1273 that is, characters or symbols in it except for the last one
1274 fail to be a valid sequence of prefix characters in KEYMAP.
1275 The number is how many characters at the front of KEY
1276 it takes to reach a non-prefix key.
1278 Normally, `lookup-key' ignores bindings for t, which act as default
1279 bindings, used when nothing else in the keymap applies; this makes it
1280 usable as a general function for probing keymaps. However, if the
1281 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1282 recognize the default bindings, just as `read-key-sequence' does. */)
1283 (keymap
, key
, accept_default
)
1286 Lisp_Object accept_default
;
1289 register Lisp_Object cmd
;
1290 register Lisp_Object c
;
1292 int t_ok
= !NILP (accept_default
);
1293 struct gcpro gcpro1
, gcpro2
;
1295 GCPRO2 (keymap
, key
);
1296 keymap
= get_keymap (keymap
, 1, 1);
1298 CHECK_VECTOR_OR_STRING (key
);
1300 length
= XFASTINT (Flength (key
));
1302 RETURN_UNGCPRO (keymap
);
1307 c
= Faref (key
, make_number (idx
++));
1309 if (CONSP (c
) && lucid_event_type_list_p (c
))
1310 c
= Fevent_convert_list (c
);
1312 /* Turn the 8th bit of string chars into a meta modifier. */
1313 if (INTEGERP (c
) && XINT (c
) & 0x80 && STRINGP (key
))
1314 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1316 /* Allow string since binding for `menu-bar-select-buffer'
1317 includes the buffer name in the key sequence. */
1318 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1319 error ("Key sequence contains invalid event");
1321 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1323 RETURN_UNGCPRO (cmd
);
1325 keymap
= get_keymap (cmd
, 0, 1);
1326 if (!CONSP (keymap
))
1327 RETURN_UNGCPRO (make_number (idx
));
1333 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1334 Assume that currently it does not define C at all.
1335 Return the keymap. */
1338 define_as_prefix (keymap
, c
)
1339 Lisp_Object keymap
, c
;
1343 cmd
= Fmake_sparse_keymap (Qnil
);
1344 /* If this key is defined as a prefix in an inherited keymap,
1345 make it a prefix in this map, and make its definition
1346 inherit the other prefix definition. */
1347 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1348 store_in_keymap (keymap
, c
, cmd
);
1353 /* Append a key to the end of a key sequence. We always make a vector. */
1356 append_key (key_sequence
, key
)
1357 Lisp_Object key_sequence
, key
;
1359 Lisp_Object args
[2];
1361 args
[0] = key_sequence
;
1363 args
[1] = Fcons (key
, Qnil
);
1364 return Fvconcat (2, args
);
1367 /* Given a event type C which is a symbol,
1368 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1371 silly_event_symbol_error (c
)
1374 Lisp_Object parsed
, base
, name
, assoc
;
1377 parsed
= parse_modifiers (c
);
1378 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1379 base
= XCAR (parsed
);
1380 name
= Fsymbol_name (base
);
1381 /* This alist includes elements such as ("RET" . "\\r"). */
1382 assoc
= Fassoc (name
, exclude_keys
);
1386 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1388 Lisp_Object keystring
;
1389 if (modifiers
& alt_modifier
)
1390 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1391 if (modifiers
& ctrl_modifier
)
1392 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1393 if (modifiers
& hyper_modifier
)
1394 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1395 if (modifiers
& meta_modifier
)
1396 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1397 if (modifiers
& shift_modifier
)
1398 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1399 if (modifiers
& super_modifier
)
1400 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1403 c
= reorder_modifiers (c
);
1404 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1406 error ((modifiers
& ~meta_modifier
1407 ? "To bind the key %s, use [?%s], not [%s]"
1408 : "To bind the key %s, use \"%s\", not [%s]"),
1409 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1410 SDATA (SYMBOL_NAME (c
)));
1414 /* Global, local, and minor mode keymap stuff. */
1416 /* We can't put these variables inside current_minor_maps, since under
1417 some systems, static gets macro-defined to be the empty string.
1419 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1420 static int cmm_size
= 0;
1422 /* Store a pointer to an array of the keymaps of the currently active
1423 minor modes in *buf, and return the number of maps it contains.
1425 This function always returns a pointer to the same buffer, and may
1426 free or reallocate it, so if you want to keep it for a long time or
1427 hand it out to lisp code, copy it. This procedure will be called
1428 for every key sequence read, so the nice lispy approach (return a
1429 new assoclist, list, what have you) for each invocation would
1430 result in a lot of consing over time.
1432 If we used xrealloc/xmalloc and ran out of memory, they would throw
1433 back to the command loop, which would try to read a key sequence,
1434 which would call this function again, resulting in an infinite
1435 loop. Instead, we'll use realloc/malloc and silently truncate the
1436 list, let the key sequence be read, and hope some other piece of
1437 code signals the error. */
1439 current_minor_maps (modeptr
, mapptr
)
1440 Lisp_Object
**modeptr
, **mapptr
;
1443 int list_number
= 0;
1444 Lisp_Object alist
, assoc
, var
, val
;
1445 Lisp_Object emulation_alists
;
1446 Lisp_Object lists
[2];
1448 emulation_alists
= Vemulation_mode_map_alists
;
1449 lists
[0] = Vminor_mode_overriding_map_alist
;
1450 lists
[1] = Vminor_mode_map_alist
;
1452 for (list_number
= 0; list_number
< 2; list_number
++)
1454 if (CONSP (emulation_alists
))
1456 alist
= XCAR (emulation_alists
);
1457 emulation_alists
= XCDR (emulation_alists
);
1458 if (SYMBOLP (alist
))
1459 alist
= find_symbol_value (alist
);
1463 alist
= lists
[list_number
];
1465 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1466 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1467 && (var
= XCAR (assoc
), SYMBOLP (var
))
1468 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1473 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1474 and also an entry in Vminor_mode_map_alist,
1475 ignore the latter. */
1476 if (list_number
== 1)
1478 val
= assq_no_quit (var
, lists
[0]);
1485 int newsize
, allocsize
;
1486 Lisp_Object
*newmodes
, *newmaps
;
1488 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1489 allocsize
= newsize
* sizeof *newmodes
;
1491 /* Use malloc here. See the comment above this function.
1492 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1494 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1499 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1502 cmm_modes
= newmodes
;
1505 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1510 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1517 if (newmodes
== NULL
|| newmaps
== NULL
)
1522 /* Get the keymap definition--or nil if it is not defined. */
1523 temp
= Findirect_function (XCDR (assoc
), Qt
);
1527 cmm_maps
[i
] = temp
;
1533 if (modeptr
) *modeptr
= cmm_modes
;
1534 if (mapptr
) *mapptr
= cmm_maps
;
1538 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1540 doc
: /* Return a list of the currently active keymaps.
1541 OLP if non-nil indicates that we should obey `overriding-local-map' and
1542 `overriding-terminal-local-map'. */)
1546 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1550 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1551 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1552 /* The doc said that overriding-terminal-local-map should
1553 override overriding-local-map. The code used them both,
1554 but it seems clearer to use just one. rms, jan 2005. */
1555 else if (!NILP (Voverriding_local_map
))
1556 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1558 if (NILP (XCDR (keymaps
)))
1564 /* This usually returns the buffer's local map,
1565 but that can be overridden by a `local-map' property. */
1566 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1568 keymaps
= Fcons (local
, keymaps
);
1570 /* Now put all the minor mode keymaps on the list. */
1571 nmaps
= current_minor_maps (0, &maps
);
1573 for (i
= --nmaps
; i
>= 0; i
--)
1574 if (!NILP (maps
[i
]))
1575 keymaps
= Fcons (maps
[i
], keymaps
);
1577 /* This returns nil unless there is a `keymap' property. */
1578 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1580 keymaps
= Fcons (local
, keymaps
);
1586 /* GC is possible in this function if it autoloads a keymap. */
1588 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 3, 0,
1589 doc
: /* Return the binding for command KEY in current keymaps.
1590 KEY is a string or vector, a sequence of keystrokes.
1591 The binding is probably a symbol with a function definition.
1593 Normally, `key-binding' ignores bindings for t, which act as default
1594 bindings, used when nothing else in the keymap applies; this makes it
1595 usable as a general function for probing keymaps. However, if the
1596 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1597 recognize the default bindings, just as `read-key-sequence' does.
1599 Like the normal command loop, `key-binding' will remap the command
1600 resulting from looking up KEY by looking up the command in the
1601 current keymaps. However, if the optional third argument NO-REMAP
1602 is non-nil, `key-binding' returns the unmapped command. */)
1603 (key
, accept_default
, no_remap
)
1604 Lisp_Object key
, accept_default
, no_remap
;
1606 Lisp_Object
*maps
, value
;
1608 struct gcpro gcpro1
;
1613 if (VECTORP (key
) && ASIZE (key
) > 0)
1615 Lisp_Object ev
, pos
;
1616 if ((ev
= AREF (key
, 0), CONSP (ev
))
1617 && SYMBOLP (XCAR (ev
))
1618 && CONSP (XCDR (ev
))
1619 && (pos
= XCAR (XCDR (ev
)), CONSP (pos
))
1620 && XINT (Flength (pos
)) == 10
1621 && INTEGERP (XCAR (XCDR (pos
))))
1623 Lisp_Object map
, object
;
1625 object
= Fnth (make_number(4), pos
);
1628 map
= Fget_char_property (XCDR (object
), Qkeymap
, XCAR (object
));
1630 map
= Fget_char_property (XCAR (XCDR (pos
)), Qkeymap
,
1631 Fwindow_buffer (XCAR (pos
)));
1633 if (!NILP (Fkeymapp (map
)))
1635 value
= Flookup_key (map
, key
, accept_default
);
1636 if (! NILP (value
) && !INTEGERP (value
))
1641 #endif /* HAVE_MOUSE */
1643 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1645 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1646 key
, accept_default
);
1647 if (! NILP (value
) && !INTEGERP (value
))
1650 else if (!NILP (Voverriding_local_map
))
1652 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1653 if (! NILP (value
) && !INTEGERP (value
))
1660 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1663 value
= Flookup_key (local
, key
, accept_default
);
1664 if (! NILP (value
) && !INTEGERP (value
))
1668 nmaps
= current_minor_maps (0, &maps
);
1669 /* Note that all these maps are GCPRO'd
1670 in the places where we found them. */
1672 for (i
= 0; i
< nmaps
; i
++)
1673 if (! NILP (maps
[i
]))
1675 value
= Flookup_key (maps
[i
], key
, accept_default
);
1676 if (! NILP (value
) && !INTEGERP (value
))
1680 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1683 value
= Flookup_key (local
, key
, accept_default
);
1684 if (! NILP (value
) && !INTEGERP (value
))
1689 value
= Flookup_key (current_global_map
, key
, accept_default
);
1693 if (NILP (value
) || INTEGERP (value
))
1696 /* If the result of the ordinary keymap lookup is an interactive
1697 command, look for a key binding (ie. remapping) for that command. */
1699 if (NILP (no_remap
) && SYMBOLP (value
))
1702 if (value1
= Fcommand_remapping (value
), !NILP (value1
))
1709 /* GC is possible in this function if it autoloads a keymap. */
1711 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1712 doc
: /* Return the binding for command KEYS in current local keymap only.
1713 KEYS is a string or vector, a sequence of keystrokes.
1714 The binding is probably a symbol with a function definition.
1716 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1717 bindings; see the description of `lookup-key' for more details about this. */)
1718 (keys
, accept_default
)
1719 Lisp_Object keys
, accept_default
;
1721 register Lisp_Object map
;
1722 map
= current_buffer
->keymap
;
1725 return Flookup_key (map
, keys
, accept_default
);
1728 /* GC is possible in this function if it autoloads a keymap. */
1730 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1731 doc
: /* Return the binding for command KEYS in current global keymap only.
1732 KEYS is a string or vector, a sequence of keystrokes.
1733 The binding is probably a symbol with a function definition.
1734 This function's return values are the same as those of `lookup-key'
1737 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1738 bindings; see the description of `lookup-key' for more details about this. */)
1739 (keys
, accept_default
)
1740 Lisp_Object keys
, accept_default
;
1742 return Flookup_key (current_global_map
, keys
, accept_default
);
1745 /* GC is possible in this function if it autoloads a keymap. */
1747 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1748 doc
: /* Find the visible minor mode bindings of KEY.
1749 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1750 the symbol which names the minor mode binding KEY, and BINDING is
1751 KEY's definition in that mode. In particular, if KEY has no
1752 minor-mode bindings, return nil. If the first binding is a
1753 non-prefix, all subsequent bindings will be omitted, since they would
1754 be ignored. Similarly, the list doesn't include non-prefix bindings
1755 that come after prefix bindings.
1757 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1758 bindings; see the description of `lookup-key' for more details about this. */)
1759 (key
, accept_default
)
1760 Lisp_Object key
, accept_default
;
1762 Lisp_Object
*modes
, *maps
;
1764 Lisp_Object binding
;
1766 struct gcpro gcpro1
, gcpro2
;
1768 nmaps
= current_minor_maps (&modes
, &maps
);
1769 /* Note that all these maps are GCPRO'd
1770 in the places where we found them. */
1773 GCPRO2 (key
, binding
);
1775 for (i
= j
= 0; i
< nmaps
; i
++)
1777 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1778 && !INTEGERP (binding
))
1780 if (KEYMAPP (binding
))
1781 maps
[j
++] = Fcons (modes
[i
], binding
);
1783 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1787 return Flist (j
, maps
);
1790 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1791 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1792 A new sparse keymap is stored as COMMAND's function definition and its value.
1793 If a second optional argument MAPVAR is given, the map is stored as
1794 its value instead of as COMMAND's value; but COMMAND is still defined
1796 The third optional argument NAME, if given, supplies a menu name
1797 string for the map. This is required to use the keymap as a menu.
1798 This function returns COMMAND. */)
1799 (command
, mapvar
, name
)
1800 Lisp_Object command
, mapvar
, name
;
1803 map
= Fmake_sparse_keymap (name
);
1804 Ffset (command
, map
);
1808 Fset (command
, map
);
1812 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1813 doc
: /* Select KEYMAP as the global keymap. */)
1817 keymap
= get_keymap (keymap
, 1, 1);
1818 current_global_map
= keymap
;
1823 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1824 doc
: /* Select KEYMAP as the local keymap.
1825 If KEYMAP is nil, that means no local keymap. */)
1830 keymap
= get_keymap (keymap
, 1, 1);
1832 current_buffer
->keymap
= keymap
;
1837 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1838 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1841 return current_buffer
->keymap
;
1844 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1845 doc
: /* Return the current global keymap. */)
1848 return current_global_map
;
1851 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1852 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1856 int nmaps
= current_minor_maps (0, &maps
);
1858 return Flist (nmaps
, maps
);
1861 /* Help functions for describing and documenting keymaps. */
1865 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1866 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1867 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1871 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
1875 /* Look for and break cycles. */
1876 while (!NILP (tem
= Frassq (cmd
, maps
)))
1878 Lisp_Object prefix
= XCAR (tem
);
1879 int lim
= XINT (Flength (XCAR (tem
)));
1880 if (lim
<= XINT (Flength (thisseq
)))
1881 { /* This keymap was already seen with a smaller prefix. */
1883 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
1884 Faref (thisseq
, make_number (i
))))
1887 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1890 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1891 but maybe `cmd' occurs again further down in `maps', so keep
1893 maps
= XCDR (Fmemq (tem
, maps
));
1896 /* If the last key in thisseq is meta-prefix-char,
1897 turn it into a meta-ized keystroke. We know
1898 that the event we're about to append is an
1899 ascii keystroke since we're processing a
1903 int meta_bit
= meta_modifier
;
1904 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1905 tem
= Fcopy_sequence (thisseq
);
1907 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1909 /* This new sequence is the same length as
1910 thisseq, so stick it in the list right
1913 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1917 tem
= append_key (thisseq
, key
);
1918 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1923 accessible_keymaps_char_table (args
, index
, cmd
)
1924 Lisp_Object args
, index
, cmd
;
1926 accessible_keymaps_1 (index
, cmd
,
1930 XINT (XCDR (XCAR (args
))));
1933 /* This function cannot GC. */
1935 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1937 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1938 Returns a list of elements of the form (KEYS . MAP), where the sequence
1939 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1940 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1941 An optional argument PREFIX, if non-nil, should be a key sequence;
1942 then the value includes only maps for prefixes that start with PREFIX. */)
1944 Lisp_Object keymap
, prefix
;
1946 Lisp_Object maps
, tail
;
1949 /* no need for gcpro because we don't autoload any keymaps. */
1952 prefixlen
= XINT (Flength (prefix
));
1956 /* If a prefix was specified, start with the keymap (if any) for
1957 that prefix, so we don't waste time considering other prefixes. */
1959 tem
= Flookup_key (keymap
, prefix
, Qt
);
1960 /* Flookup_key may give us nil, or a number,
1961 if the prefix is not defined in this particular map.
1962 It might even give us a list that isn't a keymap. */
1963 tem
= get_keymap (tem
, 0, 0);
1966 /* Convert PREFIX to a vector now, so that later on
1967 we don't have to deal with the possibility of a string. */
1968 if (STRINGP (prefix
))
1973 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
1974 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
1978 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1979 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1980 c
^= 0200 | meta_modifier
;
1981 ASET (copy
, i_before
, make_number (c
));
1985 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1991 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1992 get_keymap (keymap
, 1, 0)),
1995 /* For each map in the list maps,
1996 look at any other maps it points to,
1997 and stick them at the end if they are not already in the list.
1999 This is a breadth-first traversal, where tail is the queue of
2000 nodes, and maps accumulates a list of all nodes visited. */
2002 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2004 register Lisp_Object thisseq
, thismap
;
2006 /* Does the current sequence end in the meta-prefix-char? */
2009 thisseq
= Fcar (Fcar (tail
));
2010 thismap
= Fcdr (Fcar (tail
));
2011 last
= make_number (XINT (Flength (thisseq
)) - 1);
2012 is_metized
= (XINT (last
) >= 0
2013 /* Don't metize the last char of PREFIX. */
2014 && XINT (last
) >= prefixlen
2015 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
2017 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
2021 elt
= XCAR (thismap
);
2025 if (CHAR_TABLE_P (elt
))
2027 map_char_table (accessible_keymaps_char_table
, Qnil
,
2028 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
2029 Fcons (tail
, thisseq
)));
2031 else if (VECTORP (elt
))
2035 /* Vector keymap. Scan all the elements. */
2036 for (i
= 0; i
< ASIZE (elt
); i
++)
2037 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
2038 maps
, tail
, thisseq
, is_metized
);
2041 else if (CONSP (elt
))
2042 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
2043 maps
, tail
, thisseq
,
2044 is_metized
&& INTEGERP (XCAR (elt
)));
2052 Lisp_Object Qsingle_key_description
, Qkey_description
;
2054 /* This function cannot GC. */
2056 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2057 doc
: /* Return a pretty description of key-sequence KEYS.
2058 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2059 Control characters turn into "C-foo" sequences, meta into "M-foo",
2060 spaces are put between sequence elements, etc. */)
2062 Lisp_Object keys
, prefix
;
2067 int size
= XINT (Flength (keys
));
2069 Lisp_Object sep
= build_string (" ");
2074 size
+= XINT (Flength (prefix
));
2076 /* This has one extra element at the end that we don't pass to Fconcat. */
2077 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2079 /* In effect, this computes
2080 (mapconcat 'single-key-description keys " ")
2081 but we shouldn't use mapconcat because it can do GC. */
2085 list
= prefix
, prefix
= Qnil
;
2086 else if (!NILP (keys
))
2087 list
= keys
, keys
= Qnil
;
2092 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2096 return empty_string
;
2097 return Fconcat (len
- 1, args
);
2101 size
= SCHARS (list
);
2102 else if (VECTORP (list
))
2103 size
= XVECTOR (list
)->size
;
2104 else if (CONSP (list
))
2105 size
= XINT (Flength (list
));
2107 wrong_type_argument (Qarrayp
, list
);
2116 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2117 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2118 c
^= 0200 | meta_modifier
;
2119 XSETFASTINT (key
, c
);
2121 else if (VECTORP (list
))
2123 key
= AREF (list
, i
++);
2135 || EQ (key
, meta_prefix_char
)
2136 || (XINT (key
) & meta_modifier
))
2138 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2140 if (EQ (key
, meta_prefix_char
))
2144 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2147 else if (EQ (key
, meta_prefix_char
))
2152 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2160 push_key_description (c
, p
, force_multibyte
)
2161 register unsigned int c
;
2163 int force_multibyte
;
2167 /* Clear all the meaningless bits above the meta bit. */
2168 c
&= meta_modifier
| ~ - meta_modifier
;
2169 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2170 | meta_modifier
| shift_modifier
| super_modifier
);
2172 if (! CHARACTERP (make_number (c2
)))
2174 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2175 p
+= sprintf (p
, "[%d]", c
);
2179 if (c
& alt_modifier
)
2185 if ((c
& ctrl_modifier
) != 0
2186 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2190 c
&= ~ctrl_modifier
;
2192 if (c
& hyper_modifier
)
2196 c
-= hyper_modifier
;
2198 if (c
& meta_modifier
)
2204 if (c
& shift_modifier
)
2208 c
-= shift_modifier
;
2210 if (c
& super_modifier
)
2214 c
-= super_modifier
;
2230 else if (c
== Ctl ('M'))
2238 /* `C-' already added above. */
2239 if (c
> 0 && c
<= Ctl ('Z'))
2258 || (NILP (current_buffer
->enable_multibyte_characters
)
2259 && SINGLE_BYTE_CHAR_P (c
)
2260 && !force_multibyte
))
2266 /* Now we are sure that C is a valid character code. */
2267 if (NILP (current_buffer
->enable_multibyte_characters
)
2268 && ! force_multibyte
)
2269 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2271 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2277 /* This function cannot GC. */
2279 DEFUN ("single-key-description", Fsingle_key_description
,
2280 Ssingle_key_description
, 1, 2, 0,
2281 doc
: /* Return a pretty description of command character KEY.
2282 Control characters turn into C-whatever, etc.
2283 Optional argument NO-ANGLES non-nil means don't put angle brackets
2284 around function keys and event symbols. */)
2286 Lisp_Object key
, no_angles
;
2288 if (CONSP (key
) && lucid_event_type_list_p (key
))
2289 key
= Fevent_convert_list (key
);
2291 key
= EVENT_HEAD (key
);
2293 if (INTEGERP (key
)) /* Normal character */
2295 char tem
[KEY_DESCRIPTION_SIZE
];
2297 *push_key_description (XUINT (key
), tem
, 1) = 0;
2298 return build_string (tem
);
2300 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2302 if (NILP (no_angles
))
2305 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2306 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2307 return build_string (buffer
);
2310 return Fsymbol_name (key
);
2312 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2313 return Fcopy_sequence (key
);
2315 error ("KEY must be an integer, cons, symbol, or string");
2320 push_text_char_description (c
, p
)
2321 register unsigned int c
;
2333 *p
++ = c
+ 64; /* 'A' - 1 */
2345 /* This function cannot GC. */
2347 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2348 doc
: /* Return a pretty description of file-character CHARACTER.
2349 Control characters turn into "^char", etc. This differs from
2350 `single-key-description' which turns them into "C-char".
2351 Also, this function recognizes the 2**7 bit as the Meta character,
2352 whereas `single-key-description' uses the 2**27 bit for Meta.
2353 See Info node `(elisp)Describing Characters' for examples. */)
2355 Lisp_Object character
;
2357 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2358 unsigned char str
[6];
2361 CHECK_NUMBER (character
);
2363 c
= XINT (character
);
2364 if (!ASCII_CHAR_P (c
))
2366 int len
= CHAR_STRING (c
, str
);
2368 return make_multibyte_string (str
, 1, len
);
2371 *push_text_char_description (c
& 0377, str
) = 0;
2373 return build_string (str
);
2376 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2379 ascii_sequence_p (seq
)
2383 int len
= XINT (Flength (seq
));
2385 for (i
= 0; i
< len
; i
++)
2387 Lisp_Object ii
, elt
;
2389 XSETFASTINT (ii
, i
);
2390 elt
= Faref (seq
, ii
);
2393 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2401 /* where-is - finding a command in a set of keymaps. */
2403 static Lisp_Object
where_is_internal ();
2404 static Lisp_Object
where_is_internal_1 ();
2405 static void where_is_internal_2 ();
2407 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2408 Returns the first non-nil binding found in any of those maps. */
2411 shadow_lookup (shadow
, key
, flag
)
2412 Lisp_Object shadow
, key
, flag
;
2414 Lisp_Object tail
, value
;
2416 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2418 value
= Flookup_key (XCAR (tail
), key
, flag
);
2419 if (NATNUMP (value
))
2421 value
= Flookup_key (XCAR (tail
),
2422 Fsubstring (key
, make_number (0), value
), flag
);
2426 else if (!NILP (value
))
2432 static Lisp_Object Vmouse_events
;
2434 /* This function can GC if Flookup_key autoloads any keymaps. */
2437 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2438 Lisp_Object definition
, keymaps
;
2439 Lisp_Object firstonly
, noindirect
, no_remap
;
2441 Lisp_Object maps
= Qnil
;
2442 Lisp_Object found
, sequences
;
2443 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2444 /* 1 means ignore all menu bindings entirely. */
2445 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2447 /* If this command is remapped, then it has no key bindings
2449 if (NILP (no_remap
) && SYMBOLP (definition
))
2452 if (tem
= Fcommand_remapping (definition
), !NILP (tem
))
2457 while (CONSP (found
))
2461 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2462 found
= XCDR (found
);
2465 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2469 for (; !NILP (maps
); maps
= Fcdr (maps
))
2471 /* Key sequence to reach map, and the map that it reaches */
2472 register Lisp_Object
this, map
, tem
;
2474 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2475 [M-CHAR] sequences, check if last character of the sequence
2476 is the meta-prefix char. */
2480 this = Fcar (Fcar (maps
));
2481 map
= Fcdr (Fcar (maps
));
2482 last
= make_number (XINT (Flength (this)) - 1);
2483 last_is_meta
= (XINT (last
) >= 0
2484 && EQ (Faref (this, last
), meta_prefix_char
));
2486 /* if (nomenus && !ascii_sequence_p (this)) */
2487 if (nomenus
&& XINT (last
) >= 0
2488 && SYMBOLP (tem
= Faref (this, make_number (0)))
2489 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2490 /* If no menu entries should be returned, skip over the
2491 keymaps bound to `menu-bar' and `tool-bar' and other
2492 non-ascii prefixes like `C-down-mouse-2'. */
2499 /* Because the code we want to run on each binding is rather
2500 large, we don't want to have two separate loop bodies for
2501 sparse keymap bindings and tables; we want to iterate one
2502 loop body over both keymap and vector bindings.
2504 For this reason, if Fcar (map) is a vector, we don't
2505 advance map to the next element until i indicates that we
2506 have finished off the vector. */
2507 Lisp_Object elt
, key
, binding
;
2515 /* Set key and binding to the current key and binding, and
2516 advance map and i to the next binding. */
2519 Lisp_Object sequence
;
2521 /* In a vector, look at each element. */
2522 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2524 binding
= AREF (elt
, i
);
2525 XSETFASTINT (key
, i
);
2526 sequence
= where_is_internal_1 (binding
, key
, definition
,
2528 last
, nomenus
, last_is_meta
);
2529 if (!NILP (sequence
))
2530 sequences
= Fcons (sequence
, sequences
);
2533 else if (CHAR_TABLE_P (elt
))
2537 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2538 Qnil
), /* Result accumulator. */
2539 Fcons (Fcons (this, last
),
2540 Fcons (make_number (nomenus
),
2541 make_number (last_is_meta
))));
2542 map_char_table (where_is_internal_2
, Qnil
, elt
, args
);
2543 sequences
= XCDR (XCAR (args
));
2545 else if (CONSP (elt
))
2547 Lisp_Object sequence
;
2550 binding
= XCDR (elt
);
2552 sequence
= where_is_internal_1 (binding
, key
, definition
,
2554 last
, nomenus
, last_is_meta
);
2555 if (!NILP (sequence
))
2556 sequences
= Fcons (sequence
, sequences
);
2560 while (!NILP (sequences
))
2562 Lisp_Object sequence
, remapped
, function
;
2564 sequence
= XCAR (sequences
);
2565 sequences
= XCDR (sequences
);
2567 /* If the current sequence is a command remapping with
2568 format [remap COMMAND], find the key sequences
2569 which run COMMAND, and use those sequences instead. */
2572 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2573 && EQ (AREF (sequence
, 0), Qremap
)
2574 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2576 Lisp_Object remapped1
;
2578 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2579 if (CONSP (remapped1
))
2581 /* Verify that this key binding actually maps to the
2582 remapped command (see below). */
2583 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2585 sequence
= XCAR (remapped1
);
2586 remapped
= XCDR (remapped1
);
2587 goto record_sequence
;
2591 /* Verify that this key binding is not shadowed by another
2592 binding for the same key, before we say it exists.
2594 Mechanism: look for local definition of this key and if
2595 it is defined and does not match what we found then
2598 Either nil or number as value from Flookup_key
2600 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2604 /* Don't annoy user with strings from a menu such as
2605 Select Paste. Change them all to "(any string)",
2606 so that there seems to be only one menu item
2608 if (! NILP (sequence
))
2611 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2613 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2614 build_string ("(any string)"));
2617 /* It is a true unshadowed match. Record it, unless it's already
2618 been seen (as could happen when inheriting keymaps). */
2619 if (NILP (Fmember (sequence
, found
)))
2620 found
= Fcons (sequence
, found
);
2622 /* If firstonly is Qnon_ascii, then we can return the first
2623 binding we find. If firstonly is not Qnon_ascii but not
2624 nil, then we should return the first ascii-only binding
2626 if (EQ (firstonly
, Qnon_ascii
))
2627 RETURN_UNGCPRO (sequence
);
2628 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2629 RETURN_UNGCPRO (sequence
);
2631 if (CONSP (remapped
))
2633 sequence
= XCAR (remapped
);
2634 remapped
= XCDR (remapped
);
2635 goto record_sequence
;
2643 found
= Fnreverse (found
);
2645 /* firstonly may have been t, but we may have gone all the way through
2646 the keymaps without finding an all-ASCII key sequence. So just
2647 return the best we could find. */
2648 if (!NILP (firstonly
))
2649 return Fcar (found
);
2654 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2655 doc
: /* Return list of keys that invoke DEFINITION.
2656 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2657 If KEYMAP is nil, search all the currently active keymaps.
2658 If KEYMAP is a list of keymaps, search only those keymaps.
2660 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2661 rather than a list of all possible key sequences.
2662 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2663 no matter what it is.
2664 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2665 \(or their meta variants) and entirely reject menu bindings.
2667 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2668 to other keymaps or slots. This makes it possible to search for an
2669 indirect definition itself.
2671 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2672 that invoke a command which is remapped to DEFINITION, but include the
2673 remapped command in the returned list. */)
2674 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2675 Lisp_Object definition
, keymap
;
2676 Lisp_Object firstonly
, noindirect
, no_remap
;
2678 Lisp_Object sequences
, keymaps
;
2679 /* 1 means ignore all menu bindings entirely. */
2680 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2683 /* Find the relevant keymaps. */
2684 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2686 else if (!NILP (keymap
))
2687 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2689 keymaps
= Fcurrent_active_maps (Qnil
);
2691 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2692 We don't really need to check `keymap'. */
2693 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2697 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2699 /* Check heuristic-consistency of the cache. */
2700 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2701 where_is_cache
= Qnil
;
2703 if (NILP (where_is_cache
))
2705 /* We need to create the cache. */
2706 Lisp_Object args
[2];
2707 where_is_cache
= Fmake_hash_table (0, args
);
2708 where_is_cache_keymaps
= Qt
;
2710 /* Fill in the cache. */
2711 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2712 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2715 where_is_cache_keymaps
= keymaps
;
2718 /* We want to process definitions from the last to the first.
2719 Instead of consing, copy definitions to a vector and step
2720 over that vector. */
2721 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2722 n
= XINT (Flength (sequences
));
2723 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2724 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2725 defns
[i
++] = XCAR (sequences
);
2727 /* Verify that the key bindings are not shadowed. Note that
2728 the following can GC. */
2729 GCPRO2 (definition
, keymaps
);
2732 for (i
= n
- 1; i
>= 0; --i
)
2733 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2735 if (ascii_sequence_p (defns
[i
]))
2741 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2746 /* Kill the cache so that where_is_internal_1 doesn't think
2747 we're filling it up. */
2748 where_is_cache
= Qnil
;
2749 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2755 /* This is the function that Fwhere_is_internal calls using map_char_table.
2757 (((DEFINITION . NOINDIRECT) . RESULT)
2759 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2760 Since map_char_table doesn't really use the return value from this function,
2761 we the result append to RESULT, the slot in ARGS.
2763 KEY may be a cons (FROM . TO) where both FROM and TO are integers
2764 (i.e. character events).
2766 This function can GC because it calls where_is_internal_1 which can
2770 where_is_internal_2 (args
, key
, binding
)
2771 Lisp_Object args
, key
, binding
;
2773 Lisp_Object definition
, noindirect
, this, last
;
2774 Lisp_Object result
, sequence
;
2775 int nomenus
, last_is_meta
;
2776 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2778 GCPRO3 (args
, key
, binding
);
2779 definition
= XCAR (XCAR (XCAR (args
)));
2780 noindirect
= XCDR (XCAR (XCAR (args
)));
2781 this = XCAR (XCAR (XCDR (args
)));
2782 last
= XCDR (XCAR (XCDR (args
)));
2783 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2784 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2787 if (CONSP (key
) && INTEGERP (XCAR (key
)) && INTEGERP (XCDR (key
)))
2789 /* Try all ASCII characters. Try also non-ASCII characters but
2790 only the first and last one because trying all of them is
2791 extremely memory and time consuming.
2793 Fixme: Perhaps it should be allowed to store a cons directly
2794 in RESULT. -- handa@m17n.org */
2795 int from
= XINT (XCAR (key
)), to
= XINT (XCDR (key
));
2798 for (; from
<= to
; to
--)
2800 k
= make_number (to
);
2801 sequence
= where_is_internal_1 (binding
, k
, definition
, noindirect
,
2802 this, last
, nomenus
, last_is_meta
);
2803 if (!NILP (sequence
))
2804 result
= Fcons (sequence
, result
);
2811 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2812 this, last
, nomenus
, last_is_meta
);
2813 if (!NILP (sequence
))
2814 result
= Fcons (sequence
, Qnil
);
2817 if (! NILP (result
))
2818 nconc2 (XCAR (args
), result
);
2824 /* This function can GC because get_keyelt can. */
2827 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2828 nomenus
, last_is_meta
)
2829 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2830 int nomenus
, last_is_meta
;
2832 Lisp_Object sequence
;
2834 /* Search through indirections unless that's not wanted. */
2835 if (NILP (noindirect
))
2836 binding
= get_keyelt (binding
, 0);
2838 /* End this iteration if this element does not match
2841 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2842 || EQ (binding
, definition
)
2843 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2844 /* Doesn't match. */
2847 /* We have found a match. Construct the key sequence where we found it. */
2848 if (INTEGERP (key
) && last_is_meta
)
2850 sequence
= Fcopy_sequence (this);
2851 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2854 sequence
= append_key (this, key
);
2856 if (!NILP (where_is_cache
))
2858 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2859 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2866 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2868 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2869 doc
: /* Insert the list of all defined keys and their definitions.
2870 The list is inserted in the current buffer, while the bindings are
2871 looked up in BUFFER.
2872 The optional argument PREFIX, if non-nil, should be a key sequence;
2873 then we display only bindings that start with that prefix.
2874 The optional argument MENUS, if non-nil, says to mention menu bindings.
2875 \(Ordinarily these are omitted from the output.) */)
2876 (buffer
, prefix
, menus
)
2877 Lisp_Object buffer
, prefix
, menus
;
2879 Lisp_Object outbuf
, shadow
;
2880 int nomenu
= NILP (menus
);
2881 register Lisp_Object start1
;
2882 struct gcpro gcpro1
;
2884 char *alternate_heading
2886 Keyboard translations:\n\n\
2887 You type Translation\n\
2888 -------- -----------\n";
2893 outbuf
= Fcurrent_buffer ();
2895 /* Report on alternates for keys. */
2896 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2899 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2900 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2902 for (c
= 0; c
< translate_len
; c
++)
2903 if (translate
[c
] != c
)
2905 char buf
[KEY_DESCRIPTION_SIZE
];
2908 if (alternate_heading
)
2910 insert_string (alternate_heading
);
2911 alternate_heading
= 0;
2914 bufend
= push_key_description (translate
[c
], buf
, 1);
2915 insert (buf
, bufend
- buf
);
2916 Findent_to (make_number (16), make_number (1));
2917 bufend
= push_key_description (c
, buf
, 1);
2918 insert (buf
, bufend
- buf
);
2922 /* Insert calls signal_after_change which may GC. */
2923 translate
= SDATA (Vkeyboard_translate_table
);
2929 if (!NILP (Vkey_translation_map
))
2930 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2931 "Key translations", nomenu
, 1, 0, 0);
2934 /* Print the (major mode) local map. */
2936 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2937 start1
= current_kboard
->Voverriding_terminal_local_map
;
2938 else if (!NILP (Voverriding_local_map
))
2939 start1
= Voverriding_local_map
;
2943 describe_map_tree (start1
, 1, shadow
, prefix
,
2944 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
2945 shadow
= Fcons (start1
, shadow
);
2949 /* Print the minor mode and major mode keymaps. */
2951 Lisp_Object
*modes
, *maps
;
2953 /* Temporarily switch to `buffer', so that we can get that buffer's
2954 minor modes correctly. */
2955 Fset_buffer (buffer
);
2957 nmaps
= current_minor_maps (&modes
, &maps
);
2958 Fset_buffer (outbuf
);
2960 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2961 XBUFFER (buffer
), Qkeymap
);
2964 describe_map_tree (start1
, 1, shadow
, prefix
,
2965 "\f\n`keymap' Property Bindings", nomenu
,
2967 shadow
= Fcons (start1
, shadow
);
2970 /* Print the minor mode maps. */
2971 for (i
= 0; i
< nmaps
; i
++)
2973 /* The title for a minor mode keymap
2974 is constructed at run time.
2975 We let describe_map_tree do the actual insertion
2976 because it takes care of other features when doing so. */
2979 if (!SYMBOLP (modes
[i
]))
2982 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
2986 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
2987 SCHARS (SYMBOL_NAME (modes
[i
])));
2988 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
2990 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2991 p
+= sizeof (" Minor Mode Bindings") - 1;
2994 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
2995 title
, nomenu
, 0, 0, 0);
2996 shadow
= Fcons (maps
[i
], shadow
);
2999 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3000 XBUFFER (buffer
), Qlocal_map
);
3003 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3004 describe_map_tree (start1
, 1, shadow
, prefix
,
3005 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3007 describe_map_tree (start1
, 1, shadow
, prefix
,
3008 "\f\n`local-map' Property Bindings",
3011 shadow
= Fcons (start1
, shadow
);
3015 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3016 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3018 /* Print the function-key-map translations under this prefix. */
3019 if (!NILP (Vfunction_key_map
))
3020 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
3021 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3027 /* Insert a description of the key bindings in STARTMAP,
3028 followed by those of all maps reachable through STARTMAP.
3029 If PARTIAL is nonzero, omit certain "uninteresting" commands
3030 (such as `undefined').
3031 If SHADOW is non-nil, it is a list of maps;
3032 don't mention keys which would be shadowed by any of them.
3033 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3034 TITLE, if not 0, is a string to insert at the beginning.
3035 TITLE should not end with a colon or a newline; we supply that.
3036 If NOMENU is not 0, then omit menu-bar commands.
3038 If TRANSL is nonzero, the definitions are actually key translations
3039 so print strings and vectors differently.
3041 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3044 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3045 don't omit it; instead, mention it but say it is shadowed. */
3048 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3049 always_title
, mention_shadow
)
3050 Lisp_Object startmap
, shadow
, prefix
;
3058 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3059 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3066 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3069 GCPRO3 (maps
, seen
, sub_shadows
);
3075 /* Delete from MAPS each element that is for the menu bar. */
3076 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3078 Lisp_Object elt
, prefix
, tem
;
3081 prefix
= Fcar (elt
);
3082 if (XVECTOR (prefix
)->size
>= 1)
3084 tem
= Faref (prefix
, make_number (0));
3085 if (EQ (tem
, Qmenu_bar
))
3086 maps
= Fdelq (elt
, maps
);
3091 if (!NILP (maps
) || always_title
)
3095 insert_string (title
);
3098 insert_string (" Starting With ");
3099 insert1 (Fkey_description (prefix
, Qnil
));
3101 insert_string (":\n");
3103 insert_string (key_heading
);
3107 for (; !NILP (maps
); maps
= Fcdr (maps
))
3109 register Lisp_Object elt
, prefix
, tail
;
3112 prefix
= Fcar (elt
);
3116 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3120 shmap
= XCAR (tail
);
3122 /* If the sequence by which we reach this keymap is zero-length,
3123 then the shadow map for this keymap is just SHADOW. */
3124 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3125 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3127 /* If the sequence by which we reach this keymap actually has
3128 some elements, then the sequence's definition in SHADOW is
3129 what we should use. */
3132 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3133 if (INTEGERP (shmap
))
3137 /* If shmap is not nil and not a keymap,
3138 it completely shadows this map, so don't
3139 describe this map at all. */
3140 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3144 sub_shadows
= Fcons (shmap
, sub_shadows
);
3147 /* Maps we have already listed in this loop shadow this map. */
3148 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3151 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3153 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3156 describe_map (Fcdr (elt
), prefix
,
3157 transl
? describe_translation
: describe_command
,
3158 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3164 insert_string ("\n");
3169 static int previous_description_column
;
3172 describe_command (definition
, args
)
3173 Lisp_Object definition
, args
;
3175 register Lisp_Object tem1
;
3176 int column
= (int) current_column (); /* iftc */
3177 int description_column
;
3179 /* If column 16 is no good, go to col 32;
3180 but don't push beyond that--go to next line instead. */
3184 description_column
= 32;
3186 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3187 description_column
= 32;
3189 description_column
= 16;
3191 Findent_to (make_number (description_column
), make_number (1));
3192 previous_description_column
= description_column
;
3194 if (SYMBOLP (definition
))
3196 tem1
= SYMBOL_NAME (definition
);
3198 insert_string ("\n");
3200 else if (STRINGP (definition
) || VECTORP (definition
))
3201 insert_string ("Keyboard Macro\n");
3202 else if (KEYMAPP (definition
))
3203 insert_string ("Prefix Command\n");
3205 insert_string ("??\n");
3209 describe_translation (definition
, args
)
3210 Lisp_Object definition
, args
;
3212 register Lisp_Object tem1
;
3214 Findent_to (make_number (16), make_number (1));
3216 if (SYMBOLP (definition
))
3218 tem1
= SYMBOL_NAME (definition
);
3220 insert_string ("\n");
3222 else if (STRINGP (definition
) || VECTORP (definition
))
3224 insert1 (Fkey_description (definition
, Qnil
));
3225 insert_string ("\n");
3227 else if (KEYMAPP (definition
))
3228 insert_string ("Prefix Command\n");
3230 insert_string ("??\n");
3233 /* describe_map puts all the usable elements of a sparse keymap
3234 into an array of `struct describe_map_elt',
3235 then sorts them by the events. */
3237 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3239 /* qsort comparison function for sorting `struct describe_map_elt' by
3243 describe_map_compare (aa
, bb
)
3244 const void *aa
, *bb
;
3246 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3247 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3248 return ((XINT (a
->event
) > XINT (b
->event
))
3249 - (XINT (a
->event
) < XINT (b
->event
)));
3250 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3252 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3254 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3255 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3256 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3261 /* Describe the contents of map MAP, assuming that this map itself is
3262 reached by the sequence of prefix keys PREFIX (a string or vector).
3263 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3266 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3267 seen
, nomenu
, mention_shadow
)
3268 register Lisp_Object map
;
3270 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3277 Lisp_Object tail
, definition
, event
;
3279 Lisp_Object suppress
;
3282 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3284 /* These accumulate the values from sparse keymap bindings,
3285 so we can sort them and handle them in order. */
3286 int length_needed
= 0;
3287 struct describe_map_elt
*vect
;
3294 suppress
= intern ("suppress-keymap");
3296 /* This vector gets used to present single keys to Flookup_key. Since
3297 that is done once per keymap element, we don't want to cons up a
3298 fresh vector every time. */
3299 kludge
= Fmake_vector (make_number (1), Qnil
);
3302 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3305 vect
= ((struct describe_map_elt
*)
3306 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3308 GCPRO3 (prefix
, definition
, kludge
);
3310 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3314 if (VECTORP (XCAR (tail
))
3315 || CHAR_TABLE_P (XCAR (tail
)))
3316 describe_vector (XCAR (tail
),
3317 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3318 (int *)0, 0, 1, mention_shadow
);
3319 else if (CONSP (XCAR (tail
)))
3321 int this_shadowed
= 0;
3323 event
= XCAR (XCAR (tail
));
3325 /* Ignore bindings whose "prefix" are not really valid events.
3326 (We get these in the frames and buffers menu.) */
3327 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3330 if (nomenu
&& EQ (event
, Qmenu_bar
))
3333 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3335 /* Don't show undefined commands or suppressed commands. */
3336 if (NILP (definition
)) continue;
3337 if (SYMBOLP (definition
) && partial
)
3339 tem
= Fget (definition
, suppress
);
3344 /* Don't show a command that isn't really visible
3345 because a local definition of the same key shadows it. */
3347 ASET (kludge
, 0, event
);
3350 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3353 /* Avoid generating duplicate entries if the
3354 shadowed binding has the same definition. */
3355 if (mention_shadow
&& !EQ (tem
, definition
))
3362 tem
= Flookup_key (map
, kludge
, Qt
);
3363 if (!EQ (tem
, definition
)) continue;
3365 vect
[slots_used
].event
= event
;
3366 vect
[slots_used
].definition
= definition
;
3367 vect
[slots_used
].shadowed
= this_shadowed
;
3370 else if (EQ (XCAR (tail
), Qkeymap
))
3372 /* The same keymap might be in the structure twice, if we're
3373 using an inherited keymap. So skip anything we've already
3375 tem
= Fassq (tail
, *seen
);
3376 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3378 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3382 /* If we found some sparse map events, sort them. */
3384 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3385 describe_map_compare
);
3387 /* Now output them in sorted order. */
3389 for (i
= 0; i
< slots_used
; i
++)
3391 Lisp_Object start
, end
;
3395 previous_description_column
= 0;
3400 ASET (kludge
, 0, vect
[i
].event
);
3401 start
= vect
[i
].event
;
3404 definition
= vect
[i
].definition
;
3406 /* Find consecutive chars that are identically defined. */
3407 if (INTEGERP (vect
[i
].event
))
3409 while (i
+ 1 < slots_used
3410 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3411 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3412 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3414 end
= vect
[i
].event
;
3417 /* Now START .. END is the range to describe next. */
3419 /* Insert the string to describe the event START. */
3420 insert1 (Fkey_description (kludge
, prefix
));
3422 if (!EQ (start
, end
))
3426 ASET (kludge
, 0, end
);
3427 /* Insert the string to describe the character END. */
3428 insert1 (Fkey_description (kludge
, prefix
));
3431 /* Print a description of the definition of this character.
3432 elt_describer will take care of spacing out far enough
3433 for alignment purposes. */
3434 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3436 if (vect
[i
].shadowed
)
3439 insert_string ("\n (that binding is currently shadowed by another mode)");
3448 describe_vector_princ (elt
, fun
)
3449 Lisp_Object elt
, fun
;
3451 Findent_to (make_number (16), make_number (1));
3456 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3457 doc
: /* Insert a description of contents of VECTOR.
3458 This is text showing the elements of vector matched against indices.
3459 DESCRIBER is the output function used; nil means use `princ'. */)
3461 Lisp_Object vector
, describer
;
3463 int count
= SPECPDL_INDEX ();
3464 if (NILP (describer
))
3465 describer
= intern ("princ");
3466 specbind (Qstandard_output
, Fcurrent_buffer ());
3467 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3468 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3469 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3471 return unbind_to (count
, Qnil
);
3474 /* Insert in the current buffer a description of the contents of VECTOR.
3475 We call ELT_DESCRIBER to insert the description of one value found
3478 ELT_PREFIX describes what "comes before" the keys or indices defined
3479 by this vector. This is a human-readable string whose size
3480 is not necessarily related to the situation.
3482 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3483 leads to this keymap.
3485 If the vector is a chartable, ELT_PREFIX is the vector
3486 of bytes that lead to the character set or portion of a character
3487 set described by this chartable.
3489 If PARTIAL is nonzero, it means do not mention suppressed commands
3490 (that assumes the vector is in a keymap).
3492 SHADOW is a list of keymaps that shadow this map.
3493 If it is non-nil, then we look up the key in those maps
3494 and we don't mention it now if it is defined by any of them.
3496 ENTIRE_MAP is the keymap in which this vector appears.
3497 If the definition in effect in the whole map does not match
3498 the one in this vector, we ignore this one.
3500 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3502 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3505 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3507 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3510 describe_vector (vector
, prefix
, args
, elt_describer
,
3511 partial
, shadow
, entire_map
,
3512 indices
, char_table_depth
, keymap_p
,
3514 register Lisp_Object vector
;
3515 Lisp_Object prefix
, args
;
3516 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3519 Lisp_Object entire_map
;
3521 int char_table_depth
;
3525 Lisp_Object definition
;
3527 Lisp_Object elt_prefix
= Qnil
;
3529 Lisp_Object suppress
;
3532 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3533 /* Range of elements to be handled. */
3535 Lisp_Object character
;
3544 /* Call Fkey_description first, to avoid GC bug for the other string. */
3545 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3548 tem
= Fkey_description (prefix
, Qnil
);
3549 elt_prefix
= concat2 (tem
, build_string (" "));
3554 /* This vector gets used to present single keys to Flookup_key. Since
3555 that is done once per vector element, we don't want to cons up a
3556 fresh vector every time. */
3557 kludge
= Fmake_vector (make_number (1), Qnil
);
3558 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3561 suppress
= intern ("suppress-keymap");
3564 to
= CHAR_TABLE_P (vector
) ? MAX_CHAR
+ 1 : XVECTOR (vector
)->size
;
3566 for (i
= from
; i
< to
; i
++)
3568 int this_shadowed
= 0;
3569 int range_beg
, range_end
;
3576 if (CHAR_TABLE_P (vector
))
3577 val
= char_table_ref_and_range (vector
, i
, &range_beg
, &i
);
3579 val
= AREF (vector
, i
);
3580 definition
= get_keyelt (val
, 0);
3582 if (NILP (definition
)) continue;
3584 /* Don't mention suppressed commands. */
3585 if (SYMBOLP (definition
) && partial
)
3589 tem
= Fget (definition
, suppress
);
3591 if (!NILP (tem
)) continue;
3594 character
= make_number (starting_i
);
3595 ASET (kludge
, 0, character
);
3597 /* If this binding is shadowed by some other map, ignore it. */
3602 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3613 /* Ignore this definition if it is shadowed by an earlier
3614 one in the same keymap. */
3615 if (!NILP (entire_map
))
3619 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3621 if (!EQ (tem
, definition
))
3631 /* Output the prefix that applies to every entry in this map. */
3632 if (!NILP (elt_prefix
))
3633 insert1 (elt_prefix
);
3635 insert1 (Fkey_description (kludge
, prefix
));
3637 /* Find all consecutive characters or rows that have the same
3638 definition. But, for elements of a top level char table, if
3639 they are for charsets, we had better describe one by one even
3640 if they have the same definition. */
3641 if (CHAR_TABLE_P (vector
))
3643 && (val
= char_table_ref_and_range (vector
, i
+ 1,
3644 &range_beg
, &range_end
),
3645 tem2
= get_keyelt (val
, 0),
3647 && !NILP (Fequal (tem2
, definition
)))
3651 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3653 && !NILP (Fequal (tem2
, definition
)))
3656 /* If we have a range of more than one character,
3657 print where the range reaches to. */
3659 if (i
!= starting_i
)
3663 ASET (kludge
, 0, make_number (i
));
3665 if (!NILP (elt_prefix
))
3666 insert1 (elt_prefix
);
3668 insert1 (Fkey_description (kludge
, prefix
));
3671 /* Print a description of the definition of this character.
3672 elt_describer will take care of spacing out far enough
3673 for alignment purposes. */
3674 (*elt_describer
) (definition
, args
);
3679 insert_string (" (binding currently shadowed)");
3684 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3686 if (!NILP (elt_prefix
))
3687 insert1 (elt_prefix
);
3688 insert ("default", 7);
3689 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3695 /* Apropos - finding all symbols whose names match a regexp. */
3696 static Lisp_Object apropos_predicate
;
3697 static Lisp_Object apropos_accumulate
;
3700 apropos_accum (symbol
, string
)
3701 Lisp_Object symbol
, string
;
3703 register Lisp_Object tem
;
3705 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3706 if (!NILP (tem
) && !NILP (apropos_predicate
))
3707 tem
= call1 (apropos_predicate
, symbol
);
3709 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3712 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3713 doc
: /* Show all symbols whose names contain match for REGEXP.
3714 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3715 for each symbol and a symbol is mentioned only if that returns non-nil.
3716 Return list of symbols found. */)
3718 Lisp_Object regexp
, predicate
;
3721 CHECK_STRING (regexp
);
3722 apropos_predicate
= predicate
;
3723 apropos_accumulate
= Qnil
;
3724 map_obarray (Vobarray
, apropos_accum
, regexp
);
3725 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3726 apropos_accumulate
= Qnil
;
3727 apropos_predicate
= Qnil
;
3734 Qkeymap
= intern ("keymap");
3735 staticpro (&Qkeymap
);
3736 staticpro (&apropos_predicate
);
3737 staticpro (&apropos_accumulate
);
3738 apropos_predicate
= Qnil
;
3739 apropos_accumulate
= Qnil
;
3741 /* Now we are ready to set up this property, so we can
3742 create char tables. */
3743 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3745 /* Initialize the keymaps standardly used.
3746 Each one is the value of a Lisp variable, and is also
3747 pointed to by a C variable */
3749 global_map
= Fmake_keymap (Qnil
);
3750 Fset (intern ("global-map"), global_map
);
3752 current_global_map
= global_map
;
3753 staticpro (&global_map
);
3754 staticpro (¤t_global_map
);
3756 meta_map
= Fmake_keymap (Qnil
);
3757 Fset (intern ("esc-map"), meta_map
);
3758 Ffset (intern ("ESC-prefix"), meta_map
);
3760 control_x_map
= Fmake_keymap (Qnil
);
3761 Fset (intern ("ctl-x-map"), control_x_map
);
3762 Ffset (intern ("Control-X-prefix"), control_x_map
);
3765 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3766 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3767 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3768 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3769 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3771 staticpro (&exclude_keys
);
3773 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3774 doc
: /* List of commands given new key bindings recently.
3775 This is used for internal purposes during Emacs startup;
3776 don't alter it yourself. */);
3777 Vdefine_key_rebound_commands
= Qt
;
3779 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3780 doc
: /* Default keymap to use when reading from the minibuffer. */);
3781 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3783 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3784 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3785 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3786 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3788 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3789 doc
: /* Local keymap for minibuffer input with completion. */);
3790 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3791 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3793 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3794 &Vminibuffer_local_filename_completion_map
,
3795 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3796 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3797 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3798 Vminibuffer_local_completion_map
);
3801 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3802 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3803 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3804 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3805 Vminibuffer_local_completion_map
);
3807 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
3808 &Vminibuffer_local_must_match_filename_map
,
3809 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3810 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
3811 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
3812 Vminibuffer_local_must_match_map
);
3814 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3815 doc
: /* Alist of keymaps to use for minor modes.
3816 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3817 key sequences and look up bindings iff VARIABLE's value is non-nil.
3818 If two active keymaps bind the same key, the keymap appearing earlier
3819 in the list takes precedence. */);
3820 Vminor_mode_map_alist
= Qnil
;
3822 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3823 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3824 This variable is an alist just like `minor-mode-map-alist', and it is
3825 used the same way (and before `minor-mode-map-alist'); however,
3826 it is provided for major modes to bind locally. */);
3827 Vminor_mode_overriding_map_alist
= Qnil
;
3829 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3830 doc
: /* List of keymap alists to use for emulations modes.
3831 It is intended for modes or packages using multiple minor-mode keymaps.
3832 Each element is a keymap alist just like `minor-mode-map-alist', or a
3833 symbol with a variable binding which is a keymap alist, and it is used
3834 the same way. The "active" keymaps in each alist are used before
3835 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3836 Vemulation_mode_map_alists
= Qnil
;
3839 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3840 doc
: /* Keymap that translates key sequences to key sequences during input.
3841 This is used mainly for mapping ASCII function key sequences into
3842 real Emacs function key events (symbols).
3844 The `read-key-sequence' function replaces any subsequence bound by
3845 `function-key-map' with its binding. More precisely, when the active
3846 keymaps have no binding for the current key sequence but
3847 `function-key-map' binds a suffix of the sequence to a vector or string,
3848 `read-key-sequence' replaces the matching suffix with its binding, and
3849 continues with the new sequence.
3851 If the binding is a function, it is called with one argument (the prompt)
3852 and its return value (a key sequence) is used.
3854 The events that come from bindings in `function-key-map' are not
3855 themselves looked up in `function-key-map'.
3857 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3858 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3859 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3860 key, typing `ESC O P x' would return [f1 x]. */);
3861 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3863 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3864 doc
: /* Keymap of key translations that can override keymaps.
3865 This keymap works like `function-key-map', but comes after that,
3866 and its non-prefix bindings override ordinary bindings. */);
3867 Vkey_translation_map
= Qnil
;
3869 staticpro (&Vmouse_events
);
3870 Vmouse_events
= Fcons (intern ("menu-bar"),
3871 Fcons (intern ("tool-bar"),
3872 Fcons (intern ("header-line"),
3873 Fcons (intern ("mode-line"),
3874 Fcons (intern ("mouse-1"),
3875 Fcons (intern ("mouse-2"),
3876 Fcons (intern ("mouse-3"),
3877 Fcons (intern ("mouse-4"),
3878 Fcons (intern ("mouse-5"),
3882 Qsingle_key_description
= intern ("single-key-description");
3883 staticpro (&Qsingle_key_description
);
3885 Qkey_description
= intern ("key-description");
3886 staticpro (&Qkey_description
);
3888 Qkeymapp
= intern ("keymapp");
3889 staticpro (&Qkeymapp
);
3891 Qnon_ascii
= intern ("non-ascii");
3892 staticpro (&Qnon_ascii
);
3894 Qmenu_item
= intern ("menu-item");
3895 staticpro (&Qmenu_item
);
3897 Qremap
= intern ("remap");
3898 staticpro (&Qremap
);
3900 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3901 staticpro (&command_remapping_vector
);
3903 where_is_cache_keymaps
= Qt
;
3904 where_is_cache
= Qnil
;
3905 staticpro (&where_is_cache
);
3906 staticpro (&where_is_cache_keymaps
);
3908 defsubr (&Skeymapp
);
3909 defsubr (&Skeymap_parent
);
3910 defsubr (&Skeymap_prompt
);
3911 defsubr (&Sset_keymap_parent
);
3912 defsubr (&Smake_keymap
);
3913 defsubr (&Smake_sparse_keymap
);
3914 defsubr (&Smap_keymap
);
3915 defsubr (&Scopy_keymap
);
3916 defsubr (&Scommand_remapping
);
3917 defsubr (&Skey_binding
);
3918 defsubr (&Slocal_key_binding
);
3919 defsubr (&Sglobal_key_binding
);
3920 defsubr (&Sminor_mode_key_binding
);
3921 defsubr (&Sdefine_key
);
3922 defsubr (&Slookup_key
);
3923 defsubr (&Sdefine_prefix_command
);
3924 defsubr (&Suse_global_map
);
3925 defsubr (&Suse_local_map
);
3926 defsubr (&Scurrent_local_map
);
3927 defsubr (&Scurrent_global_map
);
3928 defsubr (&Scurrent_minor_mode_maps
);
3929 defsubr (&Scurrent_active_maps
);
3930 defsubr (&Saccessible_keymaps
);
3931 defsubr (&Skey_description
);
3932 defsubr (&Sdescribe_vector
);
3933 defsubr (&Ssingle_key_description
);
3934 defsubr (&Stext_char_description
);
3935 defsubr (&Swhere_is_internal
);
3936 defsubr (&Sdescribe_buffer_bindings
);
3937 defsubr (&Sapropos_internal
);
3943 initial_define_key (global_map
, 033, "ESC-prefix");
3944 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
3947 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
3948 (do not change this comment) */