1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "termhooks.h"
31 #include "blockinput.h"
33 #include "intervals.h"
36 /* The number of elements in keymap vectors. */
37 #define DENSE_TABLE_SIZE (0200)
39 /* Actually allocate storage for these variables */
41 Lisp_Object current_global_map
; /* Current global keymap */
43 Lisp_Object global_map
; /* default global key bindings */
45 Lisp_Object meta_map
; /* The keymap used for globally bound
46 ESC-prefixed default commands */
48 Lisp_Object control_x_map
; /* The keymap used for globally bound
49 C-x-prefixed default commands */
51 /* was MinibufLocalMap */
52 Lisp_Object Vminibuffer_local_map
;
53 /* The keymap used by the minibuf for local
54 bindings when spaces are allowed in the
57 /* was MinibufLocalNSMap */
58 Lisp_Object Vminibuffer_local_ns_map
;
59 /* The keymap used by the minibuf for local
60 bindings when spaces are not encouraged
63 /* keymap used for minibuffers when doing completion */
64 /* was MinibufLocalCompletionMap */
65 Lisp_Object Vminibuffer_local_completion_map
;
67 /* keymap used for minibuffers when doing completion and require a match */
68 /* was MinibufLocalMustMatchMap */
69 Lisp_Object Vminibuffer_local_must_match_map
;
71 /* Alist of minor mode variables and keymaps. */
72 Lisp_Object Vminor_mode_map_alist
;
74 /* Alist of major-mode-specific overrides for
75 minor mode variables and keymaps. */
76 Lisp_Object Vminor_mode_overriding_map_alist
;
78 /* Keymap mapping ASCII function key sequences onto their preferred forms.
79 Initialized by the terminal-specific lisp files. See DEFVAR for more
81 Lisp_Object Vfunction_key_map
;
83 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
84 Lisp_Object Vkey_translation_map
;
86 /* A list of all commands given new bindings since a certain time
87 when nil was stored here.
88 This is used to speed up recomputation of menu key equivalents
89 when Emacs starts up. t means don't record anything here. */
90 Lisp_Object Vdefine_key_rebound_commands
;
92 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
;
94 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
95 in a string key sequence is equivalent to prefixing with this
97 extern Lisp_Object meta_prefix_char
;
99 extern Lisp_Object Voverriding_local_map
;
101 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
102 static Lisp_Object where_is_cache
;
103 /* Which keymaps are reverse-stored in the cache. */
104 static Lisp_Object where_is_cache_keymaps
;
106 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
107 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
109 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
110 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
111 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
112 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
113 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
114 int, Lisp_Object
, Lisp_Object
*, int));
116 /* Keymap object support - constructors and predicates. */
118 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
119 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
120 CHARTABLE is a char-table that holds the bindings for the ASCII
121 characters. ALIST is an assoc-list which holds bindings for function keys,
122 mouse events, and any other things that appear in the input stream.
123 All entries in it are initially nil, meaning "command undefined".
125 The optional arg STRING supplies a menu name for the keymap
126 in case you use it as a menu with `x-popup-menu'. */)
132 tail
= Fcons (string
, Qnil
);
135 return Fcons (Qkeymap
,
136 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
139 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
140 doc
: /* Construct and return a new sparse keymap.
141 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
142 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
143 which binds the function key or mouse event SYMBOL to DEFINITION.
144 Initially the alist is nil.
146 The optional arg STRING supplies a menu name for the keymap
147 in case you use it as a menu with `x-popup-menu'. */)
152 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
153 return Fcons (Qkeymap
, Qnil
);
156 /* This function is used for installing the standard key bindings
157 at initialization time.
161 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
164 initial_define_key (keymap
, key
, defname
)
169 store_in_keymap (keymap
, make_number (key
), intern (defname
));
173 initial_define_lispy_key (keymap
, keyname
, defname
)
178 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
181 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
182 doc
: /* Return t if OBJECT is a keymap.
184 A keymap is a list (keymap . ALIST),
185 or a symbol whose function definition is itself a keymap.
186 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
187 a vector of densely packed bindings for small character codes
188 is also allowed as an element. */)
192 return (KEYMAPP (object
) ? Qt
: Qnil
);
195 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
196 doc
: /* Return the prompt-string of a keymap MAP.
197 If non-nil, the prompt is shown in the echo-area
198 when reading a key-sequence to be looked-up in this keymap. */)
204 register Lisp_Object tem
;
213 /* Check that OBJECT is a keymap (after dereferencing through any
214 symbols). If it is, return it.
216 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
217 is an autoload form, do the autoload and try again.
218 If AUTOLOAD is nonzero, callers must assume GC is possible.
220 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
221 is zero as well), return Qt.
223 ERROR controls how we respond if OBJECT isn't a keymap.
224 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
226 Note that most of the time, we don't want to pursue autoloads.
227 Functions like Faccessible_keymaps which scan entire keymap trees
228 shouldn't load every autoloaded keymap. I'm not sure about this,
229 but it seems to me that only read_key_sequence, Flookup_key, and
230 Fdefine_key should cause keymaps to be autoloaded.
232 This function can GC when AUTOLOAD is non-zero, because it calls
233 do_autoload which can GC. */
236 get_keymap (object
, error
, autoload
)
245 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
248 tem
= indirect_function (object
);
251 if (EQ (XCAR (tem
), Qkeymap
))
254 /* Should we do an autoload? Autoload forms for keymaps have
255 Qkeymap as their fifth element. */
256 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
))
260 tail
= Fnth (make_number (4), tem
);
261 if (EQ (tail
, Qkeymap
))
265 struct gcpro gcpro1
, gcpro2
;
267 GCPRO2 (tem
, object
);
268 do_autoload (tem
, object
);
281 wrong_type_argument (Qkeymapp
, object
);
285 /* Return the parent map of the keymap MAP, or nil if it has none.
286 We assume that MAP is a valid keymap. */
288 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
289 doc
: /* Return the parent keymap of KEYMAP. */)
295 keymap
= get_keymap (keymap
, 1, 1);
297 /* Skip past the initial element `keymap'. */
298 list
= XCDR (keymap
);
299 for (; CONSP (list
); list
= XCDR (list
))
301 /* See if there is another `keymap'. */
306 return get_keymap (list
, 0, 1);
310 /* Check whether MAP is one of MAPS parents. */
312 keymap_memberp (map
, maps
)
313 Lisp_Object map
, maps
;
315 if (NILP (map
)) return 0;
316 while (KEYMAPP (maps
) && !EQ (map
, maps
))
317 maps
= Fkeymap_parent (maps
);
318 return (EQ (map
, maps
));
321 /* Set the parent keymap of MAP to PARENT. */
323 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
324 doc
: /* Modify KEYMAP to set its parent map to PARENT.
325 PARENT should be nil or another keymap. */)
327 Lisp_Object keymap
, parent
;
329 Lisp_Object list
, prev
;
333 /* Force a keymap flush for the next call to where-is.
334 Since this can be called from within where-is, we don't set where_is_cache
335 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
336 be changed during where-is, while where_is_cache_keymaps is only used at
337 the very beginning of where-is and can thus be changed here without any
339 This is a very minor correctness (rather than safety) issue. */
340 where_is_cache_keymaps
= Qt
;
342 keymap
= get_keymap (keymap
, 1, 1);
347 parent
= get_keymap (parent
, 1, 1);
349 /* Check for cycles. */
350 if (keymap_memberp (keymap
, parent
))
351 error ("Cyclic keymap inheritance");
354 /* Skip past the initial element `keymap'. */
359 /* If there is a parent keymap here, replace it.
360 If we came to the end, add the parent in PREV. */
361 if (!CONSP (list
) || KEYMAPP (list
))
363 /* If we already have the right parent, return now
364 so that we avoid the loops below. */
365 if (EQ (XCDR (prev
), parent
))
366 RETURN_UNGCPRO (parent
);
368 XSETCDR (prev
, parent
);
374 /* Scan through for submaps, and set their parents too. */
376 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
378 /* Stop the scan when we come to the parent. */
379 if (EQ (XCAR (list
), Qkeymap
))
382 /* If this element holds a prefix map, deal with it. */
383 if (CONSP (XCAR (list
))
384 && CONSP (XCDR (XCAR (list
))))
385 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
388 if (VECTORP (XCAR (list
)))
389 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
390 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
391 fix_submap_inheritance (keymap
, make_number (i
),
392 XVECTOR (XCAR (list
))->contents
[i
]);
394 if (CHAR_TABLE_P (XCAR (list
)))
396 Lisp_Object indices
[3];
398 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
),
403 RETURN_UNGCPRO (parent
);
406 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
407 if EVENT is also a prefix in MAP's parent,
408 make sure that SUBMAP inherits that definition as its own parent. */
411 fix_submap_inheritance (map
, event
, submap
)
412 Lisp_Object map
, event
, submap
;
414 Lisp_Object map_parent
, parent_entry
;
416 /* SUBMAP is a cons that we found as a key binding.
417 Discard the other things found in a menu key binding. */
419 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
421 /* If it isn't a keymap now, there's no work to do. */
425 map_parent
= Fkeymap_parent (map
);
426 if (!NILP (map_parent
))
428 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
432 /* If MAP's parent has something other than a keymap,
433 our own submap shadows it completely. */
434 if (!CONSP (parent_entry
))
437 if (! EQ (parent_entry
, submap
))
439 Lisp_Object submap_parent
;
440 submap_parent
= submap
;
445 tem
= Fkeymap_parent (submap_parent
);
449 if (keymap_memberp (tem
, parent_entry
))
450 /* Fset_keymap_parent could create a cycle. */
457 Fset_keymap_parent (submap_parent
, parent_entry
);
461 /* Look up IDX in MAP. IDX may be any sort of event.
462 Note that this does only one level of lookup; IDX must be a single
463 event, not a sequence.
465 If T_OK is non-zero, bindings for Qt are treated as default
466 bindings; any key left unmentioned by other tables and bindings is
467 given the binding of Qt.
469 If T_OK is zero, bindings for Qt are not treated specially.
471 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
474 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
483 /* Qunbound in VAL means we have found no binding yet. */
486 /* If idx is a list (some sort of mouse click, perhaps?),
487 the index we want to use is the car of the list, which
488 ought to be a symbol. */
489 idx
= EVENT_HEAD (idx
);
491 /* If idx is a symbol, it might have modifiers, which need to
492 be put in the canonical order. */
494 idx
= reorder_modifiers (idx
);
495 else if (INTEGERP (idx
))
496 /* Clobber the high bits that can be present on a machine
497 with more than 24 bits of integer. */
498 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
500 /* Handle the special meta -> esc mapping. */
501 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
503 /* See if there is a meta-map. If there's none, there is
504 no binding for IDX, unless a default binding exists in MAP. */
505 Lisp_Object meta_map
=
506 get_keymap (access_keymap (map
, meta_prefix_char
,
507 t_ok
, noinherit
, autoload
),
509 if (CONSP (meta_map
))
512 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
515 /* Set IDX to t, so that we only find a default binding. */
518 /* We know there is no binding. */
525 /* t_binding is where we put a default binding that applies,
526 to use in case we do not find a binding specifically
527 for this key sequence. */
529 Lisp_Object t_binding
;
532 /* If `t_ok' is 2, both `t' and generic-char bindings are accepted.
533 If it is 1, only generic-char bindings are accepted.
534 Otherwise, neither are. */
537 for (tail
= XCDR (map
);
539 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
544 binding
= XCAR (tail
);
545 if (SYMBOLP (binding
))
547 /* If NOINHERIT, stop finding prefix definitions
548 after we pass a second occurrence of the `keymap' symbol. */
549 if (noinherit
&& EQ (binding
, Qkeymap
))
552 else if (CONSP (binding
))
554 Lisp_Object key
= XCAR (binding
);
557 val
= XCDR (binding
);
560 && (XINT (idx
) & CHAR_MODIFIER_MASK
) == 0
562 && (XINT (key
) & CHAR_MODIFIER_MASK
) == 0
563 && !SINGLE_BYTE_CHAR_P (XINT (idx
))
564 && !SINGLE_BYTE_CHAR_P (XINT (key
))
565 && CHAR_VALID_P (XINT (key
), 1)
566 && !CHAR_VALID_P (XINT (key
), 0)
567 && (CHAR_CHARSET (XINT (key
))
568 == CHAR_CHARSET (XINT (idx
))))
570 /* KEY is the generic character of the charset of IDX.
571 Use KEY's binding if there isn't a binding for IDX
573 t_binding
= XCDR (binding
);
576 else if (t_ok
> 1 && EQ (key
, Qt
))
578 t_binding
= XCDR (binding
);
582 else if (VECTORP (binding
))
584 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
585 val
= AREF (binding
, XFASTINT (idx
));
587 else if (CHAR_TABLE_P (binding
))
589 /* Character codes with modifiers
590 are not included in a char-table.
591 All character codes without modifiers are included. */
593 && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
594 val
= Faref (binding
, idx
);
597 /* If we found a binding, clean it up and return it. */
598 if (!EQ (val
, Qunbound
))
600 val
= get_keyelt (val
, autoload
);
602 fix_submap_inheritance (map
, idx
, val
);
608 return get_keyelt (t_binding
, autoload
);
612 /* Given OBJECT which was found in a slot in a keymap,
613 trace indirect definitions to get the actual definition of that slot.
614 An indirect definition is a list of the form
615 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
616 and INDEX is the object to look up in KEYMAP to yield the definition.
618 Also if OBJECT has a menu string as the first element,
619 remove that. Also remove a menu help string as second element.
621 If AUTOLOAD is nonzero, load autoloadable keymaps
622 that are referred to with indirection. */
625 get_keyelt (object
, autoload
)
626 register Lisp_Object object
;
631 if (!(CONSP (object
)))
632 /* This is really the value. */
635 /* If the keymap contents looks like (keymap ...) or (lambda ...)
637 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
640 /* If the keymap contents looks like (menu-item name . DEFN)
641 or (menu-item name DEFN ...) then use DEFN.
642 This is a new format menu item. */
643 else if (EQ (XCAR (object
), Qmenu_item
))
645 if (CONSP (XCDR (object
)))
649 object
= XCDR (XCDR (object
));
652 object
= XCAR (object
);
654 /* If there's a `:filter FILTER', apply FILTER to the
655 menu-item's definition to get the real definition to
657 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
658 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
661 filter
= XCAR (XCDR (tem
));
662 filter
= list2 (filter
, list2 (Qquote
, object
));
663 object
= menu_item_eval_property (filter
);
672 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
673 Keymap alist elements like (CHAR MENUSTRING . DEFN)
674 will be used by HierarKey menus. */
675 else if (STRINGP (XCAR (object
)))
677 object
= XCDR (object
);
678 /* Also remove a menu help string, if any,
679 following the menu item name. */
680 if (CONSP (object
) && STRINGP (XCAR (object
)))
681 object
= XCDR (object
);
682 /* Also remove the sublist that caches key equivalences, if any. */
683 if (CONSP (object
) && CONSP (XCAR (object
)))
686 carcar
= XCAR (XCAR (object
));
687 if (NILP (carcar
) || VECTORP (carcar
))
688 object
= XCDR (object
);
692 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
696 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
697 return (!CONSP (map
) ? object
/* Invalid keymap */
698 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
704 store_in_keymap (keymap
, idx
, def
)
706 register Lisp_Object idx
;
707 register Lisp_Object def
;
709 /* Flush any reverse-map cache. */
710 where_is_cache
= Qnil
;
711 where_is_cache_keymaps
= Qt
;
713 /* If we are preparing to dump, and DEF is a menu element
714 with a menu item indicator, copy it to ensure it is not pure. */
715 if (CONSP (def
) && PURE_P (def
)
716 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
717 def
= Fcons (XCAR (def
), XCDR (def
));
719 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
720 error ("attempt to define a key in a non-keymap");
722 /* If idx is a list (some sort of mouse click, perhaps?),
723 the index we want to use is the car of the list, which
724 ought to be a symbol. */
725 idx
= EVENT_HEAD (idx
);
727 /* If idx is a symbol, it might have modifiers, which need to
728 be put in the canonical order. */
730 idx
= reorder_modifiers (idx
);
731 else if (INTEGERP (idx
))
732 /* Clobber the high bits that can be present on a machine
733 with more than 24 bits of integer. */
734 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
736 /* Scan the keymap for a binding of idx. */
740 /* The cons after which we should insert new bindings. If the
741 keymap has a table element, we record its position here, so new
742 bindings will go after it; this way, the table will stay
743 towards the front of the alist and character lookups in dense
744 keymaps will remain fast. Otherwise, this just points at the
745 front of the keymap. */
746 Lisp_Object insertion_point
;
748 insertion_point
= keymap
;
749 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
756 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
758 ASET (elt
, XFASTINT (idx
), def
);
761 insertion_point
= tail
;
763 else if (CHAR_TABLE_P (elt
))
765 /* Character codes with modifiers
766 are not included in a char-table.
767 All character codes without modifiers are included. */
770 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
771 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
773 Faset (elt
, idx
, def
);
776 insertion_point
= tail
;
778 else if (CONSP (elt
))
780 if (EQ (idx
, XCAR (elt
)))
786 else if (EQ (elt
, Qkeymap
))
787 /* If we find a 'keymap' symbol in the spine of KEYMAP,
788 then we must have found the start of a second keymap
789 being used as the tail of KEYMAP, and a binding for IDX
790 should be inserted before it. */
797 /* We have scanned the entire keymap, and not found a binding for
798 IDX. Let's add one. */
799 XSETCDR (insertion_point
,
800 Fcons (Fcons (idx
, def
), XCDR (insertion_point
)));
806 EXFUN (Fcopy_keymap
, 1);
809 copy_keymap_1 (chartable
, idx
, elt
)
810 Lisp_Object chartable
, idx
, elt
;
812 if (CONSP (elt
) && EQ (XCAR (elt
), Qkeymap
))
813 Faset (chartable
, idx
, Fcopy_keymap (elt
));
816 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
817 doc
: /* Return a copy of the keymap KEYMAP.
818 The copy starts out with the same definitions of KEYMAP,
819 but changing either the copy or KEYMAP does not affect the other.
820 Any key definitions that are subkeymaps are recursively copied.
821 However, a key definition which is a symbol whose definition is a keymap
826 /* FIXME: This doesn't properly copy menu-items in vectors. */
827 /* FIXME: This also copies the parent keymap. */
829 register Lisp_Object copy
, tail
;
831 copy
= Fcopy_alist (get_keymap (keymap
, 1, 0));
833 for (tail
= copy
; CONSP (tail
); tail
= XCDR (tail
))
838 if (CHAR_TABLE_P (elt
))
840 Lisp_Object indices
[3];
842 elt
= Fcopy_sequence (elt
);
845 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
847 else if (VECTORP (elt
))
851 elt
= Fcopy_sequence (elt
);
854 for (i
= 0; i
< ASIZE (elt
); i
++)
855 if (CONSP (AREF (elt
, i
)) && EQ (XCAR (AREF (elt
, i
)), Qkeymap
))
856 ASET (elt
, i
, Fcopy_keymap (AREF (elt
, i
)));
858 else if (CONSP (elt
) && CONSP (XCDR (elt
)))
863 /* Is this a new format menu item. */
864 if (EQ (XCAR (tem
),Qmenu_item
))
866 /* Copy cell with menu-item marker. */
868 Fcons (XCAR (tem
), XCDR (tem
)));
873 /* Copy cell with menu-item name. */
875 Fcons (XCAR (tem
), XCDR (tem
)));
881 /* Copy cell with binding and if the binding is a keymap,
884 Fcons (XCAR (tem
), XCDR (tem
)));
887 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
888 XSETCAR (elt
, Fcopy_keymap (tem
));
890 if (CONSP (tem
) && CONSP (XCAR (tem
)))
891 /* Delete cache for key equivalences. */
892 XSETCDR (elt
, XCDR (tem
));
897 /* It may be an old fomat menu item.
898 Skip the optional menu string.
900 if (STRINGP (XCAR (tem
)))
902 /* Copy the cell, since copy-alist didn't go this deep. */
904 Fcons (XCAR (tem
), XCDR (tem
)));
907 /* Also skip the optional menu help string. */
908 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
911 Fcons (XCAR (tem
), XCDR (tem
)));
915 /* There may also be a list that caches key equivalences.
916 Just delete it for the new keymap. */
918 && CONSP (XCAR (tem
))
919 && (NILP (XCAR (XCAR (tem
)))
920 || VECTORP (XCAR (XCAR (tem
)))))
921 XSETCDR (elt
, XCDR (tem
));
924 && CONSP (XCDR (elt
))
925 && EQ (XCAR (XCDR (elt
)), Qkeymap
))
926 XSETCDR (elt
, Fcopy_keymap (XCDR (elt
)));
935 /* Simple Keymap mutators and accessors. */
937 /* GC is possible in this function if it autoloads a keymap. */
939 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
940 doc
: /* Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.
941 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters
942 meaning a sequence of keystrokes and events.
943 Non-ASCII characters with codes above 127 (such as ISO Latin-1)
944 can be included if you use a vector.
945 DEF is anything that can be a key's definition:
946 nil (means key is undefined in this keymap),
947 a command (a Lisp function suitable for interactive calling)
948 a string (treated as a keyboard macro),
949 a keymap (to define a prefix key),
950 a symbol. When the key is looked up, the symbol will stand for its
951 function definition, which should at that time be one of the above,
952 or another symbol whose function definition is used, etc.
953 a cons (STRING . DEFN), meaning that DEFN is the definition
954 (DEFN should be a valid definition in its own right),
955 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.
957 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at
958 the front of KEYMAP. */)
965 register Lisp_Object c
;
966 register Lisp_Object cmd
;
970 struct gcpro gcpro1
, gcpro2
, gcpro3
;
972 keymap
= get_keymap (keymap
, 1, 1);
974 if (!VECTORP (key
) && !STRINGP (key
))
975 key
= wrong_type_argument (Qarrayp
, key
);
977 length
= XFASTINT (Flength (key
));
981 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
982 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
984 GCPRO3 (keymap
, key
, def
);
987 meta_bit
= meta_modifier
;
994 c
= Faref (key
, make_number (idx
));
996 if (CONSP (c
) && lucid_event_type_list_p (c
))
997 c
= Fevent_convert_list (c
);
1000 && (XINT (c
) & meta_bit
)
1003 c
= meta_prefix_char
;
1009 XSETINT (c
, XINT (c
) & ~meta_bit
);
1015 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1016 error ("Key sequence contains invalid events");
1019 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1021 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1023 /* If this key is undefined, make it a prefix. */
1025 cmd
= define_as_prefix (keymap
, c
);
1027 keymap
= get_keymap (cmd
, 0, 1);
1028 if (!CONSP (keymap
))
1029 /* We must use Fkey_description rather than just passing key to
1030 error; key might be a vector, not a string. */
1031 error ("Key sequence %s uses invalid prefix characters",
1032 XSTRING (Fkey_description (key
))->data
);
1036 /* Value is number if KEY is too long; NIL if valid but has no definition. */
1037 /* GC is possible in this function if it autoloads a keymap. */
1039 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1040 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1041 nil means undefined. See doc of `define-key' for kinds of definitions.
1043 A number as value means KEY is "too long";
1044 that is, characters or symbols in it except for the last one
1045 fail to be a valid sequence of prefix characters in KEYMAP.
1046 The number is how many characters at the front of KEY
1047 it takes to reach a non-prefix command.
1049 Normally, `lookup-key' ignores bindings for t, which act as default
1050 bindings, used when nothing else in the keymap applies; this makes it
1051 usable as a general function for probing keymaps. However, if the
1052 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1053 recognize the default bindings, just as `read-key-sequence' does. */)
1054 (keymap
, key
, accept_default
)
1055 register Lisp_Object keymap
;
1057 Lisp_Object accept_default
;
1060 register Lisp_Object cmd
;
1061 register Lisp_Object c
;
1063 int t_ok
= !NILP (accept_default
);
1064 struct gcpro gcpro1
;
1066 keymap
= get_keymap (keymap
, 1, 1);
1068 if (!VECTORP (key
) && !STRINGP (key
))
1069 key
= wrong_type_argument (Qarrayp
, key
);
1071 length
= XFASTINT (Flength (key
));
1080 c
= Faref (key
, make_number (idx
++));
1082 if (CONSP (c
) && lucid_event_type_list_p (c
))
1083 c
= Fevent_convert_list (c
);
1085 /* Turn the 8th bit of string chars into a meta modifier. */
1086 if (XINT (c
) & 0x80 && STRINGP (key
))
1087 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1089 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1091 RETURN_UNGCPRO (cmd
);
1093 keymap
= get_keymap (cmd
, 0, 1);
1094 if (!CONSP (keymap
))
1095 RETURN_UNGCPRO (make_number (idx
));
1101 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1102 Assume that currently it does not define C at all.
1103 Return the keymap. */
1106 define_as_prefix (keymap
, c
)
1107 Lisp_Object keymap
, c
;
1111 cmd
= Fmake_sparse_keymap (Qnil
);
1112 /* If this key is defined as a prefix in an inherited keymap,
1113 make it a prefix in this map, and make its definition
1114 inherit the other prefix definition. */
1115 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1116 store_in_keymap (keymap
, c
, cmd
);
1121 /* Append a key to the end of a key sequence. We always make a vector. */
1124 append_key (key_sequence
, key
)
1125 Lisp_Object key_sequence
, key
;
1127 Lisp_Object args
[2];
1129 args
[0] = key_sequence
;
1131 args
[1] = Fcons (key
, Qnil
);
1132 return Fvconcat (2, args
);
1136 /* Global, local, and minor mode keymap stuff. */
1138 /* We can't put these variables inside current_minor_maps, since under
1139 some systems, static gets macro-defined to be the empty string.
1141 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1142 static int cmm_size
;
1144 /* Error handler used in current_minor_maps. */
1146 current_minor_maps_error ()
1151 /* Store a pointer to an array of the keymaps of the currently active
1152 minor modes in *buf, and return the number of maps it contains.
1154 This function always returns a pointer to the same buffer, and may
1155 free or reallocate it, so if you want to keep it for a long time or
1156 hand it out to lisp code, copy it. This procedure will be called
1157 for every key sequence read, so the nice lispy approach (return a
1158 new assoclist, list, what have you) for each invocation would
1159 result in a lot of consing over time.
1161 If we used xrealloc/xmalloc and ran out of memory, they would throw
1162 back to the command loop, which would try to read a key sequence,
1163 which would call this function again, resulting in an infinite
1164 loop. Instead, we'll use realloc/malloc and silently truncate the
1165 list, let the key sequence be read, and hope some other piece of
1166 code signals the error. */
1168 current_minor_maps (modeptr
, mapptr
)
1169 Lisp_Object
**modeptr
, **mapptr
;
1172 int list_number
= 0;
1173 Lisp_Object alist
, assoc
, var
, val
;
1174 Lisp_Object lists
[2];
1176 lists
[0] = Vminor_mode_overriding_map_alist
;
1177 lists
[1] = Vminor_mode_map_alist
;
1179 for (list_number
= 0; list_number
< 2; list_number
++)
1180 for (alist
= lists
[list_number
];
1182 alist
= XCDR (alist
))
1183 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1184 && (var
= XCAR (assoc
), SYMBOLP (var
))
1185 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1190 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1191 and also an entry in Vminor_mode_map_alist,
1192 ignore the latter. */
1193 if (list_number
== 1)
1195 val
= assq_no_quit (var
, lists
[0]);
1202 Lisp_Object
*newmodes
, *newmaps
;
1204 /* Use malloc/realloc here. See the comment above
1211 = (Lisp_Object
*) realloc (cmm_modes
,
1212 cmm_size
* sizeof *newmodes
);
1214 = (Lisp_Object
*) realloc (cmm_maps
,
1215 cmm_size
* sizeof *newmaps
);
1223 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmodes
);
1225 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmaps
);
1230 cmm_modes
= newmodes
;
1234 if (newmodes
== NULL
|| newmaps
== NULL
)
1238 /* Get the keymap definition--or nil if it is not defined. */
1239 temp
= internal_condition_case_1 (Findirect_function
,
1241 Qerror
, current_minor_maps_error
);
1245 cmm_maps
[i
] = temp
;
1250 if (modeptr
) *modeptr
= cmm_modes
;
1251 if (mapptr
) *mapptr
= cmm_maps
;
1255 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1257 doc
: /* Return a list of the currently active keymaps.
1258 OLP if non-nil indicates that we should obey `overriding-local-map' and
1259 `overriding-terminal-local-map'. */)
1263 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1267 if (!NILP (Voverriding_local_map
))
1268 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1269 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1270 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1272 if (NILP (XCDR (keymaps
)))
1278 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1280 keymaps
= Fcons (local
, keymaps
);
1282 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1284 keymaps
= Fcons (local
, keymaps
);
1286 nmaps
= current_minor_maps (0, &maps
);
1288 for (i
= --nmaps
; i
>= 0; i
--)
1289 if (!NILP (maps
[i
]))
1290 keymaps
= Fcons (maps
[i
], keymaps
);
1296 /* GC is possible in this function if it autoloads a keymap. */
1298 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1299 doc
: /* Return the binding for command KEY in current keymaps.
1300 KEY is a string or vector, a sequence of keystrokes.
1301 The binding is probably a symbol with a function definition.
1303 Normally, `key-binding' ignores bindings for t, which act as default
1304 bindings, used when nothing else in the keymap applies; this makes it
1305 usable as a general function for probing keymaps. However, if the
1306 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1307 recognize the default bindings, just as `read-key-sequence' does. */)
1308 (key
, accept_default
)
1309 Lisp_Object key
, accept_default
;
1311 Lisp_Object
*maps
, value
;
1313 struct gcpro gcpro1
;
1317 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1319 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1320 key
, accept_default
);
1321 if (! NILP (value
) && !INTEGERP (value
))
1322 RETURN_UNGCPRO (value
);
1324 else if (!NILP (Voverriding_local_map
))
1326 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1327 if (! NILP (value
) && !INTEGERP (value
))
1328 RETURN_UNGCPRO (value
);
1334 nmaps
= current_minor_maps (0, &maps
);
1335 /* Note that all these maps are GCPRO'd
1336 in the places where we found them. */
1338 for (i
= 0; i
< nmaps
; i
++)
1339 if (! NILP (maps
[i
]))
1341 value
= Flookup_key (maps
[i
], key
, accept_default
);
1342 if (! NILP (value
) && !INTEGERP (value
))
1343 RETURN_UNGCPRO (value
);
1346 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1349 value
= Flookup_key (local
, key
, accept_default
);
1350 if (! NILP (value
) && !INTEGERP (value
))
1351 RETURN_UNGCPRO (value
);
1354 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1358 value
= Flookup_key (local
, key
, accept_default
);
1359 if (! NILP (value
) && !INTEGERP (value
))
1360 RETURN_UNGCPRO (value
);
1364 value
= Flookup_key (current_global_map
, key
, accept_default
);
1366 if (! NILP (value
) && !INTEGERP (value
))
1372 /* GC is possible in this function if it autoloads a keymap. */
1374 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1375 doc
: /* Return the binding for command KEYS in current local keymap only.
1376 KEYS is a string, a sequence of keystrokes.
1377 The binding is probably a symbol with a function definition.
1379 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1380 bindings; see the description of `lookup-key' for more details about this. */)
1381 (keys
, accept_default
)
1382 Lisp_Object keys
, accept_default
;
1384 register Lisp_Object map
;
1385 map
= current_buffer
->keymap
;
1388 return Flookup_key (map
, keys
, accept_default
);
1391 /* GC is possible in this function if it autoloads a keymap. */
1393 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1394 doc
: /* Return the binding for command KEYS in current global keymap only.
1395 KEYS is a string, a sequence of keystrokes.
1396 The binding is probably a symbol with a function definition.
1397 This function's return values are the same as those of lookup-key
1400 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1401 bindings; see the description of `lookup-key' for more details about this. */)
1402 (keys
, accept_default
)
1403 Lisp_Object keys
, accept_default
;
1405 return Flookup_key (current_global_map
, keys
, accept_default
);
1408 /* GC is possible in this function if it autoloads a keymap. */
1410 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1411 doc
: /* Find the visible minor mode bindings of KEY.
1412 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the
1413 the symbol which names the minor mode binding KEY, and BINDING is
1414 KEY's definition in that mode. In particular, if KEY has no
1415 minor-mode bindings, return nil. If the first binding is a
1416 non-prefix, all subsequent bindings will be omitted, since they would
1417 be ignored. Similarly, the list doesn't include non-prefix bindings
1418 that come after prefix bindings.
1420 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1421 bindings; see the description of `lookup-key' for more details about this. */)
1422 (key
, accept_default
)
1423 Lisp_Object key
, accept_default
;
1425 Lisp_Object
*modes
, *maps
;
1427 Lisp_Object binding
;
1429 struct gcpro gcpro1
, gcpro2
;
1431 nmaps
= current_minor_maps (&modes
, &maps
);
1432 /* Note that all these maps are GCPRO'd
1433 in the places where we found them. */
1436 GCPRO2 (key
, binding
);
1438 for (i
= j
= 0; i
< nmaps
; i
++)
1440 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1441 && !INTEGERP (binding
))
1443 if (KEYMAPP (binding
))
1444 maps
[j
++] = Fcons (modes
[i
], binding
);
1446 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1450 return Flist (j
, maps
);
1453 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1454 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1455 A new sparse keymap is stored as COMMAND's function definition and its value.
1456 If a second optional argument MAPVAR is given, the map is stored as
1457 its value instead of as COMMAND's value; but COMMAND is still defined
1459 The third optional argument NAME, if given, supplies a menu name
1460 string for the map. This is required to use the keymap as a menu. */)
1461 (command
, mapvar
, name
)
1462 Lisp_Object command
, mapvar
, name
;
1465 map
= Fmake_sparse_keymap (name
);
1466 Ffset (command
, map
);
1470 Fset (command
, map
);
1474 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1475 doc
: /* Select KEYMAP as the global keymap. */)
1479 keymap
= get_keymap (keymap
, 1, 1);
1480 current_global_map
= keymap
;
1485 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1486 doc
: /* Select KEYMAP as the local keymap.
1487 If KEYMAP is nil, that means no local keymap. */)
1492 keymap
= get_keymap (keymap
, 1, 1);
1494 current_buffer
->keymap
= keymap
;
1499 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1500 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1503 return current_buffer
->keymap
;
1506 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1507 doc
: /* Return the current global keymap. */)
1510 return current_global_map
;
1513 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1514 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1518 int nmaps
= current_minor_maps (0, &maps
);
1520 return Flist (nmaps
, maps
);
1523 /* Help functions for describing and documenting keymaps. */
1527 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1528 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1529 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1533 cmd
= get_keyelt (cmd
, 0);
1537 tem
= get_keymap (cmd
, 0, 0);
1541 /* Ignore keymaps that are already added to maps. */
1542 tem
= Frassq (cmd
, maps
);
1545 /* If the last key in thisseq is meta-prefix-char,
1546 turn it into a meta-ized keystroke. We know
1547 that the event we're about to append is an
1548 ascii keystroke since we're processing a
1552 int meta_bit
= meta_modifier
;
1553 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1554 tem
= Fcopy_sequence (thisseq
);
1556 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1558 /* This new sequence is the same length as
1559 thisseq, so stick it in the list right
1562 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1566 tem
= append_key (thisseq
, key
);
1567 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1574 accessible_keymaps_char_table (args
, index
, cmd
)
1575 Lisp_Object args
, index
, cmd
;
1577 accessible_keymaps_1 (index
, cmd
,
1581 XINT (XCDR (XCAR (args
))));
1584 /* This function cannot GC. */
1586 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1588 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1589 Returns a list of elements of the form (KEYS . MAP), where the sequence
1590 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1591 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1592 An optional argument PREFIX, if non-nil, should be a key sequence;
1593 then the value includes only maps for prefixes that start with PREFIX. */)
1595 Lisp_Object keymap
, prefix
;
1597 Lisp_Object maps
, good_maps
, tail
;
1600 /* no need for gcpro because we don't autoload any keymaps. */
1603 prefixlen
= XINT (Flength (prefix
));
1607 /* If a prefix was specified, start with the keymap (if any) for
1608 that prefix, so we don't waste time considering other prefixes. */
1610 tem
= Flookup_key (keymap
, prefix
, Qt
);
1611 /* Flookup_key may give us nil, or a number,
1612 if the prefix is not defined in this particular map.
1613 It might even give us a list that isn't a keymap. */
1614 tem
= get_keymap (tem
, 0, 0);
1617 /* Convert PREFIX to a vector now, so that later on
1618 we don't have to deal with the possibility of a string. */
1619 if (STRINGP (prefix
))
1624 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1625 for (i
= 0, i_byte
= 0; i
< XSTRING (prefix
)->size
;)
1629 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1630 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1631 c
^= 0200 | meta_modifier
;
1632 ASET (copy
, i_before
, make_number (c
));
1636 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1642 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1643 get_keymap (keymap
, 1, 0)),
1646 /* For each map in the list maps,
1647 look at any other maps it points to,
1648 and stick them at the end if they are not already in the list.
1650 This is a breadth-first traversal, where tail is the queue of
1651 nodes, and maps accumulates a list of all nodes visited. */
1653 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1655 register Lisp_Object thisseq
, thismap
;
1657 /* Does the current sequence end in the meta-prefix-char? */
1660 thisseq
= Fcar (Fcar (tail
));
1661 thismap
= Fcdr (Fcar (tail
));
1662 last
= make_number (XINT (Flength (thisseq
)) - 1);
1663 is_metized
= (XINT (last
) >= 0
1664 /* Don't metize the last char of PREFIX. */
1665 && XINT (last
) >= prefixlen
1666 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1668 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1672 elt
= XCAR (thismap
);
1676 if (CHAR_TABLE_P (elt
))
1678 Lisp_Object indices
[3];
1680 map_char_table (accessible_keymaps_char_table
, Qnil
,
1681 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1682 Fcons (tail
, thisseq
)),
1685 else if (VECTORP (elt
))
1689 /* Vector keymap. Scan all the elements. */
1690 for (i
= 0; i
< ASIZE (elt
); i
++)
1691 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1692 maps
, tail
, thisseq
, is_metized
);
1695 else if (CONSP (elt
))
1696 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
1697 maps
, tail
, thisseq
,
1698 is_metized
&& INTEGERP (XCAR (elt
)));
1706 /* Now find just the maps whose access prefixes start with PREFIX. */
1709 for (; CONSP (maps
); maps
= XCDR (maps
))
1711 Lisp_Object elt
, thisseq
;
1713 thisseq
= XCAR (elt
);
1714 /* The access prefix must be at least as long as PREFIX,
1715 and the first elements must match those of PREFIX. */
1716 if (XINT (Flength (thisseq
)) >= prefixlen
)
1719 for (i
= 0; i
< prefixlen
; i
++)
1722 XSETFASTINT (i1
, i
);
1723 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1727 good_maps
= Fcons (elt
, good_maps
);
1731 return Fnreverse (good_maps
);
1734 Lisp_Object Qsingle_key_description
, Qkey_description
;
1736 /* This function cannot GC. */
1738 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1739 doc
: /* Return a pretty description of key-sequence KEYS.
1740 Control characters turn into "C-foo" sequences, meta into "M-foo"
1741 spaces are put between sequence elements, etc. */)
1748 Lisp_Object
*args
= NULL
;
1753 vector
= Fmake_vector (Flength (keys
), Qnil
);
1754 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1759 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1760 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1761 c
^= 0200 | meta_modifier
;
1762 XSETFASTINT (AREF (vector
, i_before
), c
);
1769 /* In effect, this computes
1770 (mapconcat 'single-key-description keys " ")
1771 but we shouldn't use mapconcat because it can do GC. */
1773 len
= XVECTOR (keys
)->size
;
1774 sep
= build_string (" ");
1775 /* This has one extra element at the end that we don't pass to Fconcat. */
1776 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1778 for (i
= 0; i
< len
; i
++)
1780 args
[i
* 2] = Fsingle_key_description (AREF (keys
, i
), Qnil
);
1781 args
[i
* 2 + 1] = sep
;
1784 else if (CONSP (keys
))
1786 /* In effect, this computes
1787 (mapconcat 'single-key-description keys " ")
1788 but we shouldn't use mapconcat because it can do GC. */
1790 len
= XFASTINT (Flength (keys
));
1791 sep
= build_string (" ");
1792 /* This has one extra element at the end that we don't pass to Fconcat. */
1793 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1795 for (i
= 0; i
< len
; i
++)
1797 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1798 args
[i
* 2 + 1] = sep
;
1803 keys
= wrong_type_argument (Qarrayp
, keys
);
1806 return empty_string
;
1807 return Fconcat (len
* 2 - 1, args
);
1811 push_key_description (c
, p
, force_multibyte
)
1812 register unsigned int c
;
1814 int force_multibyte
;
1818 /* Clear all the meaningless bits above the meta bit. */
1819 c
&= meta_modifier
| ~ - meta_modifier
;
1820 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1821 | meta_modifier
| shift_modifier
| super_modifier
);
1823 if (c
& alt_modifier
)
1829 if ((c
& ctrl_modifier
) != 0
1830 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1834 c
&= ~ctrl_modifier
;
1836 if (c
& hyper_modifier
)
1840 c
-= hyper_modifier
;
1842 if (c
& meta_modifier
)
1848 if (c
& shift_modifier
)
1852 c
-= shift_modifier
;
1854 if (c
& super_modifier
)
1858 c
-= super_modifier
;
1874 else if (c
== Ctl ('M'))
1882 /* `C-' already added above. */
1883 if (c
> 0 && c
<= Ctl ('Z'))
1902 || (NILP (current_buffer
->enable_multibyte_characters
)
1903 && SINGLE_BYTE_CHAR_P (c
)
1904 && !force_multibyte
))
1910 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
1912 if (force_multibyte
&& valid_p
)
1914 if (SINGLE_BYTE_CHAR_P (c
))
1915 c
= unibyte_char_to_multibyte (c
);
1916 p
+= CHAR_STRING (c
, p
);
1918 else if (NILP (current_buffer
->enable_multibyte_characters
)
1923 /* The biggest character code uses 19 bits. */
1924 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1926 if (c
>= (1 << bit_offset
))
1927 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1931 p
+= CHAR_STRING (c
, p
);
1937 /* This function cannot GC. */
1939 DEFUN ("single-key-description", Fsingle_key_description
,
1940 Ssingle_key_description
, 1, 2, 0,
1941 doc
: /* Return a pretty description of command character KEY.
1942 Control characters turn into C-whatever, etc.
1943 Optional argument NO-ANGLES non-nil means don't put angle brackets
1944 around function keys and event symbols. */)
1946 Lisp_Object key
, no_angles
;
1948 if (CONSP (key
) && lucid_event_type_list_p (key
))
1949 key
= Fevent_convert_list (key
);
1951 key
= EVENT_HEAD (key
);
1953 if (INTEGERP (key
)) /* Normal character */
1955 unsigned int charset
, c1
, c2
;
1956 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1958 if (SINGLE_BYTE_CHAR_P (without_bits
))
1961 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1964 && CHARSET_DEFINED_P (charset
)
1965 && ((c1
>= 0 && c1
< 32)
1966 || (c2
>= 0 && c2
< 32)))
1968 /* Handle a generic character. */
1970 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1971 CHECK_STRING (name
);
1972 return concat2 (build_string ("Character set "), name
);
1976 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
1980 end
= push_key_description (XUINT (key
), tem
, 1);
1982 nchars
= multibyte_chars_in_text (tem
, nbytes
);
1983 if (nchars
== nbytes
)
1986 string
= build_string (tem
);
1989 string
= make_multibyte_string (tem
, nchars
, nbytes
);
1993 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1995 if (NILP (no_angles
))
1998 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
1999 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
2000 return build_string (buffer
);
2003 return Fsymbol_name (key
);
2005 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2006 return Fcopy_sequence (key
);
2008 error ("KEY must be an integer, cons, symbol, or string");
2013 push_text_char_description (c
, p
)
2014 register unsigned int c
;
2026 *p
++ = c
+ 64; /* 'A' - 1 */
2038 /* This function cannot GC. */
2040 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2041 doc
: /* Return a pretty description of file-character CHARACTER.
2042 Control characters turn into "^char", etc. */)
2044 Lisp_Object character
;
2046 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2047 unsigned char str
[6];
2050 CHECK_NUMBER (character
);
2052 c
= XINT (character
);
2053 if (!SINGLE_BYTE_CHAR_P (c
))
2055 int len
= CHAR_STRING (c
, str
);
2057 return make_multibyte_string (str
, 1, len
);
2060 *push_text_char_description (c
& 0377, str
) = 0;
2062 return build_string (str
);
2065 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2068 ascii_sequence_p (seq
)
2072 int len
= XINT (Flength (seq
));
2074 for (i
= 0; i
< len
; i
++)
2076 Lisp_Object ii
, elt
;
2078 XSETFASTINT (ii
, i
);
2079 elt
= Faref (seq
, ii
);
2082 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2090 /* where-is - finding a command in a set of keymaps. */
2092 static Lisp_Object
where_is_internal_1 ();
2093 static void where_is_internal_2 ();
2095 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2096 Returns the first non-nil binding found in any of those maps. */
2099 shadow_lookup (shadow
, key
, flag
)
2100 Lisp_Object shadow
, key
, flag
;
2102 Lisp_Object tail
, value
;
2104 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2106 value
= Flookup_key (XCAR (tail
), key
, flag
);
2107 if (!NILP (value
) && !NATNUMP (value
))
2113 /* This function can GC if Flookup_key autoloads any keymaps. */
2116 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2117 Lisp_Object definition
, keymaps
;
2118 Lisp_Object firstonly
, noindirect
;
2120 Lisp_Object maps
= Qnil
;
2121 Lisp_Object found
, sequences
;
2122 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2123 /* 1 means ignore all menu bindings entirely. */
2124 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2127 while (CONSP (found
))
2131 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2132 found
= XCDR (found
);
2135 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2139 for (; !NILP (maps
); maps
= Fcdr (maps
))
2141 /* Key sequence to reach map, and the map that it reaches */
2142 register Lisp_Object
this, map
;
2144 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2145 [M-CHAR] sequences, check if last character of the sequence
2146 is the meta-prefix char. */
2150 this = Fcar (Fcar (maps
));
2151 map
= Fcdr (Fcar (maps
));
2152 last
= make_number (XINT (Flength (this)) - 1);
2153 last_is_meta
= (XINT (last
) >= 0
2154 && EQ (Faref (this, last
), meta_prefix_char
));
2156 /* if (nomenus && !ascii_sequence_p (this)) */
2157 if (nomenus
&& XINT (last
) >= 0
2158 && !INTEGERP (Faref (this, make_number (0))))
2159 /* If no menu entries should be returned, skip over the
2160 keymaps bound to `menu-bar' and `tool-bar' and other
2161 non-ascii prefixes like `C-down-mouse-2'. */
2168 /* Because the code we want to run on each binding is rather
2169 large, we don't want to have two separate loop bodies for
2170 sparse keymap bindings and tables; we want to iterate one
2171 loop body over both keymap and vector bindings.
2173 For this reason, if Fcar (map) is a vector, we don't
2174 advance map to the next element until i indicates that we
2175 have finished off the vector. */
2176 Lisp_Object elt
, key
, binding
;
2184 /* Set key and binding to the current key and binding, and
2185 advance map and i to the next binding. */
2188 Lisp_Object sequence
;
2190 /* In a vector, look at each element. */
2191 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2193 binding
= AREF (elt
, i
);
2194 XSETFASTINT (key
, i
);
2195 sequence
= where_is_internal_1 (binding
, key
, definition
,
2197 last
, nomenus
, last_is_meta
);
2198 if (!NILP (sequence
))
2199 sequences
= Fcons (sequence
, sequences
);
2202 else if (CHAR_TABLE_P (elt
))
2204 Lisp_Object indices
[3];
2207 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2208 Qnil
), /* Result accumulator. */
2209 Fcons (Fcons (this, last
),
2210 Fcons (make_number (nomenus
),
2211 make_number (last_is_meta
))));
2212 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2214 sequences
= XCDR (XCAR (args
));
2216 else if (CONSP (elt
))
2218 Lisp_Object sequence
;
2221 binding
= XCDR (elt
);
2223 sequence
= where_is_internal_1 (binding
, key
, definition
,
2225 last
, nomenus
, last_is_meta
);
2226 if (!NILP (sequence
))
2227 sequences
= Fcons (sequence
, sequences
);
2231 for (; !NILP (sequences
); sequences
= XCDR (sequences
))
2233 Lisp_Object sequence
;
2235 sequence
= XCAR (sequences
);
2237 /* Verify that this key binding is not shadowed by another
2238 binding for the same key, before we say it exists.
2240 Mechanism: look for local definition of this key and if
2241 it is defined and does not match what we found then
2244 Either nil or number as value from Flookup_key
2246 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2249 /* It is a true unshadowed match. Record it, unless it's already
2250 been seen (as could happen when inheriting keymaps). */
2251 if (NILP (Fmember (sequence
, found
)))
2252 found
= Fcons (sequence
, found
);
2254 /* If firstonly is Qnon_ascii, then we can return the first
2255 binding we find. If firstonly is not Qnon_ascii but not
2256 nil, then we should return the first ascii-only binding
2258 if (EQ (firstonly
, Qnon_ascii
))
2259 RETURN_UNGCPRO (sequence
);
2260 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2261 RETURN_UNGCPRO (sequence
);
2268 found
= Fnreverse (found
);
2270 /* firstonly may have been t, but we may have gone all the way through
2271 the keymaps without finding an all-ASCII key sequence. So just
2272 return the best we could find. */
2273 if (!NILP (firstonly
))
2274 return Fcar (found
);
2279 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2280 doc
: /* Return list of keys that invoke DEFINITION.
2281 If KEYMAP is non-nil, search only KEYMAP and the global keymap.
2282 If KEYMAP is nil, search all the currently active keymaps.
2283 If KEYMAP is a list of keymaps, search only those keymaps.
2285 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2286 rather than a list of all possible key sequences.
2287 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2288 no matter what it is.
2289 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,
2290 and entirely reject menu bindings.
2292 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2293 to other keymaps or slots. This makes it possible to search for an
2294 indirect definition itself. */)
2295 (definition
, keymap
, firstonly
, noindirect
)
2296 Lisp_Object definition
, keymap
;
2297 Lisp_Object firstonly
, noindirect
;
2299 Lisp_Object sequences
, keymaps
;
2300 /* 1 means ignore all menu bindings entirely. */
2301 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2304 /* Find the relevant keymaps. */
2305 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2307 else if (!NILP (keymap
))
2308 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2310 keymaps
= Fcurrent_active_maps (Qnil
);
2312 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2313 We don't really need to check `keymap'. */
2314 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2318 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2320 /* Check heuristic-consistency of the cache. */
2321 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2322 where_is_cache
= Qnil
;
2324 if (NILP (where_is_cache
))
2326 /* We need to create the cache. */
2327 Lisp_Object args
[2];
2328 where_is_cache
= Fmake_hash_table (0, args
);
2329 where_is_cache_keymaps
= Qt
;
2331 /* Fill in the cache. */
2332 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2333 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2336 where_is_cache_keymaps
= keymaps
;
2339 /* We want to process definitions from the last to the first.
2340 Instead of consing, copy definitions to a vector and step
2341 over that vector. */
2342 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2343 n
= XINT (Flength (sequences
));
2344 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2345 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2346 defns
[i
++] = XCAR (sequences
);
2348 /* Verify that the key bindings are not shadowed. Note that
2349 the following can GC. */
2350 GCPRO2 (definition
, keymaps
);
2353 for (i
= n
- 1; i
>= 0; --i
)
2354 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2356 if (ascii_sequence_p (defns
[i
]))
2362 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2367 /* Kill the cache so that where_is_internal_1 doesn't think
2368 we're filling it up. */
2369 where_is_cache
= Qnil
;
2370 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2376 /* This is the function that Fwhere_is_internal calls using map_char_table.
2378 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2380 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2381 Since map_char_table doesn't really use the return value from this function,
2382 we the result append to RESULT, the slot in ARGS.
2384 This function can GC because it calls where_is_internal_1 which can
2388 where_is_internal_2 (args
, key
, binding
)
2389 Lisp_Object args
, key
, binding
;
2391 Lisp_Object definition
, noindirect
, this, last
;
2392 Lisp_Object result
, sequence
;
2393 int nomenus
, last_is_meta
;
2394 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2396 GCPRO3 (args
, key
, binding
);
2397 result
= XCDR (XCAR (args
));
2398 definition
= XCAR (XCAR (XCAR (args
)));
2399 noindirect
= XCDR (XCAR (XCAR (args
)));
2400 this = XCAR (XCAR (XCDR (args
)));
2401 last
= XCDR (XCAR (XCDR (args
)));
2402 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2403 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2405 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2406 this, last
, nomenus
, last_is_meta
);
2408 if (!NILP (sequence
))
2409 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2415 /* This function cannot GC. */
2418 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2419 nomenus
, last_is_meta
)
2420 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2421 int nomenus
, last_is_meta
;
2423 Lisp_Object sequence
;
2425 /* Search through indirections unless that's not wanted. */
2426 if (NILP (noindirect
))
2427 binding
= get_keyelt (binding
, 0);
2429 /* End this iteration if this element does not match
2432 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2433 || EQ (binding
, definition
)
2434 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2435 /* Doesn't match. */
2438 /* We have found a match. Construct the key sequence where we found it. */
2439 if (INTEGERP (key
) && last_is_meta
)
2441 sequence
= Fcopy_sequence (this);
2442 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2445 sequence
= append_key (this, key
);
2447 if (!NILP (where_is_cache
))
2449 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2450 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2457 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2459 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2460 doc
: /* Insert the list of all defined keys and their definitions.
2461 The list is inserted in the current buffer, while the bindings are
2462 looked up in BUFFER.
2463 The optional argument PREFIX, if non-nil, should be a key sequence;
2464 then we display only bindings that start with that prefix.
2465 The optional argument MENUS, if non-nil, says to mention menu bindings.
2466 \(Ordinarily these are omitted from the output.) */)
2467 (buffer
, prefix
, menus
)
2468 Lisp_Object buffer
, prefix
, menus
;
2470 Lisp_Object outbuf
, shadow
;
2471 int nomenu
= NILP (menus
);
2472 register Lisp_Object start1
;
2473 struct gcpro gcpro1
;
2475 char *alternate_heading
2477 Keyboard translations:\n\n\
2478 You type Translation\n\
2479 -------- -----------\n";
2484 outbuf
= Fcurrent_buffer ();
2486 /* Report on alternates for keys. */
2487 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2490 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2491 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2493 for (c
= 0; c
< translate_len
; c
++)
2494 if (translate
[c
] != c
)
2496 char buf
[KEY_DESCRIPTION_SIZE
];
2499 if (alternate_heading
)
2501 insert_string (alternate_heading
);
2502 alternate_heading
= 0;
2505 bufend
= push_key_description (translate
[c
], buf
, 1);
2506 insert (buf
, bufend
- buf
);
2507 Findent_to (make_number (16), make_number (1));
2508 bufend
= push_key_description (c
, buf
, 1);
2509 insert (buf
, bufend
- buf
);
2517 if (!NILP (Vkey_translation_map
))
2518 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2519 "Key translations", nomenu
, 1, 0);
2522 /* Print the (major mode) local map. */
2524 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2525 start1
= current_kboard
->Voverriding_terminal_local_map
;
2526 else if (!NILP (Voverriding_local_map
))
2527 start1
= Voverriding_local_map
;
2531 describe_map_tree (start1
, 1, shadow
, prefix
,
2532 "\f\nOverriding Bindings", nomenu
, 0, 0);
2533 shadow
= Fcons (start1
, shadow
);
2537 /* Print the minor mode and major mode keymaps. */
2539 Lisp_Object
*modes
, *maps
;
2541 /* Temporarily switch to `buffer', so that we can get that buffer's
2542 minor modes correctly. */
2543 Fset_buffer (buffer
);
2545 nmaps
= current_minor_maps (&modes
, &maps
);
2546 Fset_buffer (outbuf
);
2548 /* Print the minor mode maps. */
2549 for (i
= 0; i
< nmaps
; i
++)
2551 /* The title for a minor mode keymap
2552 is constructed at run time.
2553 We let describe_map_tree do the actual insertion
2554 because it takes care of other features when doing so. */
2557 if (!SYMBOLP (modes
[i
]))
2560 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2564 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2565 XSYMBOL (modes
[i
])->name
->size
);
2566 p
+= XSYMBOL (modes
[i
])->name
->size
;
2568 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2569 p
+= sizeof (" Minor Mode Bindings") - 1;
2572 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2573 shadow
= Fcons (maps
[i
], shadow
);
2576 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2577 XBUFFER (buffer
), Qkeymap
);
2580 describe_map_tree (start1
, 1, shadow
, prefix
,
2581 "\f\nChar Property Bindings", nomenu
, 0, 0);
2582 shadow
= Fcons (start1
, shadow
);
2585 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2586 XBUFFER (buffer
), Qlocal_map
);
2589 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
2590 describe_map_tree (start1
, 1, shadow
, prefix
,
2591 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2593 describe_map_tree (start1
, 1, shadow
, prefix
,
2594 "\f\nChar Property Bindings", nomenu
, 0, 0);
2596 shadow
= Fcons (start1
, shadow
);
2600 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2601 "\f\nGlobal Bindings", nomenu
, 0, 1);
2603 /* Print the function-key-map translations under this prefix. */
2604 if (!NILP (Vfunction_key_map
))
2605 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2606 "\f\nFunction key map translations", nomenu
, 1, 0);
2612 /* Insert a description of the key bindings in STARTMAP,
2613 followed by those of all maps reachable through STARTMAP.
2614 If PARTIAL is nonzero, omit certain "uninteresting" commands
2615 (such as `undefined').
2616 If SHADOW is non-nil, it is a list of maps;
2617 don't mention keys which would be shadowed by any of them.
2618 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2619 TITLE, if not 0, is a string to insert at the beginning.
2620 TITLE should not end with a colon or a newline; we supply that.
2621 If NOMENU is not 0, then omit menu-bar commands.
2623 If TRANSL is nonzero, the definitions are actually key translations
2624 so print strings and vectors differently.
2626 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2630 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2632 Lisp_Object startmap
, shadow
, prefix
;
2639 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2640 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2647 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2650 GCPRO3 (maps
, seen
, sub_shadows
);
2656 /* Delete from MAPS each element that is for the menu bar. */
2657 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2659 Lisp_Object elt
, prefix
, tem
;
2662 prefix
= Fcar (elt
);
2663 if (XVECTOR (prefix
)->size
>= 1)
2665 tem
= Faref (prefix
, make_number (0));
2666 if (EQ (tem
, Qmenu_bar
))
2667 maps
= Fdelq (elt
, maps
);
2672 if (!NILP (maps
) || always_title
)
2676 insert_string (title
);
2679 insert_string (" Starting With ");
2680 insert1 (Fkey_description (prefix
));
2682 insert_string (":\n");
2684 insert_string (key_heading
);
2688 for (; !NILP (maps
); maps
= Fcdr (maps
))
2690 register Lisp_Object elt
, prefix
, tail
;
2693 prefix
= Fcar (elt
);
2697 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2701 shmap
= XCAR (tail
);
2703 /* If the sequence by which we reach this keymap is zero-length,
2704 then the shadow map for this keymap is just SHADOW. */
2705 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2706 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2708 /* If the sequence by which we reach this keymap actually has
2709 some elements, then the sequence's definition in SHADOW is
2710 what we should use. */
2713 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2714 if (INTEGERP (shmap
))
2718 /* If shmap is not nil and not a keymap,
2719 it completely shadows this map, so don't
2720 describe this map at all. */
2721 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2725 sub_shadows
= Fcons (shmap
, sub_shadows
);
2728 /* Maps we have already listed in this loop shadow this map. */
2729 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
2732 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2734 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2737 describe_map (Fcdr (elt
), prefix
,
2738 transl
? describe_translation
: describe_command
,
2739 partial
, sub_shadows
, &seen
, nomenu
);
2745 insert_string ("\n");
2750 static int previous_description_column
;
2753 describe_command (definition
, args
)
2754 Lisp_Object definition
, args
;
2756 register Lisp_Object tem1
;
2757 int column
= current_column ();
2758 int description_column
;
2760 /* If column 16 is no good, go to col 32;
2761 but don't push beyond that--go to next line instead. */
2765 description_column
= 32;
2767 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2768 description_column
= 32;
2770 description_column
= 16;
2772 Findent_to (make_number (description_column
), make_number (1));
2773 previous_description_column
= description_column
;
2775 if (SYMBOLP (definition
))
2777 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2779 insert_string ("\n");
2781 else if (STRINGP (definition
) || VECTORP (definition
))
2782 insert_string ("Keyboard Macro\n");
2783 else if (KEYMAPP (definition
))
2784 insert_string ("Prefix Command\n");
2786 insert_string ("??\n");
2790 describe_translation (definition
, args
)
2791 Lisp_Object definition
, args
;
2793 register Lisp_Object tem1
;
2795 Findent_to (make_number (16), make_number (1));
2797 if (SYMBOLP (definition
))
2799 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2801 insert_string ("\n");
2803 else if (STRINGP (definition
) || VECTORP (definition
))
2805 insert1 (Fkey_description (definition
));
2806 insert_string ("\n");
2808 else if (KEYMAPP (definition
))
2809 insert_string ("Prefix Command\n");
2811 insert_string ("??\n");
2814 /* Describe the contents of map MAP, assuming that this map itself is
2815 reached by the sequence of prefix keys KEYS (a string or vector).
2816 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2819 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2820 register Lisp_Object map
;
2822 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
2828 Lisp_Object elt_prefix
;
2829 Lisp_Object tail
, definition
, event
;
2831 Lisp_Object suppress
;
2834 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2838 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2840 /* Call Fkey_description first, to avoid GC bug for the other string. */
2841 tem
= Fkey_description (keys
);
2842 elt_prefix
= concat2 (tem
, build_string (" "));
2848 suppress
= intern ("suppress-keymap");
2850 /* This vector gets used to present single keys to Flookup_key. Since
2851 that is done once per keymap element, we don't want to cons up a
2852 fresh vector every time. */
2853 kludge
= Fmake_vector (make_number (1), Qnil
);
2856 GCPRO3 (elt_prefix
, definition
, kludge
);
2858 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2862 if (VECTORP (XCAR (tail
))
2863 || CHAR_TABLE_P (XCAR (tail
)))
2864 describe_vector (XCAR (tail
),
2865 elt_prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
2867 else if (CONSP (XCAR (tail
)))
2869 event
= XCAR (XCAR (tail
));
2871 /* Ignore bindings whose "keys" are not really valid events.
2872 (We get these in the frames and buffers menu.) */
2873 if (!(SYMBOLP (event
) || INTEGERP (event
)))
2876 if (nomenu
&& EQ (event
, Qmenu_bar
))
2879 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2881 /* Don't show undefined commands or suppressed commands. */
2882 if (NILP (definition
)) continue;
2883 if (SYMBOLP (definition
) && partial
)
2885 tem
= Fget (definition
, suppress
);
2890 /* Don't show a command that isn't really visible
2891 because a local definition of the same key shadows it. */
2893 ASET (kludge
, 0, event
);
2896 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2897 if (!NILP (tem
)) continue;
2900 tem
= Flookup_key (map
, kludge
, Qt
);
2901 if (!EQ (tem
, definition
)) continue;
2905 previous_description_column
= 0;
2910 if (!NILP (elt_prefix
))
2911 insert1 (elt_prefix
);
2913 /* THIS gets the string to describe the character EVENT. */
2914 insert1 (Fsingle_key_description (event
, Qnil
));
2916 /* Print a description of the definition of this character.
2917 elt_describer will take care of spacing out far enough
2918 for alignment purposes. */
2919 (*elt_describer
) (definition
, Qnil
);
2921 else if (EQ (XCAR (tail
), Qkeymap
))
2923 /* The same keymap might be in the structure twice, if we're
2924 using an inherited keymap. So skip anything we've already
2926 tem
= Fassq (tail
, *seen
);
2927 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2929 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2937 describe_vector_princ (elt
, fun
)
2938 Lisp_Object elt
, fun
;
2940 Findent_to (make_number (16), make_number (1));
2945 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
2946 doc
: /* Insert a description of contents of VECTOR.
2947 This is text showing the elements of vector matched against indices. */)
2949 Lisp_Object vector
, describer
;
2951 int count
= specpdl_ptr
- specpdl
;
2952 if (NILP (describer
))
2953 describer
= intern ("princ");
2954 specbind (Qstandard_output
, Fcurrent_buffer ());
2955 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
2956 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
2957 Qnil
, Qnil
, (int *)0, 0);
2959 return unbind_to (count
, Qnil
);
2962 /* Insert in the current buffer a description of the contents of VECTOR.
2963 We call ELT_DESCRIBER to insert the description of one value found
2966 ELT_PREFIX describes what "comes before" the keys or indices defined
2967 by this vector. This is a human-readable string whose size
2968 is not necessarily related to the situation.
2970 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2971 leads to this keymap.
2973 If the vector is a chartable, ELT_PREFIX is the vector
2974 of bytes that lead to the character set or portion of a character
2975 set described by this chartable.
2977 If PARTIAL is nonzero, it means do not mention suppressed commands
2978 (that assumes the vector is in a keymap).
2980 SHADOW is a list of keymaps that shadow this map.
2981 If it is non-nil, then we look up the key in those maps
2982 and we don't mention it now if it is defined by any of them.
2984 ENTIRE_MAP is the keymap in which this vector appears.
2985 If the definition in effect in the whole map does not match
2986 the one in this vector, we ignore this one.
2988 When describing a sub-char-table, INDICES is a list of
2989 indices at higher levels in this char-table,
2990 and CHAR_TABLE_DEPTH says how many levels down we have gone.
2992 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
2995 describe_vector (vector
, elt_prefix
, args
, elt_describer
,
2996 partial
, shadow
, entire_map
,
2997 indices
, char_table_depth
)
2998 register Lisp_Object vector
;
2999 Lisp_Object elt_prefix
, args
;
3000 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3003 Lisp_Object entire_map
;
3005 int char_table_depth
;
3007 Lisp_Object definition
;
3010 Lisp_Object suppress
;
3013 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3014 /* Range of elements to be handled. */
3016 /* A flag to tell if a leaf in this level of char-table is not a
3017 generic character (i.e. a complete multibyte character). */
3025 indices
= (int *) alloca (3 * sizeof (int));
3029 /* This vector gets used to present single keys to Flookup_key. Since
3030 that is done once per vector element, we don't want to cons up a
3031 fresh vector every time. */
3032 kludge
= Fmake_vector (make_number (1), Qnil
);
3033 GCPRO3 (elt_prefix
, definition
, kludge
);
3036 suppress
= intern ("suppress-keymap");
3038 if (CHAR_TABLE_P (vector
))
3040 if (char_table_depth
== 0)
3042 /* VECTOR is a top level char-table. */
3045 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3049 /* VECTOR is a sub char-table. */
3050 if (char_table_depth
>= 3)
3051 /* A char-table is never that deep. */
3052 error ("Too deep char table");
3055 = (CHARSET_VALID_P (indices
[0])
3056 && ((CHARSET_DIMENSION (indices
[0]) == 1
3057 && char_table_depth
== 1)
3058 || char_table_depth
== 2));
3060 /* Meaningful elements are from 32th to 127th. */
3062 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3067 /* This does the right thing for ordinary vectors. */
3071 to
= XVECTOR (vector
)->size
;
3074 for (i
= from
; i
< to
; i
++)
3078 if (CHAR_TABLE_P (vector
))
3080 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3083 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3084 && !CHARSET_DEFINED_P (i
- 128))
3088 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3091 definition
= get_keyelt (AREF (vector
, i
), 0);
3093 if (NILP (definition
)) continue;
3095 /* Don't mention suppressed commands. */
3096 if (SYMBOLP (definition
) && partial
)
3100 tem
= Fget (definition
, suppress
);
3102 if (!NILP (tem
)) continue;
3105 /* Set CHARACTER to the character this entry describes, if any.
3106 Also update *INDICES. */
3107 if (CHAR_TABLE_P (vector
))
3109 indices
[char_table_depth
] = i
;
3111 if (char_table_depth
== 0)
3114 indices
[0] = i
- 128;
3116 else if (complete_char
)
3118 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3126 /* If this binding is shadowed by some other map, ignore it. */
3127 if (!NILP (shadow
) && complete_char
)
3131 ASET (kludge
, 0, make_number (character
));
3132 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3134 if (!NILP (tem
)) continue;
3137 /* Ignore this definition if it is shadowed by an earlier
3138 one in the same keymap. */
3139 if (!NILP (entire_map
) && complete_char
)
3143 ASET (kludge
, 0, make_number (character
));
3144 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3146 if (!EQ (tem
, definition
))
3152 if (char_table_depth
== 0)
3157 /* For a sub char-table, show the depth by indentation.
3158 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3159 if (char_table_depth
> 0)
3160 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3162 /* Output the prefix that applies to every entry in this map. */
3163 if (!NILP (elt_prefix
))
3164 insert1 (elt_prefix
);
3166 /* Insert or describe the character this slot is for,
3167 or a description of what it is for. */
3168 if (SUB_CHAR_TABLE_P (vector
))
3171 insert_char (character
);
3174 /* We need an octal representation for this block of
3177 sprintf (work
, "(row %d)", i
);
3178 insert (work
, strlen (work
));
3181 else if (CHAR_TABLE_P (vector
))
3184 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3187 /* Print the information for this character set. */
3188 insert_string ("<");
3189 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3191 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3192 STRING_BYTES (XSTRING (tem2
)), 0);
3200 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3203 /* If we find a sub char-table within a char-table,
3204 scan it recursively; it defines the details for
3205 a character set or a portion of a character set. */
3206 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3209 describe_vector (definition
, elt_prefix
, args
, elt_describer
,
3210 partial
, shadow
, entire_map
,
3211 indices
, char_table_depth
+ 1);
3217 /* Find all consecutive characters or rows that have the same
3218 definition. But, for elements of a top level char table, if
3219 they are for charsets, we had better describe one by one even
3220 if they have the same definition. */
3221 if (CHAR_TABLE_P (vector
))
3225 if (char_table_depth
== 0)
3226 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3228 while (i
+ 1 < limit
3229 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3231 && !NILP (Fequal (tem2
, definition
)))
3236 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3238 && !NILP (Fequal (tem2
, definition
)))
3242 /* If we have a range of more than one character,
3243 print where the range reaches to. */
3245 if (i
!= starting_i
)
3249 if (!NILP (elt_prefix
))
3250 insert1 (elt_prefix
);
3252 if (CHAR_TABLE_P (vector
))
3254 if (char_table_depth
== 0)
3256 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3258 else if (complete_char
)
3260 indices
[char_table_depth
] = i
;
3261 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3262 insert_char (character
);
3266 /* We need an octal representation for this block of
3269 sprintf (work
, "(row %d)", i
);
3270 insert (work
, strlen (work
));
3275 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3279 /* Print a description of the definition of this character.
3280 elt_describer will take care of spacing out far enough
3281 for alignment purposes. */
3282 (*elt_describer
) (definition
, args
);
3285 /* For (sub) char-table, print `defalt' slot at last. */
3286 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3288 insert (" ", char_table_depth
* 2);
3289 insert_string ("<<default>>");
3290 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3296 /* Apropos - finding all symbols whose names match a regexp. */
3297 Lisp_Object apropos_predicate
;
3298 Lisp_Object apropos_accumulate
;
3301 apropos_accum (symbol
, string
)
3302 Lisp_Object symbol
, string
;
3304 register Lisp_Object tem
;
3306 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3307 if (!NILP (tem
) && !NILP (apropos_predicate
))
3308 tem
= call1 (apropos_predicate
, symbol
);
3310 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3313 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3314 doc
: /* Show all symbols whose names contain match for REGEXP.
3315 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3316 for each symbol and a symbol is mentioned only if that returns non-nil.
3317 Return list of symbols found. */)
3319 Lisp_Object regexp
, predicate
;
3321 struct gcpro gcpro1
, gcpro2
;
3322 CHECK_STRING (regexp
);
3323 apropos_predicate
= predicate
;
3324 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3325 apropos_accumulate
= Qnil
;
3326 map_obarray (Vobarray
, apropos_accum
, regexp
);
3327 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3329 return apropos_accumulate
;
3335 Qkeymap
= intern ("keymap");
3336 staticpro (&Qkeymap
);
3338 /* Now we are ready to set up this property, so we can
3339 create char tables. */
3340 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3342 /* Initialize the keymaps standardly used.
3343 Each one is the value of a Lisp variable, and is also
3344 pointed to by a C variable */
3346 global_map
= Fmake_keymap (Qnil
);
3347 Fset (intern ("global-map"), global_map
);
3349 current_global_map
= global_map
;
3350 staticpro (&global_map
);
3351 staticpro (¤t_global_map
);
3353 meta_map
= Fmake_keymap (Qnil
);
3354 Fset (intern ("esc-map"), meta_map
);
3355 Ffset (intern ("ESC-prefix"), meta_map
);
3357 control_x_map
= Fmake_keymap (Qnil
);
3358 Fset (intern ("ctl-x-map"), control_x_map
);
3359 Ffset (intern ("Control-X-prefix"), control_x_map
);
3361 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3362 doc
: /* List of commands given new key bindings recently.
3363 This is used for internal purposes during Emacs startup;
3364 don't alter it yourself. */);
3365 Vdefine_key_rebound_commands
= Qt
;
3367 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3368 doc
: /* Default keymap to use when reading from the minibuffer. */);
3369 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3371 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3372 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3373 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3374 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3376 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3377 doc
: /* Local keymap for minibuffer input with completion. */);
3378 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3379 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3381 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3382 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3383 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3384 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3385 Vminibuffer_local_completion_map
);
3387 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3388 doc
: /* Alist of keymaps to use for minor modes.
3389 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3390 key sequences and look up bindings iff VARIABLE's value is non-nil.
3391 If two active keymaps bind the same key, the keymap appearing earlier
3392 in the list takes precedence. */);
3393 Vminor_mode_map_alist
= Qnil
;
3395 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3396 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3397 This variable is a alist just like `minor-mode-map-alist', and it is
3398 used the same way (and before `minor-mode-map-alist'); however,
3399 it is provided for major modes to bind locally. */);
3400 Vminor_mode_overriding_map_alist
= Qnil
;
3402 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3403 doc
: /* Keymap mapping ASCII function key sequences onto their preferred forms.
3404 This allows Emacs to recognize function keys sent from ASCII
3405 terminals at any point in a key sequence.
3407 The `read-key-sequence' function replaces any subsequence bound by
3408 `function-key-map' with its binding. More precisely, when the active
3409 keymaps have no binding for the current key sequence but
3410 `function-key-map' binds a suffix of the sequence to a vector or string,
3411 `read-key-sequence' replaces the matching suffix with its binding, and
3412 continues with the new sequence.
3414 The events that come from bindings in `function-key-map' are not
3415 themselves looked up in `function-key-map'.
3417 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3418 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3419 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3420 key, typing `ESC O P x' would return [f1 x]. */);
3421 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3423 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3424 doc
: /* Keymap of key translations that can override keymaps.
3425 This keymap works like `function-key-map', but comes after that,
3426 and applies even for keys that have ordinary bindings. */);
3427 Vkey_translation_map
= Qnil
;
3429 Qsingle_key_description
= intern ("single-key-description");
3430 staticpro (&Qsingle_key_description
);
3432 Qkey_description
= intern ("key-description");
3433 staticpro (&Qkey_description
);
3435 Qkeymapp
= intern ("keymapp");
3436 staticpro (&Qkeymapp
);
3438 Qnon_ascii
= intern ("non-ascii");
3439 staticpro (&Qnon_ascii
);
3441 Qmenu_item
= intern ("menu-item");
3442 staticpro (&Qmenu_item
);
3444 where_is_cache_keymaps
= Qt
;
3445 where_is_cache
= Qnil
;
3446 staticpro (&where_is_cache
);
3447 staticpro (&where_is_cache_keymaps
);
3449 defsubr (&Skeymapp
);
3450 defsubr (&Skeymap_parent
);
3451 defsubr (&Skeymap_prompt
);
3452 defsubr (&Sset_keymap_parent
);
3453 defsubr (&Smake_keymap
);
3454 defsubr (&Smake_sparse_keymap
);
3455 defsubr (&Scopy_keymap
);
3456 defsubr (&Skey_binding
);
3457 defsubr (&Slocal_key_binding
);
3458 defsubr (&Sglobal_key_binding
);
3459 defsubr (&Sminor_mode_key_binding
);
3460 defsubr (&Sdefine_key
);
3461 defsubr (&Slookup_key
);
3462 defsubr (&Sdefine_prefix_command
);
3463 defsubr (&Suse_global_map
);
3464 defsubr (&Suse_local_map
);
3465 defsubr (&Scurrent_local_map
);
3466 defsubr (&Scurrent_global_map
);
3467 defsubr (&Scurrent_minor_mode_maps
);
3468 defsubr (&Scurrent_active_maps
);
3469 defsubr (&Saccessible_keymaps
);
3470 defsubr (&Skey_description
);
3471 defsubr (&Sdescribe_vector
);
3472 defsubr (&Ssingle_key_description
);
3473 defsubr (&Stext_char_description
);
3474 defsubr (&Swhere_is_internal
);
3475 defsubr (&Sdescribe_buffer_bindings
);
3476 defsubr (&Sapropos_internal
);
3482 initial_define_key (global_map
, 033, "ESC-prefix");
3483 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");