1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
31 #include "termhooks.h"
32 #include "blockinput.h"
34 #include "intervals.h"
37 /* The number of elements in keymap vectors. */
38 #define DENSE_TABLE_SIZE (0200)
40 /* Actually allocate storage for these variables */
42 Lisp_Object current_global_map
; /* Current global keymap */
44 Lisp_Object global_map
; /* default global key bindings */
46 Lisp_Object meta_map
; /* The keymap used for globally bound
47 ESC-prefixed default commands */
49 Lisp_Object control_x_map
; /* The keymap used for globally bound
50 C-x-prefixed default commands */
52 /* was MinibufLocalMap */
53 Lisp_Object Vminibuffer_local_map
;
54 /* The keymap used by the minibuf for local
55 bindings when spaces are allowed in the
58 /* was MinibufLocalNSMap */
59 Lisp_Object Vminibuffer_local_ns_map
;
60 /* The keymap used by the minibuf for local
61 bindings when spaces are not encouraged
64 /* keymap used for minibuffers when doing completion */
65 /* was MinibufLocalCompletionMap */
66 Lisp_Object Vminibuffer_local_completion_map
;
68 /* keymap used for minibuffers when doing completion in filenames */
69 Lisp_Object Vminibuffer_local_filename_completion_map
;
71 /* keymap used for minibuffers when doing completion in filenames
73 Lisp_Object Vminibuffer_local_must_match_filename_map
;
75 /* keymap used for minibuffers when doing completion and require a match */
76 /* was MinibufLocalMustMatchMap */
77 Lisp_Object Vminibuffer_local_must_match_map
;
79 /* Alist of minor mode variables and keymaps. */
80 Lisp_Object Vminor_mode_map_alist
;
82 /* Alist of major-mode-specific overrides for
83 minor mode variables and keymaps. */
84 Lisp_Object Vminor_mode_overriding_map_alist
;
86 /* List of emulation mode keymap alists. */
87 Lisp_Object Vemulation_mode_map_alists
;
89 /* Keymap mapping ASCII function key sequences onto their preferred forms.
90 Initialized by the terminal-specific lisp files. See DEFVAR for more
92 Lisp_Object Vfunction_key_map
;
94 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
95 Lisp_Object Vkey_translation_map
;
97 /* A list of all commands given new bindings since a certain time
98 when nil was stored here.
99 This is used to speed up recomputation of menu key equivalents
100 when Emacs starts up. t means don't record anything here. */
101 Lisp_Object Vdefine_key_rebound_commands
;
103 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
105 /* Alist of elements like (DEL . "\d"). */
106 static Lisp_Object exclude_keys
;
108 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
109 static Lisp_Object command_remapping_vector
;
111 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
112 in a string key sequence is equivalent to prefixing with this
114 extern Lisp_Object meta_prefix_char
;
116 extern Lisp_Object Voverriding_local_map
;
118 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
119 static Lisp_Object where_is_cache
;
120 /* Which keymaps are reverse-stored in the cache. */
121 static Lisp_Object where_is_cache_keymaps
;
123 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
124 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
126 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
127 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
128 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
129 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
130 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
131 int, Lisp_Object
, Lisp_Object
*, int, int));
132 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
133 void (*) (Lisp_Object
, Lisp_Object
), int,
134 Lisp_Object
, Lisp_Object
, int *,
136 static void silly_event_symbol_error
P_ ((Lisp_Object
));
138 /* Keymap object support - constructors and predicates. */
140 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
141 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
142 CHARTABLE is a char-table that holds the bindings for all characters
143 without modifiers. All entries in it are initially nil, meaning
144 "command undefined". ALIST is an assoc-list which holds bindings for
145 function keys, mouse events, and any other things that appear in the
146 input stream. Initially, ALIST is nil.
148 The optional arg STRING supplies a menu name for the keymap
149 in case you use it as a menu with `x-popup-menu'. */)
155 tail
= Fcons (string
, Qnil
);
158 return Fcons (Qkeymap
,
159 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
162 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
163 doc
: /* Construct and return a new sparse keymap.
164 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
165 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
166 which binds the function key or mouse event SYMBOL to DEFINITION.
167 Initially the alist is nil.
169 The optional arg STRING supplies a menu name for the keymap
170 in case you use it as a menu with `x-popup-menu'. */)
175 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
176 return Fcons (Qkeymap
, Qnil
);
179 /* This function is used for installing the standard key bindings
180 at initialization time.
184 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
187 initial_define_key (keymap
, key
, defname
)
192 store_in_keymap (keymap
, make_number (key
), intern (defname
));
196 initial_define_lispy_key (keymap
, keyname
, defname
)
201 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
204 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
205 doc
: /* Return t if OBJECT is a keymap.
207 A keymap is a list (keymap . ALIST),
208 or a symbol whose function definition is itself a keymap.
209 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
210 a vector of densely packed bindings for small character codes
211 is also allowed as an element. */)
215 return (KEYMAPP (object
) ? Qt
: Qnil
);
218 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
219 doc
: /* Return the prompt-string of a keymap MAP.
220 If non-nil, the prompt is shown in the echo-area
221 when reading a key-sequence to be looked-up in this keymap. */)
225 map
= get_keymap (map
, 0, 0);
228 Lisp_Object tem
= XCAR (map
);
236 /* Check that OBJECT is a keymap (after dereferencing through any
237 symbols). If it is, return it.
239 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
240 is an autoload form, do the autoload and try again.
241 If AUTOLOAD is nonzero, callers must assume GC is possible.
243 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
244 is zero as well), return Qt.
246 ERROR controls how we respond if OBJECT isn't a keymap.
247 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
249 Note that most of the time, we don't want to pursue autoloads.
250 Functions like Faccessible_keymaps which scan entire keymap trees
251 shouldn't load every autoloaded keymap. I'm not sure about this,
252 but it seems to me that only read_key_sequence, Flookup_key, and
253 Fdefine_key should cause keymaps to be autoloaded.
255 This function can GC when AUTOLOAD is non-zero, because it calls
256 do_autoload which can GC. */
259 get_keymap (object
, error
, autoload
)
268 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
271 tem
= indirect_function (object
);
274 if (EQ (XCAR (tem
), Qkeymap
))
277 /* Should we do an autoload? Autoload forms for keymaps have
278 Qkeymap as their fifth element. */
279 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
284 tail
= Fnth (make_number (4), tem
);
285 if (EQ (tail
, Qkeymap
))
289 struct gcpro gcpro1
, gcpro2
;
291 GCPRO2 (tem
, object
);
292 do_autoload (tem
, object
);
305 wrong_type_argument (Qkeymapp
, object
);
309 /* Return the parent map of KEYMAP, or nil if it has none.
310 We assume that KEYMAP is a valid keymap. */
313 keymap_parent (keymap
, autoload
)
319 keymap
= get_keymap (keymap
, 1, autoload
);
321 /* Skip past the initial element `keymap'. */
322 list
= XCDR (keymap
);
323 for (; CONSP (list
); list
= XCDR (list
))
325 /* See if there is another `keymap'. */
330 return get_keymap (list
, 0, autoload
);
333 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
334 doc
: /* Return the parent keymap of KEYMAP. */)
338 return keymap_parent (keymap
, 1);
341 /* Check whether MAP is one of MAPS parents. */
343 keymap_memberp (map
, maps
)
344 Lisp_Object map
, maps
;
346 if (NILP (map
)) return 0;
347 while (KEYMAPP (maps
) && !EQ (map
, maps
))
348 maps
= keymap_parent (maps
, 0);
349 return (EQ (map
, maps
));
352 /* Set the parent keymap of MAP to PARENT. */
354 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
355 doc
: /* Modify KEYMAP to set its parent map to PARENT.
356 Return PARENT. PARENT should be nil or another keymap. */)
358 Lisp_Object keymap
, parent
;
360 Lisp_Object list
, prev
;
361 struct gcpro gcpro1
, gcpro2
;
364 /* Force a keymap flush for the next call to where-is.
365 Since this can be called from within where-is, we don't set where_is_cache
366 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
367 be changed during where-is, while where_is_cache_keymaps is only used at
368 the very beginning of where-is and can thus be changed here without any
370 This is a very minor correctness (rather than safety) issue. */
371 where_is_cache_keymaps
= Qt
;
373 GCPRO2 (keymap
, parent
);
374 keymap
= get_keymap (keymap
, 1, 1);
378 parent
= get_keymap (parent
, 1, 1);
380 /* Check for cycles. */
381 if (keymap_memberp (keymap
, parent
))
382 error ("Cyclic keymap inheritance");
385 /* Skip past the initial element `keymap'. */
390 /* If there is a parent keymap here, replace it.
391 If we came to the end, add the parent in PREV. */
392 if (!CONSP (list
) || KEYMAPP (list
))
394 /* If we already have the right parent, return now
395 so that we avoid the loops below. */
396 if (EQ (XCDR (prev
), parent
))
397 RETURN_UNGCPRO (parent
);
400 XSETCDR (prev
, parent
);
406 /* Scan through for submaps, and set their parents too. */
408 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
410 /* Stop the scan when we come to the parent. */
411 if (EQ (XCAR (list
), Qkeymap
))
414 /* If this element holds a prefix map, deal with it. */
415 if (CONSP (XCAR (list
))
416 && CONSP (XCDR (XCAR (list
))))
417 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
420 if (VECTORP (XCAR (list
)))
421 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
422 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
423 fix_submap_inheritance (keymap
, make_number (i
),
424 XVECTOR (XCAR (list
))->contents
[i
]);
426 if (CHAR_TABLE_P (XCAR (list
)))
428 Lisp_Object indices
[3];
430 map_char_table (fix_submap_inheritance
, Qnil
,
431 XCAR (list
), XCAR (list
),
436 RETURN_UNGCPRO (parent
);
439 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
440 if EVENT is also a prefix in MAP's parent,
441 make sure that SUBMAP inherits that definition as its own parent. */
444 fix_submap_inheritance (map
, event
, submap
)
445 Lisp_Object map
, event
, submap
;
447 Lisp_Object map_parent
, parent_entry
;
449 /* SUBMAP is a cons that we found as a key binding.
450 Discard the other things found in a menu key binding. */
452 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
454 /* If it isn't a keymap now, there's no work to do. */
458 map_parent
= keymap_parent (map
, 0);
459 if (!NILP (map_parent
))
461 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
465 /* If MAP's parent has something other than a keymap,
466 our own submap shadows it completely. */
467 if (!CONSP (parent_entry
))
470 if (! EQ (parent_entry
, submap
))
472 Lisp_Object submap_parent
;
473 submap_parent
= submap
;
478 tem
= keymap_parent (submap_parent
, 0);
482 if (keymap_memberp (tem
, parent_entry
))
483 /* Fset_keymap_parent could create a cycle. */
490 Fset_keymap_parent (submap_parent
, parent_entry
);
494 /* Look up IDX in MAP. IDX may be any sort of event.
495 Note that this does only one level of lookup; IDX must be a single
496 event, not a sequence.
498 If T_OK is non-zero, bindings for Qt are treated as default
499 bindings; any key left unmentioned by other tables and bindings is
500 given the binding of Qt.
502 If T_OK is zero, bindings for Qt are not treated specially.
504 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
507 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
516 /* Qunbound in VAL means we have found no binding yet. */
519 /* If idx is a list (some sort of mouse click, perhaps?),
520 the index we want to use is the car of the list, which
521 ought to be a symbol. */
522 idx
= EVENT_HEAD (idx
);
524 /* If idx is a symbol, it might have modifiers, which need to
525 be put in the canonical order. */
527 idx
= reorder_modifiers (idx
);
528 else if (INTEGERP (idx
))
529 /* Clobber the high bits that can be present on a machine
530 with more than 24 bits of integer. */
531 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
533 /* Handle the special meta -> esc mapping. */
534 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
536 /* See if there is a meta-map. If there's none, there is
537 no binding for IDX, unless a default binding exists in MAP. */
539 Lisp_Object meta_map
;
541 /* A strange value in which Meta is set would cause
542 infinite recursion. Protect against that. */
543 if (XINT (meta_prefix_char
) & CHAR_META
)
544 meta_prefix_char
= make_number (27);
545 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
546 t_ok
, noinherit
, autoload
),
549 if (CONSP (meta_map
))
552 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
555 /* Set IDX to t, so that we only find a default binding. */
558 /* We know there is no binding. */
562 /* t_binding is where we put a default binding that applies,
563 to use in case we do not find a binding specifically
564 for this key sequence. */
567 Lisp_Object t_binding
= Qnil
;
568 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
570 GCPRO4 (map
, tail
, idx
, t_binding
);
572 /* If `t_ok' is 2, both `t' and generic-char bindings are accepted.
573 If it is 1, only generic-char bindings are accepted.
574 Otherwise, neither are. */
577 for (tail
= XCDR (map
);
579 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
584 binding
= XCAR (tail
);
585 if (SYMBOLP (binding
))
587 /* If NOINHERIT, stop finding prefix definitions
588 after we pass a second occurrence of the `keymap' symbol. */
589 if (noinherit
&& EQ (binding
, Qkeymap
))
590 RETURN_UNGCPRO (Qnil
);
592 else if (CONSP (binding
))
594 Lisp_Object key
= XCAR (binding
);
597 val
= XCDR (binding
);
600 && (XINT (idx
) & CHAR_MODIFIER_MASK
) == 0
602 && (XINT (key
) & CHAR_MODIFIER_MASK
) == 0
603 && !SINGLE_BYTE_CHAR_P (XINT (idx
))
604 && !SINGLE_BYTE_CHAR_P (XINT (key
))
605 && CHAR_VALID_P (XINT (key
), 1)
606 && !CHAR_VALID_P (XINT (key
), 0)
607 && (CHAR_CHARSET (XINT (key
))
608 == CHAR_CHARSET (XINT (idx
))))
610 /* KEY is the generic character of the charset of IDX.
611 Use KEY's binding if there isn't a binding for IDX
613 t_binding
= XCDR (binding
);
616 else if (t_ok
> 1 && EQ (key
, Qt
))
618 t_binding
= XCDR (binding
);
622 else if (VECTORP (binding
))
624 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
625 val
= AREF (binding
, XFASTINT (idx
));
627 else if (CHAR_TABLE_P (binding
))
629 /* Character codes with modifiers
630 are not included in a char-table.
631 All character codes without modifiers are included. */
632 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
634 val
= Faref (binding
, idx
);
635 /* `nil' has a special meaning for char-tables, so
636 we use something else to record an explicitly
643 /* If we found a binding, clean it up and return it. */
644 if (!EQ (val
, Qunbound
))
647 /* A Qt binding is just like an explicit nil binding
648 (i.e. it shadows any parent binding but not bindings in
649 keymaps of lower precedence). */
651 val
= get_keyelt (val
, autoload
);
653 fix_submap_inheritance (map
, idx
, val
);
654 RETURN_UNGCPRO (val
);
659 return get_keyelt (t_binding
, autoload
);
664 map_keymap_item (fun
, args
, key
, val
, data
)
665 map_keymap_function_t fun
;
666 Lisp_Object args
, key
, val
;
669 /* We should maybe try to detect bindings shadowed by previous
670 ones and things like that. */
673 (*fun
) (key
, val
, args
, data
);
677 map_keymap_char_table_item (args
, key
, val
)
678 Lisp_Object args
, key
, val
;
682 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
684 map_keymap_item (fun
, XCDR (args
), key
, val
,
685 XSAVE_VALUE (XCAR (args
))->pointer
);
689 /* Call FUN for every binding in MAP.
690 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA).
691 AUTOLOAD if non-zero means that we can autoload keymaps if necessary. */
693 map_keymap (map
, fun
, args
, data
, autoload
)
694 map_keymap_function_t fun
;
695 Lisp_Object map
, args
;
699 struct gcpro gcpro1
, gcpro2
, gcpro3
;
703 GCPRO3 (map
, args
, tail
);
704 map
= get_keymap (map
, 1, autoload
);
705 for (tail
= (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
706 CONSP (tail
) || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
));
709 Lisp_Object binding
= XCAR (tail
);
712 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
713 else if (VECTORP (binding
))
715 /* Loop over the char values represented in the vector. */
716 int len
= ASIZE (binding
);
718 for (c
= 0; c
< len
; c
++)
720 Lisp_Object character
;
721 XSETFASTINT (character
, c
);
722 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
725 else if (CHAR_TABLE_P (binding
))
727 Lisp_Object indices
[3];
728 map_char_table (map_keymap_char_table_item
, Qnil
, binding
, binding
,
729 Fcons (make_save_value (fun
, 0),
730 Fcons (make_save_value (data
, 0),
739 map_keymap_call (key
, val
, fun
, dummy
)
740 Lisp_Object key
, val
, fun
;
743 call2 (fun
, key
, val
);
746 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
747 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
748 FUNCTION is called with two arguments: the event that is bound, and
749 the definition it is bound to.
751 If KEYMAP has a parent, the parent's bindings are included as well.
752 This works recursively: if the parent has itself a parent, then the
753 grandparent's bindings are also included and so on.
754 usage: (map-keymap FUNCTION KEYMAP) */)
755 (function
, keymap
, sort_first
)
756 Lisp_Object function
, keymap
, sort_first
;
758 if (INTEGERP (function
))
759 /* We have to stop integers early since map_keymap gives them special
761 xsignal1 (Qinvalid_function
, function
);
762 if (! NILP (sort_first
))
763 return call3 (intern ("map-keymap-internal"), function
, keymap
, Qt
);
765 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
769 /* Given OBJECT which was found in a slot in a keymap,
770 trace indirect definitions to get the actual definition of that slot.
771 An indirect definition is a list of the form
772 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
773 and INDEX is the object to look up in KEYMAP to yield the definition.
775 Also if OBJECT has a menu string as the first element,
776 remove that. Also remove a menu help string as second element.
778 If AUTOLOAD is nonzero, load autoloadable keymaps
779 that are referred to with indirection.
781 This can GC because menu_item_eval_property calls Feval. */
784 get_keyelt (object
, autoload
)
790 if (!(CONSP (object
)))
791 /* This is really the value. */
794 /* If the keymap contents looks like (keymap ...) or (lambda ...)
796 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
799 /* If the keymap contents looks like (menu-item name . DEFN)
800 or (menu-item name DEFN ...) then use DEFN.
801 This is a new format menu item. */
802 else if (EQ (XCAR (object
), Qmenu_item
))
804 if (CONSP (XCDR (object
)))
808 object
= XCDR (XCDR (object
));
811 object
= XCAR (object
);
813 /* If there's a `:filter FILTER', apply FILTER to the
814 menu-item's definition to get the real definition to
816 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
817 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
820 filter
= XCAR (XCDR (tem
));
821 filter
= list2 (filter
, list2 (Qquote
, object
));
822 object
= menu_item_eval_property (filter
);
827 /* Invalid keymap. */
831 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
832 Keymap alist elements like (CHAR MENUSTRING . DEFN)
833 will be used by HierarKey menus. */
834 else if (STRINGP (XCAR (object
)))
836 object
= XCDR (object
);
837 /* Also remove a menu help string, if any,
838 following the menu item name. */
839 if (CONSP (object
) && STRINGP (XCAR (object
)))
840 object
= XCDR (object
);
841 /* Also remove the sublist that caches key equivalences, if any. */
842 if (CONSP (object
) && CONSP (XCAR (object
)))
845 carcar
= XCAR (XCAR (object
));
846 if (NILP (carcar
) || VECTORP (carcar
))
847 object
= XCDR (object
);
851 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
857 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
859 return (!CONSP (map
) ? object
/* Invalid keymap */
860 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
866 store_in_keymap (keymap
, idx
, def
)
868 register Lisp_Object idx
;
871 /* Flush any reverse-map cache. */
872 where_is_cache
= Qnil
;
873 where_is_cache_keymaps
= Qt
;
875 /* If we are preparing to dump, and DEF is a menu element
876 with a menu item indicator, copy it to ensure it is not pure. */
877 if (CONSP (def
) && PURE_P (def
)
878 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
879 def
= Fcons (XCAR (def
), XCDR (def
));
881 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
882 error ("attempt to define a key in a non-keymap");
884 /* If idx is a list (some sort of mouse click, perhaps?),
885 the index we want to use is the car of the list, which
886 ought to be a symbol. */
887 idx
= EVENT_HEAD (idx
);
889 /* If idx is a symbol, it might have modifiers, which need to
890 be put in the canonical order. */
892 idx
= reorder_modifiers (idx
);
893 else if (INTEGERP (idx
))
894 /* Clobber the high bits that can be present on a machine
895 with more than 24 bits of integer. */
896 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
898 /* Scan the keymap for a binding of idx. */
902 /* The cons after which we should insert new bindings. If the
903 keymap has a table element, we record its position here, so new
904 bindings will go after it; this way, the table will stay
905 towards the front of the alist and character lookups in dense
906 keymaps will remain fast. Otherwise, this just points at the
907 front of the keymap. */
908 Lisp_Object insertion_point
;
910 insertion_point
= keymap
;
911 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
918 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
921 ASET (elt
, XFASTINT (idx
), def
);
924 insertion_point
= tail
;
926 else if (CHAR_TABLE_P (elt
))
928 /* Character codes with modifiers
929 are not included in a char-table.
930 All character codes without modifiers are included. */
931 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
934 /* `nil' has a special meaning for char-tables, so
935 we use something else to record an explicitly
937 NILP (def
) ? Qt
: def
);
940 insertion_point
= tail
;
942 else if (CONSP (elt
))
944 if (EQ (idx
, XCAR (elt
)))
951 else if (EQ (elt
, Qkeymap
))
952 /* If we find a 'keymap' symbol in the spine of KEYMAP,
953 then we must have found the start of a second keymap
954 being used as the tail of KEYMAP, and a binding for IDX
955 should be inserted before it. */
962 /* We have scanned the entire keymap, and not found a binding for
963 IDX. Let's add one. */
964 CHECK_IMPURE (insertion_point
);
965 XSETCDR (insertion_point
,
966 Fcons (Fcons (idx
, def
), XCDR (insertion_point
)));
972 EXFUN (Fcopy_keymap
, 1);
975 copy_keymap_item (elt
)
978 Lisp_Object res
, tem
;
985 /* Is this a new format menu item. */
986 if (EQ (XCAR (tem
), Qmenu_item
))
988 /* Copy cell with menu-item marker. */
989 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
993 /* Copy cell with menu-item name. */
994 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1000 /* Copy cell with binding and if the binding is a keymap,
1002 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1005 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1006 XSETCAR (elt
, Fcopy_keymap (tem
));
1008 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1009 /* Delete cache for key equivalences. */
1010 XSETCDR (elt
, XCDR (tem
));
1015 /* It may be an old fomat menu item.
1016 Skip the optional menu string. */
1017 if (STRINGP (XCAR (tem
)))
1019 /* Copy the cell, since copy-alist didn't go this deep. */
1020 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1022 /* Also skip the optional menu help string. */
1023 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1025 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1029 /* There may also be a list that caches key equivalences.
1030 Just delete it for the new keymap. */
1032 && CONSP (XCAR (tem
))
1033 && (NILP (XCAR (XCAR (tem
)))
1034 || VECTORP (XCAR (XCAR (tem
)))))
1036 XSETCDR (elt
, XCDR (tem
));
1039 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1040 XSETCDR (elt
, Fcopy_keymap (tem
));
1042 else if (EQ (XCAR (tem
), Qkeymap
))
1043 res
= Fcopy_keymap (elt
);
1049 copy_keymap_1 (chartable
, idx
, elt
)
1050 Lisp_Object chartable
, idx
, elt
;
1052 Faset (chartable
, idx
, copy_keymap_item (elt
));
1055 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1056 doc
: /* Return a copy of the keymap KEYMAP.
1057 The copy starts out with the same definitions of KEYMAP,
1058 but changing either the copy or KEYMAP does not affect the other.
1059 Any key definitions that are subkeymaps are recursively copied.
1060 However, a key definition which is a symbol whose definition is a keymap
1065 register Lisp_Object copy
, tail
;
1066 keymap
= get_keymap (keymap
, 1, 0);
1067 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1068 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1070 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1072 Lisp_Object elt
= XCAR (keymap
);
1073 if (CHAR_TABLE_P (elt
))
1075 Lisp_Object indices
[3];
1076 elt
= Fcopy_sequence (elt
);
1077 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, elt
, 0, indices
);
1079 else if (VECTORP (elt
))
1082 elt
= Fcopy_sequence (elt
);
1083 for (i
= 0; i
< ASIZE (elt
); i
++)
1084 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1086 else if (CONSP (elt
))
1087 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1088 XSETCDR (tail
, Fcons (elt
, Qnil
));
1090 keymap
= XCDR (keymap
);
1092 XSETCDR (tail
, keymap
);
1096 /* Simple Keymap mutators and accessors. */
1098 /* GC is possible in this function if it autoloads a keymap. */
1100 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1101 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1104 KEY is a string or a vector of symbols and characters meaning a
1105 sequence of keystrokes and events. Non-ASCII characters with codes
1106 above 127 (such as ISO Latin-1) can be included if you use a vector.
1107 Using [t] for KEY creates a default definition, which applies to any
1108 event type that has no other definition in this keymap.
1110 DEF is anything that can be a key's definition:
1111 nil (means key is undefined in this keymap),
1112 a command (a Lisp function suitable for interactive calling),
1113 a string (treated as a keyboard macro),
1114 a keymap (to define a prefix key),
1115 a symbol (when the key is looked up, the symbol will stand for its
1116 function definition, which should at that time be one of the above,
1117 or another symbol whose function definition is used, etc.),
1118 a cons (STRING . DEFN), meaning that DEFN is the definition
1119 (DEFN should be a valid definition in its own right),
1120 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP.
1122 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1123 binding is altered. If there is no binding for KEY, the new pair
1124 binding KEY to DEF is added at the front of KEYMAP. */)
1131 register Lisp_Object c
;
1132 register Lisp_Object cmd
;
1136 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1138 GCPRO3 (keymap
, key
, def
);
1139 keymap
= get_keymap (keymap
, 1, 1);
1141 CHECK_VECTOR_OR_STRING (key
);
1143 length
= XFASTINT (Flength (key
));
1145 RETURN_UNGCPRO (Qnil
);
1147 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1148 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1150 meta_bit
= VECTORP (key
) ? meta_modifier
: 0x80;
1152 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, make_number (0))))
1153 { /* DEF is apparently an XEmacs-style keyboard macro. */
1154 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1155 int i
= ASIZE (def
);
1158 Lisp_Object c
= AREF (def
, i
);
1159 if (CONSP (c
) && lucid_event_type_list_p (c
))
1160 c
= Fevent_convert_list (c
);
1169 c
= Faref (key
, make_number (idx
));
1171 if (CONSP (c
) && lucid_event_type_list_p (c
))
1172 c
= Fevent_convert_list (c
);
1175 silly_event_symbol_error (c
);
1178 && (XINT (c
) & meta_bit
)
1181 c
= meta_prefix_char
;
1187 XSETINT (c
, XINT (c
) & ~meta_bit
);
1193 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1194 error ("Key sequence contains invalid event");
1197 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1199 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1201 /* If this key is undefined, make it a prefix. */
1203 cmd
= define_as_prefix (keymap
, c
);
1205 keymap
= get_keymap (cmd
, 0, 1);
1206 if (!CONSP (keymap
))
1207 /* We must use Fkey_description rather than just passing key to
1208 error; key might be a vector, not a string. */
1209 error ("Key sequence %s starts with non-prefix key %s",
1210 SDATA (Fkey_description (key
, Qnil
)),
1211 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1217 /* This function may GC (it calls Fkey_binding). */
1219 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 1, 0,
1220 doc
: /* Return the remapping for command COMMAND in current keymaps.
1221 Returns nil if COMMAND is not remapped (or not a symbol). */)
1223 Lisp_Object command
;
1225 if (!SYMBOLP (command
))
1228 ASET (command_remapping_vector
, 1, command
);
1229 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
);
1232 /* Value is number if KEY is too long; nil if valid but has no definition. */
1233 /* GC is possible in this function if it autoloads a keymap. */
1235 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1236 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1237 nil means undefined. See doc of `define-key' for kinds of definitions.
1239 A number as value means KEY is "too long";
1240 that is, characters or symbols in it except for the last one
1241 fail to be a valid sequence of prefix characters in KEYMAP.
1242 The number is how many characters at the front of KEY
1243 it takes to reach a non-prefix key.
1245 Normally, `lookup-key' ignores bindings for t, which act as default
1246 bindings, used when nothing else in the keymap applies; this makes it
1247 usable as a general function for probing keymaps. However, if the
1248 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1249 recognize the default bindings, just as `read-key-sequence' does. */)
1250 (keymap
, key
, accept_default
)
1253 Lisp_Object accept_default
;
1256 register Lisp_Object cmd
;
1257 register Lisp_Object c
;
1259 int t_ok
= !NILP (accept_default
);
1260 struct gcpro gcpro1
, gcpro2
;
1262 GCPRO2 (keymap
, key
);
1263 keymap
= get_keymap (keymap
, 1, 1);
1265 CHECK_VECTOR_OR_STRING (key
);
1267 length
= XFASTINT (Flength (key
));
1269 RETURN_UNGCPRO (keymap
);
1274 c
= Faref (key
, make_number (idx
++));
1276 if (CONSP (c
) && lucid_event_type_list_p (c
))
1277 c
= Fevent_convert_list (c
);
1279 /* Turn the 8th bit of string chars into a meta modifier. */
1280 if (INTEGERP (c
) && XINT (c
) & 0x80 && STRINGP (key
))
1281 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1283 /* Allow string since binding for `menu-bar-select-buffer'
1284 includes the buffer name in the key sequence. */
1285 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1286 error ("Key sequence contains invalid event");
1288 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1290 RETURN_UNGCPRO (cmd
);
1292 keymap
= get_keymap (cmd
, 0, 1);
1293 if (!CONSP (keymap
))
1294 RETURN_UNGCPRO (make_number (idx
));
1300 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1301 Assume that currently it does not define C at all.
1302 Return the keymap. */
1305 define_as_prefix (keymap
, c
)
1306 Lisp_Object keymap
, c
;
1310 cmd
= Fmake_sparse_keymap (Qnil
);
1311 /* If this key is defined as a prefix in an inherited keymap,
1312 make it a prefix in this map, and make its definition
1313 inherit the other prefix definition. */
1314 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1315 store_in_keymap (keymap
, c
, cmd
);
1320 /* Append a key to the end of a key sequence. We always make a vector. */
1323 append_key (key_sequence
, key
)
1324 Lisp_Object key_sequence
, key
;
1326 Lisp_Object args
[2];
1328 args
[0] = key_sequence
;
1330 args
[1] = Fcons (key
, Qnil
);
1331 return Fvconcat (2, args
);
1334 /* Given a event type C which is a symbol,
1335 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1338 silly_event_symbol_error (c
)
1341 Lisp_Object parsed
, base
, name
, assoc
;
1344 parsed
= parse_modifiers (c
);
1345 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1346 base
= XCAR (parsed
);
1347 name
= Fsymbol_name (base
);
1348 /* This alist includes elements such as ("RET" . "\\r"). */
1349 assoc
= Fassoc (name
, exclude_keys
);
1353 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1355 Lisp_Object keystring
;
1356 if (modifiers
& alt_modifier
)
1357 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1358 if (modifiers
& ctrl_modifier
)
1359 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1360 if (modifiers
& hyper_modifier
)
1361 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1362 if (modifiers
& meta_modifier
)
1363 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1364 if (modifiers
& shift_modifier
)
1365 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1366 if (modifiers
& super_modifier
)
1367 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1370 c
= reorder_modifiers (c
);
1371 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1373 error ((modifiers
& ~meta_modifier
1374 ? "To bind the key %s, use [?%s], not [%s]"
1375 : "To bind the key %s, use \"%s\", not [%s]"),
1376 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1377 SDATA (SYMBOL_NAME (c
)));
1381 /* Global, local, and minor mode keymap stuff. */
1383 /* We can't put these variables inside current_minor_maps, since under
1384 some systems, static gets macro-defined to be the empty string.
1386 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1387 static int cmm_size
= 0;
1389 /* Store a pointer to an array of the keymaps of the currently active
1390 minor modes in *buf, and return the number of maps it contains.
1392 This function always returns a pointer to the same buffer, and may
1393 free or reallocate it, so if you want to keep it for a long time or
1394 hand it out to lisp code, copy it. This procedure will be called
1395 for every key sequence read, so the nice lispy approach (return a
1396 new assoclist, list, what have you) for each invocation would
1397 result in a lot of consing over time.
1399 If we used xrealloc/xmalloc and ran out of memory, they would throw
1400 back to the command loop, which would try to read a key sequence,
1401 which would call this function again, resulting in an infinite
1402 loop. Instead, we'll use realloc/malloc and silently truncate the
1403 list, let the key sequence be read, and hope some other piece of
1404 code signals the error. */
1406 current_minor_maps (modeptr
, mapptr
)
1407 Lisp_Object
**modeptr
, **mapptr
;
1410 int list_number
= 0;
1411 Lisp_Object alist
, assoc
, var
, val
;
1412 Lisp_Object emulation_alists
;
1413 Lisp_Object lists
[2];
1415 emulation_alists
= Vemulation_mode_map_alists
;
1416 lists
[0] = Vminor_mode_overriding_map_alist
;
1417 lists
[1] = Vminor_mode_map_alist
;
1419 for (list_number
= 0; list_number
< 2; list_number
++)
1421 if (CONSP (emulation_alists
))
1423 alist
= XCAR (emulation_alists
);
1424 emulation_alists
= XCDR (emulation_alists
);
1425 if (SYMBOLP (alist
))
1426 alist
= find_symbol_value (alist
);
1430 alist
= lists
[list_number
];
1432 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1433 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1434 && (var
= XCAR (assoc
), SYMBOLP (var
))
1435 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1440 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1441 and also an entry in Vminor_mode_map_alist,
1442 ignore the latter. */
1443 if (list_number
== 1)
1445 val
= assq_no_quit (var
, lists
[0]);
1452 int newsize
, allocsize
;
1453 Lisp_Object
*newmodes
, *newmaps
;
1455 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1456 allocsize
= newsize
* sizeof *newmodes
;
1458 /* Use malloc here. See the comment above this function.
1459 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1461 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1466 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1469 cmm_modes
= newmodes
;
1472 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1477 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1484 if (newmodes
== NULL
|| newmaps
== NULL
)
1489 /* Get the keymap definition--or nil if it is not defined. */
1490 temp
= Findirect_function (XCDR (assoc
), Qt
);
1494 cmm_maps
[i
] = temp
;
1500 if (modeptr
) *modeptr
= cmm_modes
;
1501 if (mapptr
) *mapptr
= cmm_maps
;
1505 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1507 doc
: /* Return a list of the currently active keymaps.
1508 OLP if non-nil indicates that we should obey `overriding-local-map' and
1509 `overriding-terminal-local-map'. */)
1513 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1517 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1518 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1519 /* The doc said that overriding-terminal-local-map should
1520 override overriding-local-map. The code used them both,
1521 but it seems clearer to use just one. rms, jan 2005. */
1522 else if (!NILP (Voverriding_local_map
))
1523 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1525 if (NILP (XCDR (keymaps
)))
1531 /* This usually returns the buffer's local map,
1532 but that can be overridden by a `local-map' property. */
1533 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1535 keymaps
= Fcons (local
, keymaps
);
1537 /* Now put all the minor mode keymaps on the list. */
1538 nmaps
= current_minor_maps (0, &maps
);
1540 for (i
= --nmaps
; i
>= 0; i
--)
1541 if (!NILP (maps
[i
]))
1542 keymaps
= Fcons (maps
[i
], keymaps
);
1544 /* This returns nil unless there is a `keymap' property. */
1545 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1547 keymaps
= Fcons (local
, keymaps
);
1553 /* GC is possible in this function if it autoloads a keymap. */
1555 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 3, 0,
1556 doc
: /* Return the binding for command KEY in current keymaps.
1557 KEY is a string or vector, a sequence of keystrokes.
1558 The binding is probably a symbol with a function definition.
1560 Normally, `key-binding' ignores bindings for t, which act as default
1561 bindings, used when nothing else in the keymap applies; this makes it
1562 usable as a general function for probing keymaps. However, if the
1563 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1564 recognize the default bindings, just as `read-key-sequence' does.
1566 Like the normal command loop, `key-binding' will remap the command
1567 resulting from looking up KEY by looking up the command in the
1568 current keymaps. However, if the optional third argument NO-REMAP
1569 is non-nil, `key-binding' returns the unmapped command. */)
1570 (key
, accept_default
, no_remap
)
1571 Lisp_Object key
, accept_default
, no_remap
;
1573 Lisp_Object
*maps
, value
;
1575 struct gcpro gcpro1
;
1579 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1581 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1582 key
, accept_default
);
1583 if (! NILP (value
) && !INTEGERP (value
))
1586 else if (!NILP (Voverriding_local_map
))
1588 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1589 if (! NILP (value
) && !INTEGERP (value
))
1596 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1599 value
= Flookup_key (local
, key
, accept_default
);
1600 if (! NILP (value
) && !INTEGERP (value
))
1604 nmaps
= current_minor_maps (0, &maps
);
1605 /* Note that all these maps are GCPRO'd
1606 in the places where we found them. */
1608 for (i
= 0; i
< nmaps
; i
++)
1609 if (! NILP (maps
[i
]))
1611 value
= Flookup_key (maps
[i
], key
, accept_default
);
1612 if (! NILP (value
) && !INTEGERP (value
))
1616 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1619 value
= Flookup_key (local
, key
, accept_default
);
1620 if (! NILP (value
) && !INTEGERP (value
))
1625 value
= Flookup_key (current_global_map
, key
, accept_default
);
1629 if (NILP (value
) || INTEGERP (value
))
1632 /* If the result of the ordinary keymap lookup is an interactive
1633 command, look for a key binding (ie. remapping) for that command. */
1635 if (NILP (no_remap
) && SYMBOLP (value
))
1638 if (value1
= Fcommand_remapping (value
), !NILP (value1
))
1645 /* GC is possible in this function if it autoloads a keymap. */
1647 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1648 doc
: /* Return the binding for command KEYS in current local keymap only.
1649 KEYS is a string or vector, a sequence of keystrokes.
1650 The binding is probably a symbol with a function definition.
1652 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1653 bindings; see the description of `lookup-key' for more details about this. */)
1654 (keys
, accept_default
)
1655 Lisp_Object keys
, accept_default
;
1657 register Lisp_Object map
;
1658 map
= current_buffer
->keymap
;
1661 return Flookup_key (map
, keys
, accept_default
);
1664 /* GC is possible in this function if it autoloads a keymap. */
1666 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1667 doc
: /* Return the binding for command KEYS in current global keymap only.
1668 KEYS is a string or vector, a sequence of keystrokes.
1669 The binding is probably a symbol with a function definition.
1670 This function's return values are the same as those of `lookup-key'
1673 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1674 bindings; see the description of `lookup-key' for more details about this. */)
1675 (keys
, accept_default
)
1676 Lisp_Object keys
, accept_default
;
1678 return Flookup_key (current_global_map
, keys
, accept_default
);
1681 /* GC is possible in this function if it autoloads a keymap. */
1683 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1684 doc
: /* Find the visible minor mode bindings of KEY.
1685 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1686 the symbol which names the minor mode binding KEY, and BINDING is
1687 KEY's definition in that mode. In particular, if KEY has no
1688 minor-mode bindings, return nil. If the first binding is a
1689 non-prefix, all subsequent bindings will be omitted, since they would
1690 be ignored. Similarly, the list doesn't include non-prefix bindings
1691 that come after prefix bindings.
1693 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1694 bindings; see the description of `lookup-key' for more details about this. */)
1695 (key
, accept_default
)
1696 Lisp_Object key
, accept_default
;
1698 Lisp_Object
*modes
, *maps
;
1700 Lisp_Object binding
;
1702 struct gcpro gcpro1
, gcpro2
;
1704 nmaps
= current_minor_maps (&modes
, &maps
);
1705 /* Note that all these maps are GCPRO'd
1706 in the places where we found them. */
1709 GCPRO2 (key
, binding
);
1711 for (i
= j
= 0; i
< nmaps
; i
++)
1713 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1714 && !INTEGERP (binding
))
1716 if (KEYMAPP (binding
))
1717 maps
[j
++] = Fcons (modes
[i
], binding
);
1719 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1723 return Flist (j
, maps
);
1726 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1727 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1728 A new sparse keymap is stored as COMMAND's function definition and its value.
1729 If a second optional argument MAPVAR is given, the map is stored as
1730 its value instead of as COMMAND's value; but COMMAND is still defined
1732 The third optional argument NAME, if given, supplies a menu name
1733 string for the map. This is required to use the keymap as a menu.
1734 This function returns COMMAND. */)
1735 (command
, mapvar
, name
)
1736 Lisp_Object command
, mapvar
, name
;
1739 map
= Fmake_sparse_keymap (name
);
1740 Ffset (command
, map
);
1744 Fset (command
, map
);
1748 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1749 doc
: /* Select KEYMAP as the global keymap. */)
1753 keymap
= get_keymap (keymap
, 1, 1);
1754 current_global_map
= keymap
;
1759 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1760 doc
: /* Select KEYMAP as the local keymap.
1761 If KEYMAP is nil, that means no local keymap. */)
1766 keymap
= get_keymap (keymap
, 1, 1);
1768 current_buffer
->keymap
= keymap
;
1773 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1774 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1777 return current_buffer
->keymap
;
1780 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1781 doc
: /* Return the current global keymap. */)
1784 return current_global_map
;
1787 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1788 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1792 int nmaps
= current_minor_maps (0, &maps
);
1794 return Flist (nmaps
, maps
);
1797 /* Help functions for describing and documenting keymaps. */
1801 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1802 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1803 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1807 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
1811 /* Look for and break cycles. */
1812 while (!NILP (tem
= Frassq (cmd
, maps
)))
1814 Lisp_Object prefix
= XCAR (tem
);
1815 int lim
= XINT (Flength (XCAR (tem
)));
1816 if (lim
<= XINT (Flength (thisseq
)))
1817 { /* This keymap was already seen with a smaller prefix. */
1819 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
1820 Faref (thisseq
, make_number (i
))))
1823 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1826 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1827 but maybe `cmd' occurs again further down in `maps', so keep
1829 maps
= XCDR (Fmemq (tem
, maps
));
1832 /* If the last key in thisseq is meta-prefix-char,
1833 turn it into a meta-ized keystroke. We know
1834 that the event we're about to append is an
1835 ascii keystroke since we're processing a
1839 int meta_bit
= meta_modifier
;
1840 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1841 tem
= Fcopy_sequence (thisseq
);
1843 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1845 /* This new sequence is the same length as
1846 thisseq, so stick it in the list right
1849 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1853 tem
= append_key (thisseq
, key
);
1854 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1859 accessible_keymaps_char_table (args
, index
, cmd
)
1860 Lisp_Object args
, index
, cmd
;
1862 accessible_keymaps_1 (index
, cmd
,
1866 XINT (XCDR (XCAR (args
))));
1869 /* This function cannot GC. */
1871 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1873 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1874 Returns a list of elements of the form (KEYS . MAP), where the sequence
1875 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1876 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1877 An optional argument PREFIX, if non-nil, should be a key sequence;
1878 then the value includes only maps for prefixes that start with PREFIX. */)
1880 Lisp_Object keymap
, prefix
;
1882 Lisp_Object maps
, tail
;
1885 /* no need for gcpro because we don't autoload any keymaps. */
1888 prefixlen
= XINT (Flength (prefix
));
1892 /* If a prefix was specified, start with the keymap (if any) for
1893 that prefix, so we don't waste time considering other prefixes. */
1895 tem
= Flookup_key (keymap
, prefix
, Qt
);
1896 /* Flookup_key may give us nil, or a number,
1897 if the prefix is not defined in this particular map.
1898 It might even give us a list that isn't a keymap. */
1899 tem
= get_keymap (tem
, 0, 0);
1902 /* Convert PREFIX to a vector now, so that later on
1903 we don't have to deal with the possibility of a string. */
1904 if (STRINGP (prefix
))
1909 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
1910 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
1914 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1915 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1916 c
^= 0200 | meta_modifier
;
1917 ASET (copy
, i_before
, make_number (c
));
1921 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1927 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1928 get_keymap (keymap
, 1, 0)),
1931 /* For each map in the list maps,
1932 look at any other maps it points to,
1933 and stick them at the end if they are not already in the list.
1935 This is a breadth-first traversal, where tail is the queue of
1936 nodes, and maps accumulates a list of all nodes visited. */
1938 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1940 register Lisp_Object thisseq
, thismap
;
1942 /* Does the current sequence end in the meta-prefix-char? */
1945 thisseq
= Fcar (Fcar (tail
));
1946 thismap
= Fcdr (Fcar (tail
));
1947 last
= make_number (XINT (Flength (thisseq
)) - 1);
1948 is_metized
= (XINT (last
) >= 0
1949 /* Don't metize the last char of PREFIX. */
1950 && XINT (last
) >= prefixlen
1951 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1953 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1957 elt
= XCAR (thismap
);
1961 if (CHAR_TABLE_P (elt
))
1963 Lisp_Object indices
[3];
1965 map_char_table (accessible_keymaps_char_table
, Qnil
, elt
,
1966 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1967 Fcons (tail
, thisseq
)),
1970 else if (VECTORP (elt
))
1974 /* Vector keymap. Scan all the elements. */
1975 for (i
= 0; i
< ASIZE (elt
); i
++)
1976 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1977 maps
, tail
, thisseq
, is_metized
);
1980 else if (CONSP (elt
))
1981 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
1982 maps
, tail
, thisseq
,
1983 is_metized
&& INTEGERP (XCAR (elt
)));
1991 Lisp_Object Qsingle_key_description
, Qkey_description
;
1993 /* This function cannot GC. */
1995 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
1996 doc
: /* Return a pretty description of key-sequence KEYS.
1997 Optional arg PREFIX is the sequence of keys leading up to KEYS.
1998 Control characters turn into "C-foo" sequences, meta into "M-foo",
1999 spaces are put between sequence elements, etc. */)
2001 Lisp_Object keys
, prefix
;
2006 int size
= XINT (Flength (keys
));
2008 Lisp_Object sep
= build_string (" ");
2013 size
+= XINT (Flength (prefix
));
2015 /* This has one extra element at the end that we don't pass to Fconcat. */
2016 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2018 /* In effect, this computes
2019 (mapconcat 'single-key-description keys " ")
2020 but we shouldn't use mapconcat because it can do GC. */
2024 list
= prefix
, prefix
= Qnil
;
2025 else if (!NILP (keys
))
2026 list
= keys
, keys
= Qnil
;
2031 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2035 return empty_string
;
2036 return Fconcat (len
- 1, args
);
2040 size
= SCHARS (list
);
2041 else if (VECTORP (list
))
2042 size
= XVECTOR (list
)->size
;
2043 else if (CONSP (list
))
2044 size
= XINT (Flength (list
));
2046 wrong_type_argument (Qarrayp
, list
);
2055 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2056 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2057 c
^= 0200 | meta_modifier
;
2058 XSETFASTINT (key
, c
);
2060 else if (VECTORP (list
))
2062 key
= AREF (list
, i
++);
2074 || EQ (key
, meta_prefix_char
)
2075 || (XINT (key
) & meta_modifier
))
2077 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2079 if (EQ (key
, meta_prefix_char
))
2083 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2086 else if (EQ (key
, meta_prefix_char
))
2091 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2099 push_key_description (c
, p
, force_multibyte
)
2100 register unsigned int c
;
2102 int force_multibyte
;
2107 /* Clear all the meaningless bits above the meta bit. */
2108 c
&= meta_modifier
| ~ - meta_modifier
;
2109 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2110 | meta_modifier
| shift_modifier
| super_modifier
);
2112 valid_p
= SINGLE_BYTE_CHAR_P (c2
) || char_valid_p (c2
, 0);
2115 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2116 p
+= sprintf (p
, "[%d]", c
);
2120 if (c
& alt_modifier
)
2126 if ((c
& ctrl_modifier
) != 0
2127 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2131 c
&= ~ctrl_modifier
;
2133 if (c
& hyper_modifier
)
2137 c
-= hyper_modifier
;
2139 if (c
& meta_modifier
)
2145 if (c
& shift_modifier
)
2149 c
-= shift_modifier
;
2151 if (c
& super_modifier
)
2155 c
-= super_modifier
;
2171 else if (c
== Ctl ('M'))
2179 /* `C-' already added above. */
2180 if (c
> 0 && c
<= Ctl ('Z'))
2199 || (NILP (current_buffer
->enable_multibyte_characters
)
2200 && SINGLE_BYTE_CHAR_P (c
)
2201 && !force_multibyte
))
2207 if (force_multibyte
)
2209 if (SINGLE_BYTE_CHAR_P (c
))
2210 c
= unibyte_char_to_multibyte (c
);
2211 p
+= CHAR_STRING (c
, p
);
2213 else if (NILP (current_buffer
->enable_multibyte_characters
))
2217 /* The biggest character code uses 19 bits. */
2218 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
2220 if (c
>= (1 << bit_offset
))
2221 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
2225 p
+= CHAR_STRING (c
, p
);
2231 /* This function cannot GC. */
2233 DEFUN ("single-key-description", Fsingle_key_description
,
2234 Ssingle_key_description
, 1, 2, 0,
2235 doc
: /* Return a pretty description of command character KEY.
2236 Control characters turn into C-whatever, etc.
2237 Optional argument NO-ANGLES non-nil means don't put angle brackets
2238 around function keys and event symbols. */)
2240 Lisp_Object key
, no_angles
;
2242 if (CONSP (key
) && lucid_event_type_list_p (key
))
2243 key
= Fevent_convert_list (key
);
2245 key
= EVENT_HEAD (key
);
2247 if (INTEGERP (key
)) /* Normal character */
2249 unsigned int charset
, c1
, c2
;
2250 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
2252 if (SINGLE_BYTE_CHAR_P (without_bits
))
2255 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
2258 && CHARSET_DEFINED_P (charset
)
2259 && ((c1
>= 0 && c1
< 32)
2260 || (c2
>= 0 && c2
< 32)))
2262 /* Handle a generic character. */
2264 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
2265 CHECK_STRING (name
);
2266 return concat2 (build_string ("Character set "), name
);
2270 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
2274 end
= push_key_description (XUINT (key
), tem
, 1);
2276 nchars
= multibyte_chars_in_text (tem
, nbytes
);
2277 if (nchars
== nbytes
)
2280 string
= build_string (tem
);
2283 string
= make_multibyte_string (tem
, nchars
, nbytes
);
2287 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2289 if (NILP (no_angles
))
2292 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2293 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2294 return build_string (buffer
);
2297 return Fsymbol_name (key
);
2299 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2300 return Fcopy_sequence (key
);
2302 error ("KEY must be an integer, cons, symbol, or string");
2307 push_text_char_description (c
, p
)
2308 register unsigned int c
;
2320 *p
++ = c
+ 64; /* 'A' - 1 */
2332 /* This function cannot GC. */
2334 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2335 doc
: /* Return a pretty description of file-character CHARACTER.
2336 Control characters turn into "^char", etc. This differs from
2337 `single-key-description' which turns them into "C-char".
2338 Also, this function recognizes the 2**7 bit as the Meta character,
2339 whereas `single-key-description' uses the 2**27 bit for Meta.
2340 See Info node `(elisp)Describing Characters' for examples. */)
2342 Lisp_Object character
;
2344 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2345 unsigned char str
[6];
2348 CHECK_NUMBER (character
);
2350 c
= XINT (character
);
2351 if (!SINGLE_BYTE_CHAR_P (c
))
2353 int len
= CHAR_STRING (c
, str
);
2355 return make_multibyte_string (str
, 1, len
);
2358 *push_text_char_description (c
& 0377, str
) = 0;
2360 return build_string (str
);
2363 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2366 ascii_sequence_p (seq
)
2370 int len
= XINT (Flength (seq
));
2372 for (i
= 0; i
< len
; i
++)
2374 Lisp_Object ii
, elt
;
2376 XSETFASTINT (ii
, i
);
2377 elt
= Faref (seq
, ii
);
2380 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2388 /* where-is - finding a command in a set of keymaps. */
2390 static Lisp_Object
where_is_internal ();
2391 static Lisp_Object
where_is_internal_1 ();
2392 static void where_is_internal_2 ();
2394 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2395 Returns the first non-nil binding found in any of those maps. */
2398 shadow_lookup (shadow
, key
, flag
)
2399 Lisp_Object shadow
, key
, flag
;
2401 Lisp_Object tail
, value
;
2403 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2405 value
= Flookup_key (XCAR (tail
), key
, flag
);
2406 if (NATNUMP (value
))
2408 value
= Flookup_key (XCAR (tail
),
2409 Fsubstring (key
, make_number (0), value
), flag
);
2413 else if (!NILP (value
))
2419 static Lisp_Object Vmouse_events
;
2421 /* This function can GC if Flookup_key autoloads any keymaps. */
2424 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2425 Lisp_Object definition
, keymaps
;
2426 Lisp_Object firstonly
, noindirect
, no_remap
;
2428 Lisp_Object maps
= Qnil
;
2429 Lisp_Object found
, sequences
;
2430 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2431 /* 1 means ignore all menu bindings entirely. */
2432 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2434 /* If this command is remapped, then it has no key bindings
2436 if (NILP (no_remap
) && SYMBOLP (definition
))
2439 if (tem
= Fcommand_remapping (definition
), !NILP (tem
))
2444 while (CONSP (found
))
2448 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2449 found
= XCDR (found
);
2452 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2456 for (; !NILP (maps
); maps
= Fcdr (maps
))
2458 /* Key sequence to reach map, and the map that it reaches */
2459 register Lisp_Object
this, map
, tem
;
2461 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2462 [M-CHAR] sequences, check if last character of the sequence
2463 is the meta-prefix char. */
2467 this = Fcar (Fcar (maps
));
2468 map
= Fcdr (Fcar (maps
));
2469 last
= make_number (XINT (Flength (this)) - 1);
2470 last_is_meta
= (XINT (last
) >= 0
2471 && EQ (Faref (this, last
), meta_prefix_char
));
2473 /* if (nomenus && !ascii_sequence_p (this)) */
2474 if (nomenus
&& XINT (last
) >= 0
2475 && SYMBOLP (tem
= Faref (this, make_number (0)))
2476 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2477 /* If no menu entries should be returned, skip over the
2478 keymaps bound to `menu-bar' and `tool-bar' and other
2479 non-ascii prefixes like `C-down-mouse-2'. */
2486 /* Because the code we want to run on each binding is rather
2487 large, we don't want to have two separate loop bodies for
2488 sparse keymap bindings and tables; we want to iterate one
2489 loop body over both keymap and vector bindings.
2491 For this reason, if Fcar (map) is a vector, we don't
2492 advance map to the next element until i indicates that we
2493 have finished off the vector. */
2494 Lisp_Object elt
, key
, binding
;
2502 /* Set key and binding to the current key and binding, and
2503 advance map and i to the next binding. */
2506 Lisp_Object sequence
;
2508 /* In a vector, look at each element. */
2509 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2511 binding
= AREF (elt
, i
);
2512 XSETFASTINT (key
, i
);
2513 sequence
= where_is_internal_1 (binding
, key
, definition
,
2515 last
, nomenus
, last_is_meta
);
2516 if (!NILP (sequence
))
2517 sequences
= Fcons (sequence
, sequences
);
2520 else if (CHAR_TABLE_P (elt
))
2522 Lisp_Object indices
[3];
2525 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2526 Qnil
), /* Result accumulator. */
2527 Fcons (Fcons (this, last
),
2528 Fcons (make_number (nomenus
),
2529 make_number (last_is_meta
))));
2530 map_char_table (where_is_internal_2
, Qnil
, elt
, elt
, args
,
2532 sequences
= XCDR (XCAR (args
));
2534 else if (CONSP (elt
))
2536 Lisp_Object sequence
;
2539 binding
= XCDR (elt
);
2541 sequence
= where_is_internal_1 (binding
, key
, definition
,
2543 last
, nomenus
, last_is_meta
);
2544 if (!NILP (sequence
))
2545 sequences
= Fcons (sequence
, sequences
);
2549 while (!NILP (sequences
))
2551 Lisp_Object sequence
, remapped
, function
;
2553 sequence
= XCAR (sequences
);
2554 sequences
= XCDR (sequences
);
2556 /* If the current sequence is a command remapping with
2557 format [remap COMMAND], find the key sequences
2558 which run COMMAND, and use those sequences instead. */
2561 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2562 && EQ (AREF (sequence
, 0), Qremap
)
2563 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2565 Lisp_Object remapped1
;
2567 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2568 if (CONSP (remapped1
))
2570 /* Verify that this key binding actually maps to the
2571 remapped command (see below). */
2572 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2574 sequence
= XCAR (remapped1
);
2575 remapped
= XCDR (remapped1
);
2576 goto record_sequence
;
2580 /* Verify that this key binding is not shadowed by another
2581 binding for the same key, before we say it exists.
2583 Mechanism: look for local definition of this key and if
2584 it is defined and does not match what we found then
2587 Either nil or number as value from Flookup_key
2589 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2593 /* Don't annoy user with strings from a menu such as
2594 Select Paste. Change them all to "(any string)",
2595 so that there seems to be only one menu item
2597 if (! NILP (sequence
))
2600 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2602 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2603 build_string ("(any string)"));
2606 /* It is a true unshadowed match. Record it, unless it's already
2607 been seen (as could happen when inheriting keymaps). */
2608 if (NILP (Fmember (sequence
, found
)))
2609 found
= Fcons (sequence
, found
);
2611 /* If firstonly is Qnon_ascii, then we can return the first
2612 binding we find. If firstonly is not Qnon_ascii but not
2613 nil, then we should return the first ascii-only binding
2615 if (EQ (firstonly
, Qnon_ascii
))
2616 RETURN_UNGCPRO (sequence
);
2617 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2618 RETURN_UNGCPRO (sequence
);
2620 if (CONSP (remapped
))
2622 sequence
= XCAR (remapped
);
2623 remapped
= XCDR (remapped
);
2624 goto record_sequence
;
2632 found
= Fnreverse (found
);
2634 /* firstonly may have been t, but we may have gone all the way through
2635 the keymaps without finding an all-ASCII key sequence. So just
2636 return the best we could find. */
2637 if (!NILP (firstonly
))
2638 return Fcar (found
);
2643 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2644 doc
: /* Return list of keys that invoke DEFINITION.
2645 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2646 If KEYMAP is nil, search all the currently active keymaps.
2647 If KEYMAP is a list of keymaps, search only those keymaps.
2649 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2650 rather than a list of all possible key sequences.
2651 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2652 no matter what it is.
2653 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2654 \(or their meta variants) and entirely reject menu bindings.
2656 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2657 to other keymaps or slots. This makes it possible to search for an
2658 indirect definition itself.
2660 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2661 that invoke a command which is remapped to DEFINITION, but include the
2662 remapped command in the returned list. */)
2663 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2664 Lisp_Object definition
, keymap
;
2665 Lisp_Object firstonly
, noindirect
, no_remap
;
2667 Lisp_Object sequences
, keymaps
;
2668 /* 1 means ignore all menu bindings entirely. */
2669 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2672 /* Find the relevant keymaps. */
2673 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2675 else if (!NILP (keymap
))
2676 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2678 keymaps
= Fcurrent_active_maps (Qnil
);
2680 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2681 We don't really need to check `keymap'. */
2682 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2686 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2688 /* Check heuristic-consistency of the cache. */
2689 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2690 where_is_cache
= Qnil
;
2692 if (NILP (where_is_cache
))
2694 /* We need to create the cache. */
2695 Lisp_Object args
[2];
2696 where_is_cache
= Fmake_hash_table (0, args
);
2697 where_is_cache_keymaps
= Qt
;
2699 /* Fill in the cache. */
2700 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2701 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2704 where_is_cache_keymaps
= keymaps
;
2707 /* We want to process definitions from the last to the first.
2708 Instead of consing, copy definitions to a vector and step
2709 over that vector. */
2710 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2711 n
= XINT (Flength (sequences
));
2712 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2713 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2714 defns
[i
++] = XCAR (sequences
);
2716 /* Verify that the key bindings are not shadowed. Note that
2717 the following can GC. */
2718 GCPRO2 (definition
, keymaps
);
2721 for (i
= n
- 1; i
>= 0; --i
)
2722 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2724 if (ascii_sequence_p (defns
[i
]))
2730 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2735 /* Kill the cache so that where_is_internal_1 doesn't think
2736 we're filling it up. */
2737 where_is_cache
= Qnil
;
2738 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2744 /* This is the function that Fwhere_is_internal calls using map_char_table.
2746 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2748 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2749 Since map_char_table doesn't really use the return value from this function,
2750 we the result append to RESULT, the slot in ARGS.
2752 This function can GC because it calls where_is_internal_1 which can
2756 where_is_internal_2 (args
, key
, binding
)
2757 Lisp_Object args
, key
, binding
;
2759 Lisp_Object definition
, noindirect
, this, last
;
2760 Lisp_Object result
, sequence
;
2761 int nomenus
, last_is_meta
;
2762 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2764 GCPRO3 (args
, key
, binding
);
2765 result
= XCDR (XCAR (args
));
2766 definition
= XCAR (XCAR (XCAR (args
)));
2767 noindirect
= XCDR (XCAR (XCAR (args
)));
2768 this = XCAR (XCAR (XCDR (args
)));
2769 last
= XCDR (XCAR (XCDR (args
)));
2770 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2771 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2773 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2774 this, last
, nomenus
, last_is_meta
);
2776 if (!NILP (sequence
))
2777 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2783 /* This function can GC because get_keyelt can. */
2786 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2787 nomenus
, last_is_meta
)
2788 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2789 int nomenus
, last_is_meta
;
2791 Lisp_Object sequence
;
2793 /* Search through indirections unless that's not wanted. */
2794 if (NILP (noindirect
))
2795 binding
= get_keyelt (binding
, 0);
2797 /* End this iteration if this element does not match
2800 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2801 || EQ (binding
, definition
)
2802 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2803 /* Doesn't match. */
2806 /* We have found a match. Construct the key sequence where we found it. */
2807 if (INTEGERP (key
) && last_is_meta
)
2809 sequence
= Fcopy_sequence (this);
2810 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2813 sequence
= append_key (this, key
);
2815 if (!NILP (where_is_cache
))
2817 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2818 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2825 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2827 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2828 doc
: /* Insert the list of all defined keys and their definitions.
2829 The list is inserted in the current buffer, while the bindings are
2830 looked up in BUFFER.
2831 The optional argument PREFIX, if non-nil, should be a key sequence;
2832 then we display only bindings that start with that prefix.
2833 The optional argument MENUS, if non-nil, says to mention menu bindings.
2834 \(Ordinarily these are omitted from the output.) */)
2835 (buffer
, prefix
, menus
)
2836 Lisp_Object buffer
, prefix
, menus
;
2838 Lisp_Object outbuf
, shadow
;
2839 int nomenu
= NILP (menus
);
2840 register Lisp_Object start1
;
2841 struct gcpro gcpro1
;
2843 char *alternate_heading
2845 Keyboard translations:\n\n\
2846 You type Translation\n\
2847 -------- -----------\n";
2852 outbuf
= Fcurrent_buffer ();
2854 /* Report on alternates for keys. */
2855 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2858 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2859 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2861 for (c
= 0; c
< translate_len
; c
++)
2862 if (translate
[c
] != c
)
2864 char buf
[KEY_DESCRIPTION_SIZE
];
2867 if (alternate_heading
)
2869 insert_string (alternate_heading
);
2870 alternate_heading
= 0;
2873 bufend
= push_key_description (translate
[c
], buf
, 1);
2874 insert (buf
, bufend
- buf
);
2875 Findent_to (make_number (16), make_number (1));
2876 bufend
= push_key_description (c
, buf
, 1);
2877 insert (buf
, bufend
- buf
);
2881 /* Insert calls signal_after_change which may GC. */
2882 translate
= SDATA (Vkeyboard_translate_table
);
2888 if (!NILP (Vkey_translation_map
))
2889 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2890 "Key translations", nomenu
, 1, 0, 0);
2893 /* Print the (major mode) local map. */
2895 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2896 start1
= current_kboard
->Voverriding_terminal_local_map
;
2897 else if (!NILP (Voverriding_local_map
))
2898 start1
= Voverriding_local_map
;
2902 describe_map_tree (start1
, 1, shadow
, prefix
,
2903 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
2904 shadow
= Fcons (start1
, shadow
);
2908 /* Print the minor mode and major mode keymaps. */
2910 Lisp_Object
*modes
, *maps
;
2912 /* Temporarily switch to `buffer', so that we can get that buffer's
2913 minor modes correctly. */
2914 Fset_buffer (buffer
);
2916 nmaps
= current_minor_maps (&modes
, &maps
);
2917 Fset_buffer (outbuf
);
2919 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2920 XBUFFER (buffer
), Qkeymap
);
2923 describe_map_tree (start1
, 1, shadow
, prefix
,
2924 "\f\n`keymap' Property Bindings", nomenu
,
2926 shadow
= Fcons (start1
, shadow
);
2929 /* Print the minor mode maps. */
2930 for (i
= 0; i
< nmaps
; i
++)
2932 /* The title for a minor mode keymap
2933 is constructed at run time.
2934 We let describe_map_tree do the actual insertion
2935 because it takes care of other features when doing so. */
2938 if (!SYMBOLP (modes
[i
]))
2941 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
2945 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
2946 SCHARS (SYMBOL_NAME (modes
[i
])));
2947 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
2949 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2950 p
+= sizeof (" Minor Mode Bindings") - 1;
2953 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
2954 title
, nomenu
, 0, 0, 0);
2955 shadow
= Fcons (maps
[i
], shadow
);
2958 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2959 XBUFFER (buffer
), Qlocal_map
);
2962 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
2963 describe_map_tree (start1
, 1, shadow
, prefix
,
2964 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
2966 describe_map_tree (start1
, 1, shadow
, prefix
,
2967 "\f\n`local-map' Property Bindings",
2970 shadow
= Fcons (start1
, shadow
);
2974 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2975 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
2977 /* Print the function-key-map translations under this prefix. */
2978 if (!NILP (Vfunction_key_map
))
2979 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2980 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
2986 /* Insert a description of the key bindings in STARTMAP,
2987 followed by those of all maps reachable through STARTMAP.
2988 If PARTIAL is nonzero, omit certain "uninteresting" commands
2989 (such as `undefined').
2990 If SHADOW is non-nil, it is a list of maps;
2991 don't mention keys which would be shadowed by any of them.
2992 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2993 TITLE, if not 0, is a string to insert at the beginning.
2994 TITLE should not end with a colon or a newline; we supply that.
2995 If NOMENU is not 0, then omit menu-bar commands.
2997 If TRANSL is nonzero, the definitions are actually key translations
2998 so print strings and vectors differently.
3000 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3003 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3004 don't omit it; instead, mention it but say it is shadowed. */
3007 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3008 always_title
, mention_shadow
)
3009 Lisp_Object startmap
, shadow
, prefix
;
3017 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3018 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3025 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3028 GCPRO3 (maps
, seen
, sub_shadows
);
3034 /* Delete from MAPS each element that is for the menu bar. */
3035 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3037 Lisp_Object elt
, prefix
, tem
;
3040 prefix
= Fcar (elt
);
3041 if (XVECTOR (prefix
)->size
>= 1)
3043 tem
= Faref (prefix
, make_number (0));
3044 if (EQ (tem
, Qmenu_bar
))
3045 maps
= Fdelq (elt
, maps
);
3050 if (!NILP (maps
) || always_title
)
3054 insert_string (title
);
3057 insert_string (" Starting With ");
3058 insert1 (Fkey_description (prefix
, Qnil
));
3060 insert_string (":\n");
3062 insert_string (key_heading
);
3066 for (; !NILP (maps
); maps
= Fcdr (maps
))
3068 register Lisp_Object elt
, prefix
, tail
;
3071 prefix
= Fcar (elt
);
3075 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3079 shmap
= XCAR (tail
);
3081 /* If the sequence by which we reach this keymap is zero-length,
3082 then the shadow map for this keymap is just SHADOW. */
3083 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3084 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3086 /* If the sequence by which we reach this keymap actually has
3087 some elements, then the sequence's definition in SHADOW is
3088 what we should use. */
3091 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3092 if (INTEGERP (shmap
))
3096 /* If shmap is not nil and not a keymap,
3097 it completely shadows this map, so don't
3098 describe this map at all. */
3099 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3103 sub_shadows
= Fcons (shmap
, sub_shadows
);
3106 /* Maps we have already listed in this loop shadow this map. */
3107 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3110 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3112 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3115 describe_map (Fcdr (elt
), prefix
,
3116 transl
? describe_translation
: describe_command
,
3117 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3123 insert_string ("\n");
3128 static int previous_description_column
;
3131 describe_command (definition
, args
)
3132 Lisp_Object definition
, args
;
3134 register Lisp_Object tem1
;
3135 int column
= (int) current_column (); /* iftc */
3136 int description_column
;
3138 /* If column 16 is no good, go to col 32;
3139 but don't push beyond that--go to next line instead. */
3143 description_column
= 32;
3145 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3146 description_column
= 32;
3148 description_column
= 16;
3150 Findent_to (make_number (description_column
), make_number (1));
3151 previous_description_column
= description_column
;
3153 if (SYMBOLP (definition
))
3155 tem1
= SYMBOL_NAME (definition
);
3157 insert_string ("\n");
3159 else if (STRINGP (definition
) || VECTORP (definition
))
3160 insert_string ("Keyboard Macro\n");
3161 else if (KEYMAPP (definition
))
3162 insert_string ("Prefix Command\n");
3164 insert_string ("??\n");
3168 describe_translation (definition
, args
)
3169 Lisp_Object definition
, args
;
3171 register Lisp_Object tem1
;
3173 Findent_to (make_number (16), make_number (1));
3175 if (SYMBOLP (definition
))
3177 tem1
= SYMBOL_NAME (definition
);
3179 insert_string ("\n");
3181 else if (STRINGP (definition
) || VECTORP (definition
))
3183 insert1 (Fkey_description (definition
, Qnil
));
3184 insert_string ("\n");
3186 else if (KEYMAPP (definition
))
3187 insert_string ("Prefix Command\n");
3189 insert_string ("??\n");
3192 /* describe_map puts all the usable elements of a sparse keymap
3193 into an array of `struct describe_map_elt',
3194 then sorts them by the events. */
3196 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3198 /* qsort comparison function for sorting `struct describe_map_elt' by
3202 describe_map_compare (aa
, bb
)
3203 const void *aa
, *bb
;
3205 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3206 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3207 return ((XINT (a
->event
) > XINT (b
->event
))
3208 - (XINT (a
->event
) < XINT (b
->event
)));
3209 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3211 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3213 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3214 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3215 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3220 /* Describe the contents of map MAP, assuming that this map itself is
3221 reached by the sequence of prefix keys PREFIX (a string or vector).
3222 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3225 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3226 seen
, nomenu
, mention_shadow
)
3227 register Lisp_Object map
;
3229 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3236 Lisp_Object tail
, definition
, event
;
3238 Lisp_Object suppress
;
3241 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3243 /* These accumulate the values from sparse keymap bindings,
3244 so we can sort them and handle them in order. */
3245 int length_needed
= 0;
3246 struct describe_map_elt
*vect
;
3253 suppress
= intern ("suppress-keymap");
3255 /* This vector gets used to present single keys to Flookup_key. Since
3256 that is done once per keymap element, we don't want to cons up a
3257 fresh vector every time. */
3258 kludge
= Fmake_vector (make_number (1), Qnil
);
3261 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3264 vect
= ((struct describe_map_elt
*)
3265 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3267 GCPRO3 (prefix
, definition
, kludge
);
3269 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3273 if (VECTORP (XCAR (tail
))
3274 || CHAR_TABLE_P (XCAR (tail
)))
3275 describe_vector (XCAR (tail
),
3276 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3277 (int *)0, 0, 1, mention_shadow
);
3278 else if (CONSP (XCAR (tail
)))
3280 int this_shadowed
= 0;
3282 event
= XCAR (XCAR (tail
));
3284 /* Ignore bindings whose "prefix" are not really valid events.
3285 (We get these in the frames and buffers menu.) */
3286 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3289 if (nomenu
&& EQ (event
, Qmenu_bar
))
3292 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3294 /* Don't show undefined commands or suppressed commands. */
3295 if (NILP (definition
)) continue;
3296 if (SYMBOLP (definition
) && partial
)
3298 tem
= Fget (definition
, suppress
);
3303 /* Don't show a command that isn't really visible
3304 because a local definition of the same key shadows it. */
3306 ASET (kludge
, 0, event
);
3309 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3312 /* Avoid generating duplicate entries if the
3313 shadowed binding has the same definition. */
3314 if (mention_shadow
&& !EQ (tem
, definition
))
3321 tem
= Flookup_key (map
, kludge
, Qt
);
3322 if (!EQ (tem
, definition
)) continue;
3324 vect
[slots_used
].event
= event
;
3325 vect
[slots_used
].definition
= definition
;
3326 vect
[slots_used
].shadowed
= this_shadowed
;
3329 else if (EQ (XCAR (tail
), Qkeymap
))
3331 /* The same keymap might be in the structure twice, if we're
3332 using an inherited keymap. So skip anything we've already
3334 tem
= Fassq (tail
, *seen
);
3335 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3337 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3341 /* If we found some sparse map events, sort them. */
3343 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3344 describe_map_compare
);
3346 /* Now output them in sorted order. */
3348 for (i
= 0; i
< slots_used
; i
++)
3350 Lisp_Object start
, end
;
3354 previous_description_column
= 0;
3359 ASET (kludge
, 0, vect
[i
].event
);
3360 start
= vect
[i
].event
;
3363 definition
= vect
[i
].definition
;
3365 /* Find consecutive chars that are identically defined. */
3366 if (INTEGERP (vect
[i
].event
))
3368 while (i
+ 1 < slots_used
3369 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3370 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3371 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3373 end
= vect
[i
].event
;
3376 /* Now START .. END is the range to describe next. */
3378 /* Insert the string to describe the event START. */
3379 insert1 (Fkey_description (kludge
, prefix
));
3381 if (!EQ (start
, end
))
3385 ASET (kludge
, 0, end
);
3386 /* Insert the string to describe the character END. */
3387 insert1 (Fkey_description (kludge
, prefix
));
3390 /* Print a description of the definition of this character.
3391 elt_describer will take care of spacing out far enough
3392 for alignment purposes. */
3393 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3395 if (vect
[i
].shadowed
)
3398 insert_string ("\n (that binding is currently shadowed by another mode)");
3407 describe_vector_princ (elt
, fun
)
3408 Lisp_Object elt
, fun
;
3410 Findent_to (make_number (16), make_number (1));
3415 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3416 doc
: /* Insert a description of contents of VECTOR.
3417 This is text showing the elements of vector matched against indices.
3418 DESCRIBER is the output function used; nil means use `princ'. */)
3420 Lisp_Object vector
, describer
;
3422 int count
= SPECPDL_INDEX ();
3423 if (NILP (describer
))
3424 describer
= intern ("princ");
3425 specbind (Qstandard_output
, Fcurrent_buffer ());
3426 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3427 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3428 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3430 return unbind_to (count
, Qnil
);
3433 /* Insert in the current buffer a description of the contents of VECTOR.
3434 We call ELT_DESCRIBER to insert the description of one value found
3437 ELT_PREFIX describes what "comes before" the keys or indices defined
3438 by this vector. This is a human-readable string whose size
3439 is not necessarily related to the situation.
3441 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3442 leads to this keymap.
3444 If the vector is a chartable, ELT_PREFIX is the vector
3445 of bytes that lead to the character set or portion of a character
3446 set described by this chartable.
3448 If PARTIAL is nonzero, it means do not mention suppressed commands
3449 (that assumes the vector is in a keymap).
3451 SHADOW is a list of keymaps that shadow this map.
3452 If it is non-nil, then we look up the key in those maps
3453 and we don't mention it now if it is defined by any of them.
3455 ENTIRE_MAP is the keymap in which this vector appears.
3456 If the definition in effect in the whole map does not match
3457 the one in this vector, we ignore this one.
3459 When describing a sub-char-table, INDICES is a list of
3460 indices at higher levels in this char-table,
3461 and CHAR_TABLE_DEPTH says how many levels down we have gone.
3463 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3465 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3468 describe_vector (vector
, prefix
, args
, elt_describer
,
3469 partial
, shadow
, entire_map
,
3470 indices
, char_table_depth
, keymap_p
,
3472 register Lisp_Object vector
;
3473 Lisp_Object prefix
, args
;
3474 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3477 Lisp_Object entire_map
;
3479 int char_table_depth
;
3483 Lisp_Object definition
;
3485 Lisp_Object elt_prefix
= Qnil
;
3487 Lisp_Object suppress
;
3490 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3491 /* Range of elements to be handled. */
3493 /* A flag to tell if a leaf in this level of char-table is not a
3494 generic character (i.e. a complete multibyte character). */
3502 indices
= (int *) alloca (3 * sizeof (int));
3508 /* Call Fkey_description first, to avoid GC bug for the other string. */
3509 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3512 tem
= Fkey_description (prefix
, Qnil
);
3513 elt_prefix
= concat2 (tem
, build_string (" "));
3518 /* This vector gets used to present single keys to Flookup_key. Since
3519 that is done once per vector element, we don't want to cons up a
3520 fresh vector every time. */
3521 kludge
= Fmake_vector (make_number (1), Qnil
);
3522 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3525 suppress
= intern ("suppress-keymap");
3527 if (CHAR_TABLE_P (vector
))
3529 if (char_table_depth
== 0)
3531 /* VECTOR is a top level char-table. */
3534 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3538 /* VECTOR is a sub char-table. */
3539 if (char_table_depth
>= 3)
3540 /* A char-table is never that deep. */
3541 error ("Too deep char table");
3544 = (CHARSET_VALID_P (indices
[0])
3545 && ((CHARSET_DIMENSION (indices
[0]) == 1
3546 && char_table_depth
== 1)
3547 || char_table_depth
== 2));
3549 /* Meaningful elements are from 32th to 127th. */
3551 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3556 /* This does the right thing for ordinary vectors. */
3560 to
= XVECTOR (vector
)->size
;
3563 for (i
= from
; i
< to
; i
++)
3565 int this_shadowed
= 0;
3568 if (CHAR_TABLE_P (vector
))
3570 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3573 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3574 && !CHARSET_DEFINED_P (i
- 128))
3578 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3581 definition
= get_keyelt (AREF (vector
, i
), 0);
3583 if (NILP (definition
)) continue;
3585 /* Don't mention suppressed commands. */
3586 if (SYMBOLP (definition
) && partial
)
3590 tem
= Fget (definition
, suppress
);
3592 if (!NILP (tem
)) continue;
3595 /* Set CHARACTER to the character this entry describes, if any.
3596 Also update *INDICES. */
3597 if (CHAR_TABLE_P (vector
))
3599 indices
[char_table_depth
] = i
;
3601 if (char_table_depth
== 0)
3604 indices
[0] = i
- 128;
3606 else if (complete_char
)
3608 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3616 ASET (kludge
, 0, make_number (character
));
3618 /* If this binding is shadowed by some other map, ignore it. */
3619 if (!NILP (shadow
) && complete_char
)
3623 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3634 /* Ignore this definition if it is shadowed by an earlier
3635 one in the same keymap. */
3636 if (!NILP (entire_map
) && complete_char
)
3640 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3642 if (!EQ (tem
, definition
))
3648 if (char_table_depth
== 0)
3653 /* For a sub char-table, show the depth by indentation.
3654 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3655 if (char_table_depth
> 0)
3656 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3658 /* Output the prefix that applies to every entry in this map. */
3659 if (!NILP (elt_prefix
))
3660 insert1 (elt_prefix
);
3662 /* Insert or describe the character this slot is for,
3663 or a description of what it is for. */
3664 if (SUB_CHAR_TABLE_P (vector
))
3667 insert_char (character
);
3670 /* We need an octal representation for this block of
3673 sprintf (work
, "(row %d)", i
);
3674 insert (work
, strlen (work
));
3677 else if (CHAR_TABLE_P (vector
))
3680 insert1 (Fkey_description (kludge
, prefix
));
3683 /* Print the information for this character set. */
3684 insert_string ("<");
3685 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3687 insert_from_string (tem2
, 0, 0, SCHARS (tem2
),
3696 insert1 (Fkey_description (kludge
, prefix
));
3699 /* If we find a sub char-table within a char-table,
3700 scan it recursively; it defines the details for
3701 a character set or a portion of a character set. */
3702 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3705 describe_vector (definition
, prefix
, args
, elt_describer
,
3706 partial
, shadow
, entire_map
,
3707 indices
, char_table_depth
+ 1, keymap_p
,
3714 /* Find all consecutive characters or rows that have the same
3715 definition. But, for elements of a top level char table, if
3716 they are for charsets, we had better describe one by one even
3717 if they have the same definition. */
3718 if (CHAR_TABLE_P (vector
))
3722 if (char_table_depth
== 0)
3723 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3725 while (i
+ 1 < limit
3726 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3728 && !NILP (Fequal (tem2
, definition
)))
3733 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3735 && !NILP (Fequal (tem2
, definition
)))
3739 /* If we have a range of more than one character,
3740 print where the range reaches to. */
3742 if (i
!= starting_i
)
3746 ASET (kludge
, 0, make_number (i
));
3748 if (!NILP (elt_prefix
))
3749 insert1 (elt_prefix
);
3751 if (CHAR_TABLE_P (vector
))
3753 if (char_table_depth
== 0)
3755 insert1 (Fkey_description (kludge
, prefix
));
3757 else if (complete_char
)
3759 indices
[char_table_depth
] = i
;
3760 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3761 insert_char (character
);
3765 /* We need an octal representation for this block of
3768 sprintf (work
, "(row %d)", i
);
3769 insert (work
, strlen (work
));
3774 insert1 (Fkey_description (kludge
, prefix
));
3778 /* Print a description of the definition of this character.
3779 elt_describer will take care of spacing out far enough
3780 for alignment purposes. */
3781 (*elt_describer
) (definition
, args
);
3786 insert_string (" (binding currently shadowed)");
3791 /* For (sub) char-table, print `defalt' slot at last. */
3792 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3794 insert (" ", char_table_depth
* 2);
3795 insert_string ("<<default>>");
3796 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3802 /* Apropos - finding all symbols whose names match a regexp. */
3803 static Lisp_Object apropos_predicate
;
3804 static Lisp_Object apropos_accumulate
;
3807 apropos_accum (symbol
, string
)
3808 Lisp_Object symbol
, string
;
3810 register Lisp_Object tem
;
3812 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3813 if (!NILP (tem
) && !NILP (apropos_predicate
))
3814 tem
= call1 (apropos_predicate
, symbol
);
3816 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3819 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3820 doc
: /* Show all symbols whose names contain match for REGEXP.
3821 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3822 for each symbol and a symbol is mentioned only if that returns non-nil.
3823 Return list of symbols found. */)
3825 Lisp_Object regexp
, predicate
;
3828 CHECK_STRING (regexp
);
3829 apropos_predicate
= predicate
;
3830 apropos_accumulate
= Qnil
;
3831 map_obarray (Vobarray
, apropos_accum
, regexp
);
3832 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3833 apropos_accumulate
= Qnil
;
3834 apropos_predicate
= Qnil
;
3841 Qkeymap
= intern ("keymap");
3842 staticpro (&Qkeymap
);
3843 staticpro (&apropos_predicate
);
3844 staticpro (&apropos_accumulate
);
3845 apropos_predicate
= Qnil
;
3846 apropos_accumulate
= Qnil
;
3848 /* Now we are ready to set up this property, so we can
3849 create char tables. */
3850 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3852 /* Initialize the keymaps standardly used.
3853 Each one is the value of a Lisp variable, and is also
3854 pointed to by a C variable */
3856 global_map
= Fmake_keymap (Qnil
);
3857 Fset (intern ("global-map"), global_map
);
3859 current_global_map
= global_map
;
3860 staticpro (&global_map
);
3861 staticpro (¤t_global_map
);
3863 meta_map
= Fmake_keymap (Qnil
);
3864 Fset (intern ("esc-map"), meta_map
);
3865 Ffset (intern ("ESC-prefix"), meta_map
);
3867 control_x_map
= Fmake_keymap (Qnil
);
3868 Fset (intern ("ctl-x-map"), control_x_map
);
3869 Ffset (intern ("Control-X-prefix"), control_x_map
);
3872 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3873 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3874 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3875 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3876 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3878 staticpro (&exclude_keys
);
3880 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3881 doc
: /* List of commands given new key bindings recently.
3882 This is used for internal purposes during Emacs startup;
3883 don't alter it yourself. */);
3884 Vdefine_key_rebound_commands
= Qt
;
3886 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3887 doc
: /* Default keymap to use when reading from the minibuffer. */);
3888 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3890 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3891 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3892 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3893 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3895 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3896 doc
: /* Local keymap for minibuffer input with completion. */);
3897 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3898 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3900 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3901 &Vminibuffer_local_filename_completion_map
,
3902 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3903 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3904 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3905 Vminibuffer_local_completion_map
);
3908 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3909 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3910 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3911 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3912 Vminibuffer_local_completion_map
);
3914 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
3915 &Vminibuffer_local_must_match_filename_map
,
3916 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3917 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
3918 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
3919 Vminibuffer_local_must_match_map
);
3921 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3922 doc
: /* Alist of keymaps to use for minor modes.
3923 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3924 key sequences and look up bindings iff VARIABLE's value is non-nil.
3925 If two active keymaps bind the same key, the keymap appearing earlier
3926 in the list takes precedence. */);
3927 Vminor_mode_map_alist
= Qnil
;
3929 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3930 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3931 This variable is an alist just like `minor-mode-map-alist', and it is
3932 used the same way (and before `minor-mode-map-alist'); however,
3933 it is provided for major modes to bind locally. */);
3934 Vminor_mode_overriding_map_alist
= Qnil
;
3936 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3937 doc
: /* List of keymap alists to use for emulations modes.
3938 It is intended for modes or packages using multiple minor-mode keymaps.
3939 Each element is a keymap alist just like `minor-mode-map-alist', or a
3940 symbol with a variable binding which is a keymap alist, and it is used
3941 the same way. The "active" keymaps in each alist are used before
3942 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3943 Vemulation_mode_map_alists
= Qnil
;
3946 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3947 doc
: /* Keymap that translates key sequences to key sequences during input.
3948 This is used mainly for mapping ASCII function key sequences into
3949 real Emacs function key events (symbols).
3951 The `read-key-sequence' function replaces any subsequence bound by
3952 `function-key-map' with its binding. More precisely, when the active
3953 keymaps have no binding for the current key sequence but
3954 `function-key-map' binds a suffix of the sequence to a vector or string,
3955 `read-key-sequence' replaces the matching suffix with its binding, and
3956 continues with the new sequence.
3958 If the binding is a function, it is called with one argument (the prompt)
3959 and its return value (a key sequence) is used.
3961 The events that come from bindings in `function-key-map' are not
3962 themselves looked up in `function-key-map'.
3964 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3965 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3966 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3967 key, typing `ESC O P x' would return [f1 x]. */);
3968 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3970 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3971 doc
: /* Keymap of key translations that can override keymaps.
3972 This keymap works like `function-key-map', but comes after that,
3973 and its non-prefix bindings override ordinary bindings. */);
3974 Vkey_translation_map
= Qnil
;
3976 staticpro (&Vmouse_events
);
3977 Vmouse_events
= Fcons (intern ("menu-bar"),
3978 Fcons (intern ("tool-bar"),
3979 Fcons (intern ("header-line"),
3980 Fcons (intern ("mode-line"),
3981 Fcons (intern ("mouse-1"),
3982 Fcons (intern ("mouse-2"),
3983 Fcons (intern ("mouse-3"),
3984 Fcons (intern ("mouse-4"),
3985 Fcons (intern ("mouse-5"),
3989 Qsingle_key_description
= intern ("single-key-description");
3990 staticpro (&Qsingle_key_description
);
3992 Qkey_description
= intern ("key-description");
3993 staticpro (&Qkey_description
);
3995 Qkeymapp
= intern ("keymapp");
3996 staticpro (&Qkeymapp
);
3998 Qnon_ascii
= intern ("non-ascii");
3999 staticpro (&Qnon_ascii
);
4001 Qmenu_item
= intern ("menu-item");
4002 staticpro (&Qmenu_item
);
4004 Qremap
= intern ("remap");
4005 staticpro (&Qremap
);
4007 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
4008 staticpro (&command_remapping_vector
);
4010 where_is_cache_keymaps
= Qt
;
4011 where_is_cache
= Qnil
;
4012 staticpro (&where_is_cache
);
4013 staticpro (&where_is_cache_keymaps
);
4015 defsubr (&Skeymapp
);
4016 defsubr (&Skeymap_parent
);
4017 defsubr (&Skeymap_prompt
);
4018 defsubr (&Sset_keymap_parent
);
4019 defsubr (&Smake_keymap
);
4020 defsubr (&Smake_sparse_keymap
);
4021 defsubr (&Smap_keymap
);
4022 defsubr (&Scopy_keymap
);
4023 defsubr (&Scommand_remapping
);
4024 defsubr (&Skey_binding
);
4025 defsubr (&Slocal_key_binding
);
4026 defsubr (&Sglobal_key_binding
);
4027 defsubr (&Sminor_mode_key_binding
);
4028 defsubr (&Sdefine_key
);
4029 defsubr (&Slookup_key
);
4030 defsubr (&Sdefine_prefix_command
);
4031 defsubr (&Suse_global_map
);
4032 defsubr (&Suse_local_map
);
4033 defsubr (&Scurrent_local_map
);
4034 defsubr (&Scurrent_global_map
);
4035 defsubr (&Scurrent_minor_mode_maps
);
4036 defsubr (&Scurrent_active_maps
);
4037 defsubr (&Saccessible_keymaps
);
4038 defsubr (&Skey_description
);
4039 defsubr (&Sdescribe_vector
);
4040 defsubr (&Ssingle_key_description
);
4041 defsubr (&Stext_char_description
);
4042 defsubr (&Swhere_is_internal
);
4043 defsubr (&Sdescribe_buffer_bindings
);
4044 defsubr (&Sapropos_internal
);
4050 initial_define_key (global_map
, 033, "ESC-prefix");
4051 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
4054 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4055 (do not change this comment) */