1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "character.h"
34 #include "termhooks.h"
35 #include "blockinput.h"
37 #include "intervals.h"
41 /* The number of elements in keymap vectors. */
42 #define DENSE_TABLE_SIZE (0200)
44 /* Actually allocate storage for these variables */
46 Lisp_Object current_global_map
; /* Current global keymap */
48 Lisp_Object global_map
; /* default global key bindings */
50 Lisp_Object meta_map
; /* The keymap used for globally bound
51 ESC-prefixed default commands */
53 Lisp_Object control_x_map
; /* The keymap used for globally bound
54 C-x-prefixed default commands */
56 /* was MinibufLocalMap */
57 Lisp_Object Vminibuffer_local_map
;
58 /* The keymap used by the minibuf for local
59 bindings when spaces are allowed in the
62 /* was MinibufLocalNSMap */
63 Lisp_Object Vminibuffer_local_ns_map
;
64 /* The keymap used by the minibuf for local
65 bindings when spaces are not encouraged
68 /* keymap used for minibuffers when doing completion */
69 /* was MinibufLocalCompletionMap */
70 Lisp_Object Vminibuffer_local_completion_map
;
72 /* keymap used for minibuffers when doing completion in filenames */
73 Lisp_Object Vminibuffer_local_filename_completion_map
;
75 /* keymap used for minibuffers when doing completion in filenames
77 Lisp_Object Vminibuffer_local_filename_must_match_map
;
79 /* keymap used for minibuffers when doing completion and require a match */
80 /* was MinibufLocalMustMatchMap */
81 Lisp_Object Vminibuffer_local_must_match_map
;
83 /* Alist of minor mode variables and keymaps. */
84 Lisp_Object Vminor_mode_map_alist
;
86 /* Alist of major-mode-specific overrides for
87 minor mode variables and keymaps. */
88 Lisp_Object Vminor_mode_overriding_map_alist
;
90 /* List of emulation mode keymap alists. */
91 Lisp_Object Vemulation_mode_map_alists
;
93 /* A list of all commands given new bindings since a certain time
94 when nil was stored here.
95 This is used to speed up recomputation of menu key equivalents
96 when Emacs starts up. t means don't record anything here. */
97 Lisp_Object Vdefine_key_rebound_commands
;
99 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
100 Lisp_Object QCadvertised_binding
;
102 /* Alist of elements like (DEL . "\d"). */
103 static Lisp_Object exclude_keys
;
105 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
106 static Lisp_Object command_remapping_vector
;
108 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
109 in a string key sequence is equivalent to prefixing with this
111 extern Lisp_Object meta_prefix_char
;
113 extern Lisp_Object Voverriding_local_map
;
115 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
116 static Lisp_Object where_is_cache
;
117 /* Which keymaps are reverse-stored in the cache. */
118 static Lisp_Object where_is_cache_keymaps
;
120 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
121 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
123 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
124 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
125 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
126 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
127 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
128 int, Lisp_Object
, Lisp_Object
*, int, int));
129 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
130 void (*) (Lisp_Object
, Lisp_Object
), int,
131 Lisp_Object
, Lisp_Object
, int *,
133 static void silly_event_symbol_error
P_ ((Lisp_Object
));
135 /* Keymap object support - constructors and predicates. */
137 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
138 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
139 CHARTABLE is a char-table that holds the bindings for all characters
140 without modifiers. All entries in it are initially nil, meaning
141 "command undefined". ALIST is an assoc-list which holds bindings for
142 function keys, mouse events, and any other things that appear in the
143 input stream. Initially, ALIST is nil.
145 The optional arg STRING supplies a menu name for the keymap
146 in case you use it as a menu with `x-popup-menu'. */)
152 tail
= Fcons (string
, Qnil
);
155 return Fcons (Qkeymap
,
156 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
159 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
160 doc
: /* Construct and return a new sparse keymap.
161 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
162 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
163 which binds the function key or mouse event SYMBOL to DEFINITION.
164 Initially the alist is nil.
166 The optional arg STRING supplies a menu name for the keymap
167 in case you use it as a menu with `x-popup-menu'. */)
172 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
173 return Fcons (Qkeymap
, Qnil
);
176 /* This function is used for installing the standard key bindings
177 at initialization time.
181 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
184 initial_define_key (keymap
, key
, defname
)
189 store_in_keymap (keymap
, make_number (key
), intern (defname
));
193 initial_define_lispy_key (keymap
, keyname
, defname
)
198 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
201 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
202 doc
: /* Return t if OBJECT is a keymap.
204 A keymap is a list (keymap . ALIST),
205 or a symbol whose function definition is itself a keymap.
206 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
207 a vector of densely packed bindings for small character codes
208 is also allowed as an element. */)
212 return (KEYMAPP (object
) ? Qt
: Qnil
);
215 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
216 doc
: /* Return the prompt-string of a keymap MAP.
217 If non-nil, the prompt is shown in the echo-area
218 when reading a key-sequence to be looked-up in this keymap. */)
222 map
= get_keymap (map
, 0, 0);
225 Lisp_Object tem
= XCAR (map
);
233 /* Check that OBJECT is a keymap (after dereferencing through any
234 symbols). If it is, return it.
236 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
237 is an autoload form, do the autoload and try again.
238 If AUTOLOAD is nonzero, callers must assume GC is possible.
240 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
241 is zero as well), return Qt.
243 ERROR controls how we respond if OBJECT isn't a keymap.
244 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
246 Note that most of the time, we don't want to pursue autoloads.
247 Functions like Faccessible_keymaps which scan entire keymap trees
248 shouldn't load every autoloaded keymap. I'm not sure about this,
249 but it seems to me that only read_key_sequence, Flookup_key, and
250 Fdefine_key should cause keymaps to be autoloaded.
252 This function can GC when AUTOLOAD is non-zero, because it calls
253 do_autoload which can GC. */
256 get_keymap (object
, error
, autoload
)
265 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
268 tem
= indirect_function (object
);
271 if (EQ (XCAR (tem
), Qkeymap
))
274 /* Should we do an autoload? Autoload forms for keymaps have
275 Qkeymap as their fifth element. */
276 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
281 tail
= Fnth (make_number (4), tem
);
282 if (EQ (tail
, Qkeymap
))
286 struct gcpro gcpro1
, gcpro2
;
288 GCPRO2 (tem
, object
);
289 do_autoload (tem
, object
);
302 wrong_type_argument (Qkeymapp
, object
);
306 /* Return the parent map of KEYMAP, or nil if it has none.
307 We assume that KEYMAP is a valid keymap. */
310 keymap_parent (keymap
, autoload
)
316 keymap
= get_keymap (keymap
, 1, autoload
);
318 /* Skip past the initial element `keymap'. */
319 list
= XCDR (keymap
);
320 for (; CONSP (list
); list
= XCDR (list
))
322 /* See if there is another `keymap'. */
327 return get_keymap (list
, 0, autoload
);
330 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
331 doc
: /* Return the parent keymap of KEYMAP.
332 If KEYMAP has no parent, return nil. */)
336 return keymap_parent (keymap
, 1);
339 /* Check whether MAP is one of MAPS parents. */
341 keymap_memberp (map
, maps
)
342 Lisp_Object map
, maps
;
344 if (NILP (map
)) return 0;
345 while (KEYMAPP (maps
) && !EQ (map
, maps
))
346 maps
= keymap_parent (maps
, 0);
347 return (EQ (map
, maps
));
350 /* Set the parent keymap of MAP to PARENT. */
352 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
353 doc
: /* Modify KEYMAP to set its parent map to PARENT.
354 Return PARENT. PARENT should be nil or another keymap. */)
356 Lisp_Object keymap
, parent
;
358 Lisp_Object list
, prev
;
359 struct gcpro gcpro1
, gcpro2
;
362 /* Force a keymap flush for the next call to where-is.
363 Since this can be called from within where-is, we don't set where_is_cache
364 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
365 be changed during where-is, while where_is_cache_keymaps is only used at
366 the very beginning of where-is and can thus be changed here without any
368 This is a very minor correctness (rather than safety) issue. */
369 where_is_cache_keymaps
= Qt
;
371 GCPRO2 (keymap
, parent
);
372 keymap
= get_keymap (keymap
, 1, 1);
376 parent
= get_keymap (parent
, 1, 1);
378 /* Check for cycles. */
379 if (keymap_memberp (keymap
, parent
))
380 error ("Cyclic keymap inheritance");
383 /* Skip past the initial element `keymap'. */
388 /* If there is a parent keymap here, replace it.
389 If we came to the end, add the parent in PREV. */
390 if (!CONSP (list
) || KEYMAPP (list
))
392 /* If we already have the right parent, return now
393 so that we avoid the loops below. */
394 if (EQ (XCDR (prev
), parent
))
395 RETURN_UNGCPRO (parent
);
398 XSETCDR (prev
, parent
);
404 /* Scan through for submaps, and set their parents too. */
406 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
408 /* Stop the scan when we come to the parent. */
409 if (EQ (XCAR (list
), Qkeymap
))
412 /* If this element holds a prefix map, deal with it. */
413 if (CONSP (XCAR (list
))
414 && CONSP (XCDR (XCAR (list
))))
415 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
418 if (VECTORP (XCAR (list
)))
419 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
420 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
421 fix_submap_inheritance (keymap
, make_number (i
),
422 XVECTOR (XCAR (list
))->contents
[i
]);
424 if (CHAR_TABLE_P (XCAR (list
)))
426 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
430 RETURN_UNGCPRO (parent
);
433 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
434 if EVENT is also a prefix in MAP's parent,
435 make sure that SUBMAP inherits that definition as its own parent. */
438 fix_submap_inheritance (map
, event
, submap
)
439 Lisp_Object map
, event
, submap
;
441 Lisp_Object map_parent
, parent_entry
;
443 /* SUBMAP is a cons that we found as a key binding.
444 Discard the other things found in a menu key binding. */
446 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
448 /* If it isn't a keymap now, there's no work to do. */
452 map_parent
= keymap_parent (map
, 0);
453 if (!NILP (map_parent
))
455 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
459 /* If MAP's parent has something other than a keymap,
460 our own submap shadows it completely. */
461 if (!CONSP (parent_entry
))
464 if (! EQ (parent_entry
, submap
))
466 Lisp_Object submap_parent
;
467 submap_parent
= submap
;
472 tem
= keymap_parent (submap_parent
, 0);
476 if (keymap_memberp (tem
, parent_entry
))
477 /* Fset_keymap_parent could create a cycle. */
484 Fset_keymap_parent (submap_parent
, parent_entry
);
488 /* Look up IDX in MAP. IDX may be any sort of event.
489 Note that this does only one level of lookup; IDX must be a single
490 event, not a sequence.
492 If T_OK is non-zero, bindings for Qt are treated as default
493 bindings; any key left unmentioned by other tables and bindings is
494 given the binding of Qt.
496 If T_OK is zero, bindings for Qt are not treated specially.
498 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
501 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
510 /* Qunbound in VAL means we have found no binding yet. */
513 /* If idx is a list (some sort of mouse click, perhaps?),
514 the index we want to use is the car of the list, which
515 ought to be a symbol. */
516 idx
= EVENT_HEAD (idx
);
518 /* If idx is a symbol, it might have modifiers, which need to
519 be put in the canonical order. */
521 idx
= reorder_modifiers (idx
);
522 else if (INTEGERP (idx
))
523 /* Clobber the high bits that can be present on a machine
524 with more than 24 bits of integer. */
525 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
527 /* Handle the special meta -> esc mapping. */
528 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
530 /* See if there is a meta-map. If there's none, there is
531 no binding for IDX, unless a default binding exists in MAP. */
533 Lisp_Object meta_map
;
535 /* A strange value in which Meta is set would cause
536 infinite recursion. Protect against that. */
537 if (XINT (meta_prefix_char
) & CHAR_META
)
538 meta_prefix_char
= make_number (27);
539 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
540 t_ok
, noinherit
, autoload
),
543 if (CONSP (meta_map
))
546 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
549 /* Set IDX to t, so that we only find a default binding. */
552 /* We know there is no binding. */
556 /* t_binding is where we put a default binding that applies,
557 to use in case we do not find a binding specifically
558 for this key sequence. */
561 Lisp_Object t_binding
= Qnil
;
562 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
564 GCPRO4 (map
, tail
, idx
, t_binding
);
566 for (tail
= XCDR (map
);
568 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
573 binding
= XCAR (tail
);
574 if (SYMBOLP (binding
))
576 /* If NOINHERIT, stop finding prefix definitions
577 after we pass a second occurrence of the `keymap' symbol. */
578 if (noinherit
&& EQ (binding
, Qkeymap
))
579 RETURN_UNGCPRO (Qnil
);
581 else if (CONSP (binding
))
583 Lisp_Object key
= XCAR (binding
);
586 val
= XCDR (binding
);
587 else if (t_ok
&& EQ (key
, Qt
))
589 t_binding
= XCDR (binding
);
593 else if (VECTORP (binding
))
595 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
596 val
= AREF (binding
, XFASTINT (idx
));
598 else if (CHAR_TABLE_P (binding
))
600 /* Character codes with modifiers
601 are not included in a char-table.
602 All character codes without modifiers are included. */
603 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
605 val
= Faref (binding
, idx
);
606 /* `nil' has a special meaning for char-tables, so
607 we use something else to record an explicitly
614 /* If we found a binding, clean it up and return it. */
615 if (!EQ (val
, Qunbound
))
618 /* A Qt binding is just like an explicit nil binding
619 (i.e. it shadows any parent binding but not bindings in
620 keymaps of lower precedence). */
622 val
= get_keyelt (val
, autoload
);
624 fix_submap_inheritance (map
, idx
, val
);
625 RETURN_UNGCPRO (val
);
630 return get_keyelt (t_binding
, autoload
);
635 map_keymap_item (fun
, args
, key
, val
, data
)
636 map_keymap_function_t fun
;
637 Lisp_Object args
, key
, val
;
640 /* We should maybe try to detect bindings shadowed by previous
641 ones and things like that. */
644 (*fun
) (key
, val
, args
, data
);
648 map_keymap_char_table_item (args
, key
, val
)
649 Lisp_Object args
, key
, val
;
653 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
655 /* If the key is a range, make a copy since map_char_table modifies
658 key
= Fcons (XCAR (key
), XCDR (key
));
659 map_keymap_item (fun
, XCDR (args
), key
, val
,
660 XSAVE_VALUE (XCAR (args
))->pointer
);
664 /* Call FUN for every binding in MAP and stop at (and return) the parent.
665 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA). */
667 map_keymap_internal (Lisp_Object map
,
668 map_keymap_function_t fun
,
672 struct gcpro gcpro1
, gcpro2
, gcpro3
;
674 = (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
676 GCPRO3 (map
, args
, tail
);
677 for (; CONSP (tail
) && !EQ (Qkeymap
, XCAR (tail
)); tail
= XCDR (tail
))
679 Lisp_Object binding
= XCAR (tail
);
682 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
683 else if (VECTORP (binding
))
685 /* Loop over the char values represented in the vector. */
686 int len
= ASIZE (binding
);
688 for (c
= 0; c
< len
; c
++)
690 Lisp_Object character
;
691 XSETFASTINT (character
, c
);
692 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
695 else if (CHAR_TABLE_P (binding
))
697 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
698 Fcons (make_save_value (fun
, 0),
699 Fcons (make_save_value (data
, 0),
708 map_keymap_call (key
, val
, fun
, dummy
)
709 Lisp_Object key
, val
, fun
;
712 call2 (fun
, key
, val
);
715 /* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
716 A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
718 map_keymap (map
, fun
, args
, data
, autoload
)
719 map_keymap_function_t fun
;
720 Lisp_Object map
, args
;
726 map
= get_keymap (map
, 1, autoload
);
729 map
= map_keymap_internal (map
, fun
, args
, data
);
730 map
= get_keymap (map
, 0, autoload
);
735 Lisp_Object Qkeymap_canonicalize
;
737 /* Same as map_keymap, but does it right, properly eliminating duplicate
738 bindings due to inheritance. */
740 map_keymap_canonical (map
, fun
, args
, data
)
741 map_keymap_function_t fun
;
742 Lisp_Object map
, args
;
747 /* map_keymap_canonical may be used from redisplay (e.g. when building menus)
748 so be careful to ignore errors and to inhibit redisplay. */
749 map
= safe_call1 (Qkeymap_canonicalize
, map
);
750 /* No need to use `map_keymap' here because canonical map has no parent. */
751 map_keymap_internal (map
, fun
, args
, data
);
755 DEFUN ("map-keymap-internal", Fmap_keymap_internal
, Smap_keymap_internal
, 2, 2, 0,
756 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
757 FUNCTION is called with two arguments: the event that is bound, and
758 the definition it is bound to. The event may be a character range.
759 If KEYMAP has a parent, this function returns it without processing it. */)
761 Lisp_Object function
, keymap
;
765 keymap
= get_keymap (keymap
, 1, 1);
766 keymap
= map_keymap_internal (keymap
, map_keymap_call
, function
, NULL
);
771 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
772 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
773 FUNCTION is called with two arguments: the event that is bound, and
774 the definition it is bound to. The event may be a character range.
776 If KEYMAP has a parent, the parent's bindings are included as well.
777 This works recursively: if the parent has itself a parent, then the
778 grandparent's bindings are also included and so on.
779 usage: (map-keymap FUNCTION KEYMAP) */)
780 (function
, keymap
, sort_first
)
781 Lisp_Object function
, keymap
, sort_first
;
783 if (! NILP (sort_first
))
784 return call2 (intern ("map-keymap-sorted"), function
, keymap
);
786 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
790 /* Given OBJECT which was found in a slot in a keymap,
791 trace indirect definitions to get the actual definition of that slot.
792 An indirect definition is a list of the form
793 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
794 and INDEX is the object to look up in KEYMAP to yield the definition.
796 Also if OBJECT has a menu string as the first element,
797 remove that. Also remove a menu help string as second element.
799 If AUTOLOAD is nonzero, load autoloadable keymaps
800 that are referred to with indirection.
802 This can GC because menu_item_eval_property calls Feval. */
805 get_keyelt (object
, autoload
)
811 if (!(CONSP (object
)))
812 /* This is really the value. */
815 /* If the keymap contents looks like (keymap ...) or (lambda ...)
817 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
820 /* If the keymap contents looks like (menu-item name . DEFN)
821 or (menu-item name DEFN ...) then use DEFN.
822 This is a new format menu item. */
823 else if (EQ (XCAR (object
), Qmenu_item
))
825 if (CONSP (XCDR (object
)))
829 object
= XCDR (XCDR (object
));
832 object
= XCAR (object
);
834 /* If there's a `:filter FILTER', apply FILTER to the
835 menu-item's definition to get the real definition to
837 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
838 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
841 filter
= XCAR (XCDR (tem
));
842 filter
= list2 (filter
, list2 (Qquote
, object
));
843 object
= menu_item_eval_property (filter
);
848 /* Invalid keymap. */
852 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
853 Keymap alist elements like (CHAR MENUSTRING . DEFN)
854 will be used by HierarKey menus. */
855 else if (STRINGP (XCAR (object
)))
857 object
= XCDR (object
);
858 /* Also remove a menu help string, if any,
859 following the menu item name. */
860 if (CONSP (object
) && STRINGP (XCAR (object
)))
861 object
= XCDR (object
);
862 /* Also remove the sublist that caches key equivalences, if any. */
863 if (CONSP (object
) && CONSP (XCAR (object
)))
866 carcar
= XCAR (XCAR (object
));
867 if (NILP (carcar
) || VECTORP (carcar
))
868 object
= XCDR (object
);
872 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
878 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
880 return (!CONSP (map
) ? object
/* Invalid keymap */
881 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
887 store_in_keymap (keymap
, idx
, def
)
889 register Lisp_Object idx
;
892 /* Flush any reverse-map cache. */
893 where_is_cache
= Qnil
;
894 where_is_cache_keymaps
= Qt
;
896 /* If we are preparing to dump, and DEF is a menu element
897 with a menu item indicator, copy it to ensure it is not pure. */
898 if (CONSP (def
) && PURE_P (def
)
899 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
900 def
= Fcons (XCAR (def
), XCDR (def
));
902 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
903 error ("attempt to define a key in a non-keymap");
905 /* If idx is a cons, and the car part is a character, idx must be of
906 the form (FROM-CHAR . TO-CHAR). */
907 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
908 CHECK_CHARACTER_CDR (idx
);
910 /* If idx is a list (some sort of mouse click, perhaps?),
911 the index we want to use is the car of the list, which
912 ought to be a symbol. */
913 idx
= EVENT_HEAD (idx
);
915 /* If idx is a symbol, it might have modifiers, which need to
916 be put in the canonical order. */
918 idx
= reorder_modifiers (idx
);
919 else if (INTEGERP (idx
))
920 /* Clobber the high bits that can be present on a machine
921 with more than 24 bits of integer. */
922 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
924 /* Scan the keymap for a binding of idx. */
928 /* The cons after which we should insert new bindings. If the
929 keymap has a table element, we record its position here, so new
930 bindings will go after it; this way, the table will stay
931 towards the front of the alist and character lookups in dense
932 keymaps will remain fast. Otherwise, this just points at the
933 front of the keymap. */
934 Lisp_Object insertion_point
;
936 insertion_point
= keymap
;
937 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
944 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
947 ASET (elt
, XFASTINT (idx
), def
);
950 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
952 int from
= XFASTINT (XCAR (idx
));
953 int to
= XFASTINT (XCDR (idx
));
955 if (to
>= ASIZE (elt
))
956 to
= ASIZE (elt
) - 1;
957 for (; from
<= to
; from
++)
958 ASET (elt
, from
, def
);
959 if (to
== XFASTINT (XCDR (idx
)))
960 /* We have defined all keys in IDX. */
963 insertion_point
= tail
;
965 else if (CHAR_TABLE_P (elt
))
967 /* Character codes with modifiers
968 are not included in a char-table.
969 All character codes without modifiers are included. */
970 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
973 /* `nil' has a special meaning for char-tables, so
974 we use something else to record an explicitly
976 NILP (def
) ? Qt
: def
);
979 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
981 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
984 insertion_point
= tail
;
986 else if (CONSP (elt
))
988 if (EQ (idx
, XCAR (elt
)))
994 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
996 int from
= XFASTINT (XCAR (idx
));
997 int to
= XFASTINT (XCDR (idx
));
999 if (from
<= XFASTINT (XCAR (elt
))
1000 && to
>= XFASTINT (XCAR (elt
)))
1008 else if (EQ (elt
, Qkeymap
))
1009 /* If we find a 'keymap' symbol in the spine of KEYMAP,
1010 then we must have found the start of a second keymap
1011 being used as the tail of KEYMAP, and a binding for IDX
1012 should be inserted before it. */
1019 /* We have scanned the entire keymap, and not found a binding for
1020 IDX. Let's add one. */
1024 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
1026 /* IDX specifies a range of characters, and not all of them
1027 were handled yet, which means this keymap doesn't have a
1028 char-table. So, we insert a char-table now. */
1029 elt
= Fmake_char_table (Qkeymap
, Qnil
);
1030 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
1033 elt
= Fcons (idx
, def
);
1034 CHECK_IMPURE (insertion_point
);
1035 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
1042 EXFUN (Fcopy_keymap
, 1);
1045 copy_keymap_item (elt
)
1048 Lisp_Object res
, tem
;
1055 /* Is this a new format menu item. */
1056 if (EQ (XCAR (tem
), Qmenu_item
))
1058 /* Copy cell with menu-item marker. */
1059 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1063 /* Copy cell with menu-item name. */
1064 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1070 /* Copy cell with binding and if the binding is a keymap,
1072 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1075 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1076 XSETCAR (elt
, Fcopy_keymap (tem
));
1078 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1079 /* Delete cache for key equivalences. */
1080 XSETCDR (elt
, XCDR (tem
));
1085 /* It may be an old fomat menu item.
1086 Skip the optional menu string. */
1087 if (STRINGP (XCAR (tem
)))
1089 /* Copy the cell, since copy-alist didn't go this deep. */
1090 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1092 /* Also skip the optional menu help string. */
1093 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1095 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1099 /* There may also be a list that caches key equivalences.
1100 Just delete it for the new keymap. */
1102 && CONSP (XCAR (tem
))
1103 && (NILP (XCAR (XCAR (tem
)))
1104 || VECTORP (XCAR (XCAR (tem
)))))
1106 XSETCDR (elt
, XCDR (tem
));
1109 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1110 XSETCDR (elt
, Fcopy_keymap (tem
));
1112 else if (EQ (XCAR (tem
), Qkeymap
))
1113 res
= Fcopy_keymap (elt
);
1119 copy_keymap_1 (chartable
, idx
, elt
)
1120 Lisp_Object chartable
, idx
, elt
;
1122 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1125 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1126 doc
: /* Return a copy of the keymap KEYMAP.
1127 The copy starts out with the same definitions of KEYMAP,
1128 but changing either the copy or KEYMAP does not affect the other.
1129 Any key definitions that are subkeymaps are recursively copied.
1130 However, a key definition which is a symbol whose definition is a keymap
1135 register Lisp_Object copy
, tail
;
1136 keymap
= get_keymap (keymap
, 1, 0);
1137 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1138 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1140 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1142 Lisp_Object elt
= XCAR (keymap
);
1143 if (CHAR_TABLE_P (elt
))
1145 elt
= Fcopy_sequence (elt
);
1146 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1148 else if (VECTORP (elt
))
1151 elt
= Fcopy_sequence (elt
);
1152 for (i
= 0; i
< ASIZE (elt
); i
++)
1153 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1155 else if (CONSP (elt
))
1156 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1157 XSETCDR (tail
, Fcons (elt
, Qnil
));
1159 keymap
= XCDR (keymap
);
1161 XSETCDR (tail
, keymap
);
1165 /* Simple Keymap mutators and accessors. */
1167 /* GC is possible in this function if it autoloads a keymap. */
1169 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1170 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1173 KEY is a string or a vector of symbols and characters meaning a
1174 sequence of keystrokes and events. Non-ASCII characters with codes
1175 above 127 (such as ISO Latin-1) can be included if you use a vector.
1176 Using [t] for KEY creates a default definition, which applies to any
1177 event type that has no other definition in this keymap.
1179 DEF is anything that can be a key's definition:
1180 nil (means key is undefined in this keymap),
1181 a command (a Lisp function suitable for interactive calling),
1182 a string (treated as a keyboard macro),
1183 a keymap (to define a prefix key),
1184 a symbol (when the key is looked up, the symbol will stand for its
1185 function definition, which should at that time be one of the above,
1186 or another symbol whose function definition is used, etc.),
1187 a cons (STRING . DEFN), meaning that DEFN is the definition
1188 (DEFN should be a valid definition in its own right),
1189 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
1190 or an extended menu item definition.
1191 (See info node `(elisp)Extended Menu Items'.)
1193 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1194 binding is altered. If there is no binding for KEY, the new pair
1195 binding KEY to DEF is added at the front of KEYMAP. */)
1202 register Lisp_Object c
;
1203 register Lisp_Object cmd
;
1207 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1209 GCPRO3 (keymap
, key
, def
);
1210 keymap
= get_keymap (keymap
, 1, 1);
1212 CHECK_VECTOR_OR_STRING (key
);
1214 length
= XFASTINT (Flength (key
));
1216 RETURN_UNGCPRO (Qnil
);
1218 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1219 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1221 meta_bit
= (VECTORP (key
) || (STRINGP (key
) && STRING_MULTIBYTE (key
))
1222 ? meta_modifier
: 0x80);
1224 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, 0)))
1225 { /* DEF is apparently an XEmacs-style keyboard macro. */
1226 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1227 int i
= ASIZE (def
);
1230 Lisp_Object c
= AREF (def
, i
);
1231 if (CONSP (c
) && lucid_event_type_list_p (c
))
1232 c
= Fevent_convert_list (c
);
1241 c
= Faref (key
, make_number (idx
));
1245 /* C may be a Lucid style event type list or a cons (FROM .
1246 TO) specifying a range of characters. */
1247 if (lucid_event_type_list_p (c
))
1248 c
= Fevent_convert_list (c
);
1249 else if (CHARACTERP (XCAR (c
)))
1250 CHECK_CHARACTER_CDR (c
);
1254 silly_event_symbol_error (c
);
1257 && (XINT (c
) & meta_bit
)
1260 c
= meta_prefix_char
;
1266 XSETINT (c
, XINT (c
) & ~meta_bit
);
1272 if (!INTEGERP (c
) && !SYMBOLP (c
)
1274 /* If C is a range, it must be a leaf. */
1275 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1276 error ("Key sequence contains invalid event");
1279 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1281 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1283 /* If this key is undefined, make it a prefix. */
1285 cmd
= define_as_prefix (keymap
, c
);
1287 keymap
= get_keymap (cmd
, 0, 1);
1288 if (!CONSP (keymap
))
1289 /* We must use Fkey_description rather than just passing key to
1290 error; key might be a vector, not a string. */
1291 error ("Key sequence %s starts with non-prefix key %s",
1292 SDATA (Fkey_description (key
, Qnil
)),
1293 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1299 /* This function may GC (it calls Fkey_binding). */
1301 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 3, 0,
1302 doc
: /* Return the remapping for command COMMAND.
1303 Returns nil if COMMAND is not remapped (or not a symbol).
1305 If the optional argument POSITION is non-nil, it specifies a mouse
1306 position as returned by `event-start' and `event-end', and the
1307 remapping occurs in the keymaps associated with it. It can also be a
1308 number or marker, in which case the keymap properties at the specified
1309 buffer position instead of point are used. The KEYMAPS argument is
1310 ignored if POSITION is non-nil.
1312 If the optional argument KEYMAPS is non-nil, it should be a list of
1313 keymaps to search for command remapping. Otherwise, search for the
1314 remapping in all currently active keymaps. */)
1315 (command
, position
, keymaps
)
1316 Lisp_Object command
, position
, keymaps
;
1318 if (!SYMBOLP (command
))
1321 ASET (command_remapping_vector
, 1, command
);
1324 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
, position
);
1327 Lisp_Object maps
, binding
;
1329 for (maps
= keymaps
; CONSP (maps
); maps
= XCDR (maps
))
1331 binding
= Flookup_key (XCAR (maps
), command_remapping_vector
, Qnil
);
1332 if (!NILP (binding
) && !INTEGERP (binding
))
1339 /* Value is number if KEY is too long; nil if valid but has no definition. */
1340 /* GC is possible in this function if it autoloads a keymap. */
1342 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1343 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1344 A value of nil means undefined. See doc of `define-key'
1345 for kinds of definitions.
1347 A number as value means KEY is "too long";
1348 that is, characters or symbols in it except for the last one
1349 fail to be a valid sequence of prefix characters in KEYMAP.
1350 The number is how many characters at the front of KEY
1351 it takes to reach a non-prefix key.
1353 Normally, `lookup-key' ignores bindings for t, which act as default
1354 bindings, used when nothing else in the keymap applies; this makes it
1355 usable as a general function for probing keymaps. However, if the
1356 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1357 recognize the default bindings, just as `read-key-sequence' does. */)
1358 (keymap
, key
, accept_default
)
1361 Lisp_Object accept_default
;
1364 register Lisp_Object cmd
;
1365 register Lisp_Object c
;
1367 int t_ok
= !NILP (accept_default
);
1368 struct gcpro gcpro1
, gcpro2
;
1370 GCPRO2 (keymap
, key
);
1371 keymap
= get_keymap (keymap
, 1, 1);
1373 CHECK_VECTOR_OR_STRING (key
);
1375 length
= XFASTINT (Flength (key
));
1377 RETURN_UNGCPRO (keymap
);
1382 c
= Faref (key
, make_number (idx
++));
1384 if (CONSP (c
) && lucid_event_type_list_p (c
))
1385 c
= Fevent_convert_list (c
);
1387 /* Turn the 8th bit of string chars into a meta modifier. */
1388 if (STRINGP (key
) && XINT (c
) & 0x80 && !STRING_MULTIBYTE (key
))
1389 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1391 /* Allow string since binding for `menu-bar-select-buffer'
1392 includes the buffer name in the key sequence. */
1393 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1394 error ("Key sequence contains invalid event");
1396 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1398 RETURN_UNGCPRO (cmd
);
1400 keymap
= get_keymap (cmd
, 0, 1);
1401 if (!CONSP (keymap
))
1402 RETURN_UNGCPRO (make_number (idx
));
1408 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1409 Assume that currently it does not define C at all.
1410 Return the keymap. */
1413 define_as_prefix (keymap
, c
)
1414 Lisp_Object keymap
, c
;
1418 cmd
= Fmake_sparse_keymap (Qnil
);
1419 /* If this key is defined as a prefix in an inherited keymap,
1420 make it a prefix in this map, and make its definition
1421 inherit the other prefix definition. */
1422 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1423 store_in_keymap (keymap
, c
, cmd
);
1428 /* Append a key to the end of a key sequence. We always make a vector. */
1431 append_key (key_sequence
, key
)
1432 Lisp_Object key_sequence
, key
;
1434 Lisp_Object args
[2];
1436 args
[0] = key_sequence
;
1438 args
[1] = Fcons (key
, Qnil
);
1439 return Fvconcat (2, args
);
1442 /* Given a event type C which is a symbol,
1443 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1446 silly_event_symbol_error (c
)
1449 Lisp_Object parsed
, base
, name
, assoc
;
1452 parsed
= parse_modifiers (c
);
1453 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1454 base
= XCAR (parsed
);
1455 name
= Fsymbol_name (base
);
1456 /* This alist includes elements such as ("RET" . "\\r"). */
1457 assoc
= Fassoc (name
, exclude_keys
);
1461 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1463 Lisp_Object keystring
;
1464 if (modifiers
& alt_modifier
)
1465 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1466 if (modifiers
& ctrl_modifier
)
1467 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1468 if (modifiers
& hyper_modifier
)
1469 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1470 if (modifiers
& meta_modifier
)
1471 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1472 if (modifiers
& shift_modifier
)
1473 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1474 if (modifiers
& super_modifier
)
1475 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1478 c
= reorder_modifiers (c
);
1479 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1481 error ((modifiers
& ~meta_modifier
1482 ? "To bind the key %s, use [?%s], not [%s]"
1483 : "To bind the key %s, use \"%s\", not [%s]"),
1484 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1485 SDATA (SYMBOL_NAME (c
)));
1489 /* Global, local, and minor mode keymap stuff. */
1491 /* We can't put these variables inside current_minor_maps, since under
1492 some systems, static gets macro-defined to be the empty string.
1494 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1495 static int cmm_size
= 0;
1497 /* Store a pointer to an array of the currently active minor modes in
1498 *modeptr, a pointer to an array of the keymaps of the currently
1499 active minor modes in *mapptr, and return the number of maps
1502 This function always returns a pointer to the same buffer, and may
1503 free or reallocate it, so if you want to keep it for a long time or
1504 hand it out to lisp code, copy it. This procedure will be called
1505 for every key sequence read, so the nice lispy approach (return a
1506 new assoclist, list, what have you) for each invocation would
1507 result in a lot of consing over time.
1509 If we used xrealloc/xmalloc and ran out of memory, they would throw
1510 back to the command loop, which would try to read a key sequence,
1511 which would call this function again, resulting in an infinite
1512 loop. Instead, we'll use realloc/malloc and silently truncate the
1513 list, let the key sequence be read, and hope some other piece of
1514 code signals the error. */
1516 current_minor_maps (modeptr
, mapptr
)
1517 Lisp_Object
**modeptr
, **mapptr
;
1520 int list_number
= 0;
1521 Lisp_Object alist
, assoc
, var
, val
;
1522 Lisp_Object emulation_alists
;
1523 Lisp_Object lists
[2];
1525 emulation_alists
= Vemulation_mode_map_alists
;
1526 lists
[0] = Vminor_mode_overriding_map_alist
;
1527 lists
[1] = Vminor_mode_map_alist
;
1529 for (list_number
= 0; list_number
< 2; list_number
++)
1531 if (CONSP (emulation_alists
))
1533 alist
= XCAR (emulation_alists
);
1534 emulation_alists
= XCDR (emulation_alists
);
1535 if (SYMBOLP (alist
))
1536 alist
= find_symbol_value (alist
);
1540 alist
= lists
[list_number
];
1542 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1543 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1544 && (var
= XCAR (assoc
), SYMBOLP (var
))
1545 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1550 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1551 and also an entry in Vminor_mode_map_alist,
1552 ignore the latter. */
1553 if (list_number
== 1)
1555 val
= assq_no_quit (var
, lists
[0]);
1562 int newsize
, allocsize
;
1563 Lisp_Object
*newmodes
, *newmaps
;
1565 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1566 allocsize
= newsize
* sizeof *newmodes
;
1568 /* Use malloc here. See the comment above this function.
1569 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1571 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1576 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1579 cmm_modes
= newmodes
;
1582 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1587 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1594 if (newmodes
== NULL
|| newmaps
== NULL
)
1599 /* Get the keymap definition--or nil if it is not defined. */
1600 temp
= Findirect_function (XCDR (assoc
), Qt
);
1604 cmm_maps
[i
] = temp
;
1610 if (modeptr
) *modeptr
= cmm_modes
;
1611 if (mapptr
) *mapptr
= cmm_maps
;
1615 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1617 doc
: /* Return a list of the currently active keymaps.
1618 OLP if non-nil indicates that we should obey `overriding-local-map' and
1619 `overriding-terminal-local-map'. POSITION can specify a click position
1620 like in the respective argument of `key-binding'. */)
1622 Lisp_Object olp
, position
;
1624 int count
= SPECPDL_INDEX ();
1626 Lisp_Object keymaps
;
1628 /* If a mouse click position is given, our variables are based on
1629 the buffer clicked on, not the current buffer. So we may have to
1630 switch the buffer here. */
1632 if (CONSP (position
))
1636 window
= POSN_WINDOW (position
);
1638 if (WINDOWP (window
)
1639 && BUFFERP (XWINDOW (window
)->buffer
)
1640 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1642 /* Arrange to go back to the original buffer once we're done
1643 processing the key sequence. We don't use
1644 save_excursion_{save,restore} here, in analogy to
1645 `read-key-sequence' to avoid saving point. Maybe this
1646 would not be a problem here, but it is easier to keep
1650 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1652 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1656 keymaps
= Fcons (current_global_map
, Qnil
);
1660 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1661 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1662 /* The doc said that overriding-terminal-local-map should
1663 override overriding-local-map. The code used them both,
1664 but it seems clearer to use just one. rms, jan 2005. */
1665 else if (!NILP (Voverriding_local_map
))
1666 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1668 if (NILP (XCDR (keymaps
)))
1673 Lisp_Object keymap
, local_map
;
1676 pt
= INTEGERP (position
) ? XINT (position
)
1677 : MARKERP (position
) ? marker_position (position
)
1680 /* Get the buffer local maps, possibly overriden by text or
1681 overlay properties */
1683 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1684 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1686 if (CONSP (position
))
1690 /* For a mouse click, get the local text-property keymap
1691 of the place clicked on, rather than point. */
1693 if (POSN_INBUFFER_P (position
))
1697 pos
= POSN_BUFFER_POSN (position
);
1699 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1701 local_map
= get_local_map (XINT (pos
),
1702 current_buffer
, Qlocal_map
);
1704 keymap
= get_local_map (XINT (pos
),
1705 current_buffer
, Qkeymap
);
1709 /* If on a mode line string with a local keymap,
1710 or for a click on a string, i.e. overlay string or a
1711 string displayed via the `display' property,
1712 consider `local-map' and `keymap' properties of
1715 if (string
= POSN_STRING (position
),
1716 (CONSP (string
) && STRINGP (XCAR (string
))))
1718 Lisp_Object pos
, map
;
1720 pos
= XCDR (string
);
1721 string
= XCAR (string
);
1724 && XINT (pos
) < SCHARS (string
))
1726 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1730 map
= Fget_text_property (pos
, Qkeymap
, string
);
1738 if (!NILP (local_map
))
1739 keymaps
= Fcons (local_map
, keymaps
);
1741 /* Now put all the minor mode keymaps on the list. */
1742 nmaps
= current_minor_maps (0, &maps
);
1744 for (i
= --nmaps
; i
>= 0; i
--)
1745 if (!NILP (maps
[i
]))
1746 keymaps
= Fcons (maps
[i
], keymaps
);
1749 keymaps
= Fcons (keymap
, keymaps
);
1752 unbind_to (count
, Qnil
);
1757 /* GC is possible in this function if it autoloads a keymap. */
1759 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 4, 0,
1760 doc
: /* Return the binding for command KEY in current keymaps.
1761 KEY is a string or vector, a sequence of keystrokes.
1762 The binding is probably a symbol with a function definition.
1764 Normally, `key-binding' ignores bindings for t, which act as default
1765 bindings, used when nothing else in the keymap applies; this makes it
1766 usable as a general function for probing keymaps. However, if the
1767 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1768 recognize the default bindings, just as `read-key-sequence' does.
1770 Like the normal command loop, `key-binding' will remap the command
1771 resulting from looking up KEY by looking up the command in the
1772 current keymaps. However, if the optional third argument NO-REMAP
1773 is non-nil, `key-binding' returns the unmapped command.
1775 If KEY is a key sequence initiated with the mouse, the used keymaps
1776 will depend on the clicked mouse position with regard to the buffer
1777 and possible local keymaps on strings.
1779 If the optional argument POSITION is non-nil, it specifies a mouse
1780 position as returned by `event-start' and `event-end', and the lookup
1781 occurs in the keymaps associated with it instead of KEY. It can also
1782 be a number or marker, in which case the keymap properties at the
1783 specified buffer position instead of point are used.
1785 (key
, accept_default
, no_remap
, position
)
1786 Lisp_Object key
, accept_default
, no_remap
, position
;
1788 Lisp_Object
*maps
, value
;
1790 struct gcpro gcpro1
, gcpro2
;
1791 int count
= SPECPDL_INDEX ();
1793 GCPRO2 (key
, position
);
1795 if (NILP (position
) && VECTORP (key
))
1798 /* mouse events may have a symbolic prefix indicating the
1799 scrollbar or mode line */
1800 = AREF (key
, SYMBOLP (AREF (key
, 0)) && ASIZE (key
) > 1 ? 1 : 0);
1802 /* We are not interested in locations without event data */
1804 if (EVENT_HAS_PARAMETERS (event
) && CONSP (XCDR (event
)))
1806 Lisp_Object kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1807 if (EQ (kind
, Qmouse_click
))
1808 position
= EVENT_START (event
);
1812 /* Key sequences beginning with mouse clicks
1813 are read using the keymaps of the buffer clicked on, not
1814 the current buffer. So we may have to switch the buffer
1817 if (CONSP (position
))
1821 window
= POSN_WINDOW (position
);
1823 if (WINDOWP (window
)
1824 && BUFFERP (XWINDOW (window
)->buffer
)
1825 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1827 /* Arrange to go back to the original buffer once we're done
1828 processing the key sequence. We don't use
1829 save_excursion_{save,restore} here, in analogy to
1830 `read-key-sequence' to avoid saving point. Maybe this
1831 would not be a problem here, but it is easier to keep
1835 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1837 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1841 if (! NILP (current_kboard
->Voverriding_terminal_local_map
))
1843 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1844 key
, accept_default
);
1845 if (! NILP (value
) && !INTEGERP (value
))
1848 else if (! NILP (Voverriding_local_map
))
1850 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1851 if (! NILP (value
) && !INTEGERP (value
))
1856 Lisp_Object keymap
, local_map
;
1859 pt
= INTEGERP (position
) ? XINT (position
)
1860 : MARKERP (position
) ? marker_position (position
)
1863 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1864 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1866 if (CONSP (position
))
1870 /* For a mouse click, get the local text-property keymap
1871 of the place clicked on, rather than point. */
1873 if (POSN_INBUFFER_P (position
))
1877 pos
= POSN_BUFFER_POSN (position
);
1879 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1881 local_map
= get_local_map (XINT (pos
),
1882 current_buffer
, Qlocal_map
);
1884 keymap
= get_local_map (XINT (pos
),
1885 current_buffer
, Qkeymap
);
1889 /* If on a mode line string with a local keymap,
1890 or for a click on a string, i.e. overlay string or a
1891 string displayed via the `display' property,
1892 consider `local-map' and `keymap' properties of
1895 if (string
= POSN_STRING (position
),
1896 (CONSP (string
) && STRINGP (XCAR (string
))))
1898 Lisp_Object pos
, map
;
1900 pos
= XCDR (string
);
1901 string
= XCAR (string
);
1904 && XINT (pos
) < SCHARS (string
))
1906 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1910 map
= Fget_text_property (pos
, Qkeymap
, string
);
1918 if (! NILP (keymap
))
1920 value
= Flookup_key (keymap
, key
, accept_default
);
1921 if (! NILP (value
) && !INTEGERP (value
))
1925 nmaps
= current_minor_maps (0, &maps
);
1926 /* Note that all these maps are GCPRO'd
1927 in the places where we found them. */
1929 for (i
= 0; i
< nmaps
; i
++)
1930 if (! NILP (maps
[i
]))
1932 value
= Flookup_key (maps
[i
], key
, accept_default
);
1933 if (! NILP (value
) && !INTEGERP (value
))
1937 if (! NILP (local_map
))
1939 value
= Flookup_key (local_map
, key
, accept_default
);
1940 if (! NILP (value
) && !INTEGERP (value
))
1945 value
= Flookup_key (current_global_map
, key
, accept_default
);
1948 unbind_to (count
, Qnil
);
1951 if (NILP (value
) || INTEGERP (value
))
1954 /* If the result of the ordinary keymap lookup is an interactive
1955 command, look for a key binding (ie. remapping) for that command. */
1957 if (NILP (no_remap
) && SYMBOLP (value
))
1960 if (value1
= Fcommand_remapping (value
, position
, Qnil
), !NILP (value1
))
1967 /* GC is possible in this function if it autoloads a keymap. */
1969 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1970 doc
: /* Return the binding for command KEYS in current local keymap only.
1971 KEYS is a string or vector, a sequence of keystrokes.
1972 The binding is probably a symbol with a function definition.
1974 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1975 bindings; see the description of `lookup-key' for more details about this. */)
1976 (keys
, accept_default
)
1977 Lisp_Object keys
, accept_default
;
1979 register Lisp_Object map
;
1980 map
= current_buffer
->keymap
;
1983 return Flookup_key (map
, keys
, accept_default
);
1986 /* GC is possible in this function if it autoloads a keymap. */
1988 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1989 doc
: /* Return the binding for command KEYS in current global keymap only.
1990 KEYS is a string or vector, a sequence of keystrokes.
1991 The binding is probably a symbol with a function definition.
1992 This function's return values are the same as those of `lookup-key'
1995 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1996 bindings; see the description of `lookup-key' for more details about this. */)
1997 (keys
, accept_default
)
1998 Lisp_Object keys
, accept_default
;
2000 return Flookup_key (current_global_map
, keys
, accept_default
);
2003 /* GC is possible in this function if it autoloads a keymap. */
2005 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
2006 doc
: /* Find the visible minor mode bindings of KEY.
2007 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
2008 the symbol which names the minor mode binding KEY, and BINDING is
2009 KEY's definition in that mode. In particular, if KEY has no
2010 minor-mode bindings, return nil. If the first binding is a
2011 non-prefix, all subsequent bindings will be omitted, since they would
2012 be ignored. Similarly, the list doesn't include non-prefix bindings
2013 that come after prefix bindings.
2015 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
2016 bindings; see the description of `lookup-key' for more details about this. */)
2017 (key
, accept_default
)
2018 Lisp_Object key
, accept_default
;
2020 Lisp_Object
*modes
, *maps
;
2022 Lisp_Object binding
;
2024 struct gcpro gcpro1
, gcpro2
;
2026 nmaps
= current_minor_maps (&modes
, &maps
);
2027 /* Note that all these maps are GCPRO'd
2028 in the places where we found them. */
2031 GCPRO2 (key
, binding
);
2033 for (i
= j
= 0; i
< nmaps
; i
++)
2035 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
2036 && !INTEGERP (binding
))
2038 if (KEYMAPP (binding
))
2039 maps
[j
++] = Fcons (modes
[i
], binding
);
2041 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
2045 return Flist (j
, maps
);
2048 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
2049 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
2050 A new sparse keymap is stored as COMMAND's function definition and its value.
2051 If a second optional argument MAPVAR is given, the map is stored as
2052 its value instead of as COMMAND's value; but COMMAND is still defined
2054 The third optional argument NAME, if given, supplies a menu name
2055 string for the map. This is required to use the keymap as a menu.
2056 This function returns COMMAND. */)
2057 (command
, mapvar
, name
)
2058 Lisp_Object command
, mapvar
, name
;
2061 map
= Fmake_sparse_keymap (name
);
2062 Ffset (command
, map
);
2066 Fset (command
, map
);
2070 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
2071 doc
: /* Select KEYMAP as the global keymap. */)
2075 keymap
= get_keymap (keymap
, 1, 1);
2076 current_global_map
= keymap
;
2081 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
2082 doc
: /* Select KEYMAP as the local keymap.
2083 If KEYMAP is nil, that means no local keymap. */)
2088 keymap
= get_keymap (keymap
, 1, 1);
2090 current_buffer
->keymap
= keymap
;
2095 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
2096 doc
: /* Return current buffer's local keymap, or nil if it has none.
2097 Normally the local keymap is set by the major mode with `use-local-map'. */)
2100 return current_buffer
->keymap
;
2103 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
2104 doc
: /* Return the current global keymap. */)
2107 return current_global_map
;
2110 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
2111 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
2115 int nmaps
= current_minor_maps (0, &maps
);
2117 return Flist (nmaps
, maps
);
2120 /* Help functions for describing and documenting keymaps. */
2122 struct accessible_keymaps_data
{
2123 Lisp_Object maps
, tail
, thisseq
;
2124 /* Does the current sequence end in the meta-prefix-char? */
2129 accessible_keymaps_1 (key
, cmd
, args
, data
)
2130 Lisp_Object key
, cmd
, args
;
2131 /* Use void* to be compatible with map_keymap_function_t. */
2134 struct accessible_keymaps_data
*d
= data
; /* Cast! */
2135 Lisp_Object maps
= d
->maps
;
2136 Lisp_Object tail
= d
->tail
;
2137 Lisp_Object thisseq
= d
->thisseq
;
2138 int is_metized
= d
->is_metized
&& INTEGERP (key
);
2141 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
2145 /* Look for and break cycles. */
2146 while (!NILP (tem
= Frassq (cmd
, maps
)))
2148 Lisp_Object prefix
= XCAR (tem
);
2149 int lim
= XINT (Flength (XCAR (tem
)));
2150 if (lim
<= XINT (Flength (thisseq
)))
2151 { /* This keymap was already seen with a smaller prefix. */
2153 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
2154 Faref (thisseq
, make_number (i
))))
2157 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
2160 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
2161 but maybe `cmd' occurs again further down in `maps', so keep
2163 maps
= XCDR (Fmemq (tem
, maps
));
2166 /* If the last key in thisseq is meta-prefix-char,
2167 turn it into a meta-ized keystroke. We know
2168 that the event we're about to append is an
2169 ascii keystroke since we're processing a
2173 int meta_bit
= meta_modifier
;
2174 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
2175 tem
= Fcopy_sequence (thisseq
);
2177 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
2179 /* This new sequence is the same length as
2180 thisseq, so stick it in the list right
2183 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
2187 tem
= append_key (thisseq
, key
);
2188 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
2192 /* This function cannot GC. */
2194 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
2196 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
2197 Returns a list of elements of the form (KEYS . MAP), where the sequence
2198 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
2199 so that the KEYS increase in length. The first element is ([] . KEYMAP).
2200 An optional argument PREFIX, if non-nil, should be a key sequence;
2201 then the value includes only maps for prefixes that start with PREFIX. */)
2203 Lisp_Object keymap
, prefix
;
2205 Lisp_Object maps
, tail
;
2206 int prefixlen
= XINT (Flength (prefix
));
2208 /* no need for gcpro because we don't autoload any keymaps. */
2212 /* If a prefix was specified, start with the keymap (if any) for
2213 that prefix, so we don't waste time considering other prefixes. */
2215 tem
= Flookup_key (keymap
, prefix
, Qt
);
2216 /* Flookup_key may give us nil, or a number,
2217 if the prefix is not defined in this particular map.
2218 It might even give us a list that isn't a keymap. */
2219 tem
= get_keymap (tem
, 0, 0);
2220 /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
2221 want to return it. */
2224 /* Convert PREFIX to a vector now, so that later on
2225 we don't have to deal with the possibility of a string. */
2226 if (STRINGP (prefix
))
2231 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
2232 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
2236 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
2237 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2238 c
^= 0200 | meta_modifier
;
2239 ASET (copy
, i_before
, make_number (c
));
2243 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
2249 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
2250 get_keymap (keymap
, 1, 0)),
2253 /* For each map in the list maps,
2254 look at any other maps it points to,
2255 and stick them at the end if they are not already in the list.
2257 This is a breadth-first traversal, where tail is the queue of
2258 nodes, and maps accumulates a list of all nodes visited. */
2260 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2262 struct accessible_keymaps_data data
;
2263 register Lisp_Object thismap
= Fcdr (XCAR (tail
));
2266 data
.thisseq
= Fcar (XCAR (tail
));
2269 last
= make_number (XINT (Flength (data
.thisseq
)) - 1);
2270 /* Does the current sequence end in the meta-prefix-char? */
2271 data
.is_metized
= (XINT (last
) >= 0
2272 /* Don't metize the last char of PREFIX. */
2273 && XINT (last
) >= prefixlen
2274 && EQ (Faref (data
.thisseq
, last
), meta_prefix_char
));
2276 /* Since we can't run lisp code, we can't scan autoloaded maps. */
2277 if (CONSP (thismap
))
2278 map_keymap (thismap
, accessible_keymaps_1
, Qnil
, &data
, 0);
2282 Lisp_Object Qsingle_key_description
, Qkey_description
;
2284 /* This function cannot GC. */
2286 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2287 doc
: /* Return a pretty description of key-sequence KEYS.
2288 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2289 Control characters turn into "C-foo" sequences, meta into "M-foo",
2290 spaces are put between sequence elements, etc. */)
2292 Lisp_Object keys
, prefix
;
2297 int size
= XINT (Flength (keys
));
2299 Lisp_Object sep
= build_string (" ");
2304 size
+= XINT (Flength (prefix
));
2306 /* This has one extra element at the end that we don't pass to Fconcat. */
2307 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2309 /* In effect, this computes
2310 (mapconcat 'single-key-description keys " ")
2311 but we shouldn't use mapconcat because it can do GC. */
2315 list
= prefix
, prefix
= Qnil
;
2316 else if (!NILP (keys
))
2317 list
= keys
, keys
= Qnil
;
2322 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2326 return empty_unibyte_string
;
2327 return Fconcat (len
- 1, args
);
2331 size
= SCHARS (list
);
2332 else if (VECTORP (list
))
2333 size
= XVECTOR (list
)->size
;
2334 else if (CONSP (list
))
2335 size
= XINT (Flength (list
));
2337 wrong_type_argument (Qarrayp
, list
);
2346 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2347 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2348 c
^= 0200 | meta_modifier
;
2349 XSETFASTINT (key
, c
);
2351 else if (VECTORP (list
))
2353 key
= AREF (list
, i
); i
++;
2365 || EQ (key
, meta_prefix_char
)
2366 || (XINT (key
) & meta_modifier
))
2368 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2370 if (EQ (key
, meta_prefix_char
))
2374 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2377 else if (EQ (key
, meta_prefix_char
))
2382 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2390 push_key_description (c
, p
, force_multibyte
)
2391 register unsigned int c
;
2393 int force_multibyte
;
2397 /* Clear all the meaningless bits above the meta bit. */
2398 c
&= meta_modifier
| ~ - meta_modifier
;
2399 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2400 | meta_modifier
| shift_modifier
| super_modifier
);
2402 if (! CHARACTERP (make_number (c2
)))
2404 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2405 p
+= sprintf (p
, "[%d]", c
);
2409 if (c
& alt_modifier
)
2415 if ((c
& ctrl_modifier
) != 0
2416 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2420 c
&= ~ctrl_modifier
;
2422 if (c
& hyper_modifier
)
2426 c
-= hyper_modifier
;
2428 if (c
& meta_modifier
)
2434 if (c
& shift_modifier
)
2438 c
-= shift_modifier
;
2440 if (c
& super_modifier
)
2444 c
-= super_modifier
;
2460 else if (c
== Ctl ('M'))
2468 /* `C-' already added above. */
2469 if (c
> 0 && c
<= Ctl ('Z'))
2488 || (NILP (current_buffer
->enable_multibyte_characters
)
2489 && SINGLE_BYTE_CHAR_P (c
)
2490 && !force_multibyte
))
2496 /* Now we are sure that C is a valid character code. */
2497 if (NILP (current_buffer
->enable_multibyte_characters
)
2498 && ! force_multibyte
)
2499 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2501 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2507 /* This function cannot GC. */
2509 DEFUN ("single-key-description", Fsingle_key_description
,
2510 Ssingle_key_description
, 1, 2, 0,
2511 doc
: /* Return a pretty description of command character KEY.
2512 Control characters turn into C-whatever, etc.
2513 Optional argument NO-ANGLES non-nil means don't put angle brackets
2514 around function keys and event symbols. */)
2516 Lisp_Object key
, no_angles
;
2518 if (CONSP (key
) && lucid_event_type_list_p (key
))
2519 key
= Fevent_convert_list (key
);
2521 key
= EVENT_HEAD (key
);
2523 if (INTEGERP (key
)) /* Normal character */
2525 char tem
[KEY_DESCRIPTION_SIZE
];
2527 *push_key_description (XUINT (key
), tem
, 1) = 0;
2528 return build_string (tem
);
2530 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2532 if (NILP (no_angles
))
2535 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2536 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2537 return build_string (buffer
);
2540 return Fsymbol_name (key
);
2542 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2543 return Fcopy_sequence (key
);
2545 error ("KEY must be an integer, cons, symbol, or string");
2550 push_text_char_description (c
, p
)
2551 register unsigned int c
;
2563 *p
++ = c
+ 64; /* 'A' - 1 */
2575 /* This function cannot GC. */
2577 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2578 doc
: /* Return a pretty description of file-character CHARACTER.
2579 Control characters turn into "^char", etc. This differs from
2580 `single-key-description' which turns them into "C-char".
2581 Also, this function recognizes the 2**7 bit as the Meta character,
2582 whereas `single-key-description' uses the 2**27 bit for Meta.
2583 See Info node `(elisp)Describing Characters' for examples. */)
2585 Lisp_Object character
;
2587 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2588 unsigned char str
[6];
2591 CHECK_NUMBER (character
);
2593 c
= XINT (character
);
2594 if (!ASCII_CHAR_P (c
))
2596 int len
= CHAR_STRING (c
, str
);
2598 return make_multibyte_string (str
, 1, len
);
2601 *push_text_char_description (c
& 0377, str
) = 0;
2603 return build_string (str
);
2606 static int where_is_preferred_modifier
;
2608 /* Return 0 if SEQ uses non-preferred modifiers or non-char events.
2609 Else, return 2 if SEQ uses the where_is_preferred_modifier,
2612 preferred_sequence_p (seq
)
2616 int len
= XINT (Flength (seq
));
2619 for (i
= 0; i
< len
; i
++)
2621 Lisp_Object ii
, elt
;
2623 XSETFASTINT (ii
, i
);
2624 elt
= Faref (seq
, ii
);
2626 if (!INTEGERP (elt
))
2630 int modifiers
= XUINT (elt
) & (CHAR_MODIFIER_MASK
& ~CHAR_META
);
2631 if (modifiers
== where_is_preferred_modifier
)
2642 /* where-is - finding a command in a set of keymaps. */
2644 static void where_is_internal_1
P_ ((Lisp_Object key
, Lisp_Object binding
,
2645 Lisp_Object args
, void *data
));
2647 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2648 Returns the first non-nil binding found in any of those maps. */
2651 shadow_lookup (shadow
, key
, flag
)
2652 Lisp_Object shadow
, key
, flag
;
2654 Lisp_Object tail
, value
;
2656 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2658 value
= Flookup_key (XCAR (tail
), key
, flag
);
2659 if (NATNUMP (value
))
2661 value
= Flookup_key (XCAR (tail
),
2662 Fsubstring (key
, make_number (0), value
), flag
);
2666 else if (!NILP (value
))
2672 static Lisp_Object Vmouse_events
;
2674 struct where_is_internal_data
{
2675 Lisp_Object definition
, this, last
;
2676 int last_is_meta
, noindirect
;
2677 Lisp_Object sequences
;
2680 /* This function can't GC, AFAIK. */
2681 /* Return the list of bindings found. This list is ordered "longest
2682 to shortest". It may include bindings that are actually shadowed
2683 by others, as well as duplicate bindings and remapping bindings.
2684 The list returned is potentially shared with where_is_cache, so
2685 be careful not to modify it via side-effects. */
2688 where_is_internal (Lisp_Object definition
, Lisp_Object keymaps
,
2689 int noindirect
, int nomenus
)
2691 Lisp_Object maps
= Qnil
;
2693 struct where_is_internal_data data
;
2695 /* Only important use of caching is for the menubar
2696 (i.e. where-is-internal called with (def nil t nil nil)). */
2697 if (nomenus
&& !noindirect
)
2699 /* Check heuristic-consistency of the cache. */
2700 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2701 where_is_cache
= Qnil
;
2703 if (NILP (where_is_cache
))
2705 /* We need to create the cache. */
2706 Lisp_Object args
[2];
2707 where_is_cache
= Fmake_hash_table (0, args
);
2708 where_is_cache_keymaps
= Qt
;
2711 /* We can reuse the cache. */
2712 return Fgethash (definition
, where_is_cache
, Qnil
);
2715 /* Kill the cache so that where_is_internal_1 doesn't think
2716 we're filling it up. */
2717 where_is_cache
= Qnil
;
2720 while (CONSP (found
))
2724 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2725 found
= XCDR (found
);
2728 data
.sequences
= Qnil
;
2729 for (; CONSP (maps
); maps
= XCDR (maps
))
2731 /* Key sequence to reach map, and the map that it reaches */
2732 register Lisp_Object
this, map
, tem
;
2734 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2735 [M-CHAR] sequences, check if last character of the sequence
2736 is the meta-prefix char. */
2740 this = Fcar (XCAR (maps
));
2741 map
= Fcdr (XCAR (maps
));
2742 last
= make_number (XINT (Flength (this)) - 1);
2743 last_is_meta
= (XINT (last
) >= 0
2744 && EQ (Faref (this, last
), meta_prefix_char
));
2746 /* if (nomenus && !preferred_sequence_p (this)) */
2747 if (nomenus
&& XINT (last
) >= 0
2748 && SYMBOLP (tem
= Faref (this, make_number (0)))
2749 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2750 /* If no menu entries should be returned, skip over the
2751 keymaps bound to `menu-bar' and `tool-bar' and other
2752 non-ascii prefixes like `C-down-mouse-2'. */
2757 data
.definition
= definition
;
2758 data
.noindirect
= noindirect
;
2761 data
.last_is_meta
= last_is_meta
;
2764 map_keymap (map
, where_is_internal_1
, Qnil
, &data
, 0);
2767 if (nomenus
&& !noindirect
)
2768 /* Remember for which keymaps this cache was built.
2769 We do it here (late) because we want to keep where_is_cache_keymaps
2770 set to t while the cache isn't fully filled. */
2771 where_is_cache_keymaps
= keymaps
;
2773 return data
.sequences
;
2776 static Lisp_Object Vwhere_is_preferred_modifier
;
2778 /* This function can GC if Flookup_key autoloads any keymaps. */
2780 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2781 doc
: /* Return list of keys that invoke DEFINITION.
2782 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2783 If KEYMAP is nil, search all the currently active keymaps.
2784 If KEYMAP is a list of keymaps, search only those keymaps.
2786 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2787 rather than a list of all possible key sequences.
2788 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2789 no matter what it is.
2790 If FIRSTONLY has another non-nil value, prefer bindings
2791 that use the modifier key specified in `where-is-preferred-modifier'
2792 \(or their meta variants) and entirely reject menu bindings.
2794 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2795 to other keymaps or slots. This makes it possible to search for an
2796 indirect definition itself.
2798 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2799 that invoke a command which is remapped to DEFINITION, but include the
2800 remapped command in the returned list. */)
2801 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2802 Lisp_Object definition
, keymap
;
2803 Lisp_Object firstonly
, noindirect
, no_remap
;
2805 /* The keymaps in which to search. */
2806 Lisp_Object keymaps
;
2807 /* Potentially relevant bindings in "shortest to longest" order. */
2808 Lisp_Object sequences
= Qnil
;
2809 /* Actually relevant bindings. */
2810 Lisp_Object found
= Qnil
;
2811 /* 1 means ignore all menu bindings entirely. */
2812 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2813 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2814 /* List of sequences found via remapping. Keep them in a separate
2815 variable, so as to push them later, since we prefer
2816 non-remapped binding. */
2817 Lisp_Object remapped_sequences
= Qnil
;
2818 /* Whether or not we're handling remapped sequences. This is needed
2819 because remapping is not done recursively by Fcommand_remapping: you
2820 can't remap and remapped command. */
2824 /* Refresh the C version of the modifier preference. */
2825 where_is_preferred_modifier
2826 = parse_solitary_modifier (Vwhere_is_preferred_modifier
);
2828 /* Find the relevant keymaps. */
2829 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2831 else if (!NILP (keymap
))
2832 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2834 keymaps
= Fcurrent_active_maps (Qnil
, Qnil
);
2836 GCPRO5 (definition
, keymaps
, found
, sequences
, remapped_sequences
);
2838 /* If this command is remapped, then it has no key bindings of its own.
2839 FIXME: Actually, this is not quite right: if A is remapped to
2840 `definition', then bindings to A will actually bind the key to
2841 `definition' despite the remapping from `definition' to something else.
2842 Another corner case is if `definition' is remapped to itself. */
2844 && SYMBOLP (definition
)
2845 && !NILP (Fcommand_remapping (definition
, Qnil
, keymaps
)))
2846 RETURN_UNGCPRO (Qnil
);
2848 if (SYMBOLP (definition
)
2849 && !NILP (firstonly
)
2850 && !NILP (tem
= Fget (definition
, QCadvertised_binding
)))
2852 /* We have a list of advertized bindings. */
2854 if (EQ (shadow_lookup (keymaps
, XCAR (tem
), Qnil
), definition
))
2858 if (EQ (shadow_lookup (keymaps
, tem
, Qnil
), definition
))
2862 sequences
= Freverse (where_is_internal (definition
, keymaps
,
2863 !NILP (noindirect
), nomenus
));
2865 while (CONSP (sequences
))
2867 Lisp_Object sequence
, function
;
2869 sequence
= XCAR (sequences
);
2870 sequences
= XCDR (sequences
);
2872 if (NILP (sequences
) && !remapped
)
2874 sequences
= remapped_sequences
;
2878 /* Verify that this key binding is not shadowed by another
2879 binding for the same key, before we say it exists.
2881 Mechanism: look for local definition of this key and if
2882 it is defined and does not match what we found then
2885 Either nil or number as value from Flookup_key
2887 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2890 /* If the current sequence is a command remapping with
2891 format [remap COMMAND], find the key sequences
2892 which run COMMAND, and use those sequences instead. */
2893 if (NILP (no_remap
) && !remapped
2894 && VECTORP (sequence
) && ASIZE (sequence
) == 2
2895 && EQ (AREF (sequence
, 0), Qremap
)
2896 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2898 Lisp_Object seqs
= where_is_internal (function
, keymaps
,
2899 !NILP (noindirect
), nomenus
);
2900 Lisp_Object args
[2];
2901 args
[0] = Freverse (seqs
);
2902 args
[1] = remapped_sequences
;
2903 remapped_sequences
= Fnconc (2, args
);
2907 /* Don't annoy user with strings from a menu such as the
2908 entries from the "Edit => Paste from Kill Menu".
2909 Change them all to "(any string)", so that there
2910 seems to be only one menu item to report. */
2911 if (! NILP (sequence
))
2914 tem
= Faref (sequence
, make_number (ASIZE (sequence
) - 1));
2916 Faset (sequence
, make_number (ASIZE (sequence
) - 1),
2917 build_string ("(any string)"));
2920 /* It is a true unshadowed match. Record it, unless it's already
2921 been seen (as could happen when inheriting keymaps). */
2922 if (NILP (Fmember (sequence
, found
)))
2923 found
= Fcons (sequence
, found
);
2925 /* If firstonly is Qnon_ascii, then we can return the first
2926 binding we find. If firstonly is not Qnon_ascii but not
2927 nil, then we should return the first ascii-only binding
2929 if (EQ (firstonly
, Qnon_ascii
))
2930 RETURN_UNGCPRO (sequence
);
2931 else if (!NILP (firstonly
)
2932 && 2 == preferred_sequence_p (sequence
))
2933 RETURN_UNGCPRO (sequence
);
2938 found
= Fnreverse (found
);
2940 /* firstonly may have been t, but we may have gone all the way through
2941 the keymaps without finding an all-ASCII key sequence. So just
2942 return the best we could find. */
2943 if (NILP (firstonly
))
2945 else if (where_is_preferred_modifier
== 0)
2946 return Fcar (found
);
2948 { /* Maybe we did not find a preferred_modifier binding, but we did find
2949 some ASCII binding. */
2950 Lisp_Object bindings
= found
;
2951 while (CONSP (bindings
))
2952 if (preferred_sequence_p (XCAR (bindings
)))
2953 return XCAR (bindings
);
2955 bindings
= XCDR (bindings
);
2956 return Fcar (found
);
2960 /* This function can GC because get_keyelt can. */
2963 where_is_internal_1 (key
, binding
, args
, data
)
2964 Lisp_Object key
, binding
, args
;
2967 struct where_is_internal_data
*d
= data
; /* Cast! */
2968 Lisp_Object definition
= d
->definition
;
2969 int noindirect
= d
->noindirect
;
2970 Lisp_Object
this = d
->this;
2971 Lisp_Object last
= d
->last
;
2972 int last_is_meta
= d
->last_is_meta
;
2973 Lisp_Object sequence
;
2975 /* Search through indirections unless that's not wanted. */
2977 binding
= get_keyelt (binding
, 0);
2979 /* End this iteration if this element does not match
2982 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2983 || EQ (binding
, definition
)
2984 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2985 /* Doesn't match. */
2988 /* We have found a match. Construct the key sequence where we found it. */
2989 if (INTEGERP (key
) && last_is_meta
)
2991 sequence
= Fcopy_sequence (this);
2992 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2997 key
= Fcons (XCAR (key
), XCDR (key
));
2998 sequence
= append_key (this, key
);
3001 if (!NILP (where_is_cache
))
3003 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
3004 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
3007 d
->sequences
= Fcons (sequence
, d
->sequences
);
3010 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
3012 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
3013 doc
: /* Insert the list of all defined keys and their definitions.
3014 The list is inserted in the current buffer, while the bindings are
3015 looked up in BUFFER.
3016 The optional argument PREFIX, if non-nil, should be a key sequence;
3017 then we display only bindings that start with that prefix.
3018 The optional argument MENUS, if non-nil, says to mention menu bindings.
3019 \(Ordinarily these are omitted from the output.) */)
3020 (buffer
, prefix
, menus
)
3021 Lisp_Object buffer
, prefix
, menus
;
3023 Lisp_Object outbuf
, shadow
;
3024 int nomenu
= NILP (menus
);
3025 register Lisp_Object start1
;
3026 struct gcpro gcpro1
;
3028 char *alternate_heading
3030 Keyboard translations:\n\n\
3031 You type Translation\n\
3032 -------- -----------\n";
3034 CHECK_BUFFER (buffer
);
3039 outbuf
= Fcurrent_buffer ();
3041 /* Report on alternates for keys. */
3042 if (STRINGP (current_kboard
->Vkeyboard_translate_table
) && !NILP (prefix
))
3045 const unsigned char *translate
= SDATA (current_kboard
->Vkeyboard_translate_table
);
3046 int translate_len
= SCHARS (current_kboard
->Vkeyboard_translate_table
);
3048 for (c
= 0; c
< translate_len
; c
++)
3049 if (translate
[c
] != c
)
3051 char buf
[KEY_DESCRIPTION_SIZE
];
3054 if (alternate_heading
)
3056 insert_string (alternate_heading
);
3057 alternate_heading
= 0;
3060 bufend
= push_key_description (translate
[c
], buf
, 1);
3061 insert (buf
, bufend
- buf
);
3062 Findent_to (make_number (16), make_number (1));
3063 bufend
= push_key_description (c
, buf
, 1);
3064 insert (buf
, bufend
- buf
);
3068 /* Insert calls signal_after_change which may GC. */
3069 translate
= SDATA (current_kboard
->Vkeyboard_translate_table
);
3075 if (!NILP (Vkey_translation_map
))
3076 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
3077 "Key translations", nomenu
, 1, 0, 0);
3080 /* Print the (major mode) local map. */
3082 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
3083 start1
= current_kboard
->Voverriding_terminal_local_map
;
3084 else if (!NILP (Voverriding_local_map
))
3085 start1
= Voverriding_local_map
;
3089 describe_map_tree (start1
, 1, shadow
, prefix
,
3090 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
3091 shadow
= Fcons (start1
, shadow
);
3095 /* Print the minor mode and major mode keymaps. */
3097 Lisp_Object
*modes
, *maps
;
3099 /* Temporarily switch to `buffer', so that we can get that buffer's
3100 minor modes correctly. */
3101 Fset_buffer (buffer
);
3103 nmaps
= current_minor_maps (&modes
, &maps
);
3104 Fset_buffer (outbuf
);
3106 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3107 XBUFFER (buffer
), Qkeymap
);
3110 describe_map_tree (start1
, 1, shadow
, prefix
,
3111 "\f\n`keymap' Property Bindings", nomenu
,
3113 shadow
= Fcons (start1
, shadow
);
3116 /* Print the minor mode maps. */
3117 for (i
= 0; i
< nmaps
; i
++)
3119 /* The title for a minor mode keymap
3120 is constructed at run time.
3121 We let describe_map_tree do the actual insertion
3122 because it takes care of other features when doing so. */
3125 if (!SYMBOLP (modes
[i
]))
3128 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3132 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
3133 SCHARS (SYMBOL_NAME (modes
[i
])));
3134 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3136 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
3137 p
+= sizeof (" Minor Mode Bindings") - 1;
3140 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3141 title
, nomenu
, 0, 0, 0);
3142 shadow
= Fcons (maps
[i
], shadow
);
3145 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3146 XBUFFER (buffer
), Qlocal_map
);
3149 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3150 describe_map_tree (start1
, 1, shadow
, prefix
,
3151 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3153 describe_map_tree (start1
, 1, shadow
, prefix
,
3154 "\f\n`local-map' Property Bindings",
3157 shadow
= Fcons (start1
, shadow
);
3161 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3162 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3164 /* Print the function-key-map translations under this prefix. */
3165 if (!NILP (current_kboard
->Vlocal_function_key_map
))
3166 describe_map_tree (current_kboard
->Vlocal_function_key_map
, 0, Qnil
, prefix
,
3167 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3169 /* Print the input-decode-map translations under this prefix. */
3170 if (!NILP (current_kboard
->Vinput_decode_map
))
3171 describe_map_tree (current_kboard
->Vinput_decode_map
, 0, Qnil
, prefix
,
3172 "\f\nInput decoding map translations", nomenu
, 1, 0, 0);
3178 /* Insert a description of the key bindings in STARTMAP,
3179 followed by those of all maps reachable through STARTMAP.
3180 If PARTIAL is nonzero, omit certain "uninteresting" commands
3181 (such as `undefined').
3182 If SHADOW is non-nil, it is a list of maps;
3183 don't mention keys which would be shadowed by any of them.
3184 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3185 TITLE, if not 0, is a string to insert at the beginning.
3186 TITLE should not end with a colon or a newline; we supply that.
3187 If NOMENU is not 0, then omit menu-bar commands.
3189 If TRANSL is nonzero, the definitions are actually key translations
3190 so print strings and vectors differently.
3192 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3195 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3196 don't omit it; instead, mention it but say it is shadowed. */
3199 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3200 always_title
, mention_shadow
)
3201 Lisp_Object startmap
, shadow
, prefix
;
3209 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3210 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3217 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3220 GCPRO3 (maps
, seen
, sub_shadows
);
3226 /* Delete from MAPS each element that is for the menu bar. */
3227 for (list
= maps
; CONSP (list
); list
= XCDR (list
))
3229 Lisp_Object elt
, prefix
, tem
;
3232 prefix
= Fcar (elt
);
3233 if (XVECTOR (prefix
)->size
>= 1)
3235 tem
= Faref (prefix
, make_number (0));
3236 if (EQ (tem
, Qmenu_bar
))
3237 maps
= Fdelq (elt
, maps
);
3242 if (!NILP (maps
) || always_title
)
3246 insert_string (title
);
3249 insert_string (" Starting With ");
3250 insert1 (Fkey_description (prefix
, Qnil
));
3252 insert_string (":\n");
3254 insert_string (key_heading
);
3258 for (; CONSP (maps
); maps
= XCDR (maps
))
3260 register Lisp_Object elt
, prefix
, tail
;
3263 prefix
= Fcar (elt
);
3267 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3271 shmap
= XCAR (tail
);
3273 /* If the sequence by which we reach this keymap is zero-length,
3274 then the shadow map for this keymap is just SHADOW. */
3275 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3276 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3278 /* If the sequence by which we reach this keymap actually has
3279 some elements, then the sequence's definition in SHADOW is
3280 what we should use. */
3283 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3284 if (INTEGERP (shmap
))
3288 /* If shmap is not nil and not a keymap,
3289 it completely shadows this map, so don't
3290 describe this map at all. */
3291 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3295 sub_shadows
= Fcons (shmap
, sub_shadows
);
3298 /* Maps we have already listed in this loop shadow this map. */
3299 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3302 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3304 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3307 describe_map (Fcdr (elt
), prefix
,
3308 transl
? describe_translation
: describe_command
,
3309 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3315 insert_string ("\n");
3320 static int previous_description_column
;
3323 describe_command (definition
, args
)
3324 Lisp_Object definition
, args
;
3326 register Lisp_Object tem1
;
3327 int column
= (int) current_column (); /* iftc */
3328 int description_column
;
3330 /* If column 16 is no good, go to col 32;
3331 but don't push beyond that--go to next line instead. */
3335 description_column
= 32;
3337 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3338 description_column
= 32;
3340 description_column
= 16;
3342 Findent_to (make_number (description_column
), make_number (1));
3343 previous_description_column
= description_column
;
3345 if (SYMBOLP (definition
))
3347 tem1
= SYMBOL_NAME (definition
);
3349 insert_string ("\n");
3351 else if (STRINGP (definition
) || VECTORP (definition
))
3352 insert_string ("Keyboard Macro\n");
3353 else if (KEYMAPP (definition
))
3354 insert_string ("Prefix Command\n");
3356 insert_string ("??\n");
3360 describe_translation (definition
, args
)
3361 Lisp_Object definition
, args
;
3363 register Lisp_Object tem1
;
3365 Findent_to (make_number (16), make_number (1));
3367 if (SYMBOLP (definition
))
3369 tem1
= SYMBOL_NAME (definition
);
3371 insert_string ("\n");
3373 else if (STRINGP (definition
) || VECTORP (definition
))
3375 insert1 (Fkey_description (definition
, Qnil
));
3376 insert_string ("\n");
3378 else if (KEYMAPP (definition
))
3379 insert_string ("Prefix Command\n");
3381 insert_string ("??\n");
3384 /* describe_map puts all the usable elements of a sparse keymap
3385 into an array of `struct describe_map_elt',
3386 then sorts them by the events. */
3388 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3390 /* qsort comparison function for sorting `struct describe_map_elt' by
3394 describe_map_compare (aa
, bb
)
3395 const void *aa
, *bb
;
3397 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3398 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3399 return ((XINT (a
->event
) > XINT (b
->event
))
3400 - (XINT (a
->event
) < XINT (b
->event
)));
3401 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3403 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3405 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3406 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3407 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3412 /* Describe the contents of map MAP, assuming that this map itself is
3413 reached by the sequence of prefix keys PREFIX (a string or vector).
3414 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3417 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3418 seen
, nomenu
, mention_shadow
)
3419 register Lisp_Object map
;
3421 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3428 Lisp_Object tail
, definition
, event
;
3430 Lisp_Object suppress
;
3433 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3435 /* These accumulate the values from sparse keymap bindings,
3436 so we can sort them and handle them in order. */
3437 int length_needed
= 0;
3438 struct describe_map_elt
*vect
;
3445 suppress
= intern ("suppress-keymap");
3447 /* This vector gets used to present single keys to Flookup_key. Since
3448 that is done once per keymap element, we don't want to cons up a
3449 fresh vector every time. */
3450 kludge
= Fmake_vector (make_number (1), Qnil
);
3453 GCPRO3 (prefix
, definition
, kludge
);
3455 map
= call1 (Qkeymap_canonicalize
, map
);
3457 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3460 vect
= ((struct describe_map_elt
*)
3461 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3463 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3467 if (VECTORP (XCAR (tail
))
3468 || CHAR_TABLE_P (XCAR (tail
)))
3469 describe_vector (XCAR (tail
),
3470 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3471 (int *)0, 0, 1, mention_shadow
);
3472 else if (CONSP (XCAR (tail
)))
3474 int this_shadowed
= 0;
3476 event
= XCAR (XCAR (tail
));
3478 /* Ignore bindings whose "prefix" are not really valid events.
3479 (We get these in the frames and buffers menu.) */
3480 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3483 if (nomenu
&& EQ (event
, Qmenu_bar
))
3486 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3488 /* Don't show undefined commands or suppressed commands. */
3489 if (NILP (definition
)) continue;
3490 if (SYMBOLP (definition
) && partial
)
3492 tem
= Fget (definition
, suppress
);
3497 /* Don't show a command that isn't really visible
3498 because a local definition of the same key shadows it. */
3500 ASET (kludge
, 0, event
);
3503 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3506 /* If both bindings are keymaps, this key is a prefix key,
3507 so don't say it is shadowed. */
3508 if (KEYMAPP (definition
) && KEYMAPP (tem
))
3510 /* Avoid generating duplicate entries if the
3511 shadowed binding has the same definition. */
3512 else if (mention_shadow
&& !EQ (tem
, definition
))
3519 tem
= Flookup_key (map
, kludge
, Qt
);
3520 if (!EQ (tem
, definition
)) continue;
3522 vect
[slots_used
].event
= event
;
3523 vect
[slots_used
].definition
= definition
;
3524 vect
[slots_used
].shadowed
= this_shadowed
;
3527 else if (EQ (XCAR (tail
), Qkeymap
))
3529 /* The same keymap might be in the structure twice, if we're
3530 using an inherited keymap. So skip anything we've already
3532 tem
= Fassq (tail
, *seen
);
3533 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3535 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3539 /* If we found some sparse map events, sort them. */
3541 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3542 describe_map_compare
);
3544 /* Now output them in sorted order. */
3546 for (i
= 0; i
< slots_used
; i
++)
3548 Lisp_Object start
, end
;
3552 previous_description_column
= 0;
3557 ASET (kludge
, 0, vect
[i
].event
);
3558 start
= vect
[i
].event
;
3561 definition
= vect
[i
].definition
;
3563 /* Find consecutive chars that are identically defined. */
3564 if (INTEGERP (vect
[i
].event
))
3566 while (i
+ 1 < slots_used
3567 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3568 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3569 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3571 end
= vect
[i
].event
;
3574 /* Now START .. END is the range to describe next. */
3576 /* Insert the string to describe the event START. */
3577 insert1 (Fkey_description (kludge
, prefix
));
3579 if (!EQ (start
, end
))
3583 ASET (kludge
, 0, end
);
3584 /* Insert the string to describe the character END. */
3585 insert1 (Fkey_description (kludge
, prefix
));
3588 /* Print a description of the definition of this character.
3589 elt_describer will take care of spacing out far enough
3590 for alignment purposes. */
3591 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3593 if (vect
[i
].shadowed
)
3596 insert_string ("\n (that binding is currently shadowed by another mode)");
3605 describe_vector_princ (elt
, fun
)
3606 Lisp_Object elt
, fun
;
3608 Findent_to (make_number (16), make_number (1));
3613 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3614 doc
: /* Insert a description of contents of VECTOR.
3615 This is text showing the elements of vector matched against indices.
3616 DESCRIBER is the output function used; nil means use `princ'. */)
3618 Lisp_Object vector
, describer
;
3620 int count
= SPECPDL_INDEX ();
3621 if (NILP (describer
))
3622 describer
= intern ("princ");
3623 specbind (Qstandard_output
, Fcurrent_buffer ());
3624 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3625 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3626 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3628 return unbind_to (count
, Qnil
);
3631 /* Insert in the current buffer a description of the contents of VECTOR.
3632 We call ELT_DESCRIBER to insert the description of one value found
3635 ELT_PREFIX describes what "comes before" the keys or indices defined
3636 by this vector. This is a human-readable string whose size
3637 is not necessarily related to the situation.
3639 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3640 leads to this keymap.
3642 If the vector is a chartable, ELT_PREFIX is the vector
3643 of bytes that lead to the character set or portion of a character
3644 set described by this chartable.
3646 If PARTIAL is nonzero, it means do not mention suppressed commands
3647 (that assumes the vector is in a keymap).
3649 SHADOW is a list of keymaps that shadow this map.
3650 If it is non-nil, then we look up the key in those maps
3651 and we don't mention it now if it is defined by any of them.
3653 ENTIRE_MAP is the keymap in which this vector appears.
3654 If the definition in effect in the whole map does not match
3655 the one in this vector, we ignore this one.
3657 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3659 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3662 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3664 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3667 describe_vector (vector
, prefix
, args
, elt_describer
,
3668 partial
, shadow
, entire_map
,
3669 indices
, char_table_depth
, keymap_p
,
3671 register Lisp_Object vector
;
3672 Lisp_Object prefix
, args
;
3673 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3676 Lisp_Object entire_map
;
3678 int char_table_depth
;
3682 Lisp_Object definition
;
3684 Lisp_Object elt_prefix
= Qnil
;
3686 Lisp_Object suppress
;
3689 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3690 /* Range of elements to be handled. */
3692 Lisp_Object character
;
3701 /* Call Fkey_description first, to avoid GC bug for the other string. */
3702 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3705 tem
= Fkey_description (prefix
, Qnil
);
3706 elt_prefix
= concat2 (tem
, build_string (" "));
3711 /* This vector gets used to present single keys to Flookup_key. Since
3712 that is done once per vector element, we don't want to cons up a
3713 fresh vector every time. */
3714 kludge
= Fmake_vector (make_number (1), Qnil
);
3715 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3718 suppress
= intern ("suppress-keymap");
3721 if (CHAR_TABLE_P (vector
))
3722 stop
= MAX_5_BYTE_CHAR
+ 1, to
= MAX_CHAR
+ 1;
3724 stop
= to
= XVECTOR (vector
)->size
;
3726 for (i
= from
; ; i
++)
3728 int this_shadowed
= 0;
3729 int range_beg
, range_end
;
3743 if (CHAR_TABLE_P (vector
))
3747 val
= char_table_ref_and_range (vector
, range_beg
, &range_beg
, &i
);
3750 val
= AREF (vector
, i
);
3751 definition
= get_keyelt (val
, 0);
3753 if (NILP (definition
)) continue;
3755 /* Don't mention suppressed commands. */
3756 if (SYMBOLP (definition
) && partial
)
3760 tem
= Fget (definition
, suppress
);
3762 if (!NILP (tem
)) continue;
3765 character
= make_number (starting_i
);
3766 ASET (kludge
, 0, character
);
3768 /* If this binding is shadowed by some other map, ignore it. */
3773 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3784 /* Ignore this definition if it is shadowed by an earlier
3785 one in the same keymap. */
3786 if (!NILP (entire_map
))
3790 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3792 if (!EQ (tem
, definition
))
3802 /* Output the prefix that applies to every entry in this map. */
3803 if (!NILP (elt_prefix
))
3804 insert1 (elt_prefix
);
3806 insert1 (Fkey_description (kludge
, prefix
));
3808 /* Find all consecutive characters or rows that have the same
3809 definition. But, VECTOR is a char-table, we had better put a
3810 boundary between normal characters (-#x3FFF7F) and 8-bit
3811 characters (#x3FFF80-). */
3812 if (CHAR_TABLE_P (vector
))
3815 && (range_beg
= i
+ 1, range_end
= stop
- 1,
3816 val
= char_table_ref_and_range (vector
, range_beg
,
3817 &range_beg
, &range_end
),
3818 tem2
= get_keyelt (val
, 0),
3820 && !NILP (Fequal (tem2
, definition
)))
3825 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3827 && !NILP (Fequal (tem2
, definition
)))
3830 /* If we have a range of more than one character,
3831 print where the range reaches to. */
3833 if (i
!= starting_i
)
3837 ASET (kludge
, 0, make_number (i
));
3839 if (!NILP (elt_prefix
))
3840 insert1 (elt_prefix
);
3842 insert1 (Fkey_description (kludge
, prefix
));
3845 /* Print a description of the definition of this character.
3846 elt_describer will take care of spacing out far enough
3847 for alignment purposes. */
3848 (*elt_describer
) (definition
, args
);
3853 insert_string (" (binding currently shadowed)");
3858 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3860 if (!NILP (elt_prefix
))
3861 insert1 (elt_prefix
);
3862 insert ("default", 7);
3863 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3869 /* Apropos - finding all symbols whose names match a regexp. */
3870 static Lisp_Object apropos_predicate
;
3871 static Lisp_Object apropos_accumulate
;
3874 apropos_accum (symbol
, string
)
3875 Lisp_Object symbol
, string
;
3877 register Lisp_Object tem
;
3879 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3880 if (!NILP (tem
) && !NILP (apropos_predicate
))
3881 tem
= call1 (apropos_predicate
, symbol
);
3883 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3886 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3887 doc
: /* Show all symbols whose names contain match for REGEXP.
3888 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3889 for each symbol and a symbol is mentioned only if that returns non-nil.
3890 Return list of symbols found. */)
3892 Lisp_Object regexp
, predicate
;
3895 CHECK_STRING (regexp
);
3896 apropos_predicate
= predicate
;
3897 apropos_accumulate
= Qnil
;
3898 map_obarray (Vobarray
, apropos_accum
, regexp
);
3899 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3900 apropos_accumulate
= Qnil
;
3901 apropos_predicate
= Qnil
;
3908 Qkeymap
= intern ("keymap");
3909 staticpro (&Qkeymap
);
3910 staticpro (&apropos_predicate
);
3911 staticpro (&apropos_accumulate
);
3912 apropos_predicate
= Qnil
;
3913 apropos_accumulate
= Qnil
;
3915 Qkeymap_canonicalize
= intern ("keymap-canonicalize");
3916 staticpro (&Qkeymap_canonicalize
);
3918 /* Now we are ready to set up this property, so we can
3919 create char tables. */
3920 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3922 /* Initialize the keymaps standardly used.
3923 Each one is the value of a Lisp variable, and is also
3924 pointed to by a C variable */
3926 global_map
= Fmake_keymap (Qnil
);
3927 Fset (intern ("global-map"), global_map
);
3929 current_global_map
= global_map
;
3930 staticpro (&global_map
);
3931 staticpro (¤t_global_map
);
3933 meta_map
= Fmake_keymap (Qnil
);
3934 Fset (intern ("esc-map"), meta_map
);
3935 Ffset (intern ("ESC-prefix"), meta_map
);
3937 control_x_map
= Fmake_keymap (Qnil
);
3938 Fset (intern ("ctl-x-map"), control_x_map
);
3939 Ffset (intern ("Control-X-prefix"), control_x_map
);
3942 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3943 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3944 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3945 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3946 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3948 staticpro (&exclude_keys
);
3950 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3951 doc
: /* List of commands given new key bindings recently.
3952 This is used for internal purposes during Emacs startup;
3953 don't alter it yourself. */);
3954 Vdefine_key_rebound_commands
= Qt
;
3956 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3957 doc
: /* Default keymap to use when reading from the minibuffer. */);
3958 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3960 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3961 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3962 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3963 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3965 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3966 doc
: /* Local keymap for minibuffer input with completion. */);
3967 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3968 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3970 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3971 &Vminibuffer_local_filename_completion_map
,
3972 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3973 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3974 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3975 Vminibuffer_local_completion_map
);
3978 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3979 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3980 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3981 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3982 Vminibuffer_local_completion_map
);
3984 DEFVAR_LISP ("minibuffer-local-filename-must-match-map",
3985 &Vminibuffer_local_filename_must_match_map
,
3986 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3987 Vminibuffer_local_filename_must_match_map
= Fmake_sparse_keymap (Qnil
);
3988 Fset_keymap_parent (Vminibuffer_local_filename_must_match_map
,
3989 Vminibuffer_local_must_match_map
);
3991 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3992 doc
: /* Alist of keymaps to use for minor modes.
3993 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3994 key sequences and look up bindings if VARIABLE's value is non-nil.
3995 If two active keymaps bind the same key, the keymap appearing earlier
3996 in the list takes precedence. */);
3997 Vminor_mode_map_alist
= Qnil
;
3999 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
4000 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
4001 This variable is an alist just like `minor-mode-map-alist', and it is
4002 used the same way (and before `minor-mode-map-alist'); however,
4003 it is provided for major modes to bind locally. */);
4004 Vminor_mode_overriding_map_alist
= Qnil
;
4006 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
4007 doc
: /* List of keymap alists to use for emulations modes.
4008 It is intended for modes or packages using multiple minor-mode keymaps.
4009 Each element is a keymap alist just like `minor-mode-map-alist', or a
4010 symbol with a variable binding which is a keymap alist, and it is used
4011 the same way. The "active" keymaps in each alist are used before
4012 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
4013 Vemulation_mode_map_alists
= Qnil
;
4015 DEFVAR_LISP ("where-is-preferred-modifier", &Vwhere_is_preferred_modifier
,
4016 doc
: /* Preferred modifier to use for `where-is'.
4017 When a single binding is requested, `where-is' will return one that
4018 uses this modifier if possible. If nil, or if no such binding exists,
4019 bindings using keys without modifiers (or only with meta) will be
4021 Vwhere_is_preferred_modifier
= Qnil
;
4022 where_is_preferred_modifier
= 0;
4024 staticpro (&Vmouse_events
);
4025 Vmouse_events
= Fcons (intern ("menu-bar"),
4026 Fcons (intern ("tool-bar"),
4027 Fcons (intern ("header-line"),
4028 Fcons (intern ("mode-line"),
4029 Fcons (intern ("mouse-1"),
4030 Fcons (intern ("mouse-2"),
4031 Fcons (intern ("mouse-3"),
4032 Fcons (intern ("mouse-4"),
4033 Fcons (intern ("mouse-5"),
4037 Qsingle_key_description
= intern ("single-key-description");
4038 staticpro (&Qsingle_key_description
);
4040 Qkey_description
= intern ("key-description");
4041 staticpro (&Qkey_description
);
4043 Qkeymapp
= intern ("keymapp");
4044 staticpro (&Qkeymapp
);
4046 Qnon_ascii
= intern ("non-ascii");
4047 staticpro (&Qnon_ascii
);
4049 Qmenu_item
= intern ("menu-item");
4050 staticpro (&Qmenu_item
);
4052 Qremap
= intern ("remap");
4053 staticpro (&Qremap
);
4055 QCadvertised_binding
= intern (":advertised-binding");
4056 staticpro (&QCadvertised_binding
);
4058 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
4059 staticpro (&command_remapping_vector
);
4061 where_is_cache_keymaps
= Qt
;
4062 where_is_cache
= Qnil
;
4063 staticpro (&where_is_cache
);
4064 staticpro (&where_is_cache_keymaps
);
4066 defsubr (&Skeymapp
);
4067 defsubr (&Skeymap_parent
);
4068 defsubr (&Skeymap_prompt
);
4069 defsubr (&Sset_keymap_parent
);
4070 defsubr (&Smake_keymap
);
4071 defsubr (&Smake_sparse_keymap
);
4072 defsubr (&Smap_keymap_internal
);
4073 defsubr (&Smap_keymap
);
4074 defsubr (&Scopy_keymap
);
4075 defsubr (&Scommand_remapping
);
4076 defsubr (&Skey_binding
);
4077 defsubr (&Slocal_key_binding
);
4078 defsubr (&Sglobal_key_binding
);
4079 defsubr (&Sminor_mode_key_binding
);
4080 defsubr (&Sdefine_key
);
4081 defsubr (&Slookup_key
);
4082 defsubr (&Sdefine_prefix_command
);
4083 defsubr (&Suse_global_map
);
4084 defsubr (&Suse_local_map
);
4085 defsubr (&Scurrent_local_map
);
4086 defsubr (&Scurrent_global_map
);
4087 defsubr (&Scurrent_minor_mode_maps
);
4088 defsubr (&Scurrent_active_maps
);
4089 defsubr (&Saccessible_keymaps
);
4090 defsubr (&Skey_description
);
4091 defsubr (&Sdescribe_vector
);
4092 defsubr (&Ssingle_key_description
);
4093 defsubr (&Stext_char_description
);
4094 defsubr (&Swhere_is_internal
);
4095 defsubr (&Sdescribe_buffer_bindings
);
4096 defsubr (&Sapropos_internal
);
4102 initial_define_key (global_map
, 033, "ESC-prefix");
4103 initial_define_key (global_map
, Ctl ('X'), "Control-X-prefix");
4106 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4107 (do not change this comment) */