1 /* Manipulation of keymaps
2 Copyright (C) 1985-1988, 1993-1995, 1998-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "character.h"
30 #include "termhooks.h"
31 #include "blockinput.h"
33 #include "intervals.h"
37 /* Actually allocate storage for these variables */
39 Lisp_Object current_global_map
; /* Current global keymap */
41 Lisp_Object global_map
; /* default global key bindings */
43 Lisp_Object meta_map
; /* The keymap used for globally bound
44 ESC-prefixed default commands */
46 Lisp_Object control_x_map
; /* The keymap used for globally bound
47 C-x-prefixed default commands */
49 /* The keymap used by the minibuf for local
50 bindings when spaces are allowed in the
53 /* The keymap used by the minibuf for local
54 bindings when spaces are not encouraged
57 /* keymap used for minibuffers when doing completion */
58 /* keymap used for minibuffers when doing completion and require a match */
59 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
60 Lisp_Object QCadvertised_binding
;
62 /* Alist of elements like (DEL . "\d"). */
63 static Lisp_Object exclude_keys
;
65 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
66 static Lisp_Object command_remapping_vector
;
68 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
69 static Lisp_Object where_is_cache
;
70 /* Which keymaps are reverse-stored in the cache. */
71 static Lisp_Object where_is_cache_keymaps
;
73 static Lisp_Object
store_in_keymap (Lisp_Object
, Lisp_Object
, Lisp_Object
);
74 static void fix_submap_inheritance (Lisp_Object
, Lisp_Object
, Lisp_Object
);
76 static Lisp_Object
define_as_prefix (Lisp_Object
, Lisp_Object
);
77 static void describe_command (Lisp_Object
, Lisp_Object
);
78 static void describe_translation (Lisp_Object
, Lisp_Object
);
79 static void describe_map (Lisp_Object
, Lisp_Object
,
80 void (*) (Lisp_Object
, Lisp_Object
),
81 int, Lisp_Object
, Lisp_Object
*, int, int);
82 static void describe_vector (Lisp_Object
, Lisp_Object
, Lisp_Object
,
83 void (*) (Lisp_Object
, Lisp_Object
), int,
84 Lisp_Object
, Lisp_Object
, int, int);
85 static void silly_event_symbol_error (Lisp_Object
);
86 static Lisp_Object
get_keyelt (Lisp_Object
, int);
88 /* Keymap object support - constructors and predicates. */
90 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
91 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
92 CHARTABLE is a char-table that holds the bindings for all characters
93 without modifiers. All entries in it are initially nil, meaning
94 "command undefined". ALIST is an assoc-list which holds bindings for
95 function keys, mouse events, and any other things that appear in the
96 input stream. Initially, ALIST is nil.
98 The optional arg STRING supplies a menu name for the keymap
99 in case you use it as a menu with `x-popup-menu'. */)
104 tail
= Fcons (string
, Qnil
);
107 return Fcons (Qkeymap
,
108 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
111 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
112 doc
: /* Construct and return a new sparse keymap.
113 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
114 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
115 which binds the function key or mouse event SYMBOL to DEFINITION.
116 Initially the alist is nil.
118 The optional arg STRING supplies a menu name for the keymap
119 in case you use it as a menu with `x-popup-menu'. */)
124 if (!NILP (Vpurify_flag
))
125 string
= Fpurecopy (string
);
126 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
128 return Fcons (Qkeymap
, Qnil
);
131 /* This function is used for installing the standard key bindings
132 at initialization time.
136 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
139 initial_define_key (Lisp_Object keymap
, int key
, const char *defname
)
141 store_in_keymap (keymap
, make_number (key
), intern_c_string (defname
));
145 initial_define_lispy_key (Lisp_Object keymap
, const char *keyname
, const char *defname
)
147 store_in_keymap (keymap
, intern_c_string (keyname
), intern_c_string (defname
));
150 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
151 doc
: /* Return t if OBJECT is a keymap.
153 A keymap is a list (keymap . ALIST),
154 or a symbol whose function definition is itself a keymap.
155 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
156 a vector of densely packed bindings for small character codes
157 is also allowed as an element. */)
160 return (KEYMAPP (object
) ? Qt
: Qnil
);
163 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
164 doc
: /* Return the prompt-string of a keymap MAP.
165 If non-nil, the prompt is shown in the echo-area
166 when reading a key-sequence to be looked-up in this keymap. */)
169 map
= get_keymap (map
, 0, 0);
172 Lisp_Object tem
= XCAR (map
);
180 /* Check that OBJECT is a keymap (after dereferencing through any
181 symbols). If it is, return it.
183 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
184 is an autoload form, do the autoload and try again.
185 If AUTOLOAD is nonzero, callers must assume GC is possible.
187 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
188 is zero as well), return Qt.
190 ERROR_IF_NOT_KEYMAP controls how we respond if OBJECT isn't a keymap.
191 If ERROR_IF_NOT_KEYMAP is non-zero, signal an error; otherwise,
194 Note that most of the time, we don't want to pursue autoloads.
195 Functions like Faccessible_keymaps which scan entire keymap trees
196 shouldn't load every autoloaded keymap. I'm not sure about this,
197 but it seems to me that only read_key_sequence, Flookup_key, and
198 Fdefine_key should cause keymaps to be autoloaded.
200 This function can GC when AUTOLOAD is non-zero, because it calls
201 do_autoload which can GC. */
204 get_keymap (Lisp_Object object
, int error_if_not_keymap
, int autoload
)
211 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
214 tem
= indirect_function (object
);
217 if (EQ (XCAR (tem
), Qkeymap
))
220 /* Should we do an autoload? Autoload forms for keymaps have
221 Qkeymap as their fifth element. */
222 if ((autoload
|| !error_if_not_keymap
) && EQ (XCAR (tem
), Qautoload
)
227 tail
= Fnth (make_number (4), tem
);
228 if (EQ (tail
, Qkeymap
))
232 struct gcpro gcpro1
, gcpro2
;
234 GCPRO2 (tem
, object
);
235 do_autoload (tem
, object
);
247 if (error_if_not_keymap
)
248 wrong_type_argument (Qkeymapp
, object
);
252 /* Return the parent map of KEYMAP, or nil if it has none.
253 We assume that KEYMAP is a valid keymap. */
256 keymap_parent (Lisp_Object keymap
, int autoload
)
260 keymap
= get_keymap (keymap
, 1, autoload
);
262 /* Skip past the initial element `keymap'. */
263 list
= XCDR (keymap
);
264 for (; CONSP (list
); list
= XCDR (list
))
266 /* See if there is another `keymap'. */
271 return get_keymap (list
, 0, autoload
);
274 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
275 doc
: /* Return the parent keymap of KEYMAP.
276 If KEYMAP has no parent, return nil. */)
279 return keymap_parent (keymap
, 1);
282 /* Check whether MAP is one of MAPS parents. */
284 keymap_memberp (Lisp_Object map
, Lisp_Object maps
)
286 if (NILP (map
)) return 0;
287 while (KEYMAPP (maps
) && !EQ (map
, maps
))
288 maps
= keymap_parent (maps
, 0);
289 return (EQ (map
, maps
));
292 /* Set the parent keymap of MAP to PARENT. */
294 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
295 doc
: /* Modify KEYMAP to set its parent map to PARENT.
296 Return PARENT. PARENT should be nil or another keymap. */)
297 (Lisp_Object keymap
, Lisp_Object parent
)
299 Lisp_Object list
, prev
;
300 struct gcpro gcpro1
, gcpro2
;
303 /* Force a keymap flush for the next call to where-is.
304 Since this can be called from within where-is, we don't set where_is_cache
305 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
306 be changed during where-is, while where_is_cache_keymaps is only used at
307 the very beginning of where-is and can thus be changed here without any
309 This is a very minor correctness (rather than safety) issue. */
310 where_is_cache_keymaps
= Qt
;
312 GCPRO2 (keymap
, parent
);
313 keymap
= get_keymap (keymap
, 1, 1);
317 parent
= get_keymap (parent
, 1, 1);
319 /* Check for cycles. */
320 if (keymap_memberp (keymap
, parent
))
321 error ("Cyclic keymap inheritance");
324 /* Skip past the initial element `keymap'. */
329 /* If there is a parent keymap here, replace it.
330 If we came to the end, add the parent in PREV. */
331 if (!CONSP (list
) || KEYMAPP (list
))
333 /* If we already have the right parent, return now
334 so that we avoid the loops below. */
335 if (EQ (XCDR (prev
), parent
))
336 RETURN_UNGCPRO (parent
);
339 XSETCDR (prev
, parent
);
345 /* Scan through for submaps, and set their parents too. */
347 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
349 /* Stop the scan when we come to the parent. */
350 if (EQ (XCAR (list
), Qkeymap
))
353 /* If this element holds a prefix map, deal with it. */
354 if (CONSP (XCAR (list
))
355 && CONSP (XCDR (XCAR (list
))))
356 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
359 if (VECTORP (XCAR (list
)))
360 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
361 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
362 fix_submap_inheritance (keymap
, make_number (i
),
363 XVECTOR (XCAR (list
))->contents
[i
]);
365 if (CHAR_TABLE_P (XCAR (list
)))
367 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
371 RETURN_UNGCPRO (parent
);
374 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
375 if EVENT is also a prefix in MAP's parent,
376 make sure that SUBMAP inherits that definition as its own parent. */
379 fix_submap_inheritance (Lisp_Object map
, Lisp_Object event
, Lisp_Object submap
)
381 Lisp_Object map_parent
, parent_entry
;
383 /* SUBMAP is a cons that we found as a key binding.
384 Discard the other things found in a menu key binding. */
386 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
388 /* If it isn't a keymap now, there's no work to do. */
392 map_parent
= keymap_parent (map
, 0);
393 if (!NILP (map_parent
))
395 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
399 /* If MAP's parent has something other than a keymap,
400 our own submap shadows it completely. */
401 if (!CONSP (parent_entry
))
404 if (! EQ (parent_entry
, submap
))
406 Lisp_Object submap_parent
;
407 submap_parent
= submap
;
412 tem
= keymap_parent (submap_parent
, 0);
416 if (keymap_memberp (tem
, parent_entry
))
417 /* Fset_keymap_parent could create a cycle. */
424 Fset_keymap_parent (submap_parent
, parent_entry
);
428 /* Look up IDX in MAP. IDX may be any sort of event.
429 Note that this does only one level of lookup; IDX must be a single
430 event, not a sequence.
432 If T_OK is non-zero, bindings for Qt are treated as default
433 bindings; any key left unmentioned by other tables and bindings is
434 given the binding of Qt.
436 If T_OK is zero, bindings for Qt are not treated specially.
438 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
441 access_keymap (Lisp_Object map
, Lisp_Object idx
, int t_ok
, int noinherit
, int autoload
)
445 /* Qunbound in VAL means we have found no binding yet. */
448 /* If idx is a list (some sort of mouse click, perhaps?),
449 the index we want to use is the car of the list, which
450 ought to be a symbol. */
451 idx
= EVENT_HEAD (idx
);
453 /* If idx is a symbol, it might have modifiers, which need to
454 be put in the canonical order. */
456 idx
= reorder_modifiers (idx
);
457 else if (INTEGERP (idx
))
458 /* Clobber the high bits that can be present on a machine
459 with more than 24 bits of integer. */
460 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
462 /* Handle the special meta -> esc mapping. */
463 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
465 /* See if there is a meta-map. If there's none, there is
466 no binding for IDX, unless a default binding exists in MAP. */
468 Lisp_Object event_meta_map
;
470 /* A strange value in which Meta is set would cause
471 infinite recursion. Protect against that. */
472 if (XINT (meta_prefix_char
) & CHAR_META
)
473 meta_prefix_char
= make_number (27);
474 event_meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
475 t_ok
, noinherit
, autoload
),
478 if (CONSP (event_meta_map
))
480 map
= event_meta_map
;
481 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
484 /* Set IDX to t, so that we only find a default binding. */
487 /* We know there is no binding. */
491 /* t_binding is where we put a default binding that applies,
492 to use in case we do not find a binding specifically
493 for this key sequence. */
496 Lisp_Object t_binding
= Qnil
;
497 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
499 GCPRO4 (map
, tail
, idx
, t_binding
);
501 for (tail
= XCDR (map
);
503 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
508 binding
= XCAR (tail
);
509 if (SYMBOLP (binding
))
511 /* If NOINHERIT, stop finding prefix definitions
512 after we pass a second occurrence of the `keymap' symbol. */
513 if (noinherit
&& EQ (binding
, Qkeymap
))
514 RETURN_UNGCPRO (Qnil
);
516 else if (CONSP (binding
))
518 Lisp_Object key
= XCAR (binding
);
521 val
= XCDR (binding
);
522 else if (t_ok
&& EQ (key
, Qt
))
524 t_binding
= XCDR (binding
);
528 else if (VECTORP (binding
))
530 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
531 val
= AREF (binding
, XFASTINT (idx
));
533 else if (CHAR_TABLE_P (binding
))
535 /* Character codes with modifiers
536 are not included in a char-table.
537 All character codes without modifiers are included. */
538 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
540 val
= Faref (binding
, idx
);
541 /* `nil' has a special meaning for char-tables, so
542 we use something else to record an explicitly
549 /* If we found a binding, clean it up and return it. */
550 if (!EQ (val
, Qunbound
))
553 /* A Qt binding is just like an explicit nil binding
554 (i.e. it shadows any parent binding but not bindings in
555 keymaps of lower precedence). */
557 val
= get_keyelt (val
, autoload
);
559 fix_submap_inheritance (map
, idx
, val
);
560 RETURN_UNGCPRO (val
);
565 return get_keyelt (t_binding
, autoload
);
570 map_keymap_item (map_keymap_function_t fun
, Lisp_Object args
, Lisp_Object key
, Lisp_Object val
, void *data
)
572 /* We should maybe try to detect bindings shadowed by previous
573 ones and things like that. */
576 (*fun
) (key
, val
, args
, data
);
580 map_keymap_char_table_item (Lisp_Object args
, Lisp_Object key
, Lisp_Object val
)
584 map_keymap_function_t fun
=
585 (map_keymap_function_t
) XSAVE_VALUE (XCAR (args
))->pointer
;
587 /* If the key is a range, make a copy since map_char_table modifies
590 key
= Fcons (XCAR (key
), XCDR (key
));
591 map_keymap_item (fun
, XCDR (args
), key
, val
,
592 XSAVE_VALUE (XCAR (args
))->pointer
);
596 /* Call FUN for every binding in MAP and stop at (and return) the parent.
597 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA). */
599 map_keymap_internal (Lisp_Object map
,
600 map_keymap_function_t fun
,
604 struct gcpro gcpro1
, gcpro2
, gcpro3
;
606 = (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
608 GCPRO3 (map
, args
, tail
);
609 for (; CONSP (tail
) && !EQ (Qkeymap
, XCAR (tail
)); tail
= XCDR (tail
))
611 Lisp_Object binding
= XCAR (tail
);
614 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
615 else if (VECTORP (binding
))
617 /* Loop over the char values represented in the vector. */
618 int len
= ASIZE (binding
);
620 for (c
= 0; c
< len
; c
++)
622 Lisp_Object character
;
623 XSETFASTINT (character
, c
);
624 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
627 else if (CHAR_TABLE_P (binding
))
629 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
630 Fcons (make_save_value ((void *) fun
, 0),
631 Fcons (make_save_value (data
, 0),
640 map_keymap_call (Lisp_Object key
, Lisp_Object val
, Lisp_Object fun
, void *dummy
)
642 call2 (fun
, key
, val
);
645 /* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
646 A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
648 map_keymap (Lisp_Object map
, map_keymap_function_t fun
, Lisp_Object args
, void *data
, int autoload
)
652 map
= get_keymap (map
, 1, autoload
);
655 map
= map_keymap_internal (map
, fun
, args
, data
);
656 map
= get_keymap (map
, 0, autoload
);
661 Lisp_Object Qkeymap_canonicalize
;
663 /* Same as map_keymap, but does it right, properly eliminating duplicate
664 bindings due to inheritance. */
666 map_keymap_canonical (Lisp_Object map
, map_keymap_function_t fun
, Lisp_Object args
, void *data
)
670 /* map_keymap_canonical may be used from redisplay (e.g. when building menus)
671 so be careful to ignore errors and to inhibit redisplay. */
672 map
= safe_call1 (Qkeymap_canonicalize
, map
);
673 /* No need to use `map_keymap' here because canonical map has no parent. */
674 map_keymap_internal (map
, fun
, args
, data
);
678 DEFUN ("map-keymap-internal", Fmap_keymap_internal
, Smap_keymap_internal
, 2, 2, 0,
679 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
680 FUNCTION is called with two arguments: the event that is bound, and
681 the definition it is bound to. The event may be a character range.
682 If KEYMAP has a parent, this function returns it without processing it. */)
683 (Lisp_Object function
, Lisp_Object keymap
)
687 keymap
= get_keymap (keymap
, 1, 1);
688 keymap
= map_keymap_internal (keymap
, map_keymap_call
, function
, NULL
);
693 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
694 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
695 FUNCTION is called with two arguments: the event that is bound, and
696 the definition it is bound to. The event may be a character range.
698 If KEYMAP has a parent, the parent's bindings are included as well.
699 This works recursively: if the parent has itself a parent, then the
700 grandparent's bindings are also included and so on.
701 usage: (map-keymap FUNCTION KEYMAP) */)
702 (Lisp_Object function
, Lisp_Object keymap
, Lisp_Object sort_first
)
704 if (! NILP (sort_first
))
705 return call2 (intern ("map-keymap-sorted"), function
, keymap
);
707 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
711 /* Given OBJECT which was found in a slot in a keymap,
712 trace indirect definitions to get the actual definition of that slot.
713 An indirect definition is a list of the form
714 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
715 and INDEX is the object to look up in KEYMAP to yield the definition.
717 Also if OBJECT has a menu string as the first element,
718 remove that. Also remove a menu help string as second element.
720 If AUTOLOAD is nonzero, load autoloadable keymaps
721 that are referred to with indirection.
723 This can GC because menu_item_eval_property calls Feval. */
726 get_keyelt (Lisp_Object object
, int autoload
)
730 if (!(CONSP (object
)))
731 /* This is really the value. */
734 /* If the keymap contents looks like (keymap ...) or (lambda ...)
736 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
739 /* If the keymap contents looks like (menu-item name . DEFN)
740 or (menu-item name DEFN ...) then use DEFN.
741 This is a new format menu item. */
742 else if (EQ (XCAR (object
), Qmenu_item
))
744 if (CONSP (XCDR (object
)))
748 object
= XCDR (XCDR (object
));
751 object
= XCAR (object
);
753 /* If there's a `:filter FILTER', apply FILTER to the
754 menu-item's definition to get the real definition to
756 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
757 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
760 filter
= XCAR (XCDR (tem
));
761 filter
= list2 (filter
, list2 (Qquote
, object
));
762 object
= menu_item_eval_property (filter
);
767 /* Invalid keymap. */
771 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
772 Keymap alist elements like (CHAR MENUSTRING . DEFN)
773 will be used by HierarKey menus. */
774 else if (STRINGP (XCAR (object
)))
776 object
= XCDR (object
);
777 /* Also remove a menu help string, if any,
778 following the menu item name. */
779 if (CONSP (object
) && STRINGP (XCAR (object
)))
780 object
= XCDR (object
);
781 /* Also remove the sublist that caches key equivalences, if any. */
782 if (CONSP (object
) && CONSP (XCAR (object
)))
785 carcar
= XCAR (XCAR (object
));
786 if (NILP (carcar
) || VECTORP (carcar
))
787 object
= XCDR (object
);
791 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
797 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
799 return (!CONSP (map
) ? object
/* Invalid keymap */
800 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
806 store_in_keymap (Lisp_Object keymap
, register Lisp_Object idx
, Lisp_Object def
)
808 /* Flush any reverse-map cache. */
809 where_is_cache
= Qnil
;
810 where_is_cache_keymaps
= Qt
;
812 /* If we are preparing to dump, and DEF is a menu element
813 with a menu item indicator, copy it to ensure it is not pure. */
814 if (CONSP (def
) && PURE_P (def
)
815 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
816 def
= Fcons (XCAR (def
), XCDR (def
));
818 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
819 error ("attempt to define a key in a non-keymap");
821 /* If idx is a cons, and the car part is a character, idx must be of
822 the form (FROM-CHAR . TO-CHAR). */
823 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
824 CHECK_CHARACTER_CDR (idx
);
826 /* If idx is a list (some sort of mouse click, perhaps?),
827 the index we want to use is the car of the list, which
828 ought to be a symbol. */
829 idx
= EVENT_HEAD (idx
);
831 /* If idx is a symbol, it might have modifiers, which need to
832 be put in the canonical order. */
834 idx
= reorder_modifiers (idx
);
835 else if (INTEGERP (idx
))
836 /* Clobber the high bits that can be present on a machine
837 with more than 24 bits of integer. */
838 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
840 /* Scan the keymap for a binding of idx. */
844 /* The cons after which we should insert new bindings. If the
845 keymap has a table element, we record its position here, so new
846 bindings will go after it; this way, the table will stay
847 towards the front of the alist and character lookups in dense
848 keymaps will remain fast. Otherwise, this just points at the
849 front of the keymap. */
850 Lisp_Object insertion_point
;
852 insertion_point
= keymap
;
853 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
860 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
863 ASET (elt
, XFASTINT (idx
), def
);
866 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
868 int from
= XFASTINT (XCAR (idx
));
869 int to
= XFASTINT (XCDR (idx
));
871 if (to
>= ASIZE (elt
))
872 to
= ASIZE (elt
) - 1;
873 for (; from
<= to
; from
++)
874 ASET (elt
, from
, def
);
875 if (to
== XFASTINT (XCDR (idx
)))
876 /* We have defined all keys in IDX. */
879 insertion_point
= tail
;
881 else if (CHAR_TABLE_P (elt
))
883 /* Character codes with modifiers
884 are not included in a char-table.
885 All character codes without modifiers are included. */
886 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
889 /* `nil' has a special meaning for char-tables, so
890 we use something else to record an explicitly
892 NILP (def
) ? Qt
: def
);
895 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
897 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
900 insertion_point
= tail
;
902 else if (CONSP (elt
))
904 if (EQ (idx
, XCAR (elt
)))
910 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
912 int from
= XFASTINT (XCAR (idx
));
913 int to
= XFASTINT (XCDR (idx
));
915 if (from
<= XFASTINT (XCAR (elt
))
916 && to
>= XFASTINT (XCAR (elt
)))
924 else if (EQ (elt
, Qkeymap
))
925 /* If we find a 'keymap' symbol in the spine of KEYMAP,
926 then we must have found the start of a second keymap
927 being used as the tail of KEYMAP, and a binding for IDX
928 should be inserted before it. */
935 /* We have scanned the entire keymap, and not found a binding for
936 IDX. Let's add one. */
940 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
942 /* IDX specifies a range of characters, and not all of them
943 were handled yet, which means this keymap doesn't have a
944 char-table. So, we insert a char-table now. */
945 elt
= Fmake_char_table (Qkeymap
, Qnil
);
946 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
949 elt
= Fcons (idx
, def
);
950 CHECK_IMPURE (insertion_point
);
951 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
958 EXFUN (Fcopy_keymap
, 1);
961 copy_keymap_item (Lisp_Object elt
)
963 Lisp_Object res
, tem
;
970 /* Is this a new format menu item. */
971 if (EQ (XCAR (tem
), Qmenu_item
))
973 /* Copy cell with menu-item marker. */
974 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
978 /* Copy cell with menu-item name. */
979 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
985 /* Copy cell with binding and if the binding is a keymap,
987 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
990 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
991 XSETCAR (elt
, Fcopy_keymap (tem
));
993 if (CONSP (tem
) && CONSP (XCAR (tem
)))
994 /* Delete cache for key equivalences. */
995 XSETCDR (elt
, XCDR (tem
));
1000 /* It may be an old fomat menu item.
1001 Skip the optional menu string. */
1002 if (STRINGP (XCAR (tem
)))
1004 /* Copy the cell, since copy-alist didn't go this deep. */
1005 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1007 /* Also skip the optional menu help string. */
1008 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1010 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1014 /* There may also be a list that caches key equivalences.
1015 Just delete it for the new keymap. */
1017 && CONSP (XCAR (tem
))
1018 && (NILP (XCAR (XCAR (tem
)))
1019 || VECTORP (XCAR (XCAR (tem
)))))
1021 XSETCDR (elt
, XCDR (tem
));
1024 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1025 XSETCDR (elt
, Fcopy_keymap (tem
));
1027 else if (EQ (XCAR (tem
), Qkeymap
))
1028 res
= Fcopy_keymap (elt
);
1034 copy_keymap_1 (Lisp_Object chartable
, Lisp_Object idx
, Lisp_Object elt
)
1036 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1039 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1040 doc
: /* Return a copy of the keymap KEYMAP.
1041 The copy starts out with the same definitions of KEYMAP,
1042 but changing either the copy or KEYMAP does not affect the other.
1043 Any key definitions that are subkeymaps are recursively copied.
1044 However, a key definition which is a symbol whose definition is a keymap
1046 (Lisp_Object keymap
)
1048 register Lisp_Object copy
, tail
;
1049 keymap
= get_keymap (keymap
, 1, 0);
1050 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1051 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1053 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1055 Lisp_Object elt
= XCAR (keymap
);
1056 if (CHAR_TABLE_P (elt
))
1058 elt
= Fcopy_sequence (elt
);
1059 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1061 else if (VECTORP (elt
))
1064 elt
= Fcopy_sequence (elt
);
1065 for (i
= 0; i
< ASIZE (elt
); i
++)
1066 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1068 else if (CONSP (elt
))
1069 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1070 XSETCDR (tail
, Fcons (elt
, Qnil
));
1072 keymap
= XCDR (keymap
);
1074 XSETCDR (tail
, keymap
);
1078 /* Simple Keymap mutators and accessors. */
1080 /* GC is possible in this function if it autoloads a keymap. */
1082 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1083 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1086 KEY is a string or a vector of symbols and characters, representing a
1087 sequence of keystrokes and events. Non-ASCII characters with codes
1088 above 127 (such as ISO Latin-1) can be represented by vectors.
1089 Two types of vector have special meanings:
1090 [remap COMMAND] remaps any key binding for COMMAND.
1091 [t] creates a default definition, which applies to any event with no
1092 other definition in KEYMAP.
1094 DEF is anything that can be a key's definition:
1095 nil (means key is undefined in this keymap),
1096 a command (a Lisp function suitable for interactive calling),
1097 a string (treated as a keyboard macro),
1098 a keymap (to define a prefix key),
1099 a symbol (when the key is looked up, the symbol will stand for its
1100 function definition, which should at that time be one of the above,
1101 or another symbol whose function definition is used, etc.),
1102 a cons (STRING . DEFN), meaning that DEFN is the definition
1103 (DEFN should be a valid definition in its own right),
1104 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
1105 or an extended menu item definition.
1106 (See info node `(elisp)Extended Menu Items'.)
1108 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1109 binding is altered. If there is no binding for KEY, the new pair
1110 binding KEY to DEF is added at the front of KEYMAP. */)
1111 (Lisp_Object keymap
, Lisp_Object key
, Lisp_Object def
)
1114 register Lisp_Object c
;
1115 register Lisp_Object cmd
;
1119 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1121 GCPRO3 (keymap
, key
, def
);
1122 keymap
= get_keymap (keymap
, 1, 1);
1124 CHECK_VECTOR_OR_STRING (key
);
1126 length
= XFASTINT (Flength (key
));
1128 RETURN_UNGCPRO (Qnil
);
1130 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1131 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1133 meta_bit
= (VECTORP (key
) || (STRINGP (key
) && STRING_MULTIBYTE (key
))
1134 ? meta_modifier
: 0x80);
1136 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, 0)))
1137 { /* DEF is apparently an XEmacs-style keyboard macro. */
1138 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1139 int i
= ASIZE (def
);
1142 Lisp_Object defi
= AREF (def
, i
);
1143 if (CONSP (defi
) && lucid_event_type_list_p (defi
))
1144 defi
= Fevent_convert_list (defi
);
1145 ASET (tmp
, i
, defi
);
1153 c
= Faref (key
, make_number (idx
));
1157 /* C may be a Lucid style event type list or a cons (FROM .
1158 TO) specifying a range of characters. */
1159 if (lucid_event_type_list_p (c
))
1160 c
= Fevent_convert_list (c
);
1161 else if (CHARACTERP (XCAR (c
)))
1162 CHECK_CHARACTER_CDR (c
);
1166 silly_event_symbol_error (c
);
1169 && (XINT (c
) & meta_bit
)
1172 c
= meta_prefix_char
;
1178 XSETINT (c
, XINT (c
) & ~meta_bit
);
1184 if (!INTEGERP (c
) && !SYMBOLP (c
)
1186 /* If C is a range, it must be a leaf. */
1187 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1188 message_with_string ("Key sequence contains invalid event %s", c
, 1);
1191 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1193 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1195 /* If this key is undefined, make it a prefix. */
1197 cmd
= define_as_prefix (keymap
, c
);
1199 keymap
= get_keymap (cmd
, 0, 1);
1200 if (!CONSP (keymap
))
1201 /* We must use Fkey_description rather than just passing key to
1202 error; key might be a vector, not a string. */
1203 error ("Key sequence %s starts with non-prefix key %s",
1204 SDATA (Fkey_description (key
, Qnil
)),
1205 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1211 /* This function may GC (it calls Fkey_binding). */
1213 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 3, 0,
1214 doc
: /* Return the remapping for command COMMAND.
1215 Returns nil if COMMAND is not remapped (or not a symbol).
1217 If the optional argument POSITION is non-nil, it specifies a mouse
1218 position as returned by `event-start' and `event-end', and the
1219 remapping occurs in the keymaps associated with it. It can also be a
1220 number or marker, in which case the keymap properties at the specified
1221 buffer position instead of point are used. The KEYMAPS argument is
1222 ignored if POSITION is non-nil.
1224 If the optional argument KEYMAPS is non-nil, it should be a list of
1225 keymaps to search for command remapping. Otherwise, search for the
1226 remapping in all currently active keymaps. */)
1227 (Lisp_Object command
, Lisp_Object position
, Lisp_Object keymaps
)
1229 if (!SYMBOLP (command
))
1232 ASET (command_remapping_vector
, 1, command
);
1235 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
, position
);
1238 Lisp_Object maps
, binding
;
1240 for (maps
= keymaps
; CONSP (maps
); maps
= XCDR (maps
))
1242 binding
= Flookup_key (XCAR (maps
), command_remapping_vector
, Qnil
);
1243 if (!NILP (binding
) && !INTEGERP (binding
))
1250 /* Value is number if KEY is too long; nil if valid but has no definition. */
1251 /* GC is possible in this function if it autoloads a keymap. */
1253 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1254 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1255 A value of nil means undefined. See doc of `define-key'
1256 for kinds of definitions.
1258 A number as value means KEY is "too long";
1259 that is, characters or symbols in it except for the last one
1260 fail to be a valid sequence of prefix characters in KEYMAP.
1261 The number is how many characters at the front of KEY
1262 it takes to reach a non-prefix key.
1264 Normally, `lookup-key' ignores bindings for t, which act as default
1265 bindings, used when nothing else in the keymap applies; this makes it
1266 usable as a general function for probing keymaps. However, if the
1267 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1268 recognize the default bindings, just as `read-key-sequence' does. */)
1269 (Lisp_Object keymap
, Lisp_Object key
, Lisp_Object accept_default
)
1272 register Lisp_Object cmd
;
1273 register Lisp_Object c
;
1275 int t_ok
= !NILP (accept_default
);
1276 struct gcpro gcpro1
, gcpro2
;
1278 GCPRO2 (keymap
, key
);
1279 keymap
= get_keymap (keymap
, 1, 1);
1281 CHECK_VECTOR_OR_STRING (key
);
1283 length
= XFASTINT (Flength (key
));
1285 RETURN_UNGCPRO (keymap
);
1290 c
= Faref (key
, make_number (idx
++));
1292 if (CONSP (c
) && lucid_event_type_list_p (c
))
1293 c
= Fevent_convert_list (c
);
1295 /* Turn the 8th bit of string chars into a meta modifier. */
1296 if (STRINGP (key
) && XINT (c
) & 0x80 && !STRING_MULTIBYTE (key
))
1297 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1299 /* Allow string since binding for `menu-bar-select-buffer'
1300 includes the buffer name in the key sequence. */
1301 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1302 message_with_string ("Key sequence contains invalid event %s", c
, 1);
1304 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1306 RETURN_UNGCPRO (cmd
);
1308 keymap
= get_keymap (cmd
, 0, 1);
1309 if (!CONSP (keymap
))
1310 RETURN_UNGCPRO (make_number (idx
));
1316 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1317 Assume that currently it does not define C at all.
1318 Return the keymap. */
1321 define_as_prefix (Lisp_Object keymap
, Lisp_Object c
)
1325 cmd
= Fmake_sparse_keymap (Qnil
);
1326 /* If this key is defined as a prefix in an inherited keymap,
1327 make it a prefix in this map, and make its definition
1328 inherit the other prefix definition. */
1329 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1330 store_in_keymap (keymap
, c
, cmd
);
1335 /* Append a key to the end of a key sequence. We always make a vector. */
1338 append_key (Lisp_Object key_sequence
, Lisp_Object key
)
1340 Lisp_Object args
[2];
1342 args
[0] = key_sequence
;
1344 args
[1] = Fcons (key
, Qnil
);
1345 return Fvconcat (2, args
);
1348 /* Given a event type C which is a symbol,
1349 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1352 silly_event_symbol_error (Lisp_Object c
)
1354 Lisp_Object parsed
, base
, name
, assoc
;
1357 parsed
= parse_modifiers (c
);
1358 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1359 base
= XCAR (parsed
);
1360 name
= Fsymbol_name (base
);
1361 /* This alist includes elements such as ("RET" . "\\r"). */
1362 assoc
= Fassoc (name
, exclude_keys
);
1366 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1368 Lisp_Object keystring
;
1369 if (modifiers
& alt_modifier
)
1370 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1371 if (modifiers
& ctrl_modifier
)
1372 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1373 if (modifiers
& hyper_modifier
)
1374 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1375 if (modifiers
& meta_modifier
)
1376 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1377 if (modifiers
& shift_modifier
)
1378 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1379 if (modifiers
& super_modifier
)
1380 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1383 c
= reorder_modifiers (c
);
1384 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1386 error ((modifiers
& ~meta_modifier
1387 ? "To bind the key %s, use [?%s], not [%s]"
1388 : "To bind the key %s, use \"%s\", not [%s]"),
1389 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1390 SDATA (SYMBOL_NAME (c
)));
1394 /* Global, local, and minor mode keymap stuff. */
1396 /* We can't put these variables inside current_minor_maps, since under
1397 some systems, static gets macro-defined to be the empty string.
1399 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1400 static int cmm_size
= 0;
1402 /* Store a pointer to an array of the currently active minor modes in
1403 *modeptr, a pointer to an array of the keymaps of the currently
1404 active minor modes in *mapptr, and return the number of maps
1407 This function always returns a pointer to the same buffer, and may
1408 free or reallocate it, so if you want to keep it for a long time or
1409 hand it out to lisp code, copy it. This procedure will be called
1410 for every key sequence read, so the nice lispy approach (return a
1411 new assoclist, list, what have you) for each invocation would
1412 result in a lot of consing over time.
1414 If we used xrealloc/xmalloc and ran out of memory, they would throw
1415 back to the command loop, which would try to read a key sequence,
1416 which would call this function again, resulting in an infinite
1417 loop. Instead, we'll use realloc/malloc and silently truncate the
1418 list, let the key sequence be read, and hope some other piece of
1419 code signals the error. */
1421 current_minor_maps (Lisp_Object
**modeptr
, Lisp_Object
**mapptr
)
1424 int list_number
= 0;
1425 Lisp_Object alist
, assoc
, var
, val
;
1426 Lisp_Object emulation_alists
;
1427 Lisp_Object lists
[2];
1429 emulation_alists
= Vemulation_mode_map_alists
;
1430 lists
[0] = Vminor_mode_overriding_map_alist
;
1431 lists
[1] = Vminor_mode_map_alist
;
1433 for (list_number
= 0; list_number
< 2; list_number
++)
1435 if (CONSP (emulation_alists
))
1437 alist
= XCAR (emulation_alists
);
1438 emulation_alists
= XCDR (emulation_alists
);
1439 if (SYMBOLP (alist
))
1440 alist
= find_symbol_value (alist
);
1444 alist
= lists
[list_number
];
1446 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1447 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1448 && (var
= XCAR (assoc
), SYMBOLP (var
))
1449 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1454 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1455 and also an entry in Vminor_mode_map_alist,
1456 ignore the latter. */
1457 if (list_number
== 1)
1459 val
= assq_no_quit (var
, lists
[0]);
1466 int newsize
, allocsize
;
1467 Lisp_Object
*newmodes
, *newmaps
;
1469 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1470 allocsize
= newsize
* sizeof *newmodes
;
1472 /* Use malloc here. See the comment above this function.
1473 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1475 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1480 memcpy (newmodes
, cmm_modes
,
1481 cmm_size
* sizeof cmm_modes
[0]);
1484 cmm_modes
= newmodes
;
1487 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1492 memcpy (newmaps
, cmm_maps
,
1493 cmm_size
* sizeof cmm_maps
[0]);
1500 if (newmodes
== NULL
|| newmaps
== NULL
)
1505 /* Get the keymap definition--or nil if it is not defined. */
1506 temp
= Findirect_function (XCDR (assoc
), Qt
);
1510 cmm_maps
[i
] = temp
;
1516 if (modeptr
) *modeptr
= cmm_modes
;
1517 if (mapptr
) *mapptr
= cmm_maps
;
1521 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1523 doc
: /* Return a list of the currently active keymaps.
1524 OLP if non-nil indicates that we should obey `overriding-local-map' and
1525 `overriding-terminal-local-map'. POSITION can specify a click position
1526 like in the respective argument of `key-binding'. */)
1527 (Lisp_Object olp
, Lisp_Object position
)
1529 int count
= SPECPDL_INDEX ();
1531 Lisp_Object keymaps
;
1533 /* If a mouse click position is given, our variables are based on
1534 the buffer clicked on, not the current buffer. So we may have to
1535 switch the buffer here. */
1537 if (CONSP (position
))
1541 window
= POSN_WINDOW (position
);
1543 if (WINDOWP (window
)
1544 && BUFFERP (XWINDOW (window
)->buffer
)
1545 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1547 /* Arrange to go back to the original buffer once we're done
1548 processing the key sequence. We don't use
1549 save_excursion_{save,restore} here, in analogy to
1550 `read-key-sequence' to avoid saving point. Maybe this
1551 would not be a problem here, but it is easier to keep
1555 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1557 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1561 keymaps
= Fcons (current_global_map
, Qnil
);
1565 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
1566 keymaps
= Fcons (KVAR (current_kboard
, Voverriding_terminal_local_map
), keymaps
);
1567 /* The doc said that overriding-terminal-local-map should
1568 override overriding-local-map. The code used them both,
1569 but it seems clearer to use just one. rms, jan 2005. */
1570 else if (!NILP (Voverriding_local_map
))
1571 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1573 if (NILP (XCDR (keymaps
)))
1578 Lisp_Object keymap
, local_map
;
1581 pt
= INTEGERP (position
) ? XINT (position
)
1582 : MARKERP (position
) ? marker_position (position
)
1585 /* Get the buffer local maps, possibly overriden by text or
1586 overlay properties */
1588 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1589 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1591 if (CONSP (position
))
1595 /* For a mouse click, get the local text-property keymap
1596 of the place clicked on, rather than point. */
1598 if (POSN_INBUFFER_P (position
))
1602 pos
= POSN_BUFFER_POSN (position
);
1604 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1606 local_map
= get_local_map (XINT (pos
),
1607 current_buffer
, Qlocal_map
);
1609 keymap
= get_local_map (XINT (pos
),
1610 current_buffer
, Qkeymap
);
1614 /* If on a mode line string with a local keymap,
1615 or for a click on a string, i.e. overlay string or a
1616 string displayed via the `display' property,
1617 consider `local-map' and `keymap' properties of
1620 if (string
= POSN_STRING (position
),
1621 (CONSP (string
) && STRINGP (XCAR (string
))))
1623 Lisp_Object pos
, map
;
1625 pos
= XCDR (string
);
1626 string
= XCAR (string
);
1629 && XINT (pos
) < SCHARS (string
))
1631 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1635 map
= Fget_text_property (pos
, Qkeymap
, string
);
1643 if (!NILP (local_map
))
1644 keymaps
= Fcons (local_map
, keymaps
);
1646 /* Now put all the minor mode keymaps on the list. */
1647 nmaps
= current_minor_maps (0, &maps
);
1649 for (i
= --nmaps
; i
>= 0; i
--)
1650 if (!NILP (maps
[i
]))
1651 keymaps
= Fcons (maps
[i
], keymaps
);
1654 keymaps
= Fcons (keymap
, keymaps
);
1657 unbind_to (count
, Qnil
);
1662 /* GC is possible in this function if it autoloads a keymap. */
1664 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 4, 0,
1665 doc
: /* Return the binding for command KEY in current keymaps.
1666 KEY is a string or vector, a sequence of keystrokes.
1667 The binding is probably a symbol with a function definition.
1669 Normally, `key-binding' ignores bindings for t, which act as default
1670 bindings, used when nothing else in the keymap applies; this makes it
1671 usable as a general function for probing keymaps. However, if the
1672 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1673 recognize the default bindings, just as `read-key-sequence' does.
1675 Like the normal command loop, `key-binding' will remap the command
1676 resulting from looking up KEY by looking up the command in the
1677 current keymaps. However, if the optional third argument NO-REMAP
1678 is non-nil, `key-binding' returns the unmapped command.
1680 If KEY is a key sequence initiated with the mouse, the used keymaps
1681 will depend on the clicked mouse position with regard to the buffer
1682 and possible local keymaps on strings.
1684 If the optional argument POSITION is non-nil, it specifies a mouse
1685 position as returned by `event-start' and `event-end', and the lookup
1686 occurs in the keymaps associated with it instead of KEY. It can also
1687 be a number or marker, in which case the keymap properties at the
1688 specified buffer position instead of point are used.
1690 (Lisp_Object key
, Lisp_Object accept_default
, Lisp_Object no_remap
, Lisp_Object position
)
1692 Lisp_Object
*maps
, value
;
1694 struct gcpro gcpro1
, gcpro2
;
1695 int count
= SPECPDL_INDEX ();
1697 GCPRO2 (key
, position
);
1699 if (NILP (position
) && VECTORP (key
))
1702 /* mouse events may have a symbolic prefix indicating the
1703 scrollbar or mode line */
1704 = AREF (key
, SYMBOLP (AREF (key
, 0)) && ASIZE (key
) > 1 ? 1 : 0);
1706 /* We are not interested in locations without event data */
1708 if (EVENT_HAS_PARAMETERS (event
) && CONSP (XCDR (event
)))
1710 Lisp_Object kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1711 if (EQ (kind
, Qmouse_click
))
1712 position
= EVENT_START (event
);
1716 /* Key sequences beginning with mouse clicks
1717 are read using the keymaps of the buffer clicked on, not
1718 the current buffer. So we may have to switch the buffer
1721 if (CONSP (position
))
1725 window
= POSN_WINDOW (position
);
1727 if (WINDOWP (window
)
1728 && BUFFERP (XWINDOW (window
)->buffer
)
1729 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1731 /* Arrange to go back to the original buffer once we're done
1732 processing the key sequence. We don't use
1733 save_excursion_{save,restore} here, in analogy to
1734 `read-key-sequence' to avoid saving point. Maybe this
1735 would not be a problem here, but it is easier to keep
1739 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1741 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1745 if (! NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
1747 value
= Flookup_key (KVAR (current_kboard
, Voverriding_terminal_local_map
),
1748 key
, accept_default
);
1749 if (! NILP (value
) && !INTEGERP (value
))
1752 else if (! NILP (Voverriding_local_map
))
1754 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1755 if (! NILP (value
) && !INTEGERP (value
))
1760 Lisp_Object keymap
, local_map
;
1763 pt
= INTEGERP (position
) ? XINT (position
)
1764 : MARKERP (position
) ? marker_position (position
)
1767 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1768 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1770 if (CONSP (position
))
1774 /* For a mouse click, get the local text-property keymap
1775 of the place clicked on, rather than point. */
1777 if (POSN_INBUFFER_P (position
))
1781 pos
= POSN_BUFFER_POSN (position
);
1783 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1785 local_map
= get_local_map (XINT (pos
),
1786 current_buffer
, Qlocal_map
);
1788 keymap
= get_local_map (XINT (pos
),
1789 current_buffer
, Qkeymap
);
1793 /* If on a mode line string with a local keymap,
1794 or for a click on a string, i.e. overlay string or a
1795 string displayed via the `display' property,
1796 consider `local-map' and `keymap' properties of
1799 if (string
= POSN_STRING (position
),
1800 (CONSP (string
) && STRINGP (XCAR (string
))))
1802 Lisp_Object pos
, map
;
1804 pos
= XCDR (string
);
1805 string
= XCAR (string
);
1808 && XINT (pos
) < SCHARS (string
))
1810 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1814 map
= Fget_text_property (pos
, Qkeymap
, string
);
1822 if (! NILP (keymap
))
1824 value
= Flookup_key (keymap
, key
, accept_default
);
1825 if (! NILP (value
) && !INTEGERP (value
))
1829 nmaps
= current_minor_maps (0, &maps
);
1830 /* Note that all these maps are GCPRO'd
1831 in the places where we found them. */
1833 for (i
= 0; i
< nmaps
; i
++)
1834 if (! NILP (maps
[i
]))
1836 value
= Flookup_key (maps
[i
], key
, accept_default
);
1837 if (! NILP (value
) && !INTEGERP (value
))
1841 if (! NILP (local_map
))
1843 value
= Flookup_key (local_map
, key
, accept_default
);
1844 if (! NILP (value
) && !INTEGERP (value
))
1849 value
= Flookup_key (current_global_map
, key
, accept_default
);
1852 unbind_to (count
, Qnil
);
1855 if (NILP (value
) || INTEGERP (value
))
1858 /* If the result of the ordinary keymap lookup is an interactive
1859 command, look for a key binding (ie. remapping) for that command. */
1861 if (NILP (no_remap
) && SYMBOLP (value
))
1864 if (value1
= Fcommand_remapping (value
, position
, Qnil
), !NILP (value1
))
1871 /* GC is possible in this function if it autoloads a keymap. */
1873 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1874 doc
: /* Return the binding for command KEYS in current local keymap only.
1875 KEYS is a string or vector, a sequence of keystrokes.
1876 The binding is probably a symbol with a function definition.
1878 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1879 bindings; see the description of `lookup-key' for more details about this. */)
1880 (Lisp_Object keys
, Lisp_Object accept_default
)
1882 register Lisp_Object map
;
1883 map
= BVAR (current_buffer
, keymap
);
1886 return Flookup_key (map
, keys
, accept_default
);
1889 /* GC is possible in this function if it autoloads a keymap. */
1891 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1892 doc
: /* Return the binding for command KEYS in current global keymap only.
1893 KEYS is a string or vector, a sequence of keystrokes.
1894 The binding is probably a symbol with a function definition.
1895 This function's return values are the same as those of `lookup-key'
1898 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1899 bindings; see the description of `lookup-key' for more details about this. */)
1900 (Lisp_Object keys
, Lisp_Object accept_default
)
1902 return Flookup_key (current_global_map
, keys
, accept_default
);
1905 /* GC is possible in this function if it autoloads a keymap. */
1907 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1908 doc
: /* Find the visible minor mode bindings of KEY.
1909 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1910 the symbol which names the minor mode binding KEY, and BINDING is
1911 KEY's definition in that mode. In particular, if KEY has no
1912 minor-mode bindings, return nil. If the first binding is a
1913 non-prefix, all subsequent bindings will be omitted, since they would
1914 be ignored. Similarly, the list doesn't include non-prefix bindings
1915 that come after prefix bindings.
1917 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1918 bindings; see the description of `lookup-key' for more details about this. */)
1919 (Lisp_Object key
, Lisp_Object accept_default
)
1921 Lisp_Object
*modes
, *maps
;
1923 Lisp_Object binding
;
1925 struct gcpro gcpro1
, gcpro2
;
1927 nmaps
= current_minor_maps (&modes
, &maps
);
1928 /* Note that all these maps are GCPRO'd
1929 in the places where we found them. */
1932 GCPRO2 (key
, binding
);
1934 for (i
= j
= 0; i
< nmaps
; i
++)
1936 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1937 && !INTEGERP (binding
))
1939 if (KEYMAPP (binding
))
1940 maps
[j
++] = Fcons (modes
[i
], binding
);
1942 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1946 return Flist (j
, maps
);
1949 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1950 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1951 A new sparse keymap is stored as COMMAND's function definition and its value.
1952 If a second optional argument MAPVAR is given, the map is stored as
1953 its value instead of as COMMAND's value; but COMMAND is still defined
1955 The third optional argument NAME, if given, supplies a menu name
1956 string for the map. This is required to use the keymap as a menu.
1957 This function returns COMMAND. */)
1958 (Lisp_Object command
, Lisp_Object mapvar
, Lisp_Object name
)
1961 map
= Fmake_sparse_keymap (name
);
1962 Ffset (command
, map
);
1966 Fset (command
, map
);
1970 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1971 doc
: /* Select KEYMAP as the global keymap. */)
1972 (Lisp_Object keymap
)
1974 keymap
= get_keymap (keymap
, 1, 1);
1975 current_global_map
= keymap
;
1980 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1981 doc
: /* Select KEYMAP as the local keymap.
1982 If KEYMAP is nil, that means no local keymap. */)
1983 (Lisp_Object keymap
)
1986 keymap
= get_keymap (keymap
, 1, 1);
1988 BVAR (current_buffer
, keymap
) = keymap
;
1993 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1994 doc
: /* Return current buffer's local keymap, or nil if it has none.
1995 Normally the local keymap is set by the major mode with `use-local-map'. */)
1998 return BVAR (current_buffer
, keymap
);
2001 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
2002 doc
: /* Return the current global keymap. */)
2005 return current_global_map
;
2008 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
2009 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
2013 int nmaps
= current_minor_maps (0, &maps
);
2015 return Flist (nmaps
, maps
);
2018 /* Help functions for describing and documenting keymaps. */
2020 struct accessible_keymaps_data
{
2021 Lisp_Object maps
, tail
, thisseq
;
2022 /* Does the current sequence end in the meta-prefix-char? */
2027 accessible_keymaps_1 (Lisp_Object key
, Lisp_Object cmd
, Lisp_Object args
, void *data
)
2028 /* Use void* data to be compatible with map_keymap_function_t. */
2030 struct accessible_keymaps_data
*d
= data
; /* Cast! */
2031 Lisp_Object maps
= d
->maps
;
2032 Lisp_Object tail
= d
->tail
;
2033 Lisp_Object thisseq
= d
->thisseq
;
2034 int is_metized
= d
->is_metized
&& INTEGERP (key
);
2037 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
2041 /* Look for and break cycles. */
2042 while (!NILP (tem
= Frassq (cmd
, maps
)))
2044 Lisp_Object prefix
= XCAR (tem
);
2045 int lim
= XINT (Flength (XCAR (tem
)));
2046 if (lim
<= XINT (Flength (thisseq
)))
2047 { /* This keymap was already seen with a smaller prefix. */
2049 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
2050 Faref (thisseq
, make_number (i
))))
2053 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
2056 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
2057 but maybe `cmd' occurs again further down in `maps', so keep
2059 maps
= XCDR (Fmemq (tem
, maps
));
2062 /* If the last key in thisseq is meta-prefix-char,
2063 turn it into a meta-ized keystroke. We know
2064 that the event we're about to append is an
2065 ascii keystroke since we're processing a
2069 int meta_bit
= meta_modifier
;
2070 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
2071 tem
= Fcopy_sequence (thisseq
);
2073 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
2075 /* This new sequence is the same length as
2076 thisseq, so stick it in the list right
2079 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
2083 tem
= append_key (thisseq
, key
);
2084 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
2088 /* This function cannot GC. */
2090 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
2092 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
2093 Returns a list of elements of the form (KEYS . MAP), where the sequence
2094 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
2095 so that the KEYS increase in length. The first element is ([] . KEYMAP).
2096 An optional argument PREFIX, if non-nil, should be a key sequence;
2097 then the value includes only maps for prefixes that start with PREFIX. */)
2098 (Lisp_Object keymap
, Lisp_Object prefix
)
2100 Lisp_Object maps
, tail
;
2101 int prefixlen
= XINT (Flength (prefix
));
2103 /* no need for gcpro because we don't autoload any keymaps. */
2107 /* If a prefix was specified, start with the keymap (if any) for
2108 that prefix, so we don't waste time considering other prefixes. */
2110 tem
= Flookup_key (keymap
, prefix
, Qt
);
2111 /* Flookup_key may give us nil, or a number,
2112 if the prefix is not defined in this particular map.
2113 It might even give us a list that isn't a keymap. */
2114 tem
= get_keymap (tem
, 0, 0);
2115 /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
2116 want to return it. */
2119 /* Convert PREFIX to a vector now, so that later on
2120 we don't have to deal with the possibility of a string. */
2121 if (STRINGP (prefix
))
2126 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
2127 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
2131 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
2132 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2133 c
^= 0200 | meta_modifier
;
2134 ASET (copy
, i_before
, make_number (c
));
2138 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
2144 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
2145 get_keymap (keymap
, 1, 0)),
2148 /* For each map in the list maps,
2149 look at any other maps it points to,
2150 and stick them at the end if they are not already in the list.
2152 This is a breadth-first traversal, where tail is the queue of
2153 nodes, and maps accumulates a list of all nodes visited. */
2155 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2157 struct accessible_keymaps_data data
;
2158 register Lisp_Object thismap
= Fcdr (XCAR (tail
));
2161 data
.thisseq
= Fcar (XCAR (tail
));
2164 last
= make_number (XINT (Flength (data
.thisseq
)) - 1);
2165 /* Does the current sequence end in the meta-prefix-char? */
2166 data
.is_metized
= (XINT (last
) >= 0
2167 /* Don't metize the last char of PREFIX. */
2168 && XINT (last
) >= prefixlen
2169 && EQ (Faref (data
.thisseq
, last
), meta_prefix_char
));
2171 /* Since we can't run lisp code, we can't scan autoloaded maps. */
2172 if (CONSP (thismap
))
2173 map_keymap (thismap
, accessible_keymaps_1
, Qnil
, &data
, 0);
2177 Lisp_Object Qsingle_key_description
, Qkey_description
;
2179 /* This function cannot GC. */
2181 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2182 doc
: /* Return a pretty description of key-sequence KEYS.
2183 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2184 Control characters turn into "C-foo" sequences, meta into "M-foo",
2185 spaces are put between sequence elements, etc. */)
2186 (Lisp_Object keys
, Lisp_Object prefix
)
2191 int size
= XINT (Flength (keys
));
2193 Lisp_Object sep
= build_string (" ");
2198 size
+= XINT (Flength (prefix
));
2200 /* This has one extra element at the end that we don't pass to Fconcat. */
2201 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2203 /* In effect, this computes
2204 (mapconcat 'single-key-description keys " ")
2205 but we shouldn't use mapconcat because it can do GC. */
2209 list
= prefix
, prefix
= Qnil
;
2210 else if (!NILP (keys
))
2211 list
= keys
, keys
= Qnil
;
2216 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2220 return empty_unibyte_string
;
2221 return Fconcat (len
- 1, args
);
2225 size
= SCHARS (list
);
2226 else if (VECTORP (list
))
2227 size
= XVECTOR (list
)->size
;
2228 else if (CONSP (list
))
2229 size
= XINT (Flength (list
));
2231 wrong_type_argument (Qarrayp
, list
);
2240 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2241 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2242 c
^= 0200 | meta_modifier
;
2243 XSETFASTINT (key
, c
);
2245 else if (VECTORP (list
))
2247 key
= AREF (list
, i
); i
++;
2259 || EQ (key
, meta_prefix_char
)
2260 || (XINT (key
) & meta_modifier
))
2262 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2264 if (EQ (key
, meta_prefix_char
))
2268 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2271 else if (EQ (key
, meta_prefix_char
))
2276 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2284 push_key_description (register unsigned int c
, register char *p
, int force_multibyte
)
2288 /* Clear all the meaningless bits above the meta bit. */
2289 c
&= meta_modifier
| ~ - meta_modifier
;
2290 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2291 | meta_modifier
| shift_modifier
| super_modifier
);
2293 if (! CHARACTERP (make_number (c2
)))
2295 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2296 p
+= sprintf (p
, "[%d]", c
);
2300 if (c
& alt_modifier
)
2306 if ((c
& ctrl_modifier
) != 0
2307 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2311 c
&= ~ctrl_modifier
;
2313 if (c
& hyper_modifier
)
2317 c
-= hyper_modifier
;
2319 if (c
& meta_modifier
)
2325 if (c
& shift_modifier
)
2329 c
-= shift_modifier
;
2331 if (c
& super_modifier
)
2335 c
-= super_modifier
;
2351 else if (c
== Ctl ('M'))
2359 /* `C-' already added above. */
2360 if (c
> 0 && c
<= Ctl ('Z'))
2379 || (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
2380 && SINGLE_BYTE_CHAR_P (c
)
2381 && !force_multibyte
))
2387 /* Now we are sure that C is a valid character code. */
2388 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
2389 && ! force_multibyte
)
2390 *p
++ = multibyte_char_to_unibyte (c
);
2392 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2398 /* This function cannot GC. */
2400 DEFUN ("single-key-description", Fsingle_key_description
,
2401 Ssingle_key_description
, 1, 2, 0,
2402 doc
: /* Return a pretty description of command character KEY.
2403 Control characters turn into C-whatever, etc.
2404 Optional argument NO-ANGLES non-nil means don't put angle brackets
2405 around function keys and event symbols. */)
2406 (Lisp_Object key
, Lisp_Object no_angles
)
2408 if (CONSP (key
) && lucid_event_type_list_p (key
))
2409 key
= Fevent_convert_list (key
);
2411 key
= EVENT_HEAD (key
);
2413 if (INTEGERP (key
)) /* Normal character */
2415 char tem
[KEY_DESCRIPTION_SIZE
];
2417 *push_key_description (XUINT (key
), tem
, 1) = 0;
2418 return build_string (tem
);
2420 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2422 if (NILP (no_angles
))
2425 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2426 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2427 return build_string (buffer
);
2430 return Fsymbol_name (key
);
2432 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2433 return Fcopy_sequence (key
);
2435 error ("KEY must be an integer, cons, symbol, or string");
2440 push_text_char_description (register unsigned int c
, register char *p
)
2451 *p
++ = c
+ 64; /* 'A' - 1 */
2463 /* This function cannot GC. */
2465 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2466 doc
: /* Return a pretty description of file-character CHARACTER.
2467 Control characters turn into "^char", etc. This differs from
2468 `single-key-description' which turns them into "C-char".
2469 Also, this function recognizes the 2**7 bit as the Meta character,
2470 whereas `single-key-description' uses the 2**27 bit for Meta.
2471 See Info node `(elisp)Describing Characters' for examples. */)
2472 (Lisp_Object character
)
2474 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2478 CHECK_NUMBER (character
);
2480 c
= XINT (character
);
2481 if (!ASCII_CHAR_P (c
))
2483 int len
= CHAR_STRING (c
, (unsigned char *) str
);
2485 return make_multibyte_string (str
, 1, len
);
2488 *push_text_char_description (c
& 0377, str
) = 0;
2490 return build_string (str
);
2493 static int where_is_preferred_modifier
;
2495 /* Return 0 if SEQ uses non-preferred modifiers or non-char events.
2496 Else, return 2 if SEQ uses the where_is_preferred_modifier,
2499 preferred_sequence_p (Lisp_Object seq
)
2502 int len
= XINT (Flength (seq
));
2505 for (i
= 0; i
< len
; i
++)
2507 Lisp_Object ii
, elt
;
2509 XSETFASTINT (ii
, i
);
2510 elt
= Faref (seq
, ii
);
2512 if (!INTEGERP (elt
))
2516 int modifiers
= XUINT (elt
) & (CHAR_MODIFIER_MASK
& ~CHAR_META
);
2517 if (modifiers
== where_is_preferred_modifier
)
2528 /* where-is - finding a command in a set of keymaps. */
2530 static void where_is_internal_1 (Lisp_Object key
, Lisp_Object binding
,
2531 Lisp_Object args
, void *data
);
2533 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2534 Returns the first non-nil binding found in any of those maps.
2535 If REMAP is true, pass the result of the lookup through command
2536 remapping before returning it. */
2539 shadow_lookup (Lisp_Object shadow
, Lisp_Object key
, Lisp_Object flag
,
2542 Lisp_Object tail
, value
;
2544 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2546 value
= Flookup_key (XCAR (tail
), key
, flag
);
2547 if (NATNUMP (value
))
2549 value
= Flookup_key (XCAR (tail
),
2550 Fsubstring (key
, make_number (0), value
), flag
);
2554 else if (!NILP (value
))
2556 Lisp_Object remapping
;
2557 if (remap
&& SYMBOLP (value
)
2558 && (remapping
= Fcommand_remapping (value
, Qnil
, shadow
),
2568 static Lisp_Object Vmouse_events
;
2570 struct where_is_internal_data
{
2571 Lisp_Object definition
, this, last
;
2572 int last_is_meta
, noindirect
;
2573 Lisp_Object sequences
;
2576 /* This function can't GC, AFAIK. */
2577 /* Return the list of bindings found. This list is ordered "longest
2578 to shortest". It may include bindings that are actually shadowed
2579 by others, as well as duplicate bindings and remapping bindings.
2580 The list returned is potentially shared with where_is_cache, so
2581 be careful not to modify it via side-effects. */
2584 where_is_internal (Lisp_Object definition
, Lisp_Object keymaps
,
2585 int noindirect
, int nomenus
)
2587 Lisp_Object maps
= Qnil
;
2589 struct where_is_internal_data data
;
2591 /* Only important use of caching is for the menubar
2592 (i.e. where-is-internal called with (def nil t nil nil)). */
2593 if (nomenus
&& !noindirect
)
2595 /* Check heuristic-consistency of the cache. */
2596 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2597 where_is_cache
= Qnil
;
2599 if (NILP (where_is_cache
))
2601 /* We need to create the cache. */
2602 Lisp_Object args
[2];
2603 where_is_cache
= Fmake_hash_table (0, args
);
2604 where_is_cache_keymaps
= Qt
;
2607 /* We can reuse the cache. */
2608 return Fgethash (definition
, where_is_cache
, Qnil
);
2611 /* Kill the cache so that where_is_internal_1 doesn't think
2612 we're filling it up. */
2613 where_is_cache
= Qnil
;
2616 while (CONSP (found
))
2620 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2621 found
= XCDR (found
);
2624 data
.sequences
= Qnil
;
2625 for (; CONSP (maps
); maps
= XCDR (maps
))
2627 /* Key sequence to reach map, and the map that it reaches */
2628 register Lisp_Object
this, map
, tem
;
2630 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2631 [M-CHAR] sequences, check if last character of the sequence
2632 is the meta-prefix char. */
2636 this = Fcar (XCAR (maps
));
2637 map
= Fcdr (XCAR (maps
));
2638 last
= make_number (XINT (Flength (this)) - 1);
2639 last_is_meta
= (XINT (last
) >= 0
2640 && EQ (Faref (this, last
), meta_prefix_char
));
2642 /* if (nomenus && !preferred_sequence_p (this)) */
2643 if (nomenus
&& XINT (last
) >= 0
2644 && SYMBOLP (tem
= Faref (this, make_number (0)))
2645 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2646 /* If no menu entries should be returned, skip over the
2647 keymaps bound to `menu-bar' and `tool-bar' and other
2648 non-ascii prefixes like `C-down-mouse-2'. */
2653 data
.definition
= definition
;
2654 data
.noindirect
= noindirect
;
2657 data
.last_is_meta
= last_is_meta
;
2660 map_keymap (map
, where_is_internal_1
, Qnil
, &data
, 0);
2663 if (nomenus
&& !noindirect
)
2664 { /* Remember for which keymaps this cache was built.
2665 We do it here (late) because we want to keep where_is_cache_keymaps
2666 set to t while the cache isn't fully filled. */
2667 where_is_cache_keymaps
= keymaps
;
2668 /* During cache-filling, data.sequences is not filled by
2669 where_is_internal_1. */
2670 return Fgethash (definition
, where_is_cache
, Qnil
);
2673 return data
.sequences
;
2676 /* This function can GC if Flookup_key autoloads any keymaps. */
2678 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2679 doc
: /* Return list of keys that invoke DEFINITION.
2680 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2681 If KEYMAP is nil, search all the currently active keymaps.
2682 If KEYMAP is a list of keymaps, search only those keymaps.
2684 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2685 rather than a list of all possible key sequences.
2686 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2687 no matter what it is.
2688 If FIRSTONLY has another non-nil value, prefer bindings
2689 that use the modifier key specified in `where-is-preferred-modifier'
2690 \(or their meta variants) and entirely reject menu bindings.
2692 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2693 to other keymaps or slots. This makes it possible to search for an
2694 indirect definition itself.
2696 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2697 that invoke a command which is remapped to DEFINITION, but include the
2698 remapped command in the returned list. */)
2699 (Lisp_Object definition
, Lisp_Object keymap
, Lisp_Object firstonly
, Lisp_Object noindirect
, Lisp_Object no_remap
)
2701 /* The keymaps in which to search. */
2702 Lisp_Object keymaps
;
2703 /* Potentially relevant bindings in "shortest to longest" order. */
2704 Lisp_Object sequences
= Qnil
;
2705 /* Actually relevant bindings. */
2706 Lisp_Object found
= Qnil
;
2707 /* 1 means ignore all menu bindings entirely. */
2708 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2709 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
2710 /* List of sequences found via remapping. Keep them in a separate
2711 variable, so as to push them later, since we prefer
2712 non-remapped binding. */
2713 Lisp_Object remapped_sequences
= Qnil
;
2714 /* Whether or not we're handling remapped sequences. This is needed
2715 because remapping is not done recursively by Fcommand_remapping: you
2716 can't remap a remapped command. */
2718 Lisp_Object tem
= Qnil
;
2720 /* Refresh the C version of the modifier preference. */
2721 where_is_preferred_modifier
2722 = parse_solitary_modifier (Vwhere_is_preferred_modifier
);
2724 /* Find the relevant keymaps. */
2725 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2727 else if (!NILP (keymap
))
2728 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2730 keymaps
= Fcurrent_active_maps (Qnil
, Qnil
);
2732 GCPRO6 (definition
, keymaps
, found
, sequences
, remapped_sequences
, tem
);
2734 tem
= Fcommand_remapping (definition
, Qnil
, keymaps
);
2735 /* If `definition' is remapped to tem', then OT1H no key will run
2736 that command (since they will run `tem' instead), so we should
2737 return nil; but OTOH all keys bound to `definition' (or to `tem')
2738 will run the same command.
2739 So for menu-shortcut purposes, we want to find all the keys bound (maybe
2740 via remapping) to `tem'. But for the purpose of finding the keys that
2741 run `definition', then we'd want to just return nil.
2742 We choose to make it work right for menu-shortcuts, since it's the most
2744 Known bugs: if you remap switch-to-buffer to toto, C-h f switch-to-buffer
2745 will tell you that switch-to-buffer is bound to C-x b even though C-x b
2746 will run toto instead. And if `toto' is itself remapped to forward-char,
2747 then C-h f toto will tell you that it's bound to C-f even though C-f does
2748 not run toto and it won't tell you that C-x b does run toto. */
2749 if (NILP (no_remap
) && !NILP (tem
))
2752 if (SYMBOLP (definition
)
2753 && !NILP (firstonly
)
2754 && !NILP (tem
= Fget (definition
, QCadvertised_binding
)))
2756 /* We have a list of advertised bindings. */
2758 if (EQ (shadow_lookup (keymaps
, XCAR (tem
), Qnil
, 0), definition
))
2762 if (EQ (shadow_lookup (keymaps
, tem
, Qnil
, 0), definition
))
2766 sequences
= Freverse (where_is_internal (definition
, keymaps
,
2767 !NILP (noindirect
), nomenus
));
2769 while (CONSP (sequences
)
2770 /* If we're at the end of the `sequences' list and we haven't
2771 considered remapped sequences yet, copy them over and
2773 || (!remapped
&& (sequences
= remapped_sequences
,
2775 CONSP (sequences
))))
2777 Lisp_Object sequence
, function
;
2779 sequence
= XCAR (sequences
);
2780 sequences
= XCDR (sequences
);
2782 /* Verify that this key binding is not shadowed by another
2783 binding for the same key, before we say it exists.
2785 Mechanism: look for local definition of this key and if
2786 it is defined and does not match what we found then
2789 Either nil or number as value from Flookup_key
2791 if (NILP (Fequal (shadow_lookup (keymaps
, sequence
, Qnil
, remapped
),
2795 /* If the current sequence is a command remapping with
2796 format [remap COMMAND], find the key sequences
2797 which run COMMAND, and use those sequences instead. */
2798 if (NILP (no_remap
) && !remapped
2799 && VECTORP (sequence
) && ASIZE (sequence
) == 2
2800 && EQ (AREF (sequence
, 0), Qremap
)
2801 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2803 Lisp_Object seqs
= where_is_internal (function
, keymaps
,
2804 !NILP (noindirect
), nomenus
);
2805 remapped_sequences
= nconc2 (Freverse (seqs
), remapped_sequences
);
2809 /* Don't annoy user with strings from a menu such as the
2810 entries from the "Edit => Paste from Kill Menu".
2811 Change them all to "(any string)", so that there
2812 seems to be only one menu item to report. */
2813 if (! NILP (sequence
))
2816 tem1
= Faref (sequence
, make_number (ASIZE (sequence
) - 1));
2818 Faset (sequence
, make_number (ASIZE (sequence
) - 1),
2819 build_string ("(any string)"));
2822 /* It is a true unshadowed match. Record it, unless it's already
2823 been seen (as could happen when inheriting keymaps). */
2824 if (NILP (Fmember (sequence
, found
)))
2825 found
= Fcons (sequence
, found
);
2827 /* If firstonly is Qnon_ascii, then we can return the first
2828 binding we find. If firstonly is not Qnon_ascii but not
2829 nil, then we should return the first ascii-only binding
2831 if (EQ (firstonly
, Qnon_ascii
))
2832 RETURN_UNGCPRO (sequence
);
2833 else if (!NILP (firstonly
)
2834 && 2 == preferred_sequence_p (sequence
))
2835 RETURN_UNGCPRO (sequence
);
2840 found
= Fnreverse (found
);
2842 /* firstonly may have been t, but we may have gone all the way through
2843 the keymaps without finding an all-ASCII key sequence. So just
2844 return the best we could find. */
2845 if (NILP (firstonly
))
2847 else if (where_is_preferred_modifier
== 0)
2848 return Fcar (found
);
2850 { /* Maybe we did not find a preferred_modifier binding, but we did find
2851 some ASCII binding. */
2852 Lisp_Object bindings
= found
;
2853 while (CONSP (bindings
))
2854 if (preferred_sequence_p (XCAR (bindings
)))
2855 return XCAR (bindings
);
2857 bindings
= XCDR (bindings
);
2858 return Fcar (found
);
2862 /* This function can GC because get_keyelt can. */
2865 where_is_internal_1 (Lisp_Object key
, Lisp_Object binding
, Lisp_Object args
, void *data
)
2867 struct where_is_internal_data
*d
= data
; /* Cast! */
2868 Lisp_Object definition
= d
->definition
;
2869 int noindirect
= d
->noindirect
;
2870 Lisp_Object
this = d
->this;
2871 Lisp_Object last
= d
->last
;
2872 int last_is_meta
= d
->last_is_meta
;
2873 Lisp_Object sequence
;
2875 /* Search through indirections unless that's not wanted. */
2877 binding
= get_keyelt (binding
, 0);
2879 /* End this iteration if this element does not match
2882 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2883 || EQ (binding
, definition
)
2884 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2885 /* Doesn't match. */
2888 /* We have found a match. Construct the key sequence where we found it. */
2889 if (INTEGERP (key
) && last_is_meta
)
2891 sequence
= Fcopy_sequence (this);
2892 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2897 key
= Fcons (XCAR (key
), XCDR (key
));
2898 sequence
= append_key (this, key
);
2901 if (!NILP (where_is_cache
))
2903 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2904 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2907 d
->sequences
= Fcons (sequence
, d
->sequences
);
2910 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2912 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2913 doc
: /* Insert the list of all defined keys and their definitions.
2914 The list is inserted in the current buffer, while the bindings are
2915 looked up in BUFFER.
2916 The optional argument PREFIX, if non-nil, should be a key sequence;
2917 then we display only bindings that start with that prefix.
2918 The optional argument MENUS, if non-nil, says to mention menu bindings.
2919 \(Ordinarily these are omitted from the output.) */)
2920 (Lisp_Object buffer
, Lisp_Object prefix
, Lisp_Object menus
)
2922 Lisp_Object outbuf
, shadow
;
2923 int nomenu
= NILP (menus
);
2924 register Lisp_Object start1
;
2925 struct gcpro gcpro1
;
2927 const char *alternate_heading
2929 Keyboard translations:\n\n\
2930 You type Translation\n\
2931 -------- -----------\n";
2933 CHECK_BUFFER (buffer
);
2938 outbuf
= Fcurrent_buffer ();
2940 /* Report on alternates for keys. */
2941 if (STRINGP (KVAR (current_kboard
, Vkeyboard_translate_table
)) && !NILP (prefix
))
2944 const unsigned char *translate
= SDATA (KVAR (current_kboard
, Vkeyboard_translate_table
));
2945 int translate_len
= SCHARS (KVAR (current_kboard
, Vkeyboard_translate_table
));
2947 for (c
= 0; c
< translate_len
; c
++)
2948 if (translate
[c
] != c
)
2950 char buf
[KEY_DESCRIPTION_SIZE
];
2953 if (alternate_heading
)
2955 insert_string (alternate_heading
);
2956 alternate_heading
= 0;
2959 bufend
= push_key_description (translate
[c
], buf
, 1);
2960 insert (buf
, bufend
- buf
);
2961 Findent_to (make_number (16), make_number (1));
2962 bufend
= push_key_description (c
, buf
, 1);
2963 insert (buf
, bufend
- buf
);
2967 /* Insert calls signal_after_change which may GC. */
2968 translate
= SDATA (KVAR (current_kboard
, Vkeyboard_translate_table
));
2974 if (!NILP (Vkey_translation_map
))
2975 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2976 "Key translations", nomenu
, 1, 0, 0);
2979 /* Print the (major mode) local map. */
2981 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
2982 start1
= KVAR (current_kboard
, Voverriding_terminal_local_map
);
2983 else if (!NILP (Voverriding_local_map
))
2984 start1
= Voverriding_local_map
;
2988 describe_map_tree (start1
, 1, shadow
, prefix
,
2989 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
2990 shadow
= Fcons (start1
, shadow
);
2994 /* Print the minor mode and major mode keymaps. */
2996 Lisp_Object
*modes
, *maps
;
2998 /* Temporarily switch to `buffer', so that we can get that buffer's
2999 minor modes correctly. */
3000 Fset_buffer (buffer
);
3002 nmaps
= current_minor_maps (&modes
, &maps
);
3003 Fset_buffer (outbuf
);
3005 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3006 XBUFFER (buffer
), Qkeymap
);
3009 describe_map_tree (start1
, 1, shadow
, prefix
,
3010 "\f\n`keymap' Property Bindings", nomenu
,
3012 shadow
= Fcons (start1
, shadow
);
3015 /* Print the minor mode maps. */
3016 for (i
= 0; i
< nmaps
; i
++)
3018 /* The title for a minor mode keymap
3019 is constructed at run time.
3020 We let describe_map_tree do the actual insertion
3021 because it takes care of other features when doing so. */
3024 if (!SYMBOLP (modes
[i
]))
3027 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3031 memcpy (p
, SDATA (SYMBOL_NAME (modes
[i
])),
3032 SCHARS (SYMBOL_NAME (modes
[i
])));
3033 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3035 memcpy (p
, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
3036 p
+= strlen (" Minor Mode Bindings");
3039 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3040 title
, nomenu
, 0, 0, 0);
3041 shadow
= Fcons (maps
[i
], shadow
);
3044 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3045 XBUFFER (buffer
), Qlocal_map
);
3048 if (EQ (start1
, BVAR (XBUFFER (buffer
), keymap
)))
3049 describe_map_tree (start1
, 1, shadow
, prefix
,
3050 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3052 describe_map_tree (start1
, 1, shadow
, prefix
,
3053 "\f\n`local-map' Property Bindings",
3056 shadow
= Fcons (start1
, shadow
);
3060 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3061 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3063 /* Print the function-key-map translations under this prefix. */
3064 if (!NILP (KVAR (current_kboard
, Vlocal_function_key_map
)))
3065 describe_map_tree (KVAR (current_kboard
, Vlocal_function_key_map
), 0, Qnil
, prefix
,
3066 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3068 /* Print the input-decode-map translations under this prefix. */
3069 if (!NILP (KVAR (current_kboard
, Vinput_decode_map
)))
3070 describe_map_tree (KVAR (current_kboard
, Vinput_decode_map
), 0, Qnil
, prefix
,
3071 "\f\nInput decoding map translations", nomenu
, 1, 0, 0);
3077 /* Insert a description of the key bindings in STARTMAP,
3078 followed by those of all maps reachable through STARTMAP.
3079 If PARTIAL is nonzero, omit certain "uninteresting" commands
3080 (such as `undefined').
3081 If SHADOW is non-nil, it is a list of maps;
3082 don't mention keys which would be shadowed by any of them.
3083 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3084 TITLE, if not 0, is a string to insert at the beginning.
3085 TITLE should not end with a colon or a newline; we supply that.
3086 If NOMENU is not 0, then omit menu-bar commands.
3088 If TRANSL is nonzero, the definitions are actually key translations
3089 so print strings and vectors differently.
3091 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3094 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3095 don't omit it; instead, mention it but say it is shadowed. */
3098 describe_map_tree (Lisp_Object startmap
, int partial
, Lisp_Object shadow
,
3099 Lisp_Object prefix
, const char *title
, int nomenu
, int transl
,
3100 int always_title
, int mention_shadow
)
3102 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3103 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3105 const char *key_heading
3110 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3113 GCPRO3 (maps
, seen
, sub_shadows
);
3119 /* Delete from MAPS each element that is for the menu bar. */
3120 for (list
= maps
; CONSP (list
); list
= XCDR (list
))
3122 Lisp_Object elt
, elt_prefix
, tem
;
3125 elt_prefix
= Fcar (elt
);
3126 if (XVECTOR (elt_prefix
)->size
>= 1)
3128 tem
= Faref (elt_prefix
, make_number (0));
3129 if (EQ (tem
, Qmenu_bar
))
3130 maps
= Fdelq (elt
, maps
);
3135 if (!NILP (maps
) || always_title
)
3139 insert_string (title
);
3142 insert_string (" Starting With ");
3143 insert1 (Fkey_description (prefix
, Qnil
));
3145 insert_string (":\n");
3147 insert_string (key_heading
);
3151 for (; CONSP (maps
); maps
= XCDR (maps
))
3153 register Lisp_Object elt
, elt_prefix
, tail
;
3156 elt_prefix
= Fcar (elt
);
3160 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3164 shmap
= XCAR (tail
);
3166 /* If the sequence by which we reach this keymap is zero-length,
3167 then the shadow map for this keymap is just SHADOW. */
3168 if ((STRINGP (elt_prefix
) && SCHARS (elt_prefix
) == 0)
3169 || (VECTORP (elt_prefix
) && XVECTOR (elt_prefix
)->size
== 0))
3171 /* If the sequence by which we reach this keymap actually has
3172 some elements, then the sequence's definition in SHADOW is
3173 what we should use. */
3176 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3177 if (INTEGERP (shmap
))
3181 /* If shmap is not nil and not a keymap,
3182 it completely shadows this map, so don't
3183 describe this map at all. */
3184 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3188 sub_shadows
= Fcons (shmap
, sub_shadows
);
3191 /* Maps we have already listed in this loop shadow this map. */
3192 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3195 tem
= Fequal (Fcar (XCAR (tail
)), elt_prefix
);
3197 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3200 describe_map (Fcdr (elt
), elt_prefix
,
3201 transl
? describe_translation
: describe_command
,
3202 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3208 insert_string ("\n");
3213 static int previous_description_column
;
3216 describe_command (Lisp_Object definition
, Lisp_Object args
)
3218 register Lisp_Object tem1
;
3219 EMACS_INT column
= current_column ();
3220 int description_column
;
3222 /* If column 16 is no good, go to col 32;
3223 but don't push beyond that--go to next line instead. */
3227 description_column
= 32;
3229 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3230 description_column
= 32;
3232 description_column
= 16;
3234 Findent_to (make_number (description_column
), make_number (1));
3235 previous_description_column
= description_column
;
3237 if (SYMBOLP (definition
))
3239 tem1
= SYMBOL_NAME (definition
);
3241 insert_string ("\n");
3243 else if (STRINGP (definition
) || VECTORP (definition
))
3244 insert_string ("Keyboard Macro\n");
3245 else if (KEYMAPP (definition
))
3246 insert_string ("Prefix Command\n");
3248 insert_string ("??\n");
3252 describe_translation (Lisp_Object definition
, Lisp_Object args
)
3254 register Lisp_Object tem1
;
3256 Findent_to (make_number (16), make_number (1));
3258 if (SYMBOLP (definition
))
3260 tem1
= SYMBOL_NAME (definition
);
3262 insert_string ("\n");
3264 else if (STRINGP (definition
) || VECTORP (definition
))
3266 insert1 (Fkey_description (definition
, Qnil
));
3267 insert_string ("\n");
3269 else if (KEYMAPP (definition
))
3270 insert_string ("Prefix Command\n");
3272 insert_string ("??\n");
3275 /* describe_map puts all the usable elements of a sparse keymap
3276 into an array of `struct describe_map_elt',
3277 then sorts them by the events. */
3279 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3281 /* qsort comparison function for sorting `struct describe_map_elt' by
3285 describe_map_compare (const void *aa
, const void *bb
)
3287 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3288 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3289 return ((XINT (a
->event
) > XINT (b
->event
))
3290 - (XINT (a
->event
) < XINT (b
->event
)));
3291 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3293 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3295 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3296 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3297 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3302 /* Describe the contents of map MAP, assuming that this map itself is
3303 reached by the sequence of prefix keys PREFIX (a string or vector).
3304 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3307 describe_map (Lisp_Object map
, Lisp_Object prefix
,
3308 void (*elt_describer
) (Lisp_Object
, Lisp_Object
),
3309 int partial
, Lisp_Object shadow
,
3310 Lisp_Object
*seen
, int nomenu
, int mention_shadow
)
3312 Lisp_Object tail
, definition
, event
;
3314 Lisp_Object suppress
;
3317 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3319 /* These accumulate the values from sparse keymap bindings,
3320 so we can sort them and handle them in order. */
3321 int length_needed
= 0;
3322 struct describe_map_elt
*vect
;
3329 suppress
= intern ("suppress-keymap");
3331 /* This vector gets used to present single keys to Flookup_key. Since
3332 that is done once per keymap element, we don't want to cons up a
3333 fresh vector every time. */
3334 kludge
= Fmake_vector (make_number (1), Qnil
);
3337 GCPRO3 (prefix
, definition
, kludge
);
3339 map
= call1 (Qkeymap_canonicalize
, map
);
3341 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3344 vect
= ((struct describe_map_elt
*)
3345 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3347 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3351 if (VECTORP (XCAR (tail
))
3352 || CHAR_TABLE_P (XCAR (tail
)))
3353 describe_vector (XCAR (tail
),
3354 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3356 else if (CONSP (XCAR (tail
)))
3358 int this_shadowed
= 0;
3360 event
= XCAR (XCAR (tail
));
3362 /* Ignore bindings whose "prefix" are not really valid events.
3363 (We get these in the frames and buffers menu.) */
3364 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3367 if (nomenu
&& EQ (event
, Qmenu_bar
))
3370 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3372 /* Don't show undefined commands or suppressed commands. */
3373 if (NILP (definition
)) continue;
3374 if (SYMBOLP (definition
) && partial
)
3376 tem
= Fget (definition
, suppress
);
3381 /* Don't show a command that isn't really visible
3382 because a local definition of the same key shadows it. */
3384 ASET (kludge
, 0, event
);
3387 tem
= shadow_lookup (shadow
, kludge
, Qt
, 0);
3390 /* If both bindings are keymaps, this key is a prefix key,
3391 so don't say it is shadowed. */
3392 if (KEYMAPP (definition
) && KEYMAPP (tem
))
3394 /* Avoid generating duplicate entries if the
3395 shadowed binding has the same definition. */
3396 else if (mention_shadow
&& !EQ (tem
, definition
))
3403 tem
= Flookup_key (map
, kludge
, Qt
);
3404 if (!EQ (tem
, definition
)) continue;
3406 vect
[slots_used
].event
= event
;
3407 vect
[slots_used
].definition
= definition
;
3408 vect
[slots_used
].shadowed
= this_shadowed
;
3411 else if (EQ (XCAR (tail
), Qkeymap
))
3413 /* The same keymap might be in the structure twice, if we're
3414 using an inherited keymap. So skip anything we've already
3416 tem
= Fassq (tail
, *seen
);
3417 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3419 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3423 /* If we found some sparse map events, sort them. */
3425 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3426 describe_map_compare
);
3428 /* Now output them in sorted order. */
3430 for (i
= 0; i
< slots_used
; i
++)
3432 Lisp_Object start
, end
;
3436 previous_description_column
= 0;
3441 ASET (kludge
, 0, vect
[i
].event
);
3442 start
= vect
[i
].event
;
3445 definition
= vect
[i
].definition
;
3447 /* Find consecutive chars that are identically defined. */
3448 if (INTEGERP (vect
[i
].event
))
3450 while (i
+ 1 < slots_used
3451 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3452 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3453 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3455 end
= vect
[i
].event
;
3458 /* Now START .. END is the range to describe next. */
3460 /* Insert the string to describe the event START. */
3461 insert1 (Fkey_description (kludge
, prefix
));
3463 if (!EQ (start
, end
))
3467 ASET (kludge
, 0, end
);
3468 /* Insert the string to describe the character END. */
3469 insert1 (Fkey_description (kludge
, prefix
));
3472 /* Print a description of the definition of this character.
3473 elt_describer will take care of spacing out far enough
3474 for alignment purposes. */
3475 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3477 if (vect
[i
].shadowed
)
3480 insert_string ("\n (that binding is currently shadowed by another mode)");
3489 describe_vector_princ (Lisp_Object elt
, Lisp_Object fun
)
3491 Findent_to (make_number (16), make_number (1));
3496 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3497 doc
: /* Insert a description of contents of VECTOR.
3498 This is text showing the elements of vector matched against indices.
3499 DESCRIBER is the output function used; nil means use `princ'. */)
3500 (Lisp_Object vector
, Lisp_Object describer
)
3502 int count
= SPECPDL_INDEX ();
3503 if (NILP (describer
))
3504 describer
= intern ("princ");
3505 specbind (Qstandard_output
, Fcurrent_buffer ());
3506 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3507 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3510 return unbind_to (count
, Qnil
);
3513 /* Insert in the current buffer a description of the contents of VECTOR.
3514 We call ELT_DESCRIBER to insert the description of one value found
3517 ELT_PREFIX describes what "comes before" the keys or indices defined
3518 by this vector. This is a human-readable string whose size
3519 is not necessarily related to the situation.
3521 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3522 leads to this keymap.
3524 If the vector is a chartable, ELT_PREFIX is the vector
3525 of bytes that lead to the character set or portion of a character
3526 set described by this chartable.
3528 If PARTIAL is nonzero, it means do not mention suppressed commands
3529 (that assumes the vector is in a keymap).
3531 SHADOW is a list of keymaps that shadow this map.
3532 If it is non-nil, then we look up the key in those maps
3533 and we don't mention it now if it is defined by any of them.
3535 ENTIRE_MAP is the keymap in which this vector appears.
3536 If the definition in effect in the whole map does not match
3537 the one in this vector, we ignore this one.
3539 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3541 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3543 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3546 describe_vector (Lisp_Object vector
, Lisp_Object prefix
, Lisp_Object args
,
3547 void (*elt_describer
) (Lisp_Object
, Lisp_Object
),
3548 int partial
, Lisp_Object shadow
, Lisp_Object entire_map
,
3549 int keymap_p
, int mention_shadow
)
3551 Lisp_Object definition
;
3553 Lisp_Object elt_prefix
= Qnil
;
3555 Lisp_Object suppress
;
3558 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3559 /* Range of elements to be handled. */
3561 Lisp_Object character
;
3570 /* Call Fkey_description first, to avoid GC bug for the other string. */
3571 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3574 tem
= Fkey_description (prefix
, Qnil
);
3575 elt_prefix
= concat2 (tem
, build_string (" "));
3580 /* This vector gets used to present single keys to Flookup_key. Since
3581 that is done once per vector element, we don't want to cons up a
3582 fresh vector every time. */
3583 kludge
= Fmake_vector (make_number (1), Qnil
);
3584 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3587 suppress
= intern ("suppress-keymap");
3590 if (CHAR_TABLE_P (vector
))
3591 stop
= MAX_5_BYTE_CHAR
+ 1, to
= MAX_CHAR
+ 1;
3593 stop
= to
= XVECTOR (vector
)->size
;
3595 for (i
= from
; ; i
++)
3597 int this_shadowed
= 0;
3598 int range_beg
, range_end
;
3612 if (CHAR_TABLE_P (vector
))
3616 val
= char_table_ref_and_range (vector
, range_beg
, &range_beg
, &i
);
3619 val
= AREF (vector
, i
);
3620 definition
= get_keyelt (val
, 0);
3622 if (NILP (definition
)) continue;
3624 /* Don't mention suppressed commands. */
3625 if (SYMBOLP (definition
) && partial
)
3629 tem
= Fget (definition
, suppress
);
3631 if (!NILP (tem
)) continue;
3634 character
= make_number (starting_i
);
3635 ASET (kludge
, 0, character
);
3637 /* If this binding is shadowed by some other map, ignore it. */
3642 tem
= shadow_lookup (shadow
, kludge
, Qt
, 0);
3653 /* Ignore this definition if it is shadowed by an earlier
3654 one in the same keymap. */
3655 if (!NILP (entire_map
))
3659 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3661 if (!EQ (tem
, definition
))
3671 /* Output the prefix that applies to every entry in this map. */
3672 if (!NILP (elt_prefix
))
3673 insert1 (elt_prefix
);
3675 insert1 (Fkey_description (kludge
, prefix
));
3677 /* Find all consecutive characters or rows that have the same
3678 definition. But, VECTOR is a char-table, we had better put a
3679 boundary between normal characters (-#x3FFF7F) and 8-bit
3680 characters (#x3FFF80-). */
3681 if (CHAR_TABLE_P (vector
))
3684 && (range_beg
= i
+ 1, range_end
= stop
- 1,
3685 val
= char_table_ref_and_range (vector
, range_beg
,
3686 &range_beg
, &range_end
),
3687 tem2
= get_keyelt (val
, 0),
3689 && !NILP (Fequal (tem2
, definition
)))
3694 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3696 && !NILP (Fequal (tem2
, definition
)))
3699 /* If we have a range of more than one character,
3700 print where the range reaches to. */
3702 if (i
!= starting_i
)
3706 ASET (kludge
, 0, make_number (i
));
3708 if (!NILP (elt_prefix
))
3709 insert1 (elt_prefix
);
3711 insert1 (Fkey_description (kludge
, prefix
));
3714 /* Print a description of the definition of this character.
3715 elt_describer will take care of spacing out far enough
3716 for alignment purposes. */
3717 (*elt_describer
) (definition
, args
);
3722 insert_string (" (binding currently shadowed)");
3727 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3729 if (!NILP (elt_prefix
))
3730 insert1 (elt_prefix
);
3731 insert ("default", 7);
3732 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3738 /* Apropos - finding all symbols whose names match a regexp. */
3739 static Lisp_Object apropos_predicate
;
3740 static Lisp_Object apropos_accumulate
;
3743 apropos_accum (Lisp_Object symbol
, Lisp_Object string
)
3745 register Lisp_Object tem
;
3747 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3748 if (!NILP (tem
) && !NILP (apropos_predicate
))
3749 tem
= call1 (apropos_predicate
, symbol
);
3751 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3754 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3755 doc
: /* Show all symbols whose names contain match for REGEXP.
3756 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3757 for each symbol and a symbol is mentioned only if that returns non-nil.
3758 Return list of symbols found. */)
3759 (Lisp_Object regexp
, Lisp_Object predicate
)
3762 CHECK_STRING (regexp
);
3763 apropos_predicate
= predicate
;
3764 apropos_accumulate
= Qnil
;
3765 map_obarray (Vobarray
, apropos_accum
, regexp
);
3766 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3767 apropos_accumulate
= Qnil
;
3768 apropos_predicate
= Qnil
;
3773 syms_of_keymap (void)
3775 Qkeymap
= intern_c_string ("keymap");
3776 staticpro (&Qkeymap
);
3777 staticpro (&apropos_predicate
);
3778 staticpro (&apropos_accumulate
);
3779 apropos_predicate
= Qnil
;
3780 apropos_accumulate
= Qnil
;
3782 Qkeymap_canonicalize
= intern_c_string ("keymap-canonicalize");
3783 staticpro (&Qkeymap_canonicalize
);
3785 /* Now we are ready to set up this property, so we can
3786 create char tables. */
3787 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3789 /* Initialize the keymaps standardly used.
3790 Each one is the value of a Lisp variable, and is also
3791 pointed to by a C variable */
3793 global_map
= Fmake_keymap (Qnil
);
3794 Fset (intern_c_string ("global-map"), global_map
);
3796 current_global_map
= global_map
;
3797 staticpro (&global_map
);
3798 staticpro (¤t_global_map
);
3800 meta_map
= Fmake_keymap (Qnil
);
3801 Fset (intern_c_string ("esc-map"), meta_map
);
3802 Ffset (intern_c_string ("ESC-prefix"), meta_map
);
3804 control_x_map
= Fmake_keymap (Qnil
);
3805 Fset (intern_c_string ("ctl-x-map"), control_x_map
);
3806 Ffset (intern_c_string ("Control-X-prefix"), control_x_map
);
3809 = pure_cons (pure_cons (make_pure_c_string ("DEL"), make_pure_c_string ("\\d")),
3810 pure_cons (pure_cons (make_pure_c_string ("TAB"), make_pure_c_string ("\\t")),
3811 pure_cons (pure_cons (make_pure_c_string ("RET"), make_pure_c_string ("\\r")),
3812 pure_cons (pure_cons (make_pure_c_string ("ESC"), make_pure_c_string ("\\e")),
3813 pure_cons (pure_cons (make_pure_c_string ("SPC"), make_pure_c_string (" ")),
3815 staticpro (&exclude_keys
);
3817 DEFVAR_LISP ("define-key-rebound-commands", Vdefine_key_rebound_commands
,
3818 doc
: /* List of commands given new key bindings recently.
3819 This is used for internal purposes during Emacs startup;
3820 don't alter it yourself. */);
3821 Vdefine_key_rebound_commands
= Qt
;
3823 DEFVAR_LISP ("minibuffer-local-map", Vminibuffer_local_map
,
3824 doc
: /* Default keymap to use when reading from the minibuffer. */);
3825 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3827 DEFVAR_LISP ("minibuffer-local-ns-map", Vminibuffer_local_ns_map
,
3828 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3829 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3830 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3832 DEFVAR_LISP ("minibuffer-local-completion-map", Vminibuffer_local_completion_map
,
3833 doc
: /* Local keymap for minibuffer input with completion. */);
3834 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3835 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3837 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3838 Vminibuffer_local_filename_completion_map
,
3839 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3840 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3841 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3842 Vminibuffer_local_completion_map
);
3845 DEFVAR_LISP ("minibuffer-local-must-match-map", Vminibuffer_local_must_match_map
,
3846 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3847 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3848 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3849 Vminibuffer_local_completion_map
);
3851 DEFVAR_LISP ("minibuffer-local-filename-must-match-map",
3852 Vminibuffer_local_filename_must_match_map
,
3853 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3854 Vminibuffer_local_filename_must_match_map
= Fmake_sparse_keymap (Qnil
);
3855 Fset_keymap_parent (Vminibuffer_local_filename_must_match_map
,
3856 Vminibuffer_local_must_match_map
);
3858 DEFVAR_LISP ("minor-mode-map-alist", Vminor_mode_map_alist
,
3859 doc
: /* Alist of keymaps to use for minor modes.
3860 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3861 key sequences and look up bindings if VARIABLE's value is non-nil.
3862 If two active keymaps bind the same key, the keymap appearing earlier
3863 in the list takes precedence. */);
3864 Vminor_mode_map_alist
= Qnil
;
3866 DEFVAR_LISP ("minor-mode-overriding-map-alist", Vminor_mode_overriding_map_alist
,
3867 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3868 This variable is an alist just like `minor-mode-map-alist', and it is
3869 used the same way (and before `minor-mode-map-alist'); however,
3870 it is provided for major modes to bind locally. */);
3871 Vminor_mode_overriding_map_alist
= Qnil
;
3873 DEFVAR_LISP ("emulation-mode-map-alists", Vemulation_mode_map_alists
,
3874 doc
: /* List of keymap alists to use for emulations modes.
3875 It is intended for modes or packages using multiple minor-mode keymaps.
3876 Each element is a keymap alist just like `minor-mode-map-alist', or a
3877 symbol with a variable binding which is a keymap alist, and it is used
3878 the same way. The "active" keymaps in each alist are used before
3879 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3880 Vemulation_mode_map_alists
= Qnil
;
3882 DEFVAR_LISP ("where-is-preferred-modifier", Vwhere_is_preferred_modifier
,
3883 doc
: /* Preferred modifier to use for `where-is'.
3884 When a single binding is requested, `where-is' will return one that
3885 uses this modifier if possible. If nil, or if no such binding exists,
3886 bindings using keys without modifiers (or only with meta) will be
3888 Vwhere_is_preferred_modifier
= Qnil
;
3889 where_is_preferred_modifier
= 0;
3891 staticpro (&Vmouse_events
);
3892 Vmouse_events
= pure_cons (intern_c_string ("menu-bar"),
3893 pure_cons (intern_c_string ("tool-bar"),
3894 pure_cons (intern_c_string ("header-line"),
3895 pure_cons (intern_c_string ("mode-line"),
3896 pure_cons (intern_c_string ("mouse-1"),
3897 pure_cons (intern_c_string ("mouse-2"),
3898 pure_cons (intern_c_string ("mouse-3"),
3899 pure_cons (intern_c_string ("mouse-4"),
3900 pure_cons (intern_c_string ("mouse-5"),
3904 Qsingle_key_description
= intern_c_string ("single-key-description");
3905 staticpro (&Qsingle_key_description
);
3907 Qkey_description
= intern_c_string ("key-description");
3908 staticpro (&Qkey_description
);
3910 Qkeymapp
= intern_c_string ("keymapp");
3911 staticpro (&Qkeymapp
);
3913 Qnon_ascii
= intern_c_string ("non-ascii");
3914 staticpro (&Qnon_ascii
);
3916 Qmenu_item
= intern_c_string ("menu-item");
3917 staticpro (&Qmenu_item
);
3919 Qremap
= intern_c_string ("remap");
3920 staticpro (&Qremap
);
3922 QCadvertised_binding
= intern_c_string (":advertised-binding");
3923 staticpro (&QCadvertised_binding
);
3925 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3926 staticpro (&command_remapping_vector
);
3928 where_is_cache_keymaps
= Qt
;
3929 where_is_cache
= Qnil
;
3930 staticpro (&where_is_cache
);
3931 staticpro (&where_is_cache_keymaps
);
3933 defsubr (&Skeymapp
);
3934 defsubr (&Skeymap_parent
);
3935 defsubr (&Skeymap_prompt
);
3936 defsubr (&Sset_keymap_parent
);
3937 defsubr (&Smake_keymap
);
3938 defsubr (&Smake_sparse_keymap
);
3939 defsubr (&Smap_keymap_internal
);
3940 defsubr (&Smap_keymap
);
3941 defsubr (&Scopy_keymap
);
3942 defsubr (&Scommand_remapping
);
3943 defsubr (&Skey_binding
);
3944 defsubr (&Slocal_key_binding
);
3945 defsubr (&Sglobal_key_binding
);
3946 defsubr (&Sminor_mode_key_binding
);
3947 defsubr (&Sdefine_key
);
3948 defsubr (&Slookup_key
);
3949 defsubr (&Sdefine_prefix_command
);
3950 defsubr (&Suse_global_map
);
3951 defsubr (&Suse_local_map
);
3952 defsubr (&Scurrent_local_map
);
3953 defsubr (&Scurrent_global_map
);
3954 defsubr (&Scurrent_minor_mode_maps
);
3955 defsubr (&Scurrent_active_maps
);
3956 defsubr (&Saccessible_keymaps
);
3957 defsubr (&Skey_description
);
3958 defsubr (&Sdescribe_vector
);
3959 defsubr (&Ssingle_key_description
);
3960 defsubr (&Stext_char_description
);
3961 defsubr (&Swhere_is_internal
);
3962 defsubr (&Sdescribe_buffer_bindings
);
3963 defsubr (&Sapropos_internal
);
3967 keys_of_keymap (void)
3969 initial_define_key (global_map
, 033, "ESC-prefix");
3970 initial_define_key (global_map
, Ctl ('X'), "Control-X-prefix");