1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, 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. */
32 #include "character.h"
35 #include "termhooks.h"
36 #include "blockinput.h"
38 #include "intervals.h"
42 /* The number of elements in keymap vectors. */
43 #define DENSE_TABLE_SIZE (0200)
45 /* Actually allocate storage for these variables */
47 Lisp_Object current_global_map
; /* Current global keymap */
49 Lisp_Object global_map
; /* default global key bindings */
51 Lisp_Object meta_map
; /* The keymap used for globally bound
52 ESC-prefixed default commands */
54 Lisp_Object control_x_map
; /* The keymap used for globally bound
55 C-x-prefixed default commands */
57 /* was MinibufLocalMap */
58 Lisp_Object Vminibuffer_local_map
;
59 /* The keymap used by the minibuf for local
60 bindings when spaces are allowed in the
63 /* was MinibufLocalNSMap */
64 Lisp_Object Vminibuffer_local_ns_map
;
65 /* The keymap used by the minibuf for local
66 bindings when spaces are not encouraged
69 /* keymap used for minibuffers when doing completion */
70 /* was MinibufLocalCompletionMap */
71 Lisp_Object Vminibuffer_local_completion_map
;
73 /* keymap used for minibuffers when doing completion in filenames */
74 Lisp_Object Vminibuffer_local_filename_completion_map
;
76 /* keymap used for minibuffers when doing completion in filenames
78 Lisp_Object Vminibuffer_local_must_match_filename_map
;
80 /* keymap used for minibuffers when doing completion and require a match */
81 /* was MinibufLocalMustMatchMap */
82 Lisp_Object Vminibuffer_local_must_match_map
;
84 /* Alist of minor mode variables and keymaps. */
85 Lisp_Object Vminor_mode_map_alist
;
87 /* Alist of major-mode-specific overrides for
88 minor mode variables and keymaps. */
89 Lisp_Object Vminor_mode_overriding_map_alist
;
91 /* List of emulation mode keymap alists. */
92 Lisp_Object Vemulation_mode_map_alists
;
94 /* Keymap mapping ASCII function key sequences onto their preferred forms.
95 Initialized by the terminal-specific lisp files. See DEFVAR for more
97 Lisp_Object Vfunction_key_map
;
99 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
100 Lisp_Object Vkey_translation_map
;
102 /* A list of all commands given new bindings since a certain time
103 when nil was stored here.
104 This is used to speed up recomputation of menu key equivalents
105 when Emacs starts up. t means don't record anything here. */
106 Lisp_Object Vdefine_key_rebound_commands
;
108 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
110 /* Alist of elements like (DEL . "\d"). */
111 static Lisp_Object exclude_keys
;
113 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
114 static Lisp_Object command_remapping_vector
;
116 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
117 in a string key sequence is equivalent to prefixing with this
119 extern Lisp_Object meta_prefix_char
;
121 extern Lisp_Object Voverriding_local_map
;
123 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
124 static Lisp_Object where_is_cache
;
125 /* Which keymaps are reverse-stored in the cache. */
126 static Lisp_Object where_is_cache_keymaps
;
128 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
129 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
131 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
132 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
133 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
134 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
135 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
136 int, Lisp_Object
, Lisp_Object
*, int, int));
137 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
138 void (*) (Lisp_Object
, Lisp_Object
), int,
139 Lisp_Object
, Lisp_Object
, int *,
141 static void silly_event_symbol_error
P_ ((Lisp_Object
));
143 /* Keymap object support - constructors and predicates. */
145 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
146 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
147 CHARTABLE is a char-table that holds the bindings for all characters
148 without modifiers. All entries in it are initially nil, meaning
149 "command undefined". ALIST is an assoc-list which holds bindings for
150 function keys, mouse events, and any other things that appear in the
151 input stream. Initially, ALIST is nil.
153 The optional arg STRING supplies a menu name for the keymap
154 in case you use it as a menu with `x-popup-menu'. */)
160 tail
= Fcons (string
, Qnil
);
163 return Fcons (Qkeymap
,
164 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
167 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
168 doc
: /* Construct and return a new sparse keymap.
169 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
170 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
171 which binds the function key or mouse event SYMBOL to DEFINITION.
172 Initially the alist is nil.
174 The optional arg STRING supplies a menu name for the keymap
175 in case you use it as a menu with `x-popup-menu'. */)
180 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
181 return Fcons (Qkeymap
, Qnil
);
184 /* This function is used for installing the standard key bindings
185 at initialization time.
189 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
192 initial_define_key (keymap
, key
, defname
)
197 store_in_keymap (keymap
, make_number (key
), intern (defname
));
201 initial_define_lispy_key (keymap
, keyname
, defname
)
206 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
209 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
210 doc
: /* Return t if OBJECT is a keymap.
212 A keymap is a list (keymap . ALIST),
213 or a symbol whose function definition is itself a keymap.
214 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
215 a vector of densely packed bindings for small character codes
216 is also allowed as an element. */)
220 return (KEYMAPP (object
) ? Qt
: Qnil
);
223 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
224 doc
: /* Return the prompt-string of a keymap MAP.
225 If non-nil, the prompt is shown in the echo-area
226 when reading a key-sequence to be looked-up in this keymap. */)
230 map
= get_keymap (map
, 0, 0);
233 Lisp_Object tem
= XCAR (map
);
241 /* Check that OBJECT is a keymap (after dereferencing through any
242 symbols). If it is, return it.
244 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
245 is an autoload form, do the autoload and try again.
246 If AUTOLOAD is nonzero, callers must assume GC is possible.
248 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
249 is zero as well), return Qt.
251 ERROR controls how we respond if OBJECT isn't a keymap.
252 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
254 Note that most of the time, we don't want to pursue autoloads.
255 Functions like Faccessible_keymaps which scan entire keymap trees
256 shouldn't load every autoloaded keymap. I'm not sure about this,
257 but it seems to me that only read_key_sequence, Flookup_key, and
258 Fdefine_key should cause keymaps to be autoloaded.
260 This function can GC when AUTOLOAD is non-zero, because it calls
261 do_autoload which can GC. */
264 get_keymap (object
, error
, autoload
)
273 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
276 tem
= indirect_function (object
);
279 if (EQ (XCAR (tem
), Qkeymap
))
282 /* Should we do an autoload? Autoload forms for keymaps have
283 Qkeymap as their fifth element. */
284 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
289 tail
= Fnth (make_number (4), tem
);
290 if (EQ (tail
, Qkeymap
))
294 struct gcpro gcpro1
, gcpro2
;
296 GCPRO2 (tem
, object
);
297 do_autoload (tem
, object
);
310 wrong_type_argument (Qkeymapp
, object
);
314 /* Return the parent map of KEYMAP, or nil if it has none.
315 We assume that KEYMAP is a valid keymap. */
318 keymap_parent (keymap
, autoload
)
324 keymap
= get_keymap (keymap
, 1, autoload
);
326 /* Skip past the initial element `keymap'. */
327 list
= XCDR (keymap
);
328 for (; CONSP (list
); list
= XCDR (list
))
330 /* See if there is another `keymap'. */
335 return get_keymap (list
, 0, autoload
);
338 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
339 doc
: /* Return the parent keymap of KEYMAP. */)
343 return keymap_parent (keymap
, 1);
346 /* Check whether MAP is one of MAPS parents. */
348 keymap_memberp (map
, maps
)
349 Lisp_Object map
, maps
;
351 if (NILP (map
)) return 0;
352 while (KEYMAPP (maps
) && !EQ (map
, maps
))
353 maps
= keymap_parent (maps
, 0);
354 return (EQ (map
, maps
));
357 /* Set the parent keymap of MAP to PARENT. */
359 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
360 doc
: /* Modify KEYMAP to set its parent map to PARENT.
361 Return PARENT. PARENT should be nil or another keymap. */)
363 Lisp_Object keymap
, parent
;
365 Lisp_Object list
, prev
;
366 struct gcpro gcpro1
, gcpro2
;
369 /* Force a keymap flush for the next call to where-is.
370 Since this can be called from within where-is, we don't set where_is_cache
371 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
372 be changed during where-is, while where_is_cache_keymaps is only used at
373 the very beginning of where-is and can thus be changed here without any
375 This is a very minor correctness (rather than safety) issue. */
376 where_is_cache_keymaps
= Qt
;
378 GCPRO2 (keymap
, parent
);
379 keymap
= get_keymap (keymap
, 1, 1);
383 parent
= get_keymap (parent
, 1, 1);
385 /* Check for cycles. */
386 if (keymap_memberp (keymap
, parent
))
387 error ("Cyclic keymap inheritance");
390 /* Skip past the initial element `keymap'. */
395 /* If there is a parent keymap here, replace it.
396 If we came to the end, add the parent in PREV. */
397 if (!CONSP (list
) || KEYMAPP (list
))
399 /* If we already have the right parent, return now
400 so that we avoid the loops below. */
401 if (EQ (XCDR (prev
), parent
))
402 RETURN_UNGCPRO (parent
);
405 XSETCDR (prev
, parent
);
411 /* Scan through for submaps, and set their parents too. */
413 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
415 /* Stop the scan when we come to the parent. */
416 if (EQ (XCAR (list
), Qkeymap
))
419 /* If this element holds a prefix map, deal with it. */
420 if (CONSP (XCAR (list
))
421 && CONSP (XCDR (XCAR (list
))))
422 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
425 if (VECTORP (XCAR (list
)))
426 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
427 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
428 fix_submap_inheritance (keymap
, make_number (i
),
429 XVECTOR (XCAR (list
))->contents
[i
]);
431 if (CHAR_TABLE_P (XCAR (list
)))
433 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
437 RETURN_UNGCPRO (parent
);
440 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
441 if EVENT is also a prefix in MAP's parent,
442 make sure that SUBMAP inherits that definition as its own parent. */
445 fix_submap_inheritance (map
, event
, submap
)
446 Lisp_Object map
, event
, submap
;
448 Lisp_Object map_parent
, parent_entry
;
450 /* SUBMAP is a cons that we found as a key binding.
451 Discard the other things found in a menu key binding. */
453 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
455 /* If it isn't a keymap now, there's no work to do. */
459 map_parent
= keymap_parent (map
, 0);
460 if (!NILP (map_parent
))
462 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
466 /* If MAP's parent has something other than a keymap,
467 our own submap shadows it completely. */
468 if (!CONSP (parent_entry
))
471 if (! EQ (parent_entry
, submap
))
473 Lisp_Object submap_parent
;
474 submap_parent
= submap
;
479 tem
= keymap_parent (submap_parent
, 0);
483 if (keymap_memberp (tem
, parent_entry
))
484 /* Fset_keymap_parent could create a cycle. */
491 Fset_keymap_parent (submap_parent
, parent_entry
);
495 /* Look up IDX in MAP. IDX may be any sort of event.
496 Note that this does only one level of lookup; IDX must be a single
497 event, not a sequence.
499 If T_OK is non-zero, bindings for Qt are treated as default
500 bindings; any key left unmentioned by other tables and bindings is
501 given the binding of Qt.
503 If T_OK is zero, bindings for Qt are not treated specially.
505 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
508 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
517 /* Qunbound in VAL means we have found no binding yet. */
520 /* If idx is a list (some sort of mouse click, perhaps?),
521 the index we want to use is the car of the list, which
522 ought to be a symbol. */
523 idx
= EVENT_HEAD (idx
);
525 /* If idx is a symbol, it might have modifiers, which need to
526 be put in the canonical order. */
528 idx
= reorder_modifiers (idx
);
529 else if (INTEGERP (idx
))
530 /* Clobber the high bits that can be present on a machine
531 with more than 24 bits of integer. */
532 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
534 /* Handle the special meta -> esc mapping. */
535 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
537 /* See if there is a meta-map. If there's none, there is
538 no binding for IDX, unless a default binding exists in MAP. */
540 Lisp_Object meta_map
;
542 /* A strange value in which Meta is set would cause
543 infinite recursion. Protect against that. */
544 if (XINT (meta_prefix_char
) & CHAR_META
)
545 meta_prefix_char
= make_number (27);
546 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
547 t_ok
, noinherit
, autoload
),
550 if (CONSP (meta_map
))
553 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
556 /* Set IDX to t, so that we only find a default binding. */
559 /* We know there is no binding. */
563 /* t_binding is where we put a default binding that applies,
564 to use in case we do not find a binding specifically
565 for this key sequence. */
568 Lisp_Object t_binding
= Qnil
;
569 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
571 GCPRO4 (map
, tail
, idx
, t_binding
);
573 /* If `t_ok' is 2, both `t' is accepted. */
576 for (tail
= XCDR (map
);
578 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
583 binding
= XCAR (tail
);
584 if (SYMBOLP (binding
))
586 /* If NOINHERIT, stop finding prefix definitions
587 after we pass a second occurrence of the `keymap' symbol. */
588 if (noinherit
&& EQ (binding
, Qkeymap
))
589 RETURN_UNGCPRO (Qnil
);
591 else if (CONSP (binding
))
593 Lisp_Object key
= XCAR (binding
);
596 val
= XCDR (binding
);
597 else if (t_ok
> 1 && EQ (key
, Qt
))
599 t_binding
= XCDR (binding
);
603 else if (VECTORP (binding
))
605 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
606 val
= AREF (binding
, XFASTINT (idx
));
608 else if (CHAR_TABLE_P (binding
))
610 /* Character codes with modifiers
611 are not included in a char-table.
612 All character codes without modifiers are included. */
613 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
615 val
= Faref (binding
, idx
);
616 /* `nil' has a special meaning for char-tables, so
617 we use something else to record an explicitly
624 /* If we found a binding, clean it up and return it. */
625 if (!EQ (val
, Qunbound
))
628 /* A Qt binding is just like an explicit nil binding
629 (i.e. it shadows any parent binding but not bindings in
630 keymaps of lower precedence). */
632 val
= get_keyelt (val
, autoload
);
634 fix_submap_inheritance (map
, idx
, val
);
635 RETURN_UNGCPRO (val
);
640 return get_keyelt (t_binding
, autoload
);
645 map_keymap_item (fun
, args
, key
, val
, data
)
646 map_keymap_function_t fun
;
647 Lisp_Object args
, key
, val
;
650 /* We should maybe try to detect bindings shadowed by previous
651 ones and things like that. */
654 (*fun
) (key
, val
, args
, data
);
658 map_keymap_char_table_item (args
, key
, val
)
659 Lisp_Object args
, key
, val
;
663 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
665 map_keymap_item (fun
, XCDR (args
), key
, val
,
666 XSAVE_VALUE (XCAR (args
))->pointer
);
670 /* Call FUN for every binding in MAP.
671 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA).
672 AUTOLOAD if non-zero means that we can autoload keymaps if necessary. */
674 map_keymap (map
, fun
, args
, data
, autoload
)
675 map_keymap_function_t fun
;
676 Lisp_Object map
, args
;
680 struct gcpro gcpro1
, gcpro2
, gcpro3
;
684 GCPRO3 (map
, args
, tail
);
685 map
= get_keymap (map
, 1, autoload
);
686 for (tail
= (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
687 CONSP (tail
) || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
));
690 Lisp_Object binding
= XCAR (tail
);
693 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
694 else if (VECTORP (binding
))
696 /* Loop over the char values represented in the vector. */
697 int len
= ASIZE (binding
);
699 for (c
= 0; c
< len
; c
++)
701 Lisp_Object character
;
702 XSETFASTINT (character
, c
);
703 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
706 else if (CHAR_TABLE_P (binding
))
708 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
709 Fcons (make_save_value (fun
, 0),
710 Fcons (make_save_value (data
, 0),
718 map_keymap_call (key
, val
, fun
, dummy
)
719 Lisp_Object key
, val
, fun
;
722 call2 (fun
, key
, val
);
725 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
726 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
727 FUNCTION is called with two arguments: the event that is bound, and
728 the definition it is bound to. If the event is an integer, it may be
729 a generic character (see Info node `(elisp)Splitting Characters'), and
730 that means that all actual character events belonging to that generic
731 character are bound to the definition.
733 If KEYMAP has a parent, the parent's bindings are included as well.
734 This works recursively: if the parent has itself a parent, then the
735 grandparent's bindings are also included and so on.
736 usage: (map-keymap FUNCTION KEYMAP) */)
737 (function
, keymap
, sort_first
)
738 Lisp_Object function
, keymap
, sort_first
;
740 if (INTEGERP (function
))
741 /* We have to stop integers early since map_keymap gives them special
743 xsignal1 (Qinvalid_function
, function
);
744 if (! NILP (sort_first
))
745 return call3 (intern ("map-keymap-internal"), function
, keymap
, Qt
);
747 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
751 /* Given OBJECT which was found in a slot in a keymap,
752 trace indirect definitions to get the actual definition of that slot.
753 An indirect definition is a list of the form
754 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
755 and INDEX is the object to look up in KEYMAP to yield the definition.
757 Also if OBJECT has a menu string as the first element,
758 remove that. Also remove a menu help string as second element.
760 If AUTOLOAD is nonzero, load autoloadable keymaps
761 that are referred to with indirection.
763 This can GC because menu_item_eval_property calls Feval. */
766 get_keyelt (object
, autoload
)
772 if (!(CONSP (object
)))
773 /* This is really the value. */
776 /* If the keymap contents looks like (keymap ...) or (lambda ...)
778 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
781 /* If the keymap contents looks like (menu-item name . DEFN)
782 or (menu-item name DEFN ...) then use DEFN.
783 This is a new format menu item. */
784 else if (EQ (XCAR (object
), Qmenu_item
))
786 if (CONSP (XCDR (object
)))
790 object
= XCDR (XCDR (object
));
793 object
= XCAR (object
);
795 /* If there's a `:filter FILTER', apply FILTER to the
796 menu-item's definition to get the real definition to
798 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
799 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
802 filter
= XCAR (XCDR (tem
));
803 filter
= list2 (filter
, list2 (Qquote
, object
));
804 object
= menu_item_eval_property (filter
);
809 /* Invalid keymap. */
813 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
814 Keymap alist elements like (CHAR MENUSTRING . DEFN)
815 will be used by HierarKey menus. */
816 else if (STRINGP (XCAR (object
)))
818 object
= XCDR (object
);
819 /* Also remove a menu help string, if any,
820 following the menu item name. */
821 if (CONSP (object
) && STRINGP (XCAR (object
)))
822 object
= XCDR (object
);
823 /* Also remove the sublist that caches key equivalences, if any. */
824 if (CONSP (object
) && CONSP (XCAR (object
)))
827 carcar
= XCAR (XCAR (object
));
828 if (NILP (carcar
) || VECTORP (carcar
))
829 object
= XCDR (object
);
833 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
839 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
841 return (!CONSP (map
) ? object
/* Invalid keymap */
842 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
848 store_in_keymap (keymap
, idx
, def
)
850 register Lisp_Object idx
;
853 /* Flush any reverse-map cache. */
854 where_is_cache
= Qnil
;
855 where_is_cache_keymaps
= Qt
;
857 /* If we are preparing to dump, and DEF is a menu element
858 with a menu item indicator, copy it to ensure it is not pure. */
859 if (CONSP (def
) && PURE_P (def
)
860 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
861 def
= Fcons (XCAR (def
), XCDR (def
));
863 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
864 error ("attempt to define a key in a non-keymap");
866 /* If idx is a cons, and the car part is a character, idx must be of
867 the form (FROM-CHAR . TO-CHAR). */
868 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
869 CHECK_CHARACTER_CDR (idx
);
871 /* If idx is a list (some sort of mouse click, perhaps?),
872 the index we want to use is the car of the list, which
873 ought to be a symbol. */
874 idx
= EVENT_HEAD (idx
);
876 /* If idx is a symbol, it might have modifiers, which need to
877 be put in the canonical order. */
879 idx
= reorder_modifiers (idx
);
880 else if (INTEGERP (idx
))
881 /* Clobber the high bits that can be present on a machine
882 with more than 24 bits of integer. */
883 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
885 /* Scan the keymap for a binding of idx. */
889 /* The cons after which we should insert new bindings. If the
890 keymap has a table element, we record its position here, so new
891 bindings will go after it; this way, the table will stay
892 towards the front of the alist and character lookups in dense
893 keymaps will remain fast. Otherwise, this just points at the
894 front of the keymap. */
895 Lisp_Object insertion_point
;
897 insertion_point
= keymap
;
898 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
905 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
908 ASET (elt
, XFASTINT (idx
), def
);
911 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
913 int from
= XFASTINT (XCAR (idx
));
914 int to
= XFASTINT (XCDR (idx
));
916 if (to
>= ASIZE (elt
))
917 to
= ASIZE (elt
) - 1;
918 for (; from
<= to
; from
++)
919 ASET (elt
, from
, def
);
920 if (to
== XFASTINT (XCDR (idx
)))
921 /* We have defined all keys in IDX. */
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 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
942 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
945 insertion_point
= tail
;
947 else if (CONSP (elt
))
949 if (EQ (idx
, XCAR (elt
)))
955 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
957 int from
= XFASTINT (XCAR (idx
));
958 int to
= XFASTINT (XCDR (idx
));
960 if (from
<= XFASTINT (XCAR (elt
))
961 && to
>= XFASTINT (XCAR (elt
)))
969 else if (EQ (elt
, Qkeymap
))
970 /* If we find a 'keymap' symbol in the spine of KEYMAP,
971 then we must have found the start of a second keymap
972 being used as the tail of KEYMAP, and a binding for IDX
973 should be inserted before it. */
980 /* We have scanned the entire keymap, and not found a binding for
981 IDX. Let's add one. */
985 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
987 /* IDX specifies a range of characters, and not all of them
988 were handled yet, which means this keymap doesn't have a
989 char-table. So, we insert a char-table now. */
990 elt
= Fmake_char_table (Qkeymap
, Qnil
);
991 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
994 elt
= Fcons (idx
, def
);
995 CHECK_IMPURE (insertion_point
);
996 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
1003 EXFUN (Fcopy_keymap
, 1);
1006 copy_keymap_item (elt
)
1009 Lisp_Object res
, tem
;
1016 /* Is this a new format menu item. */
1017 if (EQ (XCAR (tem
), Qmenu_item
))
1019 /* Copy cell with menu-item marker. */
1020 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1024 /* Copy cell with menu-item name. */
1025 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1031 /* Copy cell with binding and if the binding is a keymap,
1033 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1036 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1037 XSETCAR (elt
, Fcopy_keymap (tem
));
1039 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1040 /* Delete cache for key equivalences. */
1041 XSETCDR (elt
, XCDR (tem
));
1046 /* It may be an old fomat menu item.
1047 Skip the optional menu string. */
1048 if (STRINGP (XCAR (tem
)))
1050 /* Copy the cell, since copy-alist didn't go this deep. */
1051 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1053 /* Also skip the optional menu help string. */
1054 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1056 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1060 /* There may also be a list that caches key equivalences.
1061 Just delete it for the new keymap. */
1063 && CONSP (XCAR (tem
))
1064 && (NILP (XCAR (XCAR (tem
)))
1065 || VECTORP (XCAR (XCAR (tem
)))))
1067 XSETCDR (elt
, XCDR (tem
));
1070 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1071 XSETCDR (elt
, Fcopy_keymap (tem
));
1073 else if (EQ (XCAR (tem
), Qkeymap
))
1074 res
= Fcopy_keymap (elt
);
1080 copy_keymap_1 (chartable
, idx
, elt
)
1081 Lisp_Object chartable
, idx
, elt
;
1083 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1086 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1087 doc
: /* Return a copy of the keymap KEYMAP.
1088 The copy starts out with the same definitions of KEYMAP,
1089 but changing either the copy or KEYMAP does not affect the other.
1090 Any key definitions that are subkeymaps are recursively copied.
1091 However, a key definition which is a symbol whose definition is a keymap
1096 register Lisp_Object copy
, tail
;
1097 keymap
= get_keymap (keymap
, 1, 0);
1098 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1099 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1101 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1103 Lisp_Object elt
= XCAR (keymap
);
1104 if (CHAR_TABLE_P (elt
))
1106 elt
= Fcopy_sequence (elt
);
1107 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1109 else if (VECTORP (elt
))
1112 elt
= Fcopy_sequence (elt
);
1113 for (i
= 0; i
< ASIZE (elt
); i
++)
1114 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1116 else if (CONSP (elt
))
1117 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1118 XSETCDR (tail
, Fcons (elt
, Qnil
));
1120 keymap
= XCDR (keymap
);
1122 XSETCDR (tail
, keymap
);
1126 /* Simple Keymap mutators and accessors. */
1128 /* GC is possible in this function if it autoloads a keymap. */
1130 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1131 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1134 KEY is a string or a vector of symbols and characters meaning a
1135 sequence of keystrokes and events. Non-ASCII characters with codes
1136 above 127 (such as ISO Latin-1) can be included if you use a vector.
1137 Using [t] for KEY creates a default definition, which applies to any
1138 event type that has no other definition in this keymap.
1140 DEF is anything that can be a key's definition:
1141 nil (means key is undefined in this keymap),
1142 a command (a Lisp function suitable for interactive calling),
1143 a string (treated as a keyboard macro),
1144 a keymap (to define a prefix key),
1145 a symbol (when the key is looked up, the symbol will stand for its
1146 function definition, which should at that time be one of the above,
1147 or another symbol whose function definition is used, etc.),
1148 a cons (STRING . DEFN), meaning that DEFN is the definition
1149 (DEFN should be a valid definition in its own right),
1150 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
1151 or an extended menu item definition.
1152 (See info node `(elisp)Extended Menu Items'.)
1154 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1155 binding is altered. If there is no binding for KEY, the new pair
1156 binding KEY to DEF is added at the front of KEYMAP. */)
1163 register Lisp_Object c
;
1164 register Lisp_Object cmd
;
1168 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1170 GCPRO3 (keymap
, key
, def
);
1171 keymap
= get_keymap (keymap
, 1, 1);
1173 CHECK_VECTOR_OR_STRING (key
);
1175 length
= XFASTINT (Flength (key
));
1177 RETURN_UNGCPRO (Qnil
);
1179 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1180 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1182 meta_bit
= (VECTORP (key
) || (STRINGP (key
) && STRING_MULTIBYTE (key
))
1183 ? meta_modifier
: 0x80);
1185 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, 0)))
1186 { /* DEF is apparently an XEmacs-style keyboard macro. */
1187 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1188 int i
= ASIZE (def
);
1191 Lisp_Object c
= AREF (def
, i
);
1192 if (CONSP (c
) && lucid_event_type_list_p (c
))
1193 c
= Fevent_convert_list (c
);
1202 c
= Faref (key
, make_number (idx
));
1206 /* C may be a Lucid style event type list or a cons (FROM .
1207 TO) specifying a range of characters. */
1208 if (lucid_event_type_list_p (c
))
1209 c
= Fevent_convert_list (c
);
1210 else if (CHARACTERP (XCAR (c
)))
1211 CHECK_CHARACTER_CDR (c
);
1215 silly_event_symbol_error (c
);
1218 && (XINT (c
) & meta_bit
)
1221 c
= meta_prefix_char
;
1227 XSETINT (c
, XINT (c
) & ~meta_bit
);
1233 if (!INTEGERP (c
) && !SYMBOLP (c
)
1235 /* If C is a range, it must be a leaf. */
1236 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1237 error ("Key sequence contains invalid event");
1240 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1242 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1244 /* If this key is undefined, make it a prefix. */
1246 cmd
= define_as_prefix (keymap
, c
);
1248 keymap
= get_keymap (cmd
, 0, 1);
1249 if (!CONSP (keymap
))
1250 /* We must use Fkey_description rather than just passing key to
1251 error; key might be a vector, not a string. */
1252 error ("Key sequence %s starts with non-prefix key %s",
1253 SDATA (Fkey_description (key
, Qnil
)),
1254 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1260 /* This function may GC (it calls Fkey_binding). */
1262 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 3, 0,
1263 doc
: /* Return the remapping for command COMMAND.
1264 Returns nil if COMMAND is not remapped (or not a symbol).
1266 If the optional argument POSITION is non-nil, it specifies a mouse
1267 position as returned by `event-start' and `event-end', and the
1268 remapping occurs in the keymaps associated with it. It can also be a
1269 number or marker, in which case the keymap properties at the specified
1270 buffer position instead of point are used. The KEYMAPS argument is
1271 ignored if POSITION is non-nil.
1273 If the optional argument KEYMAPS is non-nil, it should be a list of
1274 keymaps to search for command remapping. Otherwise, search for the
1275 remapping in all currently active keymaps. */)
1276 (command
, position
, keymaps
)
1277 Lisp_Object command
, position
, keymaps
;
1279 if (!SYMBOLP (command
))
1282 ASET (command_remapping_vector
, 1, command
);
1285 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
, position
);
1288 Lisp_Object maps
, binding
;
1290 for (maps
= keymaps
; !NILP (maps
); maps
= Fcdr (maps
))
1292 binding
= Flookup_key (Fcar (maps
), command_remapping_vector
, Qnil
);
1293 if (!NILP (binding
) && !INTEGERP (binding
))
1300 /* Value is number if KEY is too long; nil if valid but has no definition. */
1301 /* GC is possible in this function if it autoloads a keymap. */
1303 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1304 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1305 A value of nil means undefined. See doc of `define-key'
1306 for kinds of definitions.
1308 A number as value means KEY is "too long";
1309 that is, characters or symbols in it except for the last one
1310 fail to be a valid sequence of prefix characters in KEYMAP.
1311 The number is how many characters at the front of KEY
1312 it takes to reach a non-prefix key.
1314 Normally, `lookup-key' ignores bindings for t, which act as default
1315 bindings, used when nothing else in the keymap applies; this makes it
1316 usable as a general function for probing keymaps. However, if the
1317 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1318 recognize the default bindings, just as `read-key-sequence' does. */)
1319 (keymap
, key
, accept_default
)
1322 Lisp_Object accept_default
;
1325 register Lisp_Object cmd
;
1326 register Lisp_Object c
;
1328 int t_ok
= !NILP (accept_default
);
1329 struct gcpro gcpro1
, gcpro2
;
1331 GCPRO2 (keymap
, key
);
1332 keymap
= get_keymap (keymap
, 1, 1);
1334 CHECK_VECTOR_OR_STRING (key
);
1336 length
= XFASTINT (Flength (key
));
1338 RETURN_UNGCPRO (keymap
);
1343 c
= Faref (key
, make_number (idx
++));
1345 if (CONSP (c
) && lucid_event_type_list_p (c
))
1346 c
= Fevent_convert_list (c
);
1348 /* Turn the 8th bit of string chars into a meta modifier. */
1349 if (STRINGP (key
) && XINT (c
) & 0x80 && !STRING_MULTIBYTE (key
))
1350 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1352 /* Allow string since binding for `menu-bar-select-buffer'
1353 includes the buffer name in the key sequence. */
1354 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1355 error ("Key sequence contains invalid event");
1357 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1359 RETURN_UNGCPRO (cmd
);
1361 keymap
= get_keymap (cmd
, 0, 1);
1362 if (!CONSP (keymap
))
1363 RETURN_UNGCPRO (make_number (idx
));
1369 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1370 Assume that currently it does not define C at all.
1371 Return the keymap. */
1374 define_as_prefix (keymap
, c
)
1375 Lisp_Object keymap
, c
;
1379 cmd
= Fmake_sparse_keymap (Qnil
);
1380 /* If this key is defined as a prefix in an inherited keymap,
1381 make it a prefix in this map, and make its definition
1382 inherit the other prefix definition. */
1383 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1384 store_in_keymap (keymap
, c
, cmd
);
1389 /* Append a key to the end of a key sequence. We always make a vector. */
1392 append_key (key_sequence
, key
)
1393 Lisp_Object key_sequence
, key
;
1395 Lisp_Object args
[2];
1397 args
[0] = key_sequence
;
1399 args
[1] = Fcons (key
, Qnil
);
1400 return Fvconcat (2, args
);
1403 /* Given a event type C which is a symbol,
1404 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1407 silly_event_symbol_error (c
)
1410 Lisp_Object parsed
, base
, name
, assoc
;
1413 parsed
= parse_modifiers (c
);
1414 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1415 base
= XCAR (parsed
);
1416 name
= Fsymbol_name (base
);
1417 /* This alist includes elements such as ("RET" . "\\r"). */
1418 assoc
= Fassoc (name
, exclude_keys
);
1422 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1424 Lisp_Object keystring
;
1425 if (modifiers
& alt_modifier
)
1426 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1427 if (modifiers
& ctrl_modifier
)
1428 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1429 if (modifiers
& hyper_modifier
)
1430 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1431 if (modifiers
& meta_modifier
)
1432 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1433 if (modifiers
& shift_modifier
)
1434 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1435 if (modifiers
& super_modifier
)
1436 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1439 c
= reorder_modifiers (c
);
1440 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1442 error ((modifiers
& ~meta_modifier
1443 ? "To bind the key %s, use [?%s], not [%s]"
1444 : "To bind the key %s, use \"%s\", not [%s]"),
1445 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1446 SDATA (SYMBOL_NAME (c
)));
1450 /* Global, local, and minor mode keymap stuff. */
1452 /* We can't put these variables inside current_minor_maps, since under
1453 some systems, static gets macro-defined to be the empty string.
1455 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1456 static int cmm_size
= 0;
1458 /* Store a pointer to an array of the currently active minor modes in
1459 *modeptr, a pointer to an array of the keymaps of the currently
1460 active minor modes in *mapptr, and return the number of maps
1463 This function always returns a pointer to the same buffer, and may
1464 free or reallocate it, so if you want to keep it for a long time or
1465 hand it out to lisp code, copy it. This procedure will be called
1466 for every key sequence read, so the nice lispy approach (return a
1467 new assoclist, list, what have you) for each invocation would
1468 result in a lot of consing over time.
1470 If we used xrealloc/xmalloc and ran out of memory, they would throw
1471 back to the command loop, which would try to read a key sequence,
1472 which would call this function again, resulting in an infinite
1473 loop. Instead, we'll use realloc/malloc and silently truncate the
1474 list, let the key sequence be read, and hope some other piece of
1475 code signals the error. */
1477 current_minor_maps (modeptr
, mapptr
)
1478 Lisp_Object
**modeptr
, **mapptr
;
1481 int list_number
= 0;
1482 Lisp_Object alist
, assoc
, var
, val
;
1483 Lisp_Object emulation_alists
;
1484 Lisp_Object lists
[2];
1486 emulation_alists
= Vemulation_mode_map_alists
;
1487 lists
[0] = Vminor_mode_overriding_map_alist
;
1488 lists
[1] = Vminor_mode_map_alist
;
1490 for (list_number
= 0; list_number
< 2; list_number
++)
1492 if (CONSP (emulation_alists
))
1494 alist
= XCAR (emulation_alists
);
1495 emulation_alists
= XCDR (emulation_alists
);
1496 if (SYMBOLP (alist
))
1497 alist
= find_symbol_value (alist
);
1501 alist
= lists
[list_number
];
1503 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1504 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1505 && (var
= XCAR (assoc
), SYMBOLP (var
))
1506 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1511 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1512 and also an entry in Vminor_mode_map_alist,
1513 ignore the latter. */
1514 if (list_number
== 1)
1516 val
= assq_no_quit (var
, lists
[0]);
1523 int newsize
, allocsize
;
1524 Lisp_Object
*newmodes
, *newmaps
;
1526 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1527 allocsize
= newsize
* sizeof *newmodes
;
1529 /* Use malloc here. See the comment above this function.
1530 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1532 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1537 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1540 cmm_modes
= newmodes
;
1543 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1548 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1555 if (newmodes
== NULL
|| newmaps
== NULL
)
1560 /* Get the keymap definition--or nil if it is not defined. */
1561 temp
= Findirect_function (XCDR (assoc
), Qt
);
1565 cmm_maps
[i
] = temp
;
1571 if (modeptr
) *modeptr
= cmm_modes
;
1572 if (mapptr
) *mapptr
= cmm_maps
;
1576 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1578 doc
: /* Return a list of the currently active keymaps.
1579 OLP if non-nil indicates that we should obey `overriding-local-map' and
1580 `overriding-terminal-local-map'. POSITION can specify a click position
1581 like in the respective argument of `key-binding'. */)
1583 Lisp_Object olp
, position
;
1585 int count
= SPECPDL_INDEX ();
1587 Lisp_Object keymaps
;
1589 /* If a mouse click position is given, our variables are based on
1590 the buffer clicked on, not the current buffer. So we may have to
1591 switch the buffer here. */
1593 if (CONSP (position
))
1597 window
= POSN_WINDOW (position
);
1599 if (WINDOWP (window
)
1600 && BUFFERP (XWINDOW (window
)->buffer
)
1601 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1603 /* Arrange to go back to the original buffer once we're done
1604 processing the key sequence. We don't use
1605 save_excursion_{save,restore} here, in analogy to
1606 `read-key-sequence' to avoid saving point. Maybe this
1607 would not be a problem here, but it is easier to keep
1611 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1613 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1617 keymaps
= Fcons (current_global_map
, Qnil
);
1621 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1622 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1623 /* The doc said that overriding-terminal-local-map should
1624 override overriding-local-map. The code used them both,
1625 but it seems clearer to use just one. rms, jan 2005. */
1626 else if (!NILP (Voverriding_local_map
))
1627 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1629 if (NILP (XCDR (keymaps
)))
1634 Lisp_Object keymap
, local_map
;
1637 pt
= INTEGERP (position
) ? XINT (position
)
1638 : MARKERP (position
) ? marker_position (position
)
1641 /* Get the buffer local maps, possibly overriden by text or
1642 overlay properties */
1644 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1645 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1647 if (CONSP (position
))
1651 /* For a mouse click, get the local text-property keymap
1652 of the place clicked on, rather than point. */
1654 if (POSN_INBUFFER_P (position
))
1658 pos
= POSN_BUFFER_POSN (position
);
1660 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1662 local_map
= get_local_map (XINT (pos
),
1663 current_buffer
, Qlocal_map
);
1665 keymap
= get_local_map (XINT (pos
),
1666 current_buffer
, Qkeymap
);
1670 /* If on a mode line string with a local keymap,
1671 or for a click on a string, i.e. overlay string or a
1672 string displayed via the `display' property,
1673 consider `local-map' and `keymap' properties of
1676 if (string
= POSN_STRING (position
),
1677 (CONSP (string
) && STRINGP (XCAR (string
))))
1679 Lisp_Object pos
, map
;
1681 pos
= XCDR (string
);
1682 string
= XCAR (string
);
1685 && XINT (pos
) < SCHARS (string
))
1687 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1691 map
= Fget_text_property (pos
, Qkeymap
, string
);
1699 if (!NILP (local_map
))
1700 keymaps
= Fcons (local_map
, keymaps
);
1702 /* Now put all the minor mode keymaps on the list. */
1703 nmaps
= current_minor_maps (0, &maps
);
1705 for (i
= --nmaps
; i
>= 0; i
--)
1706 if (!NILP (maps
[i
]))
1707 keymaps
= Fcons (maps
[i
], keymaps
);
1710 keymaps
= Fcons (keymap
, keymaps
);
1713 unbind_to (count
, Qnil
);
1718 /* GC is possible in this function if it autoloads a keymap. */
1720 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 4, 0,
1721 doc
: /* Return the binding for command KEY in current keymaps.
1722 KEY is a string or vector, a sequence of keystrokes.
1723 The binding is probably a symbol with a function definition.
1725 Normally, `key-binding' ignores bindings for t, which act as default
1726 bindings, used when nothing else in the keymap applies; this makes it
1727 usable as a general function for probing keymaps. However, if the
1728 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1729 recognize the default bindings, just as `read-key-sequence' does.
1731 Like the normal command loop, `key-binding' will remap the command
1732 resulting from looking up KEY by looking up the command in the
1733 current keymaps. However, if the optional third argument NO-REMAP
1734 is non-nil, `key-binding' returns the unmapped command.
1736 If KEY is a key sequence initiated with the mouse, the used keymaps
1737 will depend on the clicked mouse position with regard to the buffer
1738 and possible local keymaps on strings.
1740 If the optional argument POSITION is non-nil, it specifies a mouse
1741 position as returned by `event-start' and `event-end', and the lookup
1742 occurs in the keymaps associated with it instead of KEY. It can also
1743 be a number or marker, in which case the keymap properties at the
1744 specified buffer position instead of point are used.
1746 (key
, accept_default
, no_remap
, position
)
1747 Lisp_Object key
, accept_default
, no_remap
, position
;
1749 Lisp_Object
*maps
, value
;
1751 struct gcpro gcpro1
, gcpro2
;
1752 int count
= SPECPDL_INDEX ();
1754 GCPRO2 (key
, position
);
1756 if (NILP (position
) && VECTORP (key
))
1759 /* mouse events may have a symbolic prefix indicating the
1760 scrollbar or mode line */
1761 = AREF (key
, SYMBOLP (AREF (key
, 0)) && ASIZE (key
) > 1 ? 1 : 0);
1763 /* We are not interested in locations without event data */
1765 if (EVENT_HAS_PARAMETERS (event
) && CONSP (XCDR (event
)))
1767 Lisp_Object kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1768 if (EQ (kind
, Qmouse_click
))
1769 position
= EVENT_START (event
);
1773 /* Key sequences beginning with mouse clicks
1774 are read using the keymaps of the buffer clicked on, not
1775 the current buffer. So we may have to switch the buffer
1778 if (CONSP (position
))
1782 window
= POSN_WINDOW (position
);
1784 if (WINDOWP (window
)
1785 && BUFFERP (XWINDOW (window
)->buffer
)
1786 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1788 /* Arrange to go back to the original buffer once we're done
1789 processing the key sequence. We don't use
1790 save_excursion_{save,restore} here, in analogy to
1791 `read-key-sequence' to avoid saving point. Maybe this
1792 would not be a problem here, but it is easier to keep
1796 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1798 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1802 if (! NILP (current_kboard
->Voverriding_terminal_local_map
))
1804 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1805 key
, accept_default
);
1806 if (! NILP (value
) && !INTEGERP (value
))
1809 else if (! NILP (Voverriding_local_map
))
1811 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1812 if (! NILP (value
) && !INTEGERP (value
))
1817 Lisp_Object keymap
, local_map
;
1820 pt
= INTEGERP (position
) ? XINT (position
)
1821 : MARKERP (position
) ? marker_position (position
)
1824 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1825 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1827 if (CONSP (position
))
1831 /* For a mouse click, get the local text-property keymap
1832 of the place clicked on, rather than point. */
1834 if (POSN_INBUFFER_P (position
))
1838 pos
= POSN_BUFFER_POSN (position
);
1840 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1842 local_map
= get_local_map (XINT (pos
),
1843 current_buffer
, Qlocal_map
);
1845 keymap
= get_local_map (XINT (pos
),
1846 current_buffer
, Qkeymap
);
1850 /* If on a mode line string with a local keymap,
1851 or for a click on a string, i.e. overlay string or a
1852 string displayed via the `display' property,
1853 consider `local-map' and `keymap' properties of
1856 if (string
= POSN_STRING (position
),
1857 (CONSP (string
) && STRINGP (XCAR (string
))))
1859 Lisp_Object pos
, map
;
1861 pos
= XCDR (string
);
1862 string
= XCAR (string
);
1865 && XINT (pos
) < SCHARS (string
))
1867 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1871 map
= Fget_text_property (pos
, Qkeymap
, string
);
1879 if (! NILP (keymap
))
1881 value
= Flookup_key (keymap
, key
, accept_default
);
1882 if (! NILP (value
) && !INTEGERP (value
))
1886 nmaps
= current_minor_maps (0, &maps
);
1887 /* Note that all these maps are GCPRO'd
1888 in the places where we found them. */
1890 for (i
= 0; i
< nmaps
; i
++)
1891 if (! NILP (maps
[i
]))
1893 value
= Flookup_key (maps
[i
], key
, accept_default
);
1894 if (! NILP (value
) && !INTEGERP (value
))
1898 if (! NILP (local_map
))
1900 value
= Flookup_key (local_map
, key
, accept_default
);
1901 if (! NILP (value
) && !INTEGERP (value
))
1906 value
= Flookup_key (current_global_map
, key
, accept_default
);
1909 unbind_to (count
, Qnil
);
1912 if (NILP (value
) || INTEGERP (value
))
1915 /* If the result of the ordinary keymap lookup is an interactive
1916 command, look for a key binding (ie. remapping) for that command. */
1918 if (NILP (no_remap
) && SYMBOLP (value
))
1921 if (value1
= Fcommand_remapping (value
, position
, Qnil
), !NILP (value1
))
1928 /* GC is possible in this function if it autoloads a keymap. */
1930 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1931 doc
: /* Return the binding for command KEYS in current local keymap only.
1932 KEYS is a string or vector, a sequence of keystrokes.
1933 The binding is probably a symbol with a function definition.
1935 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1936 bindings; see the description of `lookup-key' for more details about this. */)
1937 (keys
, accept_default
)
1938 Lisp_Object keys
, accept_default
;
1940 register Lisp_Object map
;
1941 map
= current_buffer
->keymap
;
1944 return Flookup_key (map
, keys
, accept_default
);
1947 /* GC is possible in this function if it autoloads a keymap. */
1949 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1950 doc
: /* Return the binding for command KEYS in current global keymap only.
1951 KEYS is a string or vector, a sequence of keystrokes.
1952 The binding is probably a symbol with a function definition.
1953 This function's return values are the same as those of `lookup-key'
1956 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1957 bindings; see the description of `lookup-key' for more details about this. */)
1958 (keys
, accept_default
)
1959 Lisp_Object keys
, accept_default
;
1961 return Flookup_key (current_global_map
, keys
, accept_default
);
1964 /* GC is possible in this function if it autoloads a keymap. */
1966 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1967 doc
: /* Find the visible minor mode bindings of KEY.
1968 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1969 the symbol which names the minor mode binding KEY, and BINDING is
1970 KEY's definition in that mode. In particular, if KEY has no
1971 minor-mode bindings, return nil. If the first binding is a
1972 non-prefix, all subsequent bindings will be omitted, since they would
1973 be ignored. Similarly, the list doesn't include non-prefix bindings
1974 that come after prefix bindings.
1976 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1977 bindings; see the description of `lookup-key' for more details about this. */)
1978 (key
, accept_default
)
1979 Lisp_Object key
, accept_default
;
1981 Lisp_Object
*modes
, *maps
;
1983 Lisp_Object binding
;
1985 struct gcpro gcpro1
, gcpro2
;
1987 nmaps
= current_minor_maps (&modes
, &maps
);
1988 /* Note that all these maps are GCPRO'd
1989 in the places where we found them. */
1992 GCPRO2 (key
, binding
);
1994 for (i
= j
= 0; i
< nmaps
; i
++)
1996 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1997 && !INTEGERP (binding
))
1999 if (KEYMAPP (binding
))
2000 maps
[j
++] = Fcons (modes
[i
], binding
);
2002 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
2006 return Flist (j
, maps
);
2009 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
2010 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
2011 A new sparse keymap is stored as COMMAND's function definition and its value.
2012 If a second optional argument MAPVAR is given, the map is stored as
2013 its value instead of as COMMAND's value; but COMMAND is still defined
2015 The third optional argument NAME, if given, supplies a menu name
2016 string for the map. This is required to use the keymap as a menu.
2017 This function returns COMMAND. */)
2018 (command
, mapvar
, name
)
2019 Lisp_Object command
, mapvar
, name
;
2022 map
= Fmake_sparse_keymap (name
);
2023 Ffset (command
, map
);
2027 Fset (command
, map
);
2031 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
2032 doc
: /* Select KEYMAP as the global keymap. */)
2036 keymap
= get_keymap (keymap
, 1, 1);
2037 current_global_map
= keymap
;
2042 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
2043 doc
: /* Select KEYMAP as the local keymap.
2044 If KEYMAP is nil, that means no local keymap. */)
2049 keymap
= get_keymap (keymap
, 1, 1);
2051 current_buffer
->keymap
= keymap
;
2056 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
2057 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
2060 return current_buffer
->keymap
;
2063 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
2064 doc
: /* Return the current global keymap. */)
2067 return current_global_map
;
2070 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
2071 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
2075 int nmaps
= current_minor_maps (0, &maps
);
2077 return Flist (nmaps
, maps
);
2080 /* Help functions for describing and documenting keymaps. */
2082 struct accessible_keymaps_data
{
2083 Lisp_Object maps
, tail
, thisseq
;
2084 /* Does the current sequence end in the meta-prefix-char? */
2089 accessible_keymaps_1 (key
, cmd
, args
, data
)
2090 Lisp_Object key
, cmd
, args
;
2091 /* Use void* to be compatible with map_keymap_function_t. */
2094 struct accessible_keymaps_data
*d
= data
; /* Cast! */
2095 Lisp_Object maps
= d
->maps
;
2096 Lisp_Object tail
= d
->tail
;
2097 Lisp_Object thisseq
= d
->thisseq
;
2098 int is_metized
= d
->is_metized
&& INTEGERP (key
);
2101 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
2105 /* Look for and break cycles. */
2106 while (!NILP (tem
= Frassq (cmd
, maps
)))
2108 Lisp_Object prefix
= XCAR (tem
);
2109 int lim
= XINT (Flength (XCAR (tem
)));
2110 if (lim
<= XINT (Flength (thisseq
)))
2111 { /* This keymap was already seen with a smaller prefix. */
2113 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
2114 Faref (thisseq
, make_number (i
))))
2117 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
2120 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
2121 but maybe `cmd' occurs again further down in `maps', so keep
2123 maps
= XCDR (Fmemq (tem
, maps
));
2126 /* If the last key in thisseq is meta-prefix-char,
2127 turn it into a meta-ized keystroke. We know
2128 that the event we're about to append is an
2129 ascii keystroke since we're processing a
2133 int meta_bit
= meta_modifier
;
2134 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
2135 tem
= Fcopy_sequence (thisseq
);
2137 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
2139 /* This new sequence is the same length as
2140 thisseq, so stick it in the list right
2143 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
2147 tem
= append_key (thisseq
, key
);
2148 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
2152 /* This function cannot GC. */
2154 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
2156 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
2157 Returns a list of elements of the form (KEYS . MAP), where the sequence
2158 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
2159 so that the KEYS increase in length. The first element is ([] . KEYMAP).
2160 An optional argument PREFIX, if non-nil, should be a key sequence;
2161 then the value includes only maps for prefixes that start with PREFIX. */)
2163 Lisp_Object keymap
, prefix
;
2165 Lisp_Object maps
, tail
;
2166 int prefixlen
= XINT (Flength (prefix
));
2168 /* no need for gcpro because we don't autoload any keymaps. */
2172 /* If a prefix was specified, start with the keymap (if any) for
2173 that prefix, so we don't waste time considering other prefixes. */
2175 tem
= Flookup_key (keymap
, prefix
, Qt
);
2176 /* Flookup_key may give us nil, or a number,
2177 if the prefix is not defined in this particular map.
2178 It might even give us a list that isn't a keymap. */
2179 tem
= get_keymap (tem
, 0, 0);
2180 /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
2181 want to return it. */
2184 /* Convert PREFIX to a vector now, so that later on
2185 we don't have to deal with the possibility of a string. */
2186 if (STRINGP (prefix
))
2191 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
2192 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
2196 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
2197 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2198 c
^= 0200 | meta_modifier
;
2199 ASET (copy
, i_before
, make_number (c
));
2203 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
2209 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
2210 get_keymap (keymap
, 1, 0)),
2213 /* For each map in the list maps,
2214 look at any other maps it points to,
2215 and stick them at the end if they are not already in the list.
2217 This is a breadth-first traversal, where tail is the queue of
2218 nodes, and maps accumulates a list of all nodes visited. */
2220 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2222 struct accessible_keymaps_data data
;
2223 register Lisp_Object thismap
= Fcdr (XCAR (tail
));
2226 data
.thisseq
= Fcar (XCAR (tail
));
2229 last
= make_number (XINT (Flength (data
.thisseq
)) - 1);
2230 /* Does the current sequence end in the meta-prefix-char? */
2231 data
.is_metized
= (XINT (last
) >= 0
2232 /* Don't metize the last char of PREFIX. */
2233 && XINT (last
) >= prefixlen
2234 && EQ (Faref (data
.thisseq
, last
), meta_prefix_char
));
2236 /* Since we can't run lisp code, we can't scan autoloaded maps. */
2237 if (CONSP (thismap
))
2238 map_keymap (thismap
, accessible_keymaps_1
, Qnil
, &data
, 0);
2242 Lisp_Object Qsingle_key_description
, Qkey_description
;
2244 /* This function cannot GC. */
2246 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2247 doc
: /* Return a pretty description of key-sequence KEYS.
2248 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2249 Control characters turn into "C-foo" sequences, meta into "M-foo",
2250 spaces are put between sequence elements, etc. */)
2252 Lisp_Object keys
, prefix
;
2257 int size
= XINT (Flength (keys
));
2259 Lisp_Object sep
= build_string (" ");
2264 size
+= XINT (Flength (prefix
));
2266 /* This has one extra element at the end that we don't pass to Fconcat. */
2267 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2269 /* In effect, this computes
2270 (mapconcat 'single-key-description keys " ")
2271 but we shouldn't use mapconcat because it can do GC. */
2275 list
= prefix
, prefix
= Qnil
;
2276 else if (!NILP (keys
))
2277 list
= keys
, keys
= Qnil
;
2282 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2286 return empty_unibyte_string
;
2287 return Fconcat (len
- 1, args
);
2291 size
= SCHARS (list
);
2292 else if (VECTORP (list
))
2293 size
= XVECTOR (list
)->size
;
2294 else if (CONSP (list
))
2295 size
= XINT (Flength (list
));
2297 wrong_type_argument (Qarrayp
, list
);
2306 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2307 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2308 c
^= 0200 | meta_modifier
;
2309 XSETFASTINT (key
, c
);
2311 else if (VECTORP (list
))
2313 key
= AREF (list
, i
++);
2325 || EQ (key
, meta_prefix_char
)
2326 || (XINT (key
) & meta_modifier
))
2328 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2330 if (EQ (key
, meta_prefix_char
))
2334 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2337 else if (EQ (key
, meta_prefix_char
))
2342 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2350 push_key_description (c
, p
, force_multibyte
)
2351 register unsigned int c
;
2353 int force_multibyte
;
2357 /* Clear all the meaningless bits above the meta bit. */
2358 c
&= meta_modifier
| ~ - meta_modifier
;
2359 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2360 | meta_modifier
| shift_modifier
| super_modifier
);
2362 if (! CHARACTERP (make_number (c2
)))
2364 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2365 p
+= sprintf (p
, "[%d]", c
);
2369 if (c
& alt_modifier
)
2375 if ((c
& ctrl_modifier
) != 0
2376 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2380 c
&= ~ctrl_modifier
;
2382 if (c
& hyper_modifier
)
2386 c
-= hyper_modifier
;
2388 if (c
& meta_modifier
)
2394 if (c
& shift_modifier
)
2398 c
-= shift_modifier
;
2400 if (c
& super_modifier
)
2404 c
-= super_modifier
;
2420 else if (c
== Ctl ('M'))
2428 /* `C-' already added above. */
2429 if (c
> 0 && c
<= Ctl ('Z'))
2448 || (NILP (current_buffer
->enable_multibyte_characters
)
2449 && SINGLE_BYTE_CHAR_P (c
)
2450 && !force_multibyte
))
2456 /* Now we are sure that C is a valid character code. */
2457 if (NILP (current_buffer
->enable_multibyte_characters
)
2458 && ! force_multibyte
)
2459 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2461 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2467 /* This function cannot GC. */
2469 DEFUN ("single-key-description", Fsingle_key_description
,
2470 Ssingle_key_description
, 1, 2, 0,
2471 doc
: /* Return a pretty description of command character KEY.
2472 Control characters turn into C-whatever, etc.
2473 Optional argument NO-ANGLES non-nil means don't put angle brackets
2474 around function keys and event symbols. */)
2476 Lisp_Object key
, no_angles
;
2478 if (CONSP (key
) && lucid_event_type_list_p (key
))
2479 key
= Fevent_convert_list (key
);
2481 key
= EVENT_HEAD (key
);
2483 if (INTEGERP (key
)) /* Normal character */
2485 char tem
[KEY_DESCRIPTION_SIZE
];
2487 *push_key_description (XUINT (key
), tem
, 1) = 0;
2488 return build_string (tem
);
2490 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2492 if (NILP (no_angles
))
2495 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2496 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2497 return build_string (buffer
);
2500 return Fsymbol_name (key
);
2502 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2503 return Fcopy_sequence (key
);
2505 error ("KEY must be an integer, cons, symbol, or string");
2510 push_text_char_description (c
, p
)
2511 register unsigned int c
;
2523 *p
++ = c
+ 64; /* 'A' - 1 */
2535 /* This function cannot GC. */
2537 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2538 doc
: /* Return a pretty description of file-character CHARACTER.
2539 Control characters turn into "^char", etc. This differs from
2540 `single-key-description' which turns them into "C-char".
2541 Also, this function recognizes the 2**7 bit as the Meta character,
2542 whereas `single-key-description' uses the 2**27 bit for Meta.
2543 See Info node `(elisp)Describing Characters' for examples. */)
2545 Lisp_Object character
;
2547 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2548 unsigned char str
[6];
2551 CHECK_NUMBER (character
);
2553 c
= XINT (character
);
2554 if (!ASCII_CHAR_P (c
))
2556 int len
= CHAR_STRING (c
, str
);
2558 return make_multibyte_string (str
, 1, len
);
2561 *push_text_char_description (c
& 0377, str
) = 0;
2563 return build_string (str
);
2566 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2569 ascii_sequence_p (seq
)
2573 int len
= XINT (Flength (seq
));
2575 for (i
= 0; i
< len
; i
++)
2577 Lisp_Object ii
, elt
;
2579 XSETFASTINT (ii
, i
);
2580 elt
= Faref (seq
, ii
);
2583 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2591 /* where-is - finding a command in a set of keymaps. */
2593 static Lisp_Object
where_is_internal ();
2594 static void where_is_internal_1
P_ ((Lisp_Object key
, Lisp_Object binding
,
2595 Lisp_Object args
, void *data
));
2597 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2598 Returns the first non-nil binding found in any of those maps. */
2601 shadow_lookup (shadow
, key
, flag
)
2602 Lisp_Object shadow
, key
, flag
;
2604 Lisp_Object tail
, value
;
2606 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2608 value
= Flookup_key (XCAR (tail
), key
, flag
);
2609 if (NATNUMP (value
))
2611 value
= Flookup_key (XCAR (tail
),
2612 Fsubstring (key
, make_number (0), value
), flag
);
2616 else if (!NILP (value
))
2622 static Lisp_Object Vmouse_events
;
2624 struct where_is_internal_data
{
2625 Lisp_Object definition
, noindirect
, this, last
;
2627 Lisp_Object sequences
;
2630 /* This function can GC if Flookup_key autoloads any keymaps. */
2633 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2634 Lisp_Object definition
, keymaps
;
2635 Lisp_Object firstonly
, noindirect
, no_remap
;
2637 Lisp_Object maps
= Qnil
;
2638 Lisp_Object found
, sequences
;
2639 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2640 /* 1 means ignore all menu bindings entirely. */
2641 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2644 while (CONSP (found
))
2648 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2649 found
= XCDR (found
);
2652 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2656 /* If this command is remapped, then it has no key bindings
2659 && SYMBOLP (definition
)
2660 && !NILP (Fcommand_remapping (definition
, Qnil
, keymaps
)))
2661 RETURN_UNGCPRO (Qnil
);
2663 for (; !NILP (maps
); maps
= Fcdr (maps
))
2665 /* Key sequence to reach map, and the map that it reaches */
2666 register Lisp_Object
this, map
, tem
;
2667 struct where_is_internal_data data
;
2669 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2670 [M-CHAR] sequences, check if last character of the sequence
2671 is the meta-prefix char. */
2675 this = Fcar (Fcar (maps
));
2676 map
= Fcdr (Fcar (maps
));
2677 last
= make_number (XINT (Flength (this)) - 1);
2678 last_is_meta
= (XINT (last
) >= 0
2679 && EQ (Faref (this, last
), meta_prefix_char
));
2681 /* if (nomenus && !ascii_sequence_p (this)) */
2682 if (nomenus
&& XINT (last
) >= 0
2683 && SYMBOLP (tem
= Faref (this, make_number (0)))
2684 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2685 /* If no menu entries should be returned, skip over the
2686 keymaps bound to `menu-bar' and `tool-bar' and other
2687 non-ascii prefixes like `C-down-mouse-2'. */
2692 data
.definition
= definition
;
2693 data
.noindirect
= noindirect
;
2696 data
.last_is_meta
= last_is_meta
;
2697 data
.sequences
= Qnil
;
2700 map_keymap (map
, where_is_internal_1
, Qnil
, &data
, 0);
2702 sequences
= data
.sequences
;
2704 while (CONSP (sequences
))
2706 Lisp_Object sequence
, remapped
, function
;
2708 sequence
= XCAR (sequences
);
2709 sequences
= XCDR (sequences
);
2711 /* If the current sequence is a command remapping with
2712 format [remap COMMAND], find the key sequences
2713 which run COMMAND, and use those sequences instead. */
2716 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2717 && EQ (AREF (sequence
, 0), Qremap
)
2718 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2720 Lisp_Object remapped1
;
2722 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2723 if (CONSP (remapped1
))
2725 /* Verify that this key binding actually maps to the
2726 remapped command (see below). */
2727 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2729 sequence
= XCAR (remapped1
);
2730 remapped
= XCDR (remapped1
);
2731 goto record_sequence
;
2735 /* Verify that this key binding is not shadowed by another
2736 binding for the same key, before we say it exists.
2738 Mechanism: look for local definition of this key and if
2739 it is defined and does not match what we found then
2742 Either nil or number as value from Flookup_key
2744 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2748 /* Don't annoy user with strings from a menu such as
2749 Select Paste. Change them all to "(any string)",
2750 so that there seems to be only one menu item
2752 if (! NILP (sequence
))
2755 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2757 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2758 build_string ("(any string)"));
2761 /* It is a true unshadowed match. Record it, unless it's already
2762 been seen (as could happen when inheriting keymaps). */
2763 if (NILP (Fmember (sequence
, found
)))
2764 found
= Fcons (sequence
, found
);
2766 /* If firstonly is Qnon_ascii, then we can return the first
2767 binding we find. If firstonly is not Qnon_ascii but not
2768 nil, then we should return the first ascii-only binding
2770 if (EQ (firstonly
, Qnon_ascii
))
2771 RETURN_UNGCPRO (sequence
);
2772 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2773 RETURN_UNGCPRO (sequence
);
2775 if (CONSP (remapped
))
2777 sequence
= XCAR (remapped
);
2778 remapped
= XCDR (remapped
);
2779 goto record_sequence
;
2786 found
= Fnreverse (found
);
2788 /* firstonly may have been t, but we may have gone all the way through
2789 the keymaps without finding an all-ASCII key sequence. So just
2790 return the best we could find. */
2791 if (!NILP (firstonly
))
2792 return Fcar (found
);
2797 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2798 doc
: /* Return list of keys that invoke DEFINITION.
2799 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2800 If KEYMAP is nil, search all the currently active keymaps.
2801 If KEYMAP is a list of keymaps, search only those keymaps.
2803 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2804 rather than a list of all possible key sequences.
2805 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2806 no matter what it is.
2807 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2808 \(or their meta variants) and entirely reject menu bindings.
2810 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2811 to other keymaps or slots. This makes it possible to search for an
2812 indirect definition itself.
2814 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2815 that invoke a command which is remapped to DEFINITION, but include the
2816 remapped command in the returned list. */)
2817 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2818 Lisp_Object definition
, keymap
;
2819 Lisp_Object firstonly
, noindirect
, no_remap
;
2821 Lisp_Object sequences
, keymaps
;
2822 /* 1 means ignore all menu bindings entirely. */
2823 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2826 /* Find the relevant keymaps. */
2827 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2829 else if (!NILP (keymap
))
2830 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2832 keymaps
= Fcurrent_active_maps (Qnil
, Qnil
);
2834 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2835 We don't really need to check `keymap'. */
2836 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2840 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2842 /* Check heuristic-consistency of the cache. */
2843 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2844 where_is_cache
= Qnil
;
2846 if (NILP (where_is_cache
))
2848 /* We need to create the cache. */
2849 Lisp_Object args
[2];
2850 where_is_cache
= Fmake_hash_table (0, args
);
2851 where_is_cache_keymaps
= Qt
;
2853 /* Fill in the cache. */
2854 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2855 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2858 where_is_cache_keymaps
= keymaps
;
2861 /* We want to process definitions from the last to the first.
2862 Instead of consing, copy definitions to a vector and step
2863 over that vector. */
2864 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2865 n
= XINT (Flength (sequences
));
2866 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2867 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2868 defns
[i
++] = XCAR (sequences
);
2870 /* Verify that the key bindings are not shadowed. Note that
2871 the following can GC. */
2872 GCPRO2 (definition
, keymaps
);
2875 for (i
= n
- 1; i
>= 0; --i
)
2876 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2878 if (ascii_sequence_p (defns
[i
]))
2884 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2889 /* Kill the cache so that where_is_internal_1 doesn't think
2890 we're filling it up. */
2891 where_is_cache
= Qnil
;
2892 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2898 /* This function can GC because get_keyelt can. */
2901 where_is_internal_1 (key
, binding
, args
, data
)
2902 Lisp_Object key
, binding
, args
;
2905 struct where_is_internal_data
*d
= data
; /* Cast! */
2906 Lisp_Object definition
= d
->definition
;
2907 Lisp_Object noindirect
= d
->noindirect
;
2908 Lisp_Object
this = d
->this;
2909 Lisp_Object last
= d
->last
;
2910 int last_is_meta
= d
->last_is_meta
;
2911 Lisp_Object sequence
;
2913 /* Search through indirections unless that's not wanted. */
2914 if (NILP (noindirect
))
2915 binding
= get_keyelt (binding
, 0);
2917 /* End this iteration if this element does not match
2920 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2921 || EQ (binding
, definition
)
2922 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2923 /* Doesn't match. */
2926 /* We have found a match. Construct the key sequence where we found it. */
2927 if (INTEGERP (key
) && last_is_meta
)
2929 sequence
= Fcopy_sequence (this);
2930 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2933 sequence
= append_key (this, key
);
2935 if (!NILP (where_is_cache
))
2937 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2938 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2941 d
->sequences
= Fcons (sequence
, d
->sequences
);
2944 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2946 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2947 doc
: /* Insert the list of all defined keys and their definitions.
2948 The list is inserted in the current buffer, while the bindings are
2949 looked up in BUFFER.
2950 The optional argument PREFIX, if non-nil, should be a key sequence;
2951 then we display only bindings that start with that prefix.
2952 The optional argument MENUS, if non-nil, says to mention menu bindings.
2953 \(Ordinarily these are omitted from the output.) */)
2954 (buffer
, prefix
, menus
)
2955 Lisp_Object buffer
, prefix
, menus
;
2957 Lisp_Object outbuf
, shadow
;
2958 int nomenu
= NILP (menus
);
2959 register Lisp_Object start1
;
2960 struct gcpro gcpro1
;
2962 char *alternate_heading
2964 Keyboard translations:\n\n\
2965 You type Translation\n\
2966 -------- -----------\n";
2968 CHECK_BUFFER (buffer
);
2973 outbuf
= Fcurrent_buffer ();
2975 /* Report on alternates for keys. */
2976 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2979 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2980 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2982 for (c
= 0; c
< translate_len
; c
++)
2983 if (translate
[c
] != c
)
2985 char buf
[KEY_DESCRIPTION_SIZE
];
2988 if (alternate_heading
)
2990 insert_string (alternate_heading
);
2991 alternate_heading
= 0;
2994 bufend
= push_key_description (translate
[c
], buf
, 1);
2995 insert (buf
, bufend
- buf
);
2996 Findent_to (make_number (16), make_number (1));
2997 bufend
= push_key_description (c
, buf
, 1);
2998 insert (buf
, bufend
- buf
);
3002 /* Insert calls signal_after_change which may GC. */
3003 translate
= SDATA (Vkeyboard_translate_table
);
3009 if (!NILP (Vkey_translation_map
))
3010 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
3011 "Key translations", nomenu
, 1, 0, 0);
3014 /* Print the (major mode) local map. */
3016 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
3017 start1
= current_kboard
->Voverriding_terminal_local_map
;
3018 else if (!NILP (Voverriding_local_map
))
3019 start1
= Voverriding_local_map
;
3023 describe_map_tree (start1
, 1, shadow
, prefix
,
3024 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
3025 shadow
= Fcons (start1
, shadow
);
3029 /* Print the minor mode and major mode keymaps. */
3031 Lisp_Object
*modes
, *maps
;
3033 /* Temporarily switch to `buffer', so that we can get that buffer's
3034 minor modes correctly. */
3035 Fset_buffer (buffer
);
3037 nmaps
= current_minor_maps (&modes
, &maps
);
3038 Fset_buffer (outbuf
);
3040 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3041 XBUFFER (buffer
), Qkeymap
);
3044 describe_map_tree (start1
, 1, shadow
, prefix
,
3045 "\f\n`keymap' Property Bindings", nomenu
,
3047 shadow
= Fcons (start1
, shadow
);
3050 /* Print the minor mode maps. */
3051 for (i
= 0; i
< nmaps
; i
++)
3053 /* The title for a minor mode keymap
3054 is constructed at run time.
3055 We let describe_map_tree do the actual insertion
3056 because it takes care of other features when doing so. */
3059 if (!SYMBOLP (modes
[i
]))
3062 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3066 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
3067 SCHARS (SYMBOL_NAME (modes
[i
])));
3068 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3070 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
3071 p
+= sizeof (" Minor Mode Bindings") - 1;
3074 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3075 title
, nomenu
, 0, 0, 0);
3076 shadow
= Fcons (maps
[i
], shadow
);
3079 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3080 XBUFFER (buffer
), Qlocal_map
);
3083 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3084 describe_map_tree (start1
, 1, shadow
, prefix
,
3085 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3087 describe_map_tree (start1
, 1, shadow
, prefix
,
3088 "\f\n`local-map' Property Bindings",
3091 shadow
= Fcons (start1
, shadow
);
3095 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3096 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3098 /* Print the function-key-map translations under this prefix. */
3099 if (!NILP (Vfunction_key_map
))
3100 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
3101 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3107 /* Insert a description of the key bindings in STARTMAP,
3108 followed by those of all maps reachable through STARTMAP.
3109 If PARTIAL is nonzero, omit certain "uninteresting" commands
3110 (such as `undefined').
3111 If SHADOW is non-nil, it is a list of maps;
3112 don't mention keys which would be shadowed by any of them.
3113 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3114 TITLE, if not 0, is a string to insert at the beginning.
3115 TITLE should not end with a colon or a newline; we supply that.
3116 If NOMENU is not 0, then omit menu-bar commands.
3118 If TRANSL is nonzero, the definitions are actually key translations
3119 so print strings and vectors differently.
3121 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3124 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3125 don't omit it; instead, mention it but say it is shadowed. */
3128 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3129 always_title
, mention_shadow
)
3130 Lisp_Object startmap
, shadow
, prefix
;
3138 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3139 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3146 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3149 GCPRO3 (maps
, seen
, sub_shadows
);
3155 /* Delete from MAPS each element that is for the menu bar. */
3156 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3158 Lisp_Object elt
, prefix
, tem
;
3161 prefix
= Fcar (elt
);
3162 if (XVECTOR (prefix
)->size
>= 1)
3164 tem
= Faref (prefix
, make_number (0));
3165 if (EQ (tem
, Qmenu_bar
))
3166 maps
= Fdelq (elt
, maps
);
3171 if (!NILP (maps
) || always_title
)
3175 insert_string (title
);
3178 insert_string (" Starting With ");
3179 insert1 (Fkey_description (prefix
, Qnil
));
3181 insert_string (":\n");
3183 insert_string (key_heading
);
3187 for (; !NILP (maps
); maps
= Fcdr (maps
))
3189 register Lisp_Object elt
, prefix
, tail
;
3192 prefix
= Fcar (elt
);
3196 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3200 shmap
= XCAR (tail
);
3202 /* If the sequence by which we reach this keymap is zero-length,
3203 then the shadow map for this keymap is just SHADOW. */
3204 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3205 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3207 /* If the sequence by which we reach this keymap actually has
3208 some elements, then the sequence's definition in SHADOW is
3209 what we should use. */
3212 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3213 if (INTEGERP (shmap
))
3217 /* If shmap is not nil and not a keymap,
3218 it completely shadows this map, so don't
3219 describe this map at all. */
3220 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3224 sub_shadows
= Fcons (shmap
, sub_shadows
);
3227 /* Maps we have already listed in this loop shadow this map. */
3228 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3231 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3233 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3236 describe_map (Fcdr (elt
), prefix
,
3237 transl
? describe_translation
: describe_command
,
3238 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3244 insert_string ("\n");
3249 static int previous_description_column
;
3252 describe_command (definition
, args
)
3253 Lisp_Object definition
, args
;
3255 register Lisp_Object tem1
;
3256 int column
= (int) current_column (); /* iftc */
3257 int description_column
;
3259 /* If column 16 is no good, go to col 32;
3260 but don't push beyond that--go to next line instead. */
3264 description_column
= 32;
3266 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3267 description_column
= 32;
3269 description_column
= 16;
3271 Findent_to (make_number (description_column
), make_number (1));
3272 previous_description_column
= description_column
;
3274 if (SYMBOLP (definition
))
3276 tem1
= SYMBOL_NAME (definition
);
3278 insert_string ("\n");
3280 else if (STRINGP (definition
) || VECTORP (definition
))
3281 insert_string ("Keyboard Macro\n");
3282 else if (KEYMAPP (definition
))
3283 insert_string ("Prefix Command\n");
3285 insert_string ("??\n");
3289 describe_translation (definition
, args
)
3290 Lisp_Object definition
, args
;
3292 register Lisp_Object tem1
;
3294 Findent_to (make_number (16), make_number (1));
3296 if (SYMBOLP (definition
))
3298 tem1
= SYMBOL_NAME (definition
);
3300 insert_string ("\n");
3302 else if (STRINGP (definition
) || VECTORP (definition
))
3304 insert1 (Fkey_description (definition
, Qnil
));
3305 insert_string ("\n");
3307 else if (KEYMAPP (definition
))
3308 insert_string ("Prefix Command\n");
3310 insert_string ("??\n");
3313 /* describe_map puts all the usable elements of a sparse keymap
3314 into an array of `struct describe_map_elt',
3315 then sorts them by the events. */
3317 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3319 /* qsort comparison function for sorting `struct describe_map_elt' by
3323 describe_map_compare (aa
, bb
)
3324 const void *aa
, *bb
;
3326 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3327 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3328 return ((XINT (a
->event
) > XINT (b
->event
))
3329 - (XINT (a
->event
) < XINT (b
->event
)));
3330 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3332 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3334 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3335 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3336 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3341 /* Describe the contents of map MAP, assuming that this map itself is
3342 reached by the sequence of prefix keys PREFIX (a string or vector).
3343 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3346 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3347 seen
, nomenu
, mention_shadow
)
3348 register Lisp_Object map
;
3350 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3357 Lisp_Object tail
, definition
, event
;
3359 Lisp_Object suppress
;
3362 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3364 /* These accumulate the values from sparse keymap bindings,
3365 so we can sort them and handle them in order. */
3366 int length_needed
= 0;
3367 struct describe_map_elt
*vect
;
3374 suppress
= intern ("suppress-keymap");
3376 /* This vector gets used to present single keys to Flookup_key. Since
3377 that is done once per keymap element, we don't want to cons up a
3378 fresh vector every time. */
3379 kludge
= Fmake_vector (make_number (1), Qnil
);
3382 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3385 vect
= ((struct describe_map_elt
*)
3386 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3388 GCPRO3 (prefix
, definition
, kludge
);
3390 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3394 if (VECTORP (XCAR (tail
))
3395 || CHAR_TABLE_P (XCAR (tail
)))
3396 describe_vector (XCAR (tail
),
3397 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3398 (int *)0, 0, 1, mention_shadow
);
3399 else if (CONSP (XCAR (tail
)))
3401 int this_shadowed
= 0;
3403 event
= XCAR (XCAR (tail
));
3405 /* Ignore bindings whose "prefix" are not really valid events.
3406 (We get these in the frames and buffers menu.) */
3407 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3410 if (nomenu
&& EQ (event
, Qmenu_bar
))
3413 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3415 /* Don't show undefined commands or suppressed commands. */
3416 if (NILP (definition
)) continue;
3417 if (SYMBOLP (definition
) && partial
)
3419 tem
= Fget (definition
, suppress
);
3424 /* Don't show a command that isn't really visible
3425 because a local definition of the same key shadows it. */
3427 ASET (kludge
, 0, event
);
3430 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3433 /* If both bindings are keymaps, this key is a prefix key,
3434 so don't say it is shadowed. */
3435 if (KEYMAPP (definition
) && KEYMAPP (tem
))
3437 /* Avoid generating duplicate entries if the
3438 shadowed binding has the same definition. */
3439 else if (mention_shadow
&& !EQ (tem
, definition
))
3446 tem
= Flookup_key (map
, kludge
, Qt
);
3447 if (!EQ (tem
, definition
)) continue;
3449 vect
[slots_used
].event
= event
;
3450 vect
[slots_used
].definition
= definition
;
3451 vect
[slots_used
].shadowed
= this_shadowed
;
3454 else if (EQ (XCAR (tail
), Qkeymap
))
3456 /* The same keymap might be in the structure twice, if we're
3457 using an inherited keymap. So skip anything we've already
3459 tem
= Fassq (tail
, *seen
);
3460 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3462 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3466 /* If we found some sparse map events, sort them. */
3468 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3469 describe_map_compare
);
3471 /* Now output them in sorted order. */
3473 for (i
= 0; i
< slots_used
; i
++)
3475 Lisp_Object start
, end
;
3479 previous_description_column
= 0;
3484 ASET (kludge
, 0, vect
[i
].event
);
3485 start
= vect
[i
].event
;
3488 definition
= vect
[i
].definition
;
3490 /* Find consecutive chars that are identically defined. */
3491 if (INTEGERP (vect
[i
].event
))
3493 while (i
+ 1 < slots_used
3494 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3495 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3496 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3498 end
= vect
[i
].event
;
3501 /* Now START .. END is the range to describe next. */
3503 /* Insert the string to describe the event START. */
3504 insert1 (Fkey_description (kludge
, prefix
));
3506 if (!EQ (start
, end
))
3510 ASET (kludge
, 0, end
);
3511 /* Insert the string to describe the character END. */
3512 insert1 (Fkey_description (kludge
, prefix
));
3515 /* Print a description of the definition of this character.
3516 elt_describer will take care of spacing out far enough
3517 for alignment purposes. */
3518 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3520 if (vect
[i
].shadowed
)
3523 insert_string ("\n (that binding is currently shadowed by another mode)");
3532 describe_vector_princ (elt
, fun
)
3533 Lisp_Object elt
, fun
;
3535 Findent_to (make_number (16), make_number (1));
3540 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3541 doc
: /* Insert a description of contents of VECTOR.
3542 This is text showing the elements of vector matched against indices.
3543 DESCRIBER is the output function used; nil means use `princ'. */)
3545 Lisp_Object vector
, describer
;
3547 int count
= SPECPDL_INDEX ();
3548 if (NILP (describer
))
3549 describer
= intern ("princ");
3550 specbind (Qstandard_output
, Fcurrent_buffer ());
3551 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3552 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3553 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3555 return unbind_to (count
, Qnil
);
3558 /* Insert in the current buffer a description of the contents of VECTOR.
3559 We call ELT_DESCRIBER to insert the description of one value found
3562 ELT_PREFIX describes what "comes before" the keys or indices defined
3563 by this vector. This is a human-readable string whose size
3564 is not necessarily related to the situation.
3566 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3567 leads to this keymap.
3569 If the vector is a chartable, ELT_PREFIX is the vector
3570 of bytes that lead to the character set or portion of a character
3571 set described by this chartable.
3573 If PARTIAL is nonzero, it means do not mention suppressed commands
3574 (that assumes the vector is in a keymap).
3576 SHADOW is a list of keymaps that shadow this map.
3577 If it is non-nil, then we look up the key in those maps
3578 and we don't mention it now if it is defined by any of them.
3580 ENTIRE_MAP is the keymap in which this vector appears.
3581 If the definition in effect in the whole map does not match
3582 the one in this vector, we ignore this one.
3584 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3586 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3589 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3591 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3594 describe_vector (vector
, prefix
, args
, elt_describer
,
3595 partial
, shadow
, entire_map
,
3596 indices
, char_table_depth
, keymap_p
,
3598 register Lisp_Object vector
;
3599 Lisp_Object prefix
, args
;
3600 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3603 Lisp_Object entire_map
;
3605 int char_table_depth
;
3609 Lisp_Object definition
;
3611 Lisp_Object elt_prefix
= Qnil
;
3613 Lisp_Object suppress
;
3616 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3617 /* Range of elements to be handled. */
3619 Lisp_Object character
;
3628 /* Call Fkey_description first, to avoid GC bug for the other string. */
3629 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3632 tem
= Fkey_description (prefix
, Qnil
);
3633 elt_prefix
= concat2 (tem
, build_string (" "));
3638 /* This vector gets used to present single keys to Flookup_key. Since
3639 that is done once per vector element, we don't want to cons up a
3640 fresh vector every time. */
3641 kludge
= Fmake_vector (make_number (1), Qnil
);
3642 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3645 suppress
= intern ("suppress-keymap");
3648 to
= CHAR_TABLE_P (vector
) ? MAX_CHAR
+ 1 : XVECTOR (vector
)->size
;
3650 for (i
= from
; i
< to
; i
++)
3652 int this_shadowed
= 0;
3653 int range_beg
, range_end
;
3660 if (CHAR_TABLE_P (vector
))
3661 val
= char_table_ref_and_range (vector
, i
, &range_beg
, &i
);
3663 val
= AREF (vector
, i
);
3664 definition
= get_keyelt (val
, 0);
3666 if (NILP (definition
)) continue;
3668 /* Don't mention suppressed commands. */
3669 if (SYMBOLP (definition
) && partial
)
3673 tem
= Fget (definition
, suppress
);
3675 if (!NILP (tem
)) continue;
3678 character
= make_number (starting_i
);
3679 ASET (kludge
, 0, character
);
3681 /* If this binding is shadowed by some other map, ignore it. */
3686 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3697 /* Ignore this definition if it is shadowed by an earlier
3698 one in the same keymap. */
3699 if (!NILP (entire_map
))
3703 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3705 if (!EQ (tem
, definition
))
3715 /* Output the prefix that applies to every entry in this map. */
3716 if (!NILP (elt_prefix
))
3717 insert1 (elt_prefix
);
3719 insert1 (Fkey_description (kludge
, prefix
));
3721 /* Find all consecutive characters or rows that have the same
3722 definition. But, for elements of a top level char table, if
3723 they are for charsets, we had better describe one by one even
3724 if they have the same definition. */
3725 if (CHAR_TABLE_P (vector
))
3727 && (val
= char_table_ref_and_range (vector
, i
+ 1,
3728 &range_beg
, &range_end
),
3729 tem2
= get_keyelt (val
, 0),
3731 && !NILP (Fequal (tem2
, definition
)))
3735 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3737 && !NILP (Fequal (tem2
, definition
)))
3740 /* If we have a range of more than one character,
3741 print where the range reaches to. */
3743 if (i
!= starting_i
)
3747 ASET (kludge
, 0, make_number (i
));
3749 if (!NILP (elt_prefix
))
3750 insert1 (elt_prefix
);
3752 insert1 (Fkey_description (kludge
, prefix
));
3755 /* Print a description of the definition of this character.
3756 elt_describer will take care of spacing out far enough
3757 for alignment purposes. */
3758 (*elt_describer
) (definition
, args
);
3763 insert_string (" (binding currently shadowed)");
3768 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3770 if (!NILP (elt_prefix
))
3771 insert1 (elt_prefix
);
3772 insert ("default", 7);
3773 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3779 /* Apropos - finding all symbols whose names match a regexp. */
3780 static Lisp_Object apropos_predicate
;
3781 static Lisp_Object apropos_accumulate
;
3784 apropos_accum (symbol
, string
)
3785 Lisp_Object symbol
, string
;
3787 register Lisp_Object tem
;
3789 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3790 if (!NILP (tem
) && !NILP (apropos_predicate
))
3791 tem
= call1 (apropos_predicate
, symbol
);
3793 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3796 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3797 doc
: /* Show all symbols whose names contain match for REGEXP.
3798 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3799 for each symbol and a symbol is mentioned only if that returns non-nil.
3800 Return list of symbols found. */)
3802 Lisp_Object regexp
, predicate
;
3805 CHECK_STRING (regexp
);
3806 apropos_predicate
= predicate
;
3807 apropos_accumulate
= Qnil
;
3808 map_obarray (Vobarray
, apropos_accum
, regexp
);
3809 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3810 apropos_accumulate
= Qnil
;
3811 apropos_predicate
= Qnil
;
3818 Qkeymap
= intern ("keymap");
3819 staticpro (&Qkeymap
);
3820 staticpro (&apropos_predicate
);
3821 staticpro (&apropos_accumulate
);
3822 apropos_predicate
= Qnil
;
3823 apropos_accumulate
= Qnil
;
3825 /* Now we are ready to set up this property, so we can
3826 create char tables. */
3827 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3829 /* Initialize the keymaps standardly used.
3830 Each one is the value of a Lisp variable, and is also
3831 pointed to by a C variable */
3833 global_map
= Fmake_keymap (Qnil
);
3834 Fset (intern ("global-map"), global_map
);
3836 current_global_map
= global_map
;
3837 staticpro (&global_map
);
3838 staticpro (¤t_global_map
);
3840 meta_map
= Fmake_keymap (Qnil
);
3841 Fset (intern ("esc-map"), meta_map
);
3842 Ffset (intern ("ESC-prefix"), meta_map
);
3844 control_x_map
= Fmake_keymap (Qnil
);
3845 Fset (intern ("ctl-x-map"), control_x_map
);
3846 Ffset (intern ("Control-X-prefix"), control_x_map
);
3849 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3850 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3851 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3852 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3853 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3855 staticpro (&exclude_keys
);
3857 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3858 doc
: /* List of commands given new key bindings recently.
3859 This is used for internal purposes during Emacs startup;
3860 don't alter it yourself. */);
3861 Vdefine_key_rebound_commands
= Qt
;
3863 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3864 doc
: /* Default keymap to use when reading from the minibuffer. */);
3865 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3867 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3868 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3869 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3870 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3872 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3873 doc
: /* Local keymap for minibuffer input with completion. */);
3874 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3875 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3877 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3878 &Vminibuffer_local_filename_completion_map
,
3879 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3880 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3881 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3882 Vminibuffer_local_completion_map
);
3885 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3886 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3887 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3888 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3889 Vminibuffer_local_completion_map
);
3891 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
3892 &Vminibuffer_local_must_match_filename_map
,
3893 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3894 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
3895 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
3896 Vminibuffer_local_must_match_map
);
3898 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3899 doc
: /* Alist of keymaps to use for minor modes.
3900 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3901 key sequences and look up bindings iff VARIABLE's value is non-nil.
3902 If two active keymaps bind the same key, the keymap appearing earlier
3903 in the list takes precedence. */);
3904 Vminor_mode_map_alist
= Qnil
;
3906 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3907 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3908 This variable is an alist just like `minor-mode-map-alist', and it is
3909 used the same way (and before `minor-mode-map-alist'); however,
3910 it is provided for major modes to bind locally. */);
3911 Vminor_mode_overriding_map_alist
= Qnil
;
3913 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3914 doc
: /* List of keymap alists to use for emulations modes.
3915 It is intended for modes or packages using multiple minor-mode keymaps.
3916 Each element is a keymap alist just like `minor-mode-map-alist', or a
3917 symbol with a variable binding which is a keymap alist, and it is used
3918 the same way. The "active" keymaps in each alist are used before
3919 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3920 Vemulation_mode_map_alists
= Qnil
;
3923 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3924 doc
: /* Keymap that translates key sequences to key sequences during input.
3925 This is used mainly for mapping ASCII function key sequences into
3926 real Emacs function key events (symbols).
3928 The `read-key-sequence' function replaces any subsequence bound by
3929 `function-key-map' with its binding. More precisely, when the active
3930 keymaps have no binding for the current key sequence but
3931 `function-key-map' binds a suffix of the sequence to a vector or string,
3932 `read-key-sequence' replaces the matching suffix with its binding, and
3933 continues with the new sequence.
3935 If the binding is a function, it is called with one argument (the prompt)
3936 and its return value (a key sequence) is used.
3938 The events that come from bindings in `function-key-map' are not
3939 themselves looked up in `function-key-map'.
3941 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3942 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3943 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3944 key, typing `ESC O P x' would return [f1 x]. */);
3945 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3947 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3948 doc
: /* Keymap of key translations that can override keymaps.
3949 This keymap works like `function-key-map', but comes after that,
3950 and its non-prefix bindings override ordinary bindings. */);
3951 Vkey_translation_map
= Qnil
;
3953 staticpro (&Vmouse_events
);
3954 Vmouse_events
= Fcons (intern ("menu-bar"),
3955 Fcons (intern ("tool-bar"),
3956 Fcons (intern ("header-line"),
3957 Fcons (intern ("mode-line"),
3958 Fcons (intern ("mouse-1"),
3959 Fcons (intern ("mouse-2"),
3960 Fcons (intern ("mouse-3"),
3961 Fcons (intern ("mouse-4"),
3962 Fcons (intern ("mouse-5"),
3966 Qsingle_key_description
= intern ("single-key-description");
3967 staticpro (&Qsingle_key_description
);
3969 Qkey_description
= intern ("key-description");
3970 staticpro (&Qkey_description
);
3972 Qkeymapp
= intern ("keymapp");
3973 staticpro (&Qkeymapp
);
3975 Qnon_ascii
= intern ("non-ascii");
3976 staticpro (&Qnon_ascii
);
3978 Qmenu_item
= intern ("menu-item");
3979 staticpro (&Qmenu_item
);
3981 Qremap
= intern ("remap");
3982 staticpro (&Qremap
);
3984 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3985 staticpro (&command_remapping_vector
);
3987 where_is_cache_keymaps
= Qt
;
3988 where_is_cache
= Qnil
;
3989 staticpro (&where_is_cache
);
3990 staticpro (&where_is_cache_keymaps
);
3992 defsubr (&Skeymapp
);
3993 defsubr (&Skeymap_parent
);
3994 defsubr (&Skeymap_prompt
);
3995 defsubr (&Sset_keymap_parent
);
3996 defsubr (&Smake_keymap
);
3997 defsubr (&Smake_sparse_keymap
);
3998 defsubr (&Smap_keymap
);
3999 defsubr (&Scopy_keymap
);
4000 defsubr (&Scommand_remapping
);
4001 defsubr (&Skey_binding
);
4002 defsubr (&Slocal_key_binding
);
4003 defsubr (&Sglobal_key_binding
);
4004 defsubr (&Sminor_mode_key_binding
);
4005 defsubr (&Sdefine_key
);
4006 defsubr (&Slookup_key
);
4007 defsubr (&Sdefine_prefix_command
);
4008 defsubr (&Suse_global_map
);
4009 defsubr (&Suse_local_map
);
4010 defsubr (&Scurrent_local_map
);
4011 defsubr (&Scurrent_global_map
);
4012 defsubr (&Scurrent_minor_mode_maps
);
4013 defsubr (&Scurrent_active_maps
);
4014 defsubr (&Saccessible_keymaps
);
4015 defsubr (&Skey_description
);
4016 defsubr (&Sdescribe_vector
);
4017 defsubr (&Ssingle_key_description
);
4018 defsubr (&Stext_char_description
);
4019 defsubr (&Swhere_is_internal
);
4020 defsubr (&Sdescribe_buffer_bindings
);
4021 defsubr (&Sapropos_internal
);
4027 initial_define_key (global_map
, 033, "ESC-prefix");
4028 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
4031 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4032 (do not change this comment) */