1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000
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"
35 #define min(a, b) ((a) < (b) ? (a) : (b))
37 /* The number of elements in keymap vectors. */
38 #define DENSE_TABLE_SIZE (0200)
40 /* Actually allocate storage for these variables */
42 Lisp_Object current_global_map
; /* Current global keymap */
44 Lisp_Object global_map
; /* default global key bindings */
46 Lisp_Object meta_map
; /* The keymap used for globally bound
47 ESC-prefixed default commands */
49 Lisp_Object control_x_map
; /* The keymap used for globally bound
50 C-x-prefixed default commands */
52 /* was MinibufLocalMap */
53 Lisp_Object Vminibuffer_local_map
;
54 /* The keymap used by the minibuf for local
55 bindings when spaces are allowed in the
58 /* was MinibufLocalNSMap */
59 Lisp_Object Vminibuffer_local_ns_map
;
60 /* The keymap used by the minibuf for local
61 bindings when spaces are not encouraged
64 /* keymap used for minibuffers when doing completion */
65 /* was MinibufLocalCompletionMap */
66 Lisp_Object Vminibuffer_local_completion_map
;
68 /* keymap used for minibuffers when doing completion and require a match */
69 /* was MinibufLocalMustMatchMap */
70 Lisp_Object Vminibuffer_local_must_match_map
;
72 /* Alist of minor mode variables and keymaps. */
73 Lisp_Object Vminor_mode_map_alist
;
75 /* Alist of major-mode-specific overrides for
76 minor mode variables and keymaps. */
77 Lisp_Object Vminor_mode_overriding_map_alist
;
79 /* Keymap mapping ASCII function key sequences onto their preferred forms.
80 Initialized by the terminal-specific lisp files. See DEFVAR for more
82 Lisp_Object Vfunction_key_map
;
84 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
85 Lisp_Object Vkey_translation_map
;
87 /* A list of all commands given new bindings since a certain time
88 when nil was stored here.
89 This is used to speed up recomputation of menu key equivalents
90 when Emacs starts up. t means don't record anything here. */
91 Lisp_Object Vdefine_key_rebound_commands
;
93 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
;
95 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
96 in a string key sequence is equivalent to prefixing with this
98 extern Lisp_Object meta_prefix_char
;
100 extern Lisp_Object Voverriding_local_map
;
102 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
103 static Lisp_Object where_is_cache
;
104 /* Which keymaps are reverse-stored in the cache. */
105 static Lisp_Object where_is_cache_keymaps
;
107 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
108 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
110 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
111 static Lisp_Object describe_buffer_bindings
P_ ((Lisp_Object
));
112 static void describe_command
P_ ((Lisp_Object
));
113 static void describe_translation
P_ ((Lisp_Object
));
114 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
115 void (*) P_ ((Lisp_Object
)),
116 int, Lisp_Object
, Lisp_Object
*, int));
118 /* Keymap object support - constructors and predicates. */
120 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
121 "Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).\n\
122 CHARTABLE is a char-table that holds the bindings for the ASCII\n\
123 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
124 mouse events, and any other things that appear in the input stream.\n\
125 All entries in it are initially nil, meaning \"command undefined\".\n\n\
126 The optional arg STRING supplies a menu name for the keymap\n\
127 in case you use it as a menu with `x-popup-menu'.")
133 tail
= Fcons (string
, Qnil
);
136 return Fcons (Qkeymap
,
137 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
140 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
141 "Construct and return a new sparse keymap.\n\
142 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
143 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
144 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
145 Initially the alist is nil.\n\n\
146 The optional arg STRING supplies a menu name for the keymap\n\
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 "Return t if OBJECT is a keymap.\n\
184 A keymap is a list (keymap . ALIST),\n\
185 or a symbol whose function definition is itself a keymap.\n\
186 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
187 a vector of densely packed bindings for small character codes\n\
188 is also allowed as an element.")
192 return (KEYMAPP (object
) ? Qt
: Qnil
);
195 /* Check that OBJECT is a keymap (after dereferencing through any
196 symbols). If it is, return it.
198 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
199 is an autoload form, do the autoload and try again.
200 If AUTOLOAD is nonzero, callers must assume GC is possible.
202 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
203 is zero as well), return Qt.
205 ERROR controls how we respond if OBJECT isn't a keymap.
206 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
208 Note that most of the time, we don't want to pursue autoloads.
209 Functions like Faccessible_keymaps which scan entire keymap trees
210 shouldn't load every autoloaded keymap. I'm not sure about this,
211 but it seems to me that only read_key_sequence, Flookup_key, and
212 Fdefine_key should cause keymaps to be autoloaded.
214 This function can GC when AUTOLOAD is non-zero, because it calls
215 do_autoload which can GC. */
218 get_keymap (object
, error
, autoload
)
227 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
230 tem
= indirect_function (object
);
233 if (EQ (XCAR (tem
), Qkeymap
))
236 /* Should we do an autoload? Autoload forms for keymaps have
237 Qkeymap as their fifth element. */
238 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
))
242 tail
= Fnth (make_number (4), tem
);
243 if (EQ (tail
, Qkeymap
))
247 struct gcpro gcpro1
, gcpro2
;
249 GCPRO2 (tem
, object
);
250 do_autoload (tem
, object
);
263 wrong_type_argument (Qkeymapp
, object
);
267 /* Return the parent map of the keymap MAP, or nil if it has none.
268 We assume that MAP is a valid keymap. */
270 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
271 "Return the parent keymap of KEYMAP.")
277 keymap
= get_keymap (keymap
, 1, 1);
279 /* Skip past the initial element `keymap'. */
280 list
= XCDR (keymap
);
281 for (; CONSP (list
); list
= XCDR (list
))
283 /* See if there is another `keymap'. */
288 return get_keymap (list
, 0, 1);
292 /* Check whether MAP is one of MAPS parents. */
294 keymap_memberp (map
, maps
)
295 Lisp_Object map
, maps
;
297 if (NILP (map
)) return 0;
298 while (KEYMAPP (maps
) && !EQ (map
, maps
))
299 maps
= Fkeymap_parent (maps
);
300 return (EQ (map
, maps
));
303 /* Set the parent keymap of MAP to PARENT. */
305 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
306 "Modify KEYMAP to set its parent map to PARENT.\n\
307 PARENT should be nil or another keymap.")
309 Lisp_Object keymap
, parent
;
311 Lisp_Object list
, prev
;
315 /* Force a keymap flush for the next call to where-is.
316 Since this can be called from within where-is, we don't set where_is_cache
317 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
318 be changed during where-is, while where_is_cache_keymaps is only used at
319 the very beginning of where-is and can thus be changed here without any
321 This is a very minor correctness (rather than safety) issue. */
322 where_is_cache_keymaps
= Qt
;
324 keymap
= get_keymap (keymap
, 1, 1);
329 parent
= get_keymap (parent
, 1, 1);
331 /* Check for cycles. */
332 if (keymap_memberp (keymap
, parent
))
333 error ("Cyclic keymap inheritance");
336 /* Skip past the initial element `keymap'. */
341 /* If there is a parent keymap here, replace it.
342 If we came to the end, add the parent in PREV. */
343 if (! CONSP (list
) || KEYMAPP (list
))
345 /* If we already have the right parent, return now
346 so that we avoid the loops below. */
347 if (EQ (XCDR (prev
), parent
))
348 RETURN_UNGCPRO (parent
);
350 XCDR (prev
) = parent
;
356 /* Scan through for submaps, and set their parents too. */
358 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
360 /* Stop the scan when we come to the parent. */
361 if (EQ (XCAR (list
), Qkeymap
))
364 /* If this element holds a prefix map, deal with it. */
365 if (CONSP (XCAR (list
))
366 && CONSP (XCDR (XCAR (list
))))
367 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
370 if (VECTORP (XCAR (list
)))
371 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
372 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
373 fix_submap_inheritance (keymap
, make_number (i
),
374 XVECTOR (XCAR (list
))->contents
[i
]);
376 if (CHAR_TABLE_P (XCAR (list
)))
378 Lisp_Object indices
[3];
380 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
),
385 RETURN_UNGCPRO (parent
);
388 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
389 if EVENT is also a prefix in MAP's parent,
390 make sure that SUBMAP inherits that definition as its own parent. */
393 fix_submap_inheritance (map
, event
, submap
)
394 Lisp_Object map
, event
, submap
;
396 Lisp_Object map_parent
, parent_entry
;
398 /* SUBMAP is a cons that we found as a key binding.
399 Discard the other things found in a menu key binding. */
401 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
403 /* If it isn't a keymap now, there's no work to do. */
407 map_parent
= Fkeymap_parent (map
);
408 if (!NILP (map_parent
))
410 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
414 /* If MAP's parent has something other than a keymap,
415 our own submap shadows it completely. */
416 if (!CONSP (parent_entry
))
419 if (! EQ (parent_entry
, submap
))
421 Lisp_Object submap_parent
;
422 submap_parent
= submap
;
427 tem
= Fkeymap_parent (submap_parent
);
431 if (keymap_memberp (tem
, parent_entry
))
432 /* Fset_keymap_parent could create a cycle. */
439 Fset_keymap_parent (submap_parent
, parent_entry
);
443 /* Look up IDX in MAP. IDX may be any sort of event.
444 Note that this does only one level of lookup; IDX must be a single
445 event, not a sequence.
447 If T_OK is non-zero, bindings for Qt are treated as default
448 bindings; any key left unmentioned by other tables and bindings is
449 given the binding of Qt.
451 If T_OK is zero, bindings for Qt are not treated specially.
453 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
456 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
466 /* If idx is a list (some sort of mouse click, perhaps?),
467 the index we want to use is the car of the list, which
468 ought to be a symbol. */
469 idx
= EVENT_HEAD (idx
);
471 /* If idx is a symbol, it might have modifiers, which need to
472 be put in the canonical order. */
474 idx
= reorder_modifiers (idx
);
475 else if (INTEGERP (idx
))
476 /* Clobber the high bits that can be present on a machine
477 with more than 24 bits of integer. */
478 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
480 /* Handle the special meta -> esc mapping. */
481 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
483 /* See if there is a meta-map. If there's none, there is
484 no binding for IDX, unless a default binding exists in MAP. */
485 Lisp_Object meta_map
=
486 get_keymap (access_keymap (map
, meta_prefix_char
,
487 t_ok
, noinherit
, autoload
),
489 if (CONSP (meta_map
))
492 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
495 /* Set IDX to t, so that we only find a default binding. */
498 /* We know there is no binding. */
504 Lisp_Object t_binding
;
507 for (tail
= XCDR (map
);
509 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
514 binding
= XCAR (tail
);
515 if (SYMBOLP (binding
))
517 /* If NOINHERIT, stop finding prefix definitions
518 after we pass a second occurrence of the `keymap' symbol. */
519 if (noinherit
&& EQ (binding
, Qkeymap
))
522 else if (CONSP (binding
))
524 if (EQ (XCAR (binding
), idx
))
526 val
= XCDR (binding
);
527 if (noprefix
&& KEYMAPP (val
))
530 fix_submap_inheritance (map
, idx
, val
);
531 return get_keyelt (val
, autoload
);
533 if (t_ok
&& EQ (XCAR (binding
), Qt
))
534 t_binding
= XCDR (binding
);
536 else if (VECTORP (binding
))
538 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
540 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
541 if (noprefix
&& KEYMAPP (val
))
544 fix_submap_inheritance (map
, idx
, val
);
545 return get_keyelt (val
, autoload
);
548 else if (CHAR_TABLE_P (binding
))
550 /* Character codes with modifiers
551 are not included in a char-table.
552 All character codes without modifiers are included. */
555 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
556 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
558 val
= Faref (binding
, idx
);
559 if (noprefix
&& KEYMAPP (val
))
562 fix_submap_inheritance (map
, idx
, val
);
563 return get_keyelt (val
, autoload
);
570 return get_keyelt (t_binding
, autoload
);
574 /* Given OBJECT which was found in a slot in a keymap,
575 trace indirect definitions to get the actual definition of that slot.
576 An indirect definition is a list of the form
577 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
578 and INDEX is the object to look up in KEYMAP to yield the definition.
580 Also if OBJECT has a menu string as the first element,
581 remove that. Also remove a menu help string as second element.
583 If AUTOLOAD is nonzero, load autoloadable keymaps
584 that are referred to with indirection. */
587 get_keyelt (object
, autoload
)
588 register Lisp_Object object
;
593 if (!(CONSP (object
)))
594 /* This is really the value. */
597 /* If the keymap contents looks like (keymap ...) or (lambda ...)
599 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
602 /* If the keymap contents looks like (menu-item name . DEFN)
603 or (menu-item name DEFN ...) then use DEFN.
604 This is a new format menu item. */
605 else if (EQ (XCAR (object
), Qmenu_item
))
607 if (CONSP (XCDR (object
)))
611 object
= XCDR (XCDR (object
));
614 object
= XCAR (object
);
616 /* If there's a `:filter FILTER', apply FILTER to the
617 menu-item's definition to get the real definition to
619 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
620 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
623 filter
= XCAR (XCDR (tem
));
624 filter
= list2 (filter
, list2 (Qquote
, object
));
625 object
= menu_item_eval_property (filter
);
634 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
635 Keymap alist elements like (CHAR MENUSTRING . DEFN)
636 will be used by HierarKey menus. */
637 else if (STRINGP (XCAR (object
)))
639 object
= XCDR (object
);
640 /* Also remove a menu help string, if any,
641 following the menu item name. */
642 if (CONSP (object
) && STRINGP (XCAR (object
)))
643 object
= XCDR (object
);
644 /* Also remove the sublist that caches key equivalences, if any. */
645 if (CONSP (object
) && CONSP (XCAR (object
)))
648 carcar
= XCAR (XCAR (object
));
649 if (NILP (carcar
) || VECTORP (carcar
))
650 object
= XCDR (object
);
654 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
658 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
659 return (!CONSP (map
) ? object
/* Invalid keymap */
660 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
666 store_in_keymap (keymap
, idx
, def
)
668 register Lisp_Object idx
;
669 register Lisp_Object def
;
671 /* Flush any reverse-map cache. */
672 where_is_cache
= Qnil
;
673 where_is_cache_keymaps
= Qt
;
675 /* If we are preparing to dump, and DEF is a menu element
676 with a menu item indicator, copy it to ensure it is not pure. */
677 if (CONSP (def
) && PURE_P (def
)
678 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
679 def
= Fcons (XCAR (def
), XCDR (def
));
681 if (!CONSP (keymap
) || ! EQ (XCAR (keymap
), Qkeymap
))
682 error ("attempt to define a key in a non-keymap");
684 /* If idx is a list (some sort of mouse click, perhaps?),
685 the index we want to use is the car of the list, which
686 ought to be a symbol. */
687 idx
= EVENT_HEAD (idx
);
689 /* If idx is a symbol, it might have modifiers, which need to
690 be put in the canonical order. */
692 idx
= reorder_modifiers (idx
);
693 else if (INTEGERP (idx
))
694 /* Clobber the high bits that can be present on a machine
695 with more than 24 bits of integer. */
696 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
698 /* Scan the keymap for a binding of idx. */
702 /* The cons after which we should insert new bindings. If the
703 keymap has a table element, we record its position here, so new
704 bindings will go after it; this way, the table will stay
705 towards the front of the alist and character lookups in dense
706 keymaps will remain fast. Otherwise, this just points at the
707 front of the keymap. */
708 Lisp_Object insertion_point
;
710 insertion_point
= keymap
;
711 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
718 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
720 ASET (elt
, XFASTINT (idx
), def
);
723 insertion_point
= tail
;
725 else if (CHAR_TABLE_P (elt
))
727 /* Character codes with modifiers
728 are not included in a char-table.
729 All character codes without modifiers are included. */
732 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
733 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
735 Faset (elt
, idx
, def
);
738 insertion_point
= tail
;
740 else if (CONSP (elt
))
742 if (EQ (idx
, XCAR (elt
)))
748 else if (EQ (elt
, Qkeymap
))
749 /* If we find a 'keymap' symbol in the spine of KEYMAP,
750 then we must have found the start of a second keymap
751 being used as the tail of KEYMAP, and a binding for IDX
752 should be inserted before it. */
759 /* We have scanned the entire keymap, and not found a binding for
760 IDX. Let's add one. */
761 XCDR (insertion_point
)
762 = Fcons (Fcons (idx
, def
), XCDR (insertion_point
));
769 copy_keymap_1 (chartable
, idx
, elt
)
770 Lisp_Object chartable
, idx
, elt
;
772 if (CONSP (elt
) && EQ (XCAR (elt
), Qkeymap
))
773 Faset (chartable
, idx
, Fcopy_keymap (elt
));
776 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
777 "Return a copy of the keymap KEYMAP.\n\
778 The copy starts out with the same definitions of KEYMAP,\n\
779 but changing either the copy or KEYMAP does not affect the other.\n\
780 Any key definitions that are subkeymaps are recursively copied.\n\
781 However, a key definition which is a symbol whose definition is a keymap\n\
786 register Lisp_Object copy
, tail
;
788 copy
= Fcopy_alist (get_keymap (keymap
, 1, 0));
790 for (tail
= copy
; CONSP (tail
); tail
= XCDR (tail
))
795 if (CHAR_TABLE_P (elt
))
797 Lisp_Object indices
[3];
799 elt
= Fcopy_sequence (elt
);
802 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
804 else if (VECTORP (elt
))
808 elt
= Fcopy_sequence (elt
);
811 for (i
= 0; i
< ASIZE (elt
); i
++)
812 if (CONSP (AREF (elt
, i
)) && EQ (XCAR (AREF (elt
, i
)), Qkeymap
))
813 ASET (elt
, i
, Fcopy_keymap (AREF (elt
, i
)));
815 else if (CONSP (elt
) && CONSP (XCDR (elt
)))
820 /* Is this a new format menu item. */
821 if (EQ (XCAR (tem
),Qmenu_item
))
823 /* Copy cell with menu-item marker. */
825 = Fcons (XCAR (tem
), XCDR (tem
));
830 /* Copy cell with menu-item name. */
832 = Fcons (XCAR (tem
), XCDR (tem
));
838 /* Copy cell with binding and if the binding is a keymap,
841 = Fcons (XCAR (tem
), XCDR (tem
));
844 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
845 XCAR (elt
) = Fcopy_keymap (tem
);
847 if (CONSP (tem
) && CONSP (XCAR (tem
)))
848 /* Delete cache for key equivalences. */
849 XCDR (elt
) = XCDR (tem
);
854 /* It may be an old fomat menu item.
855 Skip the optional menu string.
857 if (STRINGP (XCAR (tem
)))
859 /* Copy the cell, since copy-alist didn't go this deep. */
861 = Fcons (XCAR (tem
), XCDR (tem
));
864 /* Also skip the optional menu help string. */
865 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
868 = Fcons (XCAR (tem
), XCDR (tem
));
872 /* There may also be a list that caches key equivalences.
873 Just delete it for the new keymap. */
875 && CONSP (XCAR (tem
))
876 && (NILP (XCAR (XCAR (tem
)))
877 || VECTORP (XCAR (XCAR (tem
)))))
878 XCDR (elt
) = XCDR (tem
);
881 && CONSP (XCDR (elt
))
882 && EQ (XCAR (XCDR (elt
)), Qkeymap
))
883 XCDR (elt
) = Fcopy_keymap (XCDR (elt
));
892 /* Simple Keymap mutators and accessors. */
894 /* GC is possible in this function if it autoloads a keymap. */
896 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
897 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
898 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
899 meaning a sequence of keystrokes and events.\n\
900 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
901 can be included if you use a vector.\n\
902 DEF is anything that can be a key's definition:\n\
903 nil (means key is undefined in this keymap),\n\
904 a command (a Lisp function suitable for interactive calling)\n\
905 a string (treated as a keyboard macro),\n\
906 a keymap (to define a prefix key),\n\
907 a symbol. When the key is looked up, the symbol will stand for its\n\
908 function definition, which should at that time be one of the above,\n\
909 or another symbol whose function definition is used, etc.\n\
910 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
911 (DEFN should be a valid definition in its own right),\n\
912 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
914 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
915 the front of KEYMAP.")
922 register Lisp_Object c
;
923 register Lisp_Object cmd
;
927 struct gcpro gcpro1
, gcpro2
, gcpro3
;
929 keymap
= get_keymap (keymap
, 1, 1);
931 if (!VECTORP (key
) && !STRINGP (key
))
932 key
= wrong_type_argument (Qarrayp
, key
);
934 length
= XFASTINT (Flength (key
));
938 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
939 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
941 GCPRO3 (keymap
, key
, def
);
944 meta_bit
= meta_modifier
;
951 c
= Faref (key
, make_number (idx
));
953 if (CONSP (c
) && lucid_event_type_list_p (c
))
954 c
= Fevent_convert_list (c
);
957 && (XINT (c
) & meta_bit
)
960 c
= meta_prefix_char
;
966 XSETINT (c
, XINT (c
) & ~meta_bit
);
972 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
973 error ("Key sequence contains invalid events");
976 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
978 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
980 /* If this key is undefined, make it a prefix. */
982 cmd
= define_as_prefix (keymap
, c
);
984 keymap
= get_keymap (cmd
, 0, 1);
986 /* We must use Fkey_description rather than just passing key to
987 error; key might be a vector, not a string. */
988 error ("Key sequence %s uses invalid prefix characters",
989 XSTRING (Fkey_description (key
))->data
);
993 /* Value is number if KEY is too long; NIL if valid but has no definition. */
994 /* GC is possible in this function if it autoloads a keymap. */
996 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
997 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
998 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
1000 A number as value means KEY is \"too long\";\n\
1001 that is, characters or symbols in it except for the last one\n\
1002 fail to be a valid sequence of prefix characters in KEYMAP.\n\
1003 The number is how many characters at the front of KEY\n\
1004 it takes to reach a non-prefix command.\n\
1006 Normally, `lookup-key' ignores bindings for t, which act as default\n\
1007 bindings, used when nothing else in the keymap applies; this makes it\n\
1008 usable as a general function for probing keymaps. However, if the\n\
1009 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
1010 recognize the default bindings, just as `read-key-sequence' does.")
1011 (keymap
, key
, accept_default
)
1012 register Lisp_Object keymap
;
1014 Lisp_Object accept_default
;
1017 register Lisp_Object cmd
;
1018 register Lisp_Object c
;
1020 int t_ok
= ! NILP (accept_default
);
1021 struct gcpro gcpro1
;
1023 keymap
= get_keymap (keymap
, 1, 1);
1025 if (!VECTORP (key
) && !STRINGP (key
))
1026 key
= wrong_type_argument (Qarrayp
, key
);
1028 length
= XFASTINT (Flength (key
));
1037 c
= Faref (key
, make_number (idx
++));
1039 if (CONSP (c
) && lucid_event_type_list_p (c
))
1040 c
= Fevent_convert_list (c
);
1042 /* Turn the 8th bit of string chars into a meta modifier. */
1043 if (XINT (c
) & 0x80 && STRINGP (key
))
1044 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1046 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1048 RETURN_UNGCPRO (cmd
);
1050 keymap
= get_keymap (cmd
, 0, 1);
1051 if (!CONSP (keymap
))
1052 RETURN_UNGCPRO (make_number (idx
));
1058 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1059 Assume that currently it does not define C at all.
1060 Return the keymap. */
1063 define_as_prefix (keymap
, c
)
1064 Lisp_Object keymap
, c
;
1068 cmd
= Fmake_sparse_keymap (Qnil
);
1069 /* If this key is defined as a prefix in an inherited keymap,
1070 make it a prefix in this map, and make its definition
1071 inherit the other prefix definition. */
1072 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1073 store_in_keymap (keymap
, c
, cmd
);
1078 /* Append a key to the end of a key sequence. We always make a vector. */
1081 append_key (key_sequence
, key
)
1082 Lisp_Object key_sequence
, key
;
1084 Lisp_Object args
[2];
1086 args
[0] = key_sequence
;
1088 args
[1] = Fcons (key
, Qnil
);
1089 return Fvconcat (2, args
);
1093 /* Global, local, and minor mode keymap stuff. */
1095 /* We can't put these variables inside current_minor_maps, since under
1096 some systems, static gets macro-defined to be the empty string.
1098 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1099 static int cmm_size
;
1101 /* Error handler used in current_minor_maps. */
1103 current_minor_maps_error ()
1108 /* Store a pointer to an array of the keymaps of the currently active
1109 minor modes in *buf, and return the number of maps it contains.
1111 This function always returns a pointer to the same buffer, and may
1112 free or reallocate it, so if you want to keep it for a long time or
1113 hand it out to lisp code, copy it. This procedure will be called
1114 for every key sequence read, so the nice lispy approach (return a
1115 new assoclist, list, what have you) for each invocation would
1116 result in a lot of consing over time.
1118 If we used xrealloc/xmalloc and ran out of memory, they would throw
1119 back to the command loop, which would try to read a key sequence,
1120 which would call this function again, resulting in an infinite
1121 loop. Instead, we'll use realloc/malloc and silently truncate the
1122 list, let the key sequence be read, and hope some other piece of
1123 code signals the error. */
1125 current_minor_maps (modeptr
, mapptr
)
1126 Lisp_Object
**modeptr
, **mapptr
;
1129 int list_number
= 0;
1130 Lisp_Object alist
, assoc
, var
, val
;
1131 Lisp_Object lists
[2];
1133 lists
[0] = Vminor_mode_overriding_map_alist
;
1134 lists
[1] = Vminor_mode_map_alist
;
1136 for (list_number
= 0; list_number
< 2; list_number
++)
1137 for (alist
= lists
[list_number
];
1139 alist
= XCDR (alist
))
1140 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1141 && (var
= XCAR (assoc
), SYMBOLP (var
))
1142 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1147 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1148 and also an entry in Vminor_mode_map_alist,
1149 ignore the latter. */
1150 if (list_number
== 1)
1152 val
= assq_no_quit (var
, lists
[0]);
1159 Lisp_Object
*newmodes
, *newmaps
;
1161 /* Use malloc/realloc here. See the comment above
1168 = (Lisp_Object
*) realloc (cmm_modes
,
1169 cmm_size
* sizeof *newmodes
);
1171 = (Lisp_Object
*) realloc (cmm_maps
,
1172 cmm_size
* sizeof *newmaps
);
1180 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmodes
);
1182 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmaps
);
1187 cmm_modes
= newmodes
;
1191 if (newmodes
== NULL
|| newmaps
== NULL
)
1195 /* Get the keymap definition--or nil if it is not defined. */
1196 temp
= internal_condition_case_1 (Findirect_function
,
1198 Qerror
, current_minor_maps_error
);
1202 cmm_maps
[i
] = temp
;
1207 if (modeptr
) *modeptr
= cmm_modes
;
1208 if (mapptr
) *mapptr
= cmm_maps
;
1212 /* GC is possible in this function if it autoloads a keymap. */
1214 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1215 "Return the binding for command KEY in current keymaps.\n\
1216 KEY is a string or vector, a sequence of keystrokes.\n\
1217 The binding is probably a symbol with a function definition.\n\
1219 Normally, `key-binding' ignores bindings for t, which act as default\n\
1220 bindings, used when nothing else in the keymap applies; this makes it\n\
1221 usable as a general function for probing keymaps. However, if the\n\
1222 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1223 recognize the default bindings, just as `read-key-sequence' does.")
1224 (key
, accept_default
)
1225 Lisp_Object key
, accept_default
;
1227 Lisp_Object
*maps
, value
;
1229 struct gcpro gcpro1
;
1233 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1235 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1236 key
, accept_default
);
1237 if (! NILP (value
) && !INTEGERP (value
))
1238 RETURN_UNGCPRO (value
);
1240 else if (!NILP (Voverriding_local_map
))
1242 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1243 if (! NILP (value
) && !INTEGERP (value
))
1244 RETURN_UNGCPRO (value
);
1250 nmaps
= current_minor_maps (0, &maps
);
1251 /* Note that all these maps are GCPRO'd
1252 in the places where we found them. */
1254 for (i
= 0; i
< nmaps
; i
++)
1255 if (! NILP (maps
[i
]))
1257 value
= Flookup_key (maps
[i
], key
, accept_default
);
1258 if (! NILP (value
) && !INTEGERP (value
))
1259 RETURN_UNGCPRO (value
);
1262 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1265 value
= Flookup_key (local
, key
, accept_default
);
1266 if (! NILP (value
) && !INTEGERP (value
))
1267 RETURN_UNGCPRO (value
);
1270 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1274 value
= Flookup_key (local
, key
, accept_default
);
1275 if (! NILP (value
) && !INTEGERP (value
))
1276 RETURN_UNGCPRO (value
);
1280 value
= Flookup_key (current_global_map
, key
, accept_default
);
1282 if (! NILP (value
) && !INTEGERP (value
))
1288 /* GC is possible in this function if it autoloads a keymap. */
1290 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1291 "Return the binding for command KEYS in current local keymap only.\n\
1292 KEYS is a string, a sequence of keystrokes.\n\
1293 The binding is probably a symbol with a function definition.\n\
1295 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1296 bindings; see the description of `lookup-key' for more details about this.")
1297 (keys
, accept_default
)
1298 Lisp_Object keys
, accept_default
;
1300 register Lisp_Object map
;
1301 map
= current_buffer
->keymap
;
1304 return Flookup_key (map
, keys
, accept_default
);
1307 /* GC is possible in this function if it autoloads a keymap. */
1309 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1310 "Return the binding for command KEYS in current global keymap only.\n\
1311 KEYS is a string, a sequence of keystrokes.\n\
1312 The binding is probably a symbol with a function definition.\n\
1313 This function's return values are the same as those of lookup-key\n\
1316 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1317 bindings; see the description of `lookup-key' for more details about this.")
1318 (keys
, accept_default
)
1319 Lisp_Object keys
, accept_default
;
1321 return Flookup_key (current_global_map
, keys
, accept_default
);
1324 /* GC is possible in this function if it autoloads a keymap. */
1326 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1327 "Find the visible minor mode bindings of KEY.\n\
1328 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1329 the symbol which names the minor mode binding KEY, and BINDING is\n\
1330 KEY's definition in that mode. In particular, if KEY has no\n\
1331 minor-mode bindings, return nil. If the first binding is a\n\
1332 non-prefix, all subsequent bindings will be omitted, since they would\n\
1333 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1334 that come after prefix bindings.\n\
1336 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1337 bindings; see the description of `lookup-key' for more details about this.")
1338 (key
, accept_default
)
1339 Lisp_Object key
, accept_default
;
1341 Lisp_Object
*modes
, *maps
;
1343 Lisp_Object binding
;
1345 struct gcpro gcpro1
, gcpro2
;
1347 nmaps
= current_minor_maps (&modes
, &maps
);
1348 /* Note that all these maps are GCPRO'd
1349 in the places where we found them. */
1352 GCPRO2 (key
, binding
);
1354 for (i
= j
= 0; i
< nmaps
; i
++)
1356 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1357 && !INTEGERP (binding
))
1359 if (KEYMAPP (binding
))
1360 maps
[j
++] = Fcons (modes
[i
], binding
);
1362 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1366 return Flist (j
, maps
);
1369 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1370 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1371 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1372 If a second optional argument MAPVAR is given, the map is stored as\n\
1373 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1375 The third optional argument NAME, if given, supplies a menu name\n\
1376 string for the map. This is required to use the keymap as a menu.")
1377 (command
, mapvar
, name
)
1378 Lisp_Object command
, mapvar
, name
;
1381 map
= Fmake_sparse_keymap (name
);
1382 Ffset (command
, map
);
1386 Fset (command
, map
);
1390 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1391 "Select KEYMAP as the global keymap.")
1395 keymap
= get_keymap (keymap
, 1, 1);
1396 current_global_map
= keymap
;
1401 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1402 "Select KEYMAP as the local keymap.\n\
1403 If KEYMAP is nil, that means no local keymap.")
1408 keymap
= get_keymap (keymap
, 1, 1);
1410 current_buffer
->keymap
= keymap
;
1415 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1416 "Return current buffer's local keymap, or nil if it has none.")
1419 return current_buffer
->keymap
;
1422 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1423 "Return the current global keymap.")
1426 return current_global_map
;
1429 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1430 "Return a list of keymaps for the minor modes of the current buffer.")
1434 int nmaps
= current_minor_maps (0, &maps
);
1436 return Flist (nmaps
, maps
);
1439 /* Help functions for describing and documenting keymaps. */
1441 static void accessible_keymaps_char_table
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
1443 /* This function cannot GC. */
1445 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1447 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1448 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1449 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1450 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1451 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1452 then the value includes only maps for prefixes that start with PREFIX.")
1454 Lisp_Object keymap
, prefix
;
1456 Lisp_Object maps
, good_maps
, tail
;
1459 /* no need for gcpro because we don't autoload any keymaps. */
1462 prefixlen
= XINT (Flength (prefix
));
1466 /* If a prefix was specified, start with the keymap (if any) for
1467 that prefix, so we don't waste time considering other prefixes. */
1469 tem
= Flookup_key (keymap
, prefix
, Qt
);
1470 /* Flookup_key may give us nil, or a number,
1471 if the prefix is not defined in this particular map.
1472 It might even give us a list that isn't a keymap. */
1473 tem
= get_keymap (tem
, 0, 0);
1476 /* Convert PREFIX to a vector now, so that later on
1477 we don't have to deal with the possibility of a string. */
1478 if (STRINGP (prefix
))
1483 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1484 for (i
= 0, i_byte
= 0; i
< XSTRING (prefix
)->size
;)
1488 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1489 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1490 c
^= 0200 | meta_modifier
;
1491 ASET (copy
, i_before
, make_number (c
));
1495 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1501 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1502 get_keymap (keymap
, 1, 0)),
1505 /* For each map in the list maps,
1506 look at any other maps it points to,
1507 and stick them at the end if they are not already in the list.
1509 This is a breadth-first traversal, where tail is the queue of
1510 nodes, and maps accumulates a list of all nodes visited. */
1512 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1514 register Lisp_Object thisseq
, thismap
;
1516 /* Does the current sequence end in the meta-prefix-char? */
1519 thisseq
= Fcar (Fcar (tail
));
1520 thismap
= Fcdr (Fcar (tail
));
1521 last
= make_number (XINT (Flength (thisseq
)) - 1);
1522 is_metized
= (XINT (last
) >= 0
1523 /* Don't metize the last char of PREFIX. */
1524 && XINT (last
) >= prefixlen
1525 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1527 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1531 elt
= XCAR (thismap
);
1535 if (CHAR_TABLE_P (elt
))
1537 Lisp_Object indices
[3];
1539 map_char_table (accessible_keymaps_char_table
, Qnil
,
1540 elt
, Fcons (Fcons (maps
, is_metized
),
1541 Fcons (tail
, thisseq
)),
1544 else if (VECTORP (elt
))
1548 /* Vector keymap. Scan all the elements. */
1549 for (i
= 0; i
< ASIZE (elt
); i
++)
1551 register Lisp_Object tem
;
1552 register Lisp_Object cmd
;
1554 cmd
= get_keyelt (AREF (elt
, i
), 0);
1555 if (NILP (cmd
)) continue;
1556 tem
= get_keymap (cmd
, 0, 0);
1560 /* Ignore keymaps that are already added to maps. */
1561 tem
= Frassq (cmd
, maps
);
1564 /* If the last key in thisseq is meta-prefix-char,
1565 turn it into a meta-ized keystroke. We know
1566 that the event we're about to append is an
1567 ascii keystroke since we're processing a
1571 int meta_bit
= meta_modifier
;
1572 tem
= Fcopy_sequence (thisseq
);
1574 Faset (tem
, last
, make_number (i
| meta_bit
));
1576 /* This new sequence is the same length as
1577 thisseq, so stick it in the list right
1580 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1584 tem
= append_key (thisseq
, make_number (i
));
1585 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1591 else if (CONSP (elt
))
1593 register Lisp_Object cmd
, tem
;
1595 cmd
= get_keyelt (XCDR (elt
), 0);
1596 /* Ignore definitions that aren't keymaps themselves. */
1597 tem
= get_keymap (cmd
, 0, 0);
1600 /* Ignore keymaps that have been seen already. */
1602 tem
= Frassq (cmd
, maps
);
1605 /* Let elt be the event defined by this map entry. */
1608 /* If the last key in thisseq is meta-prefix-char, and
1609 this entry is a binding for an ascii keystroke,
1610 turn it into a meta-ized keystroke. */
1611 if (is_metized
&& INTEGERP (elt
))
1613 Lisp_Object element
;
1616 tem
= Fvconcat (1, &element
);
1617 XSETFASTINT (AREF (tem
, XINT (last
)),
1618 XINT (elt
) | meta_modifier
);
1620 /* This new sequence is the same length as
1621 thisseq, so stick it in the list right
1624 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1628 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1639 /* Now find just the maps whose access prefixes start with PREFIX. */
1642 for (; CONSP (maps
); maps
= XCDR (maps
))
1644 Lisp_Object elt
, thisseq
;
1646 thisseq
= XCAR (elt
);
1647 /* The access prefix must be at least as long as PREFIX,
1648 and the first elements must match those of PREFIX. */
1649 if (XINT (Flength (thisseq
)) >= prefixlen
)
1652 for (i
= 0; i
< prefixlen
; i
++)
1655 XSETFASTINT (i1
, i
);
1656 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1660 good_maps
= Fcons (elt
, good_maps
);
1664 return Fnreverse (good_maps
);
1668 accessible_keymaps_char_table (args
, index
, cmd
)
1669 Lisp_Object args
, index
, cmd
;
1672 Lisp_Object maps
, tail
, thisseq
, is_metized
;
1674 cmd
= get_keyelt (cmd
, 0);
1678 maps
= XCAR (XCAR (args
));
1679 is_metized
= XCDR (XCAR (args
));
1680 tail
= XCAR (XCDR (args
));
1681 thisseq
= XCDR (XCDR (args
));
1683 tem
= get_keymap (cmd
, 0, 0);
1687 /* Ignore keymaps that are already added to maps. */
1688 tem
= Frassq (cmd
, maps
);
1691 /* If the last key in thisseq is meta-prefix-char,
1692 turn it into a meta-ized keystroke. We know
1693 that the event we're about to append is an
1694 ascii keystroke since we're processing a
1698 int meta_bit
= meta_modifier
;
1699 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1700 tem
= Fcopy_sequence (thisseq
);
1702 Faset (tem
, last
, make_number (XINT (index
) | meta_bit
));
1704 /* This new sequence is the same length as
1705 thisseq, so stick it in the list right
1708 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1712 tem
= append_key (thisseq
, index
);
1713 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1719 Lisp_Object Qsingle_key_description
, Qkey_description
;
1721 /* This function cannot GC. */
1723 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1724 "Return a pretty description of key-sequence KEYS.\n\
1725 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1726 spaces are put between sequence elements, etc.")
1733 Lisp_Object
*args
= NULL
;
1738 vector
= Fmake_vector (Flength (keys
), Qnil
);
1739 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1744 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1745 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1746 c
^= 0200 | meta_modifier
;
1747 XSETFASTINT (AREF (vector
, i_before
), c
);
1754 /* In effect, this computes
1755 (mapconcat 'single-key-description keys " ")
1756 but we shouldn't use mapconcat because it can do GC. */
1758 len
= XVECTOR (keys
)->size
;
1759 sep
= build_string (" ");
1760 /* This has one extra element at the end that we don't pass to Fconcat. */
1761 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1763 for (i
= 0; i
< len
; i
++)
1765 args
[i
* 2] = Fsingle_key_description (AREF (keys
, i
), Qnil
);
1766 args
[i
* 2 + 1] = sep
;
1769 else if (CONSP (keys
))
1771 /* In effect, this computes
1772 (mapconcat 'single-key-description keys " ")
1773 but we shouldn't use mapconcat because it can do GC. */
1775 len
= XFASTINT (Flength (keys
));
1776 sep
= build_string (" ");
1777 /* This has one extra element at the end that we don't pass to Fconcat. */
1778 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1780 for (i
= 0; i
< len
; i
++)
1782 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1783 args
[i
* 2 + 1] = sep
;
1788 keys
= wrong_type_argument (Qarrayp
, keys
);
1791 return build_string ("");
1792 return Fconcat (len
* 2 - 1, args
);
1796 push_key_description (c
, p
, force_multibyte
)
1797 register unsigned int c
;
1799 int force_multibyte
;
1803 /* Clear all the meaningless bits above the meta bit. */
1804 c
&= meta_modifier
| ~ - meta_modifier
;
1805 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1806 | meta_modifier
| shift_modifier
| super_modifier
);
1808 if (c
& alt_modifier
)
1814 if ((c
& ctrl_modifier
) != 0
1815 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1819 c
&= ~ctrl_modifier
;
1821 if (c
& hyper_modifier
)
1825 c
-= hyper_modifier
;
1827 if (c
& meta_modifier
)
1833 if (c
& shift_modifier
)
1837 c
-= shift_modifier
;
1839 if (c
& super_modifier
)
1843 c
-= super_modifier
;
1859 else if (c
== Ctl ('M'))
1867 /* `C-' already added above. */
1868 if (c
> 0 && c
<= Ctl ('Z'))
1887 || (NILP (current_buffer
->enable_multibyte_characters
)
1888 && SINGLE_BYTE_CHAR_P (c
)
1889 && !force_multibyte
))
1895 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
1897 if (force_multibyte
&& valid_p
)
1899 if (SINGLE_BYTE_CHAR_P (c
))
1900 c
= unibyte_char_to_multibyte (c
);
1901 p
+= CHAR_STRING (c
, p
);
1903 else if (NILP (current_buffer
->enable_multibyte_characters
)
1908 /* The biggest character code uses 19 bits. */
1909 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1911 if (c
>= (1 << bit_offset
))
1912 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1916 p
+= CHAR_STRING (c
, p
);
1922 /* This function cannot GC. */
1924 DEFUN ("single-key-description", Fsingle_key_description
,
1925 Ssingle_key_description
, 1, 2, 0,
1926 "Return a pretty description of command character KEY.\n\
1927 Control characters turn into C-whatever, etc.\n\
1928 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1929 around function keys and event symbols.")
1931 Lisp_Object key
, no_angles
;
1933 if (CONSP (key
) && lucid_event_type_list_p (key
))
1934 key
= Fevent_convert_list (key
);
1936 key
= EVENT_HEAD (key
);
1938 if (INTEGERP (key
)) /* Normal character */
1940 unsigned int charset
, c1
, c2
;
1941 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1943 if (SINGLE_BYTE_CHAR_P (without_bits
))
1946 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1949 && CHARSET_DEFINED_P (charset
)
1950 && ((c1
>= 0 && c1
< 32)
1951 || (c2
>= 0 && c2
< 32)))
1953 /* Handle a generic character. */
1955 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1956 CHECK_STRING (name
, 0);
1957 return concat2 (build_string ("Character set "), name
);
1961 char tem
[KEY_DESCRIPTION_SIZE
];
1963 *push_key_description (XUINT (key
), tem
, 1) = 0;
1964 return build_string (tem
);
1967 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1969 if (NILP (no_angles
))
1972 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
1973 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
1974 return build_string (buffer
);
1977 return Fsymbol_name (key
);
1979 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1980 return Fcopy_sequence (key
);
1982 error ("KEY must be an integer, cons, symbol, or string");
1987 push_text_char_description (c
, p
)
1988 register unsigned int c
;
2000 *p
++ = c
+ 64; /* 'A' - 1 */
2012 /* This function cannot GC. */
2014 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2015 "Return a pretty description of file-character CHARACTER.\n\
2016 Control characters turn into \"^char\", etc.")
2018 Lisp_Object character
;
2020 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2021 unsigned char str
[6];
2024 CHECK_NUMBER (character
, 0);
2026 c
= XINT (character
);
2027 if (!SINGLE_BYTE_CHAR_P (c
))
2029 int len
= CHAR_STRING (c
, str
);
2031 return make_multibyte_string (str
, 1, len
);
2034 *push_text_char_description (c
& 0377, str
) = 0;
2036 return build_string (str
);
2039 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2042 ascii_sequence_p (seq
)
2046 int len
= XINT (Flength (seq
));
2048 for (i
= 0; i
< len
; i
++)
2050 Lisp_Object ii
, elt
;
2052 XSETFASTINT (ii
, i
);
2053 elt
= Faref (seq
, ii
);
2056 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2064 /* where-is - finding a command in a set of keymaps. */
2066 static Lisp_Object
where_is_internal_1 ();
2067 static void where_is_internal_2 ();
2069 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2070 Returns the first non-nil binding found in any of those maps. */
2073 shadow_lookup (shadow
, key
, flag
)
2074 Lisp_Object shadow
, key
, flag
;
2076 Lisp_Object tail
, value
;
2078 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2080 value
= Flookup_key (XCAR (tail
), key
, flag
);
2081 if (!NILP (value
) && !NATNUMP (value
))
2087 /* This function can GC if Flookup_key autoloads any keymaps. */
2090 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2091 Lisp_Object definition
, keymaps
;
2092 Lisp_Object firstonly
, noindirect
;
2094 Lisp_Object maps
= Qnil
;
2095 Lisp_Object found
, sequences
;
2096 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2097 /* 1 means ignore all menu bindings entirely. */
2098 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2101 while (CONSP (found
))
2105 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2106 found
= XCDR (found
);
2109 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2113 for (; !NILP (maps
); maps
= Fcdr (maps
))
2115 /* Key sequence to reach map, and the map that it reaches */
2116 register Lisp_Object
this, map
;
2118 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2119 [M-CHAR] sequences, check if last character of the sequence
2120 is the meta-prefix char. */
2124 this = Fcar (Fcar (maps
));
2125 map
= Fcdr (Fcar (maps
));
2126 last
= make_number (XINT (Flength (this)) - 1);
2127 last_is_meta
= (XINT (last
) >= 0
2128 && EQ (Faref (this, last
), meta_prefix_char
));
2130 /* if (nomenus && !ascii_sequence_p (this)) */
2131 if (nomenus
&& XINT (last
) >= 0
2132 && !INTEGERP (Faref (this, make_number (0))))
2133 /* If no menu entries should be returned, skip over the
2134 keymaps bound to `menu-bar' and `tool-bar' and other
2135 non-ascii prefixes like `C-down-mouse-2'. */
2142 /* Because the code we want to run on each binding is rather
2143 large, we don't want to have two separate loop bodies for
2144 sparse keymap bindings and tables; we want to iterate one
2145 loop body over both keymap and vector bindings.
2147 For this reason, if Fcar (map) is a vector, we don't
2148 advance map to the next element until i indicates that we
2149 have finished off the vector. */
2150 Lisp_Object elt
, key
, binding
;
2158 /* Set key and binding to the current key and binding, and
2159 advance map and i to the next binding. */
2162 Lisp_Object sequence
;
2164 /* In a vector, look at each element. */
2165 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2167 binding
= AREF (elt
, i
);
2168 XSETFASTINT (key
, i
);
2169 sequence
= where_is_internal_1 (binding
, key
, definition
,
2171 last
, nomenus
, last_is_meta
);
2172 if (!NILP (sequence
))
2173 sequences
= Fcons (sequence
, sequences
);
2176 else if (CHAR_TABLE_P (elt
))
2178 Lisp_Object indices
[3];
2181 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2182 Qnil
), /* Result accumulator. */
2183 Fcons (Fcons (this, last
),
2184 Fcons (make_number (nomenus
),
2185 make_number (last_is_meta
))));
2186 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2188 sequences
= XCDR (XCAR (args
));
2190 else if (CONSP (elt
))
2192 Lisp_Object sequence
;
2195 binding
= XCDR (elt
);
2197 sequence
= where_is_internal_1 (binding
, key
, definition
,
2199 last
, nomenus
, last_is_meta
);
2200 if (!NILP (sequence
))
2201 sequences
= Fcons (sequence
, sequences
);
2205 for (; ! NILP (sequences
); sequences
= XCDR (sequences
))
2207 Lisp_Object sequence
;
2209 sequence
= XCAR (sequences
);
2211 /* Verify that this key binding is not shadowed by another
2212 binding for the same key, before we say it exists.
2214 Mechanism: look for local definition of this key and if
2215 it is defined and does not match what we found then
2218 Either nil or number as value from Flookup_key
2220 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2223 /* It is a true unshadowed match. Record it, unless it's already
2224 been seen (as could happen when inheriting keymaps). */
2225 if (NILP (Fmember (sequence
, found
)))
2226 found
= Fcons (sequence
, found
);
2228 /* If firstonly is Qnon_ascii, then we can return the first
2229 binding we find. If firstonly is not Qnon_ascii but not
2230 nil, then we should return the first ascii-only binding
2232 if (EQ (firstonly
, Qnon_ascii
))
2233 RETURN_UNGCPRO (sequence
);
2234 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2235 RETURN_UNGCPRO (sequence
);
2242 found
= Fnreverse (found
);
2244 /* firstonly may have been t, but we may have gone all the way through
2245 the keymaps without finding an all-ASCII key sequence. So just
2246 return the best we could find. */
2247 if (! NILP (firstonly
))
2248 return Fcar (found
);
2253 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2254 "Return list of keys that invoke DEFINITION.\n\
2255 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2256 If KEYMAP is nil, search all the currently active keymaps.\n\
2257 If KEYMAP is a list of keymaps, search only those keymaps.\n\
2259 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2260 rather than a list of all possible key sequences.\n\
2261 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2262 no matter what it is.\n\
2263 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2264 and entirely reject menu bindings.\n\
2266 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2267 to other keymaps or slots. This makes it possible to search for an\n\
2268 indirect definition itself.")
2269 (definition
, keymap
, firstonly
, noindirect
)
2270 Lisp_Object definition
, keymap
;
2271 Lisp_Object firstonly
, noindirect
;
2273 Lisp_Object sequences
, keymaps
;
2274 /* 1 means ignore all menu bindings entirely. */
2275 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2278 /* Find the relevant keymaps. */
2279 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2281 else if (! NILP (keymap
))
2282 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2286 nconc2 (Fcurrent_minor_mode_maps (),
2287 Fcons (get_local_map (PT
, current_buffer
, Qkeymap
),
2288 Fcons (get_local_map (PT
, current_buffer
,
2290 Fcons (current_global_map
, Qnil
)))));
2292 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2293 We don't really need to check `keymap'. */
2294 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2298 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2300 /* Check heuristic-consistency of the cache. */
2301 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2302 where_is_cache
= Qnil
;
2304 if (NILP (where_is_cache
))
2306 /* We need to create the cache. */
2307 Lisp_Object args
[2];
2308 where_is_cache
= Fmake_hash_table (0, args
);
2309 where_is_cache_keymaps
= Qt
;
2311 /* Fill in the cache. */
2312 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2313 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2316 where_is_cache_keymaps
= keymaps
;
2319 /* We want to process definitions from the last to the first.
2320 Instead of consing, copy definitions to a vector and step
2321 over that vector. */
2322 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2323 n
= XINT (Flength (sequences
));
2324 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2325 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2326 defns
[i
++] = XCAR (sequences
);
2328 /* Verify that the key bindings are not shadowed. Note that
2329 the following can GC. */
2330 GCPRO2 (definition
, keymaps
);
2333 for (i
= n
- 1; i
>= 0; --i
)
2334 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2336 if (ascii_sequence_p (defns
[i
]))
2342 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2347 /* Kill the cache so that where_is_internal_1 doesn't think
2348 we're filling it up. */
2349 where_is_cache
= Qnil
;
2350 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2356 /* This is the function that Fwhere_is_internal calls using map_char_table.
2358 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2360 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2361 Since map_char_table doesn't really use the return value from this function,
2362 we the result append to RESULT, the slot in ARGS.
2364 This function can GC because it calls where_is_internal_1 which can
2368 where_is_internal_2 (args
, key
, binding
)
2369 Lisp_Object args
, key
, binding
;
2371 Lisp_Object definition
, noindirect
, this, last
;
2372 Lisp_Object result
, sequence
;
2373 int nomenus
, last_is_meta
;
2374 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2376 GCPRO3 (args
, key
, binding
);
2377 result
= XCDR (XCAR (args
));
2378 definition
= XCAR (XCAR (XCAR (args
)));
2379 noindirect
= XCDR (XCAR (XCAR (args
)));
2380 this = XCAR (XCAR (XCDR (args
)));
2381 last
= XCDR (XCAR (XCDR (args
)));
2382 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2383 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2385 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2386 this, last
, nomenus
, last_is_meta
);
2388 if (!NILP (sequence
))
2389 XCDR (XCAR (args
)) = Fcons (sequence
, result
);
2395 /* This function cannot GC. */
2398 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2399 nomenus
, last_is_meta
)
2400 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2401 int nomenus
, last_is_meta
;
2403 Lisp_Object sequence
;
2405 /* Search through indirections unless that's not wanted. */
2406 if (NILP (noindirect
))
2407 binding
= get_keyelt (binding
, 0);
2409 /* End this iteration if this element does not match
2412 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2413 || EQ (binding
, definition
)
2414 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2415 /* Doesn't match. */
2418 /* We have found a match. Construct the key sequence where we found it. */
2419 if (INTEGERP (key
) && last_is_meta
)
2421 sequence
= Fcopy_sequence (this);
2422 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2425 sequence
= append_key (this, key
);
2427 if (!NILP (where_is_cache
))
2429 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2430 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2437 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2439 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal
, Sdescribe_bindings_internal
, 0, 2, "",
2440 "Show a list of all defined keys, and their definitions.\n\
2441 We put that list in a buffer, and display the buffer.\n\
2443 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2444 \(Ordinarily these are omitted from the output.)\n\
2445 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2446 then we display only bindings that start with that prefix.")
2448 Lisp_Object menus
, prefix
;
2450 register Lisp_Object thisbuf
;
2451 XSETBUFFER (thisbuf
, current_buffer
);
2452 internal_with_output_to_temp_buffer ("*Help*",
2453 describe_buffer_bindings
,
2454 list3 (thisbuf
, prefix
, menus
));
2458 /* ARG is (BUFFER PREFIX MENU-FLAG). */
2461 describe_buffer_bindings (arg
)
2464 Lisp_Object descbuf
, prefix
, shadow
;
2466 register Lisp_Object start1
;
2467 struct gcpro gcpro1
;
2469 char *alternate_heading
2471 Keyboard translations:\n\n\
2472 You type Translation\n\
2473 -------- -----------\n";
2475 descbuf
= XCAR (arg
);
2477 prefix
= XCAR (arg
);
2479 nomenu
= NILP (XCAR (arg
));
2484 Fset_buffer (Vstandard_output
);
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);
2523 Lisp_Object
*modes
, *maps
;
2525 /* Temporarily switch to descbuf, so that we can get that buffer's
2526 minor modes correctly. */
2527 Fset_buffer (descbuf
);
2529 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2530 || !NILP (Voverriding_local_map
))
2533 nmaps
= current_minor_maps (&modes
, &maps
);
2534 Fset_buffer (Vstandard_output
);
2536 /* Print the minor mode maps. */
2537 for (i
= 0; i
< nmaps
; i
++)
2539 /* The title for a minor mode keymap
2540 is constructed at run time.
2541 We let describe_map_tree do the actual insertion
2542 because it takes care of other features when doing so. */
2545 if (!SYMBOLP (modes
[i
]))
2548 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2552 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2553 XSYMBOL (modes
[i
])->name
->size
);
2554 p
+= XSYMBOL (modes
[i
])->name
->size
;
2556 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2557 p
+= sizeof (" Minor Mode Bindings") - 1;
2560 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2561 shadow
= Fcons (maps
[i
], shadow
);
2565 /* Print the (major mode) local map. */
2566 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2567 start1
= current_kboard
->Voverriding_terminal_local_map
;
2568 else if (!NILP (Voverriding_local_map
))
2569 start1
= Voverriding_local_map
;
2571 start1
= XBUFFER (descbuf
)->keymap
;
2575 describe_map_tree (start1
, 1, shadow
, prefix
,
2576 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2577 shadow
= Fcons (start1
, shadow
);
2580 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2581 "\f\nGlobal Bindings", nomenu
, 0, 1);
2583 /* Print the function-key-map translations under this prefix. */
2584 if (!NILP (Vfunction_key_map
))
2585 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2586 "\f\nFunction key map translations", nomenu
, 1, 0);
2588 call0 (intern ("help-mode"));
2589 Fset_buffer (descbuf
);
2594 /* Insert a description of the key bindings in STARTMAP,
2595 followed by those of all maps reachable through STARTMAP.
2596 If PARTIAL is nonzero, omit certain "uninteresting" commands
2597 (such as `undefined').
2598 If SHADOW is non-nil, it is a list of maps;
2599 don't mention keys which would be shadowed by any of them.
2600 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2601 TITLE, if not 0, is a string to insert at the beginning.
2602 TITLE should not end with a colon or a newline; we supply that.
2603 If NOMENU is not 0, then omit menu-bar commands.
2605 If TRANSL is nonzero, the definitions are actually key translations
2606 so print strings and vectors differently.
2608 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2612 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2614 Lisp_Object startmap
, shadow
, prefix
;
2621 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2622 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2629 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2632 GCPRO3 (maps
, seen
, sub_shadows
);
2638 /* Delete from MAPS each element that is for the menu bar. */
2639 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2641 Lisp_Object elt
, prefix
, tem
;
2644 prefix
= Fcar (elt
);
2645 if (XVECTOR (prefix
)->size
>= 1)
2647 tem
= Faref (prefix
, make_number (0));
2648 if (EQ (tem
, Qmenu_bar
))
2649 maps
= Fdelq (elt
, maps
);
2654 if (!NILP (maps
) || always_title
)
2658 insert_string (title
);
2661 insert_string (" Starting With ");
2662 insert1 (Fkey_description (prefix
));
2664 insert_string (":\n");
2666 insert_string (key_heading
);
2670 for (; !NILP (maps
); maps
= Fcdr (maps
))
2672 register Lisp_Object elt
, prefix
, tail
;
2675 prefix
= Fcar (elt
);
2679 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2683 shmap
= XCAR (tail
);
2685 /* If the sequence by which we reach this keymap is zero-length,
2686 then the shadow map for this keymap is just SHADOW. */
2687 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2688 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2690 /* If the sequence by which we reach this keymap actually has
2691 some elements, then the sequence's definition in SHADOW is
2692 what we should use. */
2695 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2696 if (INTEGERP (shmap
))
2700 /* If shmap is not nil and not a keymap,
2701 it completely shadows this map, so don't
2702 describe this map at all. */
2703 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2707 sub_shadows
= Fcons (shmap
, sub_shadows
);
2710 /* Maps we have already listed in this loop shadow this map. */
2711 for (tail
= orig_maps
; ! EQ (tail
, maps
); tail
= XCDR (tail
))
2714 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2716 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2719 describe_map (Fcdr (elt
), prefix
,
2720 transl
? describe_translation
: describe_command
,
2721 partial
, sub_shadows
, &seen
, nomenu
);
2727 insert_string ("\n");
2732 static int previous_description_column
;
2735 describe_command (definition
)
2736 Lisp_Object definition
;
2738 register Lisp_Object tem1
;
2739 int column
= current_column ();
2740 int description_column
;
2742 /* If column 16 is no good, go to col 32;
2743 but don't push beyond that--go to next line instead. */
2747 description_column
= 32;
2749 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2750 description_column
= 32;
2752 description_column
= 16;
2754 Findent_to (make_number (description_column
), make_number (1));
2755 previous_description_column
= description_column
;
2757 if (SYMBOLP (definition
))
2759 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2761 insert_string ("\n");
2763 else if (STRINGP (definition
) || VECTORP (definition
))
2764 insert_string ("Keyboard Macro\n");
2765 else if (KEYMAPP (definition
))
2766 insert_string ("Prefix Command\n");
2768 insert_string ("??\n");
2772 describe_translation (definition
)
2773 Lisp_Object definition
;
2775 register Lisp_Object tem1
;
2777 Findent_to (make_number (16), make_number (1));
2779 if (SYMBOLP (definition
))
2781 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2783 insert_string ("\n");
2785 else if (STRINGP (definition
) || VECTORP (definition
))
2787 insert1 (Fkey_description (definition
));
2788 insert_string ("\n");
2790 else if (KEYMAPP (definition
))
2791 insert_string ("Prefix Command\n");
2793 insert_string ("??\n");
2796 /* Describe the contents of map MAP, assuming that this map itself is
2797 reached by the sequence of prefix keys KEYS (a string or vector).
2798 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2801 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2802 register Lisp_Object map
;
2804 void (*elt_describer
) P_ ((Lisp_Object
));
2810 Lisp_Object elt_prefix
;
2811 Lisp_Object tail
, definition
, event
;
2813 Lisp_Object suppress
;
2816 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2820 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2822 /* Call Fkey_description first, to avoid GC bug for the other string. */
2823 tem
= Fkey_description (keys
);
2824 elt_prefix
= concat2 (tem
, build_string (" "));
2830 suppress
= intern ("suppress-keymap");
2832 /* This vector gets used to present single keys to Flookup_key. Since
2833 that is done once per keymap element, we don't want to cons up a
2834 fresh vector every time. */
2835 kludge
= Fmake_vector (make_number (1), Qnil
);
2838 GCPRO3 (elt_prefix
, definition
, kludge
);
2840 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2844 if (VECTORP (XCAR (tail
))
2845 || CHAR_TABLE_P (XCAR (tail
)))
2846 describe_vector (XCAR (tail
),
2847 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2849 else if (CONSP (XCAR (tail
)))
2851 event
= XCAR (XCAR (tail
));
2853 /* Ignore bindings whose "keys" are not really valid events.
2854 (We get these in the frames and buffers menu.) */
2855 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2858 if (nomenu
&& EQ (event
, Qmenu_bar
))
2861 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2863 /* Don't show undefined commands or suppressed commands. */
2864 if (NILP (definition
)) continue;
2865 if (SYMBOLP (definition
) && partial
)
2867 tem
= Fget (definition
, suppress
);
2872 /* Don't show a command that isn't really visible
2873 because a local definition of the same key shadows it. */
2875 ASET (kludge
, 0, event
);
2878 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2879 if (!NILP (tem
)) continue;
2882 tem
= Flookup_key (map
, kludge
, Qt
);
2883 if (! EQ (tem
, definition
)) continue;
2887 previous_description_column
= 0;
2892 if (!NILP (elt_prefix
))
2893 insert1 (elt_prefix
);
2895 /* THIS gets the string to describe the character EVENT. */
2896 insert1 (Fsingle_key_description (event
, Qnil
));
2898 /* Print a description of the definition of this character.
2899 elt_describer will take care of spacing out far enough
2900 for alignment purposes. */
2901 (*elt_describer
) (definition
);
2903 else if (EQ (XCAR (tail
), Qkeymap
))
2905 /* The same keymap might be in the structure twice, if we're
2906 using an inherited keymap. So skip anything we've already
2908 tem
= Fassq (tail
, *seen
);
2909 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2911 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2919 describe_vector_princ (elt
)
2922 Findent_to (make_number (16), make_number (1));
2927 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2928 "Insert a description of contents of VECTOR.\n\
2929 This is text showing the elements of vector matched against indices.")
2933 int count
= specpdl_ptr
- specpdl
;
2935 specbind (Qstandard_output
, Fcurrent_buffer ());
2936 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2937 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2938 Qnil
, Qnil
, (int *)0, 0);
2940 return unbind_to (count
, Qnil
);
2943 /* Insert in the current buffer a description of the contents of VECTOR.
2944 We call ELT_DESCRIBER to insert the description of one value found
2947 ELT_PREFIX describes what "comes before" the keys or indices defined
2948 by this vector. This is a human-readable string whose size
2949 is not necessarily related to the situation.
2951 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2952 leads to this keymap.
2954 If the vector is a chartable, ELT_PREFIX is the vector
2955 of bytes that lead to the character set or portion of a character
2956 set described by this chartable.
2958 If PARTIAL is nonzero, it means do not mention suppressed commands
2959 (that assumes the vector is in a keymap).
2961 SHADOW is a list of keymaps that shadow this map.
2962 If it is non-nil, then we look up the key in those maps
2963 and we don't mention it now if it is defined by any of them.
2965 ENTIRE_MAP is the keymap in which this vector appears.
2966 If the definition in effect in the whole map does not match
2967 the one in this vector, we ignore this one.
2969 When describing a sub-char-table, INDICES is a list of
2970 indices at higher levels in this char-table,
2971 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2974 describe_vector (vector
, elt_prefix
, elt_describer
,
2975 partial
, shadow
, entire_map
,
2976 indices
, char_table_depth
)
2977 register Lisp_Object vector
;
2978 Lisp_Object elt_prefix
;
2979 void (*elt_describer
) P_ ((Lisp_Object
));
2982 Lisp_Object entire_map
;
2984 int char_table_depth
;
2986 Lisp_Object definition
;
2989 Lisp_Object suppress
;
2992 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2993 /* Range of elements to be handled. */
2995 /* A flag to tell if a leaf in this level of char-table is not a
2996 generic character (i.e. a complete multibyte character). */
3004 indices
= (int *) alloca (3 * sizeof (int));
3008 /* This vector gets used to present single keys to Flookup_key. Since
3009 that is done once per vector element, we don't want to cons up a
3010 fresh vector every time. */
3011 kludge
= Fmake_vector (make_number (1), Qnil
);
3012 GCPRO3 (elt_prefix
, definition
, kludge
);
3015 suppress
= intern ("suppress-keymap");
3017 if (CHAR_TABLE_P (vector
))
3019 if (char_table_depth
== 0)
3021 /* VECTOR is a top level char-table. */
3024 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3028 /* VECTOR is a sub char-table. */
3029 if (char_table_depth
>= 3)
3030 /* A char-table is never that deep. */
3031 error ("Too deep char table");
3034 = (CHARSET_VALID_P (indices
[0])
3035 && ((CHARSET_DIMENSION (indices
[0]) == 1
3036 && char_table_depth
== 1)
3037 || char_table_depth
== 2));
3039 /* Meaningful elements are from 32th to 127th. */
3041 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3046 /* This does the right thing for ordinary vectors. */
3050 to
= XVECTOR (vector
)->size
;
3053 for (i
= from
; i
< to
; i
++)
3057 if (CHAR_TABLE_P (vector
))
3059 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3062 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3063 && !CHARSET_DEFINED_P (i
- 128))
3067 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3070 definition
= get_keyelt (AREF (vector
, i
), 0);
3072 if (NILP (definition
)) continue;
3074 /* Don't mention suppressed commands. */
3075 if (SYMBOLP (definition
) && partial
)
3079 tem
= Fget (definition
, suppress
);
3081 if (!NILP (tem
)) continue;
3084 /* Set CHARACTER to the character this entry describes, if any.
3085 Also update *INDICES. */
3086 if (CHAR_TABLE_P (vector
))
3088 indices
[char_table_depth
] = i
;
3090 if (char_table_depth
== 0)
3093 indices
[0] = i
- 128;
3095 else if (complete_char
)
3097 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3105 /* If this binding is shadowed by some other map, ignore it. */
3106 if (!NILP (shadow
) && complete_char
)
3110 ASET (kludge
, 0, make_number (character
));
3111 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3113 if (!NILP (tem
)) continue;
3116 /* Ignore this definition if it is shadowed by an earlier
3117 one in the same keymap. */
3118 if (!NILP (entire_map
) && complete_char
)
3122 ASET (kludge
, 0, make_number (character
));
3123 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3125 if (! EQ (tem
, definition
))
3131 if (char_table_depth
== 0)
3136 /* For a sub char-table, show the depth by indentation.
3137 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3138 if (char_table_depth
> 0)
3139 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3141 /* Output the prefix that applies to every entry in this map. */
3142 if (!NILP (elt_prefix
))
3143 insert1 (elt_prefix
);
3145 /* Insert or describe the character this slot is for,
3146 or a description of what it is for. */
3147 if (SUB_CHAR_TABLE_P (vector
))
3150 insert_char (character
);
3153 /* We need an octal representation for this block of
3156 sprintf (work
, "(row %d)", i
);
3157 insert (work
, strlen (work
));
3160 else if (CHAR_TABLE_P (vector
))
3163 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3166 /* Print the information for this character set. */
3167 insert_string ("<");
3168 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3170 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3171 STRING_BYTES (XSTRING (tem2
)), 0);
3179 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3182 /* If we find a sub char-table within a char-table,
3183 scan it recursively; it defines the details for
3184 a character set or a portion of a character set. */
3185 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3188 describe_vector (definition
, elt_prefix
, elt_describer
,
3189 partial
, shadow
, entire_map
,
3190 indices
, char_table_depth
+ 1);
3196 /* Find all consecutive characters or rows that have the same
3197 definition. But, for elements of a top level char table, if
3198 they are for charsets, we had better describe one by one even
3199 if they have the same definition. */
3200 if (CHAR_TABLE_P (vector
))
3204 if (char_table_depth
== 0)
3205 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3207 while (i
+ 1 < limit
3208 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3210 && !NILP (Fequal (tem2
, definition
)))
3215 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3217 && !NILP (Fequal (tem2
, definition
)))
3221 /* If we have a range of more than one character,
3222 print where the range reaches to. */
3224 if (i
!= starting_i
)
3228 if (!NILP (elt_prefix
))
3229 insert1 (elt_prefix
);
3231 if (CHAR_TABLE_P (vector
))
3233 if (char_table_depth
== 0)
3235 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3237 else if (complete_char
)
3239 indices
[char_table_depth
] = i
;
3240 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3241 insert_char (character
);
3245 /* We need an octal representation for this block of
3248 sprintf (work
, "(row %d)", i
);
3249 insert (work
, strlen (work
));
3254 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3258 /* Print a description of the definition of this character.
3259 elt_describer will take care of spacing out far enough
3260 for alignment purposes. */
3261 (*elt_describer
) (definition
);
3264 /* For (sub) char-table, print `defalt' slot at last. */
3265 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3267 insert (" ", char_table_depth
* 2);
3268 insert_string ("<<default>>");
3269 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3275 /* Apropos - finding all symbols whose names match a regexp. */
3276 Lisp_Object apropos_predicate
;
3277 Lisp_Object apropos_accumulate
;
3280 apropos_accum (symbol
, string
)
3281 Lisp_Object symbol
, string
;
3283 register Lisp_Object tem
;
3285 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3286 if (!NILP (tem
) && !NILP (apropos_predicate
))
3287 tem
= call1 (apropos_predicate
, symbol
);
3289 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3292 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3293 "Show all symbols whose names contain match for REGEXP.\n\
3294 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3295 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3296 Return list of symbols found.")
3298 Lisp_Object regexp
, predicate
;
3300 struct gcpro gcpro1
, gcpro2
;
3301 CHECK_STRING (regexp
, 0);
3302 apropos_predicate
= predicate
;
3303 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3304 apropos_accumulate
= Qnil
;
3305 map_obarray (Vobarray
, apropos_accum
, regexp
);
3306 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3308 return apropos_accumulate
;
3314 Qkeymap
= intern ("keymap");
3315 staticpro (&Qkeymap
);
3317 /* Now we are ready to set up this property, so we can
3318 create char tables. */
3319 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3321 /* Initialize the keymaps standardly used.
3322 Each one is the value of a Lisp variable, and is also
3323 pointed to by a C variable */
3325 global_map
= Fmake_keymap (Qnil
);
3326 Fset (intern ("global-map"), global_map
);
3328 current_global_map
= global_map
;
3329 staticpro (&global_map
);
3330 staticpro (¤t_global_map
);
3332 meta_map
= Fmake_keymap (Qnil
);
3333 Fset (intern ("esc-map"), meta_map
);
3334 Ffset (intern ("ESC-prefix"), meta_map
);
3336 control_x_map
= Fmake_keymap (Qnil
);
3337 Fset (intern ("ctl-x-map"), control_x_map
);
3338 Ffset (intern ("Control-X-prefix"), control_x_map
);
3340 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3341 "List of commands given new key bindings recently.\n\
3342 This is used for internal purposes during Emacs startup;\n\
3343 don't alter it yourself.");
3344 Vdefine_key_rebound_commands
= Qt
;
3346 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3347 "Default keymap to use when reading from the minibuffer.");
3348 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3350 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3351 "Local keymap for the minibuffer when spaces are not allowed.");
3352 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3354 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3355 "Local keymap for minibuffer input with completion.");
3356 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3358 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3359 "Local keymap for minibuffer input with completion, for exact match.");
3360 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3362 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3363 "Alist of keymaps to use for minor modes.\n\
3364 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3365 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3366 If two active keymaps bind the same key, the keymap appearing earlier\n\
3367 in the list takes precedence.");
3368 Vminor_mode_map_alist
= Qnil
;
3370 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3371 "Alist of keymaps to use for minor modes, in current major mode.\n\
3372 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3373 used the same way (and before `minor-mode-map-alist'); however,\n\
3374 it is provided for major modes to bind locally.");
3375 Vminor_mode_overriding_map_alist
= Qnil
;
3377 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3378 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3379 This allows Emacs to recognize function keys sent from ASCII\n\
3380 terminals at any point in a key sequence.\n\
3382 The `read-key-sequence' function replaces any subsequence bound by\n\
3383 `function-key-map' with its binding. More precisely, when the active\n\
3384 keymaps have no binding for the current key sequence but\n\
3385 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3386 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3387 continues with the new sequence.\n\
3389 The events that come from bindings in `function-key-map' are not\n\
3390 themselves looked up in `function-key-map'.\n\
3392 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3393 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3394 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3395 key, typing `ESC O P x' would return [f1 x].");
3396 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3398 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3399 "Keymap of key translations that can override keymaps.\n\
3400 This keymap works like `function-key-map', but comes after that,\n\
3401 and applies even for keys that have ordinary bindings.");
3402 Vkey_translation_map
= Qnil
;
3404 Qsingle_key_description
= intern ("single-key-description");
3405 staticpro (&Qsingle_key_description
);
3407 Qkey_description
= intern ("key-description");
3408 staticpro (&Qkey_description
);
3410 Qkeymapp
= intern ("keymapp");
3411 staticpro (&Qkeymapp
);
3413 Qnon_ascii
= intern ("non-ascii");
3414 staticpro (&Qnon_ascii
);
3416 Qmenu_item
= intern ("menu-item");
3417 staticpro (&Qmenu_item
);
3419 where_is_cache_keymaps
= Qt
;
3420 where_is_cache
= Qnil
;
3421 staticpro (&where_is_cache
);
3422 staticpro (&where_is_cache_keymaps
);
3424 defsubr (&Skeymapp
);
3425 defsubr (&Skeymap_parent
);
3426 defsubr (&Sset_keymap_parent
);
3427 defsubr (&Smake_keymap
);
3428 defsubr (&Smake_sparse_keymap
);
3429 defsubr (&Scopy_keymap
);
3430 defsubr (&Skey_binding
);
3431 defsubr (&Slocal_key_binding
);
3432 defsubr (&Sglobal_key_binding
);
3433 defsubr (&Sminor_mode_key_binding
);
3434 defsubr (&Sdefine_key
);
3435 defsubr (&Slookup_key
);
3436 defsubr (&Sdefine_prefix_command
);
3437 defsubr (&Suse_global_map
);
3438 defsubr (&Suse_local_map
);
3439 defsubr (&Scurrent_local_map
);
3440 defsubr (&Scurrent_global_map
);
3441 defsubr (&Scurrent_minor_mode_maps
);
3442 defsubr (&Saccessible_keymaps
);
3443 defsubr (&Skey_description
);
3444 defsubr (&Sdescribe_vector
);
3445 defsubr (&Ssingle_key_description
);
3446 defsubr (&Stext_char_description
);
3447 defsubr (&Swhere_is_internal
);
3448 defsubr (&Sdescribe_bindings_internal
);
3449 defsubr (&Sapropos_internal
);
3455 initial_define_key (global_map
, 033, "ESC-prefix");
3456 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");