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 ();
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 (maps
, Fcons (tail
, thisseq
)),
1543 else if (VECTORP (elt
))
1547 /* Vector keymap. Scan all the elements. */
1548 for (i
= 0; i
< ASIZE (elt
); i
++)
1550 register Lisp_Object tem
;
1551 register Lisp_Object cmd
;
1553 cmd
= get_keyelt (AREF (elt
, i
), 0);
1554 if (NILP (cmd
)) continue;
1555 tem
= get_keymap (cmd
, 0, 0);
1559 /* Ignore keymaps that are already added to maps. */
1560 tem
= Frassq (cmd
, maps
);
1563 /* If the last key in thisseq is meta-prefix-char,
1564 turn it into a meta-ized keystroke. We know
1565 that the event we're about to append is an
1566 ascii keystroke since we're processing a
1570 int meta_bit
= meta_modifier
;
1571 tem
= Fcopy_sequence (thisseq
);
1573 Faset (tem
, last
, make_number (i
| meta_bit
));
1575 /* This new sequence is the same length as
1576 thisseq, so stick it in the list right
1579 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1583 tem
= append_key (thisseq
, make_number (i
));
1584 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1590 else if (CONSP (elt
))
1592 register Lisp_Object cmd
, tem
;
1594 cmd
= get_keyelt (XCDR (elt
), 0);
1595 /* Ignore definitions that aren't keymaps themselves. */
1596 tem
= get_keymap (cmd
, 0, 0);
1599 /* Ignore keymaps that have been seen already. */
1601 tem
= Frassq (cmd
, maps
);
1604 /* Let elt be the event defined by this map entry. */
1607 /* If the last key in thisseq is meta-prefix-char, and
1608 this entry is a binding for an ascii keystroke,
1609 turn it into a meta-ized keystroke. */
1610 if (is_metized
&& INTEGERP (elt
))
1612 Lisp_Object element
;
1615 tem
= Fvconcat (1, &element
);
1616 XSETFASTINT (AREF (tem
, XINT (last
)),
1617 XINT (elt
) | meta_modifier
);
1619 /* This new sequence is the same length as
1620 thisseq, so stick it in the list right
1623 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1627 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1638 /* Now find just the maps whose access prefixes start with PREFIX. */
1641 for (; CONSP (maps
); maps
= XCDR (maps
))
1643 Lisp_Object elt
, thisseq
;
1645 thisseq
= XCAR (elt
);
1646 /* The access prefix must be at least as long as PREFIX,
1647 and the first elements must match those of PREFIX. */
1648 if (XINT (Flength (thisseq
)) >= prefixlen
)
1651 for (i
= 0; i
< prefixlen
; i
++)
1654 XSETFASTINT (i1
, i
);
1655 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1659 good_maps
= Fcons (elt
, good_maps
);
1663 return Fnreverse (good_maps
);
1667 accessible_keymaps_char_table (args
, index
, cmd
)
1668 Lisp_Object args
, index
, cmd
;
1671 Lisp_Object maps
, tail
, thisseq
;
1677 tail
= XCAR (XCDR (args
));
1678 thisseq
= XCDR (XCDR (args
));
1680 tem
= get_keymap (cmd
, 0, 0);
1684 /* Ignore keymaps that are already added to maps. */
1685 tem
= Frassq (cmd
, maps
);
1688 tem
= append_key (thisseq
, index
);
1689 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1694 Lisp_Object Qsingle_key_description
, Qkey_description
;
1696 /* This function cannot GC. */
1698 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1699 "Return a pretty description of key-sequence KEYS.\n\
1700 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1701 spaces are put between sequence elements, etc.")
1708 Lisp_Object
*args
= NULL
;
1713 vector
= Fmake_vector (Flength (keys
), Qnil
);
1714 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1719 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1720 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1721 c
^= 0200 | meta_modifier
;
1722 XSETFASTINT (AREF (vector
, i_before
), c
);
1729 /* In effect, this computes
1730 (mapconcat 'single-key-description keys " ")
1731 but we shouldn't use mapconcat because it can do GC. */
1733 len
= XVECTOR (keys
)->size
;
1734 sep
= build_string (" ");
1735 /* This has one extra element at the end that we don't pass to Fconcat. */
1736 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1738 for (i
= 0; i
< len
; i
++)
1740 args
[i
* 2] = Fsingle_key_description (AREF (keys
, i
), Qnil
);
1741 args
[i
* 2 + 1] = sep
;
1744 else if (CONSP (keys
))
1746 /* In effect, this computes
1747 (mapconcat 'single-key-description keys " ")
1748 but we shouldn't use mapconcat because it can do GC. */
1750 len
= XFASTINT (Flength (keys
));
1751 sep
= build_string (" ");
1752 /* This has one extra element at the end that we don't pass to Fconcat. */
1753 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1755 for (i
= 0; i
< len
; i
++)
1757 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1758 args
[i
* 2 + 1] = sep
;
1763 keys
= wrong_type_argument (Qarrayp
, keys
);
1766 return build_string ("");
1767 return Fconcat (len
* 2 - 1, args
);
1771 push_key_description (c
, p
, force_multibyte
)
1772 register unsigned int c
;
1774 int force_multibyte
;
1778 /* Clear all the meaningless bits above the meta bit. */
1779 c
&= meta_modifier
| ~ - meta_modifier
;
1780 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1781 | meta_modifier
| shift_modifier
| super_modifier
);
1783 if (c
& alt_modifier
)
1789 if ((c
& ctrl_modifier
) != 0
1790 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1794 c
&= ~ctrl_modifier
;
1796 if (c
& hyper_modifier
)
1800 c
-= hyper_modifier
;
1802 if (c
& meta_modifier
)
1808 if (c
& shift_modifier
)
1812 c
-= shift_modifier
;
1814 if (c
& super_modifier
)
1818 c
-= super_modifier
;
1834 else if (c
== Ctl ('M'))
1842 /* `C-' already added above. */
1843 if (c
> 0 && c
<= Ctl ('Z'))
1862 || (NILP (current_buffer
->enable_multibyte_characters
)
1863 && SINGLE_BYTE_CHAR_P (c
)
1864 && !force_multibyte
))
1870 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
1872 if (force_multibyte
&& valid_p
)
1874 if (SINGLE_BYTE_CHAR_P (c
))
1875 c
= unibyte_char_to_multibyte (c
);
1876 p
+= CHAR_STRING (c
, p
);
1878 else if (NILP (current_buffer
->enable_multibyte_characters
)
1883 /* The biggest character code uses 19 bits. */
1884 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1886 if (c
>= (1 << bit_offset
))
1887 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1891 p
+= CHAR_STRING (c
, p
);
1897 /* This function cannot GC. */
1899 DEFUN ("single-key-description", Fsingle_key_description
,
1900 Ssingle_key_description
, 1, 2, 0,
1901 "Return a pretty description of command character KEY.\n\
1902 Control characters turn into C-whatever, etc.\n\
1903 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1904 around function keys and event symbols.")
1906 Lisp_Object key
, no_angles
;
1908 if (CONSP (key
) && lucid_event_type_list_p (key
))
1909 key
= Fevent_convert_list (key
);
1911 key
= EVENT_HEAD (key
);
1913 if (INTEGERP (key
)) /* Normal character */
1915 unsigned int charset
, c1
, c2
;
1916 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1918 if (SINGLE_BYTE_CHAR_P (without_bits
))
1921 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1924 && CHARSET_DEFINED_P (charset
)
1925 && ((c1
>= 0 && c1
< 32)
1926 || (c2
>= 0 && c2
< 32)))
1928 /* Handle a generic character. */
1930 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1931 CHECK_STRING (name
, 0);
1932 return concat2 (build_string ("Character set "), name
);
1936 char tem
[KEY_DESCRIPTION_SIZE
];
1938 *push_key_description (XUINT (key
), tem
, 1) = 0;
1939 return build_string (tem
);
1942 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1944 if (NILP (no_angles
))
1947 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
1948 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
1949 return build_string (buffer
);
1952 return Fsymbol_name (key
);
1954 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1955 return Fcopy_sequence (key
);
1957 error ("KEY must be an integer, cons, symbol, or string");
1962 push_text_char_description (c
, p
)
1963 register unsigned int c
;
1975 *p
++ = c
+ 64; /* 'A' - 1 */
1987 /* This function cannot GC. */
1989 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1990 "Return a pretty description of file-character CHARACTER.\n\
1991 Control characters turn into \"^char\", etc.")
1993 Lisp_Object character
;
1995 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
1996 unsigned char str
[6];
1999 CHECK_NUMBER (character
, 0);
2001 c
= XINT (character
);
2002 if (!SINGLE_BYTE_CHAR_P (c
))
2004 int len
= CHAR_STRING (c
, str
);
2006 return make_multibyte_string (str
, 1, len
);
2009 *push_text_char_description (c
& 0377, str
) = 0;
2011 return build_string (str
);
2014 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2017 ascii_sequence_p (seq
)
2021 int len
= XINT (Flength (seq
));
2023 for (i
= 0; i
< len
; i
++)
2025 Lisp_Object ii
, elt
;
2027 XSETFASTINT (ii
, i
);
2028 elt
= Faref (seq
, ii
);
2031 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2039 /* where-is - finding a command in a set of keymaps. */
2041 static Lisp_Object
where_is_internal_1 ();
2042 static void where_is_internal_2 ();
2044 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2045 Returns the first non-nil binding found in any of those maps. */
2048 shadow_lookup (shadow
, key
, flag
)
2049 Lisp_Object shadow
, key
, flag
;
2051 Lisp_Object tail
, value
;
2053 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2055 value
= Flookup_key (XCAR (tail
), key
, flag
);
2056 if (!NILP (value
) && !NATNUMP (value
))
2062 /* This function can GC if Flookup_key autoloads any keymaps. */
2065 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2066 Lisp_Object definition
, keymaps
;
2067 Lisp_Object firstonly
, noindirect
;
2069 Lisp_Object maps
= Qnil
;
2070 Lisp_Object found
, sequences
;
2071 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2072 /* 1 means ignore all menu bindings entirely. */
2073 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2076 while (CONSP (found
))
2080 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2081 found
= XCDR (found
);
2084 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2088 for (; !NILP (maps
); maps
= Fcdr (maps
))
2090 /* Key sequence to reach map, and the map that it reaches */
2091 register Lisp_Object
this, map
;
2093 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2094 [M-CHAR] sequences, check if last character of the sequence
2095 is the meta-prefix char. */
2099 this = Fcar (Fcar (maps
));
2100 map
= Fcdr (Fcar (maps
));
2101 last
= make_number (XINT (Flength (this)) - 1);
2102 last_is_meta
= (XINT (last
) >= 0
2103 && EQ (Faref (this, last
), meta_prefix_char
));
2105 /* if (nomenus && !ascii_sequence_p (this)) */
2106 if (nomenus
&& XINT (last
) >= 0 && !INTEGERP (Faref (this, 0)))
2107 /* If no menu entries should be returned, skip over the
2108 keymaps bound to `menu-bar' and `tool-bar' and other
2109 non-ascii prefixes like `C-down-mouse-2'. */
2116 /* Because the code we want to run on each binding is rather
2117 large, we don't want to have two separate loop bodies for
2118 sparse keymap bindings and tables; we want to iterate one
2119 loop body over both keymap and vector bindings.
2121 For this reason, if Fcar (map) is a vector, we don't
2122 advance map to the next element until i indicates that we
2123 have finished off the vector. */
2124 Lisp_Object elt
, key
, binding
;
2132 /* Set key and binding to the current key and binding, and
2133 advance map and i to the next binding. */
2136 Lisp_Object sequence
;
2138 /* In a vector, look at each element. */
2139 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2141 binding
= AREF (elt
, i
);
2142 XSETFASTINT (key
, i
);
2143 sequence
= where_is_internal_1 (binding
, key
, definition
,
2145 last
, nomenus
, last_is_meta
);
2146 if (!NILP (sequence
))
2147 sequences
= Fcons (sequence
, sequences
);
2150 else if (CHAR_TABLE_P (elt
))
2152 Lisp_Object indices
[3];
2155 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2156 Qnil
), /* Result accumulator. */
2157 Fcons (Fcons (this, last
),
2158 Fcons (make_number (nomenus
),
2159 make_number (last_is_meta
))));
2160 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2162 sequences
= XCDR (XCAR (args
));
2164 else if (CONSP (elt
))
2166 Lisp_Object sequence
;
2169 binding
= XCDR (elt
);
2171 sequence
= where_is_internal_1 (binding
, key
, definition
,
2173 last
, nomenus
, last_is_meta
);
2174 if (!NILP (sequence
))
2175 sequences
= Fcons (sequence
, sequences
);
2179 for (; ! NILP (sequences
); sequences
= XCDR (sequences
))
2181 Lisp_Object sequence
;
2183 sequence
= XCAR (sequences
);
2185 /* Verify that this key binding is not shadowed by another
2186 binding for the same key, before we say it exists.
2188 Mechanism: look for local definition of this key and if
2189 it is defined and does not match what we found then
2192 Either nil or number as value from Flookup_key
2194 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2197 /* It is a true unshadowed match. Record it, unless it's already
2198 been seen (as could happen when inheriting keymaps). */
2199 if (NILP (Fmember (sequence
, found
)))
2200 found
= Fcons (sequence
, found
);
2202 /* If firstonly is Qnon_ascii, then we can return the first
2203 binding we find. If firstonly is not Qnon_ascii but not
2204 nil, then we should return the first ascii-only binding
2206 if (EQ (firstonly
, Qnon_ascii
))
2207 RETURN_UNGCPRO (sequence
);
2208 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2209 RETURN_UNGCPRO (sequence
);
2216 found
= Fnreverse (found
);
2218 /* firstonly may have been t, but we may have gone all the way through
2219 the keymaps without finding an all-ASCII key sequence. So just
2220 return the best we could find. */
2221 if (! NILP (firstonly
))
2222 return Fcar (found
);
2227 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2228 "Return list of keys that invoke DEFINITION.\n\
2229 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2230 If KEYMAP is nil, search all the currently active keymaps.\n\
2231 If KEYMAP is a list of keymaps, search only those keymaps.\n\
2233 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2234 rather than a list of all possible key sequences.\n\
2235 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2236 no matter what it is.\n\
2237 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2238 and entirely reject menu bindings.\n\
2240 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2241 to other keymaps or slots. This makes it possible to search for an\n\
2242 indirect definition itself.")
2243 (definition
, keymap
, firstonly
, noindirect
)
2244 Lisp_Object definition
, keymap
;
2245 Lisp_Object firstonly
, noindirect
;
2247 Lisp_Object sequences
, keymaps
;
2248 /* 1 means ignore all menu bindings entirely. */
2249 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2252 /* Find the relevant keymaps. */
2253 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2255 else if (! NILP (keymap
))
2256 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2260 nconc2 (Fcurrent_minor_mode_maps (),
2261 Fcons (get_local_map (PT
, current_buffer
, Qkeymap
),
2262 Fcons (get_local_map (PT
, current_buffer
,
2264 Fcons (current_global_map
, Qnil
)))));
2266 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2267 We don't really need to check `keymap'. */
2268 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2272 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2274 /* Check heuristic-consistency of the cache. */
2275 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2276 where_is_cache
= Qnil
;
2278 if (NILP (where_is_cache
))
2280 /* We need to create the cache. */
2281 Lisp_Object args
[2];
2282 where_is_cache
= Fmake_hash_table (0, args
);
2283 where_is_cache_keymaps
= Qt
;
2285 /* Fill in the cache. */
2286 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2287 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2290 where_is_cache_keymaps
= keymaps
;
2293 /* We want to process definitions from the last to the first.
2294 Instead of consing, copy definitions to a vector and step
2295 over that vector. */
2296 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2297 n
= Flength (sequences
);
2298 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2299 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2300 defns
[i
++] = XCAR (sequences
);
2302 /* Verify that the key bindings are not shadowed. Note that
2303 the following can GC. */
2304 GCPRO2 (definition
, keymaps
);
2307 for (i
= n
- 1; i
>= 0; --i
)
2308 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2310 if (ascii_sequence_p (defns
[i
]))
2316 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2321 /* Kill the cache so that where_is_internal_1 doesn't think
2322 we're filling it up. */
2323 where_is_cache
= Qnil
;
2324 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2330 /* This is the function that Fwhere_is_internal calls using map_char_table.
2332 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2334 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2335 Since map_char_table doesn't really use the return value from this function,
2336 we the result append to RESULT, the slot in ARGS.
2338 This function can GC because it calls where_is_internal_1 which can
2342 where_is_internal_2 (args
, key
, binding
)
2343 Lisp_Object args
, key
, binding
;
2345 Lisp_Object definition
, noindirect
, this, last
;
2346 Lisp_Object result
, sequence
;
2347 int nomenus
, last_is_meta
;
2348 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2350 GCPRO3 (args
, key
, binding
);
2351 result
= XCDR (XCAR (args
));
2352 definition
= XCAR (XCAR (XCAR (args
)));
2353 noindirect
= XCDR (XCAR (XCAR (args
)));
2354 this = XCAR (XCAR (XCDR (args
)));
2355 last
= XCDR (XCAR (XCDR (args
)));
2356 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2357 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2359 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2360 this, last
, nomenus
, last_is_meta
);
2362 if (!NILP (sequence
))
2363 XCDR (XCAR (args
)) = Fcons (sequence
, result
);
2369 /* This function cannot GC. */
2372 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2373 nomenus
, last_is_meta
)
2374 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2375 int nomenus
, last_is_meta
;
2377 Lisp_Object sequence
;
2379 /* Search through indirections unless that's not wanted. */
2380 if (NILP (noindirect
))
2381 binding
= get_keyelt (binding
, 0);
2383 /* End this iteration if this element does not match
2386 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2387 || EQ (binding
, definition
)
2388 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2389 /* Doesn't match. */
2392 /* We have found a match. Construct the key sequence where we found it. */
2393 if (INTEGERP (key
) && last_is_meta
)
2395 sequence
= Fcopy_sequence (this);
2396 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2399 sequence
= append_key (this, key
);
2401 if (!NILP (where_is_cache
))
2403 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2404 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2411 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2413 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal
, Sdescribe_bindings_internal
, 0, 2, "",
2414 "Show a list of all defined keys, and their definitions.\n\
2415 We put that list in a buffer, and display the buffer.\n\
2417 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2418 \(Ordinarily these are omitted from the output.)\n\
2419 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2420 then we display only bindings that start with that prefix.")
2422 Lisp_Object menus
, prefix
;
2424 register Lisp_Object thisbuf
;
2425 XSETBUFFER (thisbuf
, current_buffer
);
2426 internal_with_output_to_temp_buffer ("*Help*",
2427 describe_buffer_bindings
,
2428 list3 (thisbuf
, prefix
, menus
));
2432 /* ARG is (BUFFER PREFIX MENU-FLAG). */
2435 describe_buffer_bindings (arg
)
2438 Lisp_Object descbuf
, prefix
, shadow
;
2440 register Lisp_Object start1
;
2441 struct gcpro gcpro1
;
2443 char *alternate_heading
2445 Keyboard translations:\n\n\
2446 You type Translation\n\
2447 -------- -----------\n";
2449 descbuf
= XCAR (arg
);
2451 prefix
= XCAR (arg
);
2453 nomenu
= NILP (XCAR (arg
));
2458 Fset_buffer (Vstandard_output
);
2460 /* Report on alternates for keys. */
2461 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2464 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2465 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2467 for (c
= 0; c
< translate_len
; c
++)
2468 if (translate
[c
] != c
)
2470 char buf
[KEY_DESCRIPTION_SIZE
];
2473 if (alternate_heading
)
2475 insert_string (alternate_heading
);
2476 alternate_heading
= 0;
2479 bufend
= push_key_description (translate
[c
], buf
, 1);
2480 insert (buf
, bufend
- buf
);
2481 Findent_to (make_number (16), make_number (1));
2482 bufend
= push_key_description (c
, buf
, 1);
2483 insert (buf
, bufend
- buf
);
2491 if (!NILP (Vkey_translation_map
))
2492 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2493 "Key translations", nomenu
, 1, 0);
2497 Lisp_Object
*modes
, *maps
;
2499 /* Temporarily switch to descbuf, so that we can get that buffer's
2500 minor modes correctly. */
2501 Fset_buffer (descbuf
);
2503 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2504 || !NILP (Voverriding_local_map
))
2507 nmaps
= current_minor_maps (&modes
, &maps
);
2508 Fset_buffer (Vstandard_output
);
2510 /* Print the minor mode maps. */
2511 for (i
= 0; i
< nmaps
; i
++)
2513 /* The title for a minor mode keymap
2514 is constructed at run time.
2515 We let describe_map_tree do the actual insertion
2516 because it takes care of other features when doing so. */
2519 if (!SYMBOLP (modes
[i
]))
2522 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2526 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2527 XSYMBOL (modes
[i
])->name
->size
);
2528 p
+= XSYMBOL (modes
[i
])->name
->size
;
2530 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2531 p
+= sizeof (" Minor Mode Bindings") - 1;
2534 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2535 shadow
= Fcons (maps
[i
], shadow
);
2539 /* Print the (major mode) local map. */
2540 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2541 start1
= current_kboard
->Voverriding_terminal_local_map
;
2542 else if (!NILP (Voverriding_local_map
))
2543 start1
= Voverriding_local_map
;
2545 start1
= XBUFFER (descbuf
)->keymap
;
2549 describe_map_tree (start1
, 1, shadow
, prefix
,
2550 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2551 shadow
= Fcons (start1
, shadow
);
2554 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2555 "\f\nGlobal Bindings", nomenu
, 0, 1);
2557 /* Print the function-key-map translations under this prefix. */
2558 if (!NILP (Vfunction_key_map
))
2559 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2560 "\f\nFunction key map translations", nomenu
, 1, 0);
2562 call0 (intern ("help-mode"));
2563 Fset_buffer (descbuf
);
2568 /* Insert a description of the key bindings in STARTMAP,
2569 followed by those of all maps reachable through STARTMAP.
2570 If PARTIAL is nonzero, omit certain "uninteresting" commands
2571 (such as `undefined').
2572 If SHADOW is non-nil, it is a list of maps;
2573 don't mention keys which would be shadowed by any of them.
2574 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2575 TITLE, if not 0, is a string to insert at the beginning.
2576 TITLE should not end with a colon or a newline; we supply that.
2577 If NOMENU is not 0, then omit menu-bar commands.
2579 If TRANSL is nonzero, the definitions are actually key translations
2580 so print strings and vectors differently.
2582 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2586 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2588 Lisp_Object startmap
, shadow
, prefix
;
2595 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2596 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2603 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2606 GCPRO3 (maps
, seen
, sub_shadows
);
2612 /* Delete from MAPS each element that is for the menu bar. */
2613 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2615 Lisp_Object elt
, prefix
, tem
;
2618 prefix
= Fcar (elt
);
2619 if (XVECTOR (prefix
)->size
>= 1)
2621 tem
= Faref (prefix
, make_number (0));
2622 if (EQ (tem
, Qmenu_bar
))
2623 maps
= Fdelq (elt
, maps
);
2628 if (!NILP (maps
) || always_title
)
2632 insert_string (title
);
2635 insert_string (" Starting With ");
2636 insert1 (Fkey_description (prefix
));
2638 insert_string (":\n");
2640 insert_string (key_heading
);
2644 for (; !NILP (maps
); maps
= Fcdr (maps
))
2646 register Lisp_Object elt
, prefix
, tail
;
2649 prefix
= Fcar (elt
);
2653 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2657 shmap
= XCAR (tail
);
2659 /* If the sequence by which we reach this keymap is zero-length,
2660 then the shadow map for this keymap is just SHADOW. */
2661 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2662 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2664 /* If the sequence by which we reach this keymap actually has
2665 some elements, then the sequence's definition in SHADOW is
2666 what we should use. */
2669 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2670 if (INTEGERP (shmap
))
2674 /* If shmap is not nil and not a keymap,
2675 it completely shadows this map, so don't
2676 describe this map at all. */
2677 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2681 sub_shadows
= Fcons (shmap
, sub_shadows
);
2684 /* Maps we have already listed in this loop shadow this map. */
2685 for (tail
= orig_maps
; ! EQ (tail
, maps
); tail
= XCDR (tail
))
2688 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2690 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2693 describe_map (Fcdr (elt
), prefix
,
2694 transl
? describe_translation
: describe_command
,
2695 partial
, sub_shadows
, &seen
, nomenu
);
2701 insert_string ("\n");
2706 static int previous_description_column
;
2709 describe_command (definition
)
2710 Lisp_Object definition
;
2712 register Lisp_Object tem1
;
2713 int column
= current_column ();
2714 int description_column
;
2716 /* If column 16 is no good, go to col 32;
2717 but don't push beyond that--go to next line instead. */
2721 description_column
= 32;
2723 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2724 description_column
= 32;
2726 description_column
= 16;
2728 Findent_to (make_number (description_column
), make_number (1));
2729 previous_description_column
= description_column
;
2731 if (SYMBOLP (definition
))
2733 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2735 insert_string ("\n");
2737 else if (STRINGP (definition
) || VECTORP (definition
))
2738 insert_string ("Keyboard Macro\n");
2739 else if (KEYMAPP (definition
))
2740 insert_string ("Prefix Command\n");
2742 insert_string ("??\n");
2746 describe_translation (definition
)
2747 Lisp_Object definition
;
2749 register Lisp_Object tem1
;
2751 Findent_to (make_number (16), make_number (1));
2753 if (SYMBOLP (definition
))
2755 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2757 insert_string ("\n");
2759 else if (STRINGP (definition
) || VECTORP (definition
))
2761 insert1 (Fkey_description (definition
));
2762 insert_string ("\n");
2764 else if (KEYMAPP (definition
))
2765 insert_string ("Prefix Command\n");
2767 insert_string ("??\n");
2770 /* Describe the contents of map MAP, assuming that this map itself is
2771 reached by the sequence of prefix keys KEYS (a string or vector).
2772 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2775 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2776 register Lisp_Object map
;
2778 void (*elt_describer
) P_ ((Lisp_Object
));
2784 Lisp_Object elt_prefix
;
2785 Lisp_Object tail
, definition
, event
;
2787 Lisp_Object suppress
;
2790 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2794 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2796 /* Call Fkey_description first, to avoid GC bug for the other string. */
2797 tem
= Fkey_description (keys
);
2798 elt_prefix
= concat2 (tem
, build_string (" "));
2804 suppress
= intern ("suppress-keymap");
2806 /* This vector gets used to present single keys to Flookup_key. Since
2807 that is done once per keymap element, we don't want to cons up a
2808 fresh vector every time. */
2809 kludge
= Fmake_vector (make_number (1), Qnil
);
2812 GCPRO3 (elt_prefix
, definition
, kludge
);
2814 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2818 if (VECTORP (XCAR (tail
))
2819 || CHAR_TABLE_P (XCAR (tail
)))
2820 describe_vector (XCAR (tail
),
2821 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2823 else if (CONSP (XCAR (tail
)))
2825 event
= XCAR (XCAR (tail
));
2827 /* Ignore bindings whose "keys" are not really valid events.
2828 (We get these in the frames and buffers menu.) */
2829 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2832 if (nomenu
&& EQ (event
, Qmenu_bar
))
2835 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2837 /* Don't show undefined commands or suppressed commands. */
2838 if (NILP (definition
)) continue;
2839 if (SYMBOLP (definition
) && partial
)
2841 tem
= Fget (definition
, suppress
);
2846 /* Don't show a command that isn't really visible
2847 because a local definition of the same key shadows it. */
2849 ASET (kludge
, 0, event
);
2852 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2853 if (!NILP (tem
)) continue;
2856 tem
= Flookup_key (map
, kludge
, Qt
);
2857 if (! EQ (tem
, definition
)) continue;
2861 previous_description_column
= 0;
2866 if (!NILP (elt_prefix
))
2867 insert1 (elt_prefix
);
2869 /* THIS gets the string to describe the character EVENT. */
2870 insert1 (Fsingle_key_description (event
, Qnil
));
2872 /* Print a description of the definition of this character.
2873 elt_describer will take care of spacing out far enough
2874 for alignment purposes. */
2875 (*elt_describer
) (definition
);
2877 else if (EQ (XCAR (tail
), Qkeymap
))
2879 /* The same keymap might be in the structure twice, if we're
2880 using an inherited keymap. So skip anything we've already
2882 tem
= Fassq (tail
, *seen
);
2883 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2885 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2893 describe_vector_princ (elt
)
2896 Findent_to (make_number (16), make_number (1));
2901 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2902 "Insert a description of contents of VECTOR.\n\
2903 This is text showing the elements of vector matched against indices.")
2907 int count
= specpdl_ptr
- specpdl
;
2909 specbind (Qstandard_output
, Fcurrent_buffer ());
2910 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2911 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2912 Qnil
, Qnil
, (int *)0, 0);
2914 return unbind_to (count
, Qnil
);
2917 /* Insert in the current buffer a description of the contents of VECTOR.
2918 We call ELT_DESCRIBER to insert the description of one value found
2921 ELT_PREFIX describes what "comes before" the keys or indices defined
2922 by this vector. This is a human-readable string whose size
2923 is not necessarily related to the situation.
2925 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2926 leads to this keymap.
2928 If the vector is a chartable, ELT_PREFIX is the vector
2929 of bytes that lead to the character set or portion of a character
2930 set described by this chartable.
2932 If PARTIAL is nonzero, it means do not mention suppressed commands
2933 (that assumes the vector is in a keymap).
2935 SHADOW is a list of keymaps that shadow this map.
2936 If it is non-nil, then we look up the key in those maps
2937 and we don't mention it now if it is defined by any of them.
2939 ENTIRE_MAP is the keymap in which this vector appears.
2940 If the definition in effect in the whole map does not match
2941 the one in this vector, we ignore this one.
2943 When describing a sub-char-table, INDICES is a list of
2944 indices at higher levels in this char-table,
2945 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2948 describe_vector (vector
, elt_prefix
, elt_describer
,
2949 partial
, shadow
, entire_map
,
2950 indices
, char_table_depth
)
2951 register Lisp_Object vector
;
2952 Lisp_Object elt_prefix
;
2953 void (*elt_describer
) P_ ((Lisp_Object
));
2956 Lisp_Object entire_map
;
2958 int char_table_depth
;
2960 Lisp_Object definition
;
2963 Lisp_Object suppress
;
2966 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2967 /* Range of elements to be handled. */
2969 /* A flag to tell if a leaf in this level of char-table is not a
2970 generic character (i.e. a complete multibyte character). */
2978 indices
= (int *) alloca (3 * sizeof (int));
2982 /* This vector gets used to present single keys to Flookup_key. Since
2983 that is done once per vector element, we don't want to cons up a
2984 fresh vector every time. */
2985 kludge
= Fmake_vector (make_number (1), Qnil
);
2986 GCPRO3 (elt_prefix
, definition
, kludge
);
2989 suppress
= intern ("suppress-keymap");
2991 if (CHAR_TABLE_P (vector
))
2993 if (char_table_depth
== 0)
2995 /* VECTOR is a top level char-table. */
2998 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3002 /* VECTOR is a sub char-table. */
3003 if (char_table_depth
>= 3)
3004 /* A char-table is never that deep. */
3005 error ("Too deep char table");
3008 = (CHARSET_VALID_P (indices
[0])
3009 && ((CHARSET_DIMENSION (indices
[0]) == 1
3010 && char_table_depth
== 1)
3011 || char_table_depth
== 2));
3013 /* Meaningful elements are from 32th to 127th. */
3015 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3020 /* This does the right thing for ordinary vectors. */
3024 to
= XVECTOR (vector
)->size
;
3027 for (i
= from
; i
< to
; i
++)
3031 if (CHAR_TABLE_P (vector
))
3033 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3036 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3037 && !CHARSET_DEFINED_P (i
- 128))
3041 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3044 definition
= get_keyelt (AREF (vector
, i
), 0);
3046 if (NILP (definition
)) continue;
3048 /* Don't mention suppressed commands. */
3049 if (SYMBOLP (definition
) && partial
)
3053 tem
= Fget (definition
, suppress
);
3055 if (!NILP (tem
)) continue;
3058 /* Set CHARACTER to the character this entry describes, if any.
3059 Also update *INDICES. */
3060 if (CHAR_TABLE_P (vector
))
3062 indices
[char_table_depth
] = i
;
3064 if (char_table_depth
== 0)
3067 indices
[0] = i
- 128;
3069 else if (complete_char
)
3071 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3079 /* If this binding is shadowed by some other map, ignore it. */
3080 if (!NILP (shadow
) && complete_char
)
3084 ASET (kludge
, 0, make_number (character
));
3085 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3087 if (!NILP (tem
)) continue;
3090 /* Ignore this definition if it is shadowed by an earlier
3091 one in the same keymap. */
3092 if (!NILP (entire_map
) && complete_char
)
3096 ASET (kludge
, 0, make_number (character
));
3097 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3099 if (! EQ (tem
, definition
))
3105 if (char_table_depth
== 0)
3110 /* For a sub char-table, show the depth by indentation.
3111 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3112 if (char_table_depth
> 0)
3113 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3115 /* Output the prefix that applies to every entry in this map. */
3116 if (!NILP (elt_prefix
))
3117 insert1 (elt_prefix
);
3119 /* Insert or describe the character this slot is for,
3120 or a description of what it is for. */
3121 if (SUB_CHAR_TABLE_P (vector
))
3124 insert_char (character
);
3127 /* We need an octal representation for this block of
3130 sprintf (work
, "(row %d)", i
);
3131 insert (work
, strlen (work
));
3134 else if (CHAR_TABLE_P (vector
))
3137 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3140 /* Print the information for this character set. */
3141 insert_string ("<");
3142 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3144 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3145 STRING_BYTES (XSTRING (tem2
)), 0);
3153 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3156 /* If we find a sub char-table within a char-table,
3157 scan it recursively; it defines the details for
3158 a character set or a portion of a character set. */
3159 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3162 describe_vector (definition
, elt_prefix
, elt_describer
,
3163 partial
, shadow
, entire_map
,
3164 indices
, char_table_depth
+ 1);
3170 /* Find all consecutive characters or rows that have the same
3171 definition. But, for elements of a top level char table, if
3172 they are for charsets, we had better describe one by one even
3173 if they have the same definition. */
3174 if (CHAR_TABLE_P (vector
))
3178 if (char_table_depth
== 0)
3179 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3181 while (i
+ 1 < limit
3182 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3184 && !NILP (Fequal (tem2
, definition
)))
3189 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3191 && !NILP (Fequal (tem2
, definition
)))
3195 /* If we have a range of more than one character,
3196 print where the range reaches to. */
3198 if (i
!= starting_i
)
3202 if (!NILP (elt_prefix
))
3203 insert1 (elt_prefix
);
3205 if (CHAR_TABLE_P (vector
))
3207 if (char_table_depth
== 0)
3209 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3211 else if (complete_char
)
3213 indices
[char_table_depth
] = i
;
3214 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3215 insert_char (character
);
3219 /* We need an octal representation for this block of
3222 sprintf (work
, "(row %d)", i
);
3223 insert (work
, strlen (work
));
3228 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3232 /* Print a description of the definition of this character.
3233 elt_describer will take care of spacing out far enough
3234 for alignment purposes. */
3235 (*elt_describer
) (definition
);
3238 /* For (sub) char-table, print `defalt' slot at last. */
3239 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3241 insert (" ", char_table_depth
* 2);
3242 insert_string ("<<default>>");
3243 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3249 /* Apropos - finding all symbols whose names match a regexp. */
3250 Lisp_Object apropos_predicate
;
3251 Lisp_Object apropos_accumulate
;
3254 apropos_accum (symbol
, string
)
3255 Lisp_Object symbol
, string
;
3257 register Lisp_Object tem
;
3259 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3260 if (!NILP (tem
) && !NILP (apropos_predicate
))
3261 tem
= call1 (apropos_predicate
, symbol
);
3263 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3266 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3267 "Show all symbols whose names contain match for REGEXP.\n\
3268 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3269 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3270 Return list of symbols found.")
3272 Lisp_Object regexp
, predicate
;
3274 struct gcpro gcpro1
, gcpro2
;
3275 CHECK_STRING (regexp
, 0);
3276 apropos_predicate
= predicate
;
3277 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3278 apropos_accumulate
= Qnil
;
3279 map_obarray (Vobarray
, apropos_accum
, regexp
);
3280 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3282 return apropos_accumulate
;
3288 Qkeymap
= intern ("keymap");
3289 staticpro (&Qkeymap
);
3291 /* Now we are ready to set up this property, so we can
3292 create char tables. */
3293 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3295 /* Initialize the keymaps standardly used.
3296 Each one is the value of a Lisp variable, and is also
3297 pointed to by a C variable */
3299 global_map
= Fmake_keymap (Qnil
);
3300 Fset (intern ("global-map"), global_map
);
3302 current_global_map
= global_map
;
3303 staticpro (&global_map
);
3304 staticpro (¤t_global_map
);
3306 meta_map
= Fmake_keymap (Qnil
);
3307 Fset (intern ("esc-map"), meta_map
);
3308 Ffset (intern ("ESC-prefix"), meta_map
);
3310 control_x_map
= Fmake_keymap (Qnil
);
3311 Fset (intern ("ctl-x-map"), control_x_map
);
3312 Ffset (intern ("Control-X-prefix"), control_x_map
);
3314 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3315 "List of commands given new key bindings recently.\n\
3316 This is used for internal purposes during Emacs startup;\n\
3317 don't alter it yourself.");
3318 Vdefine_key_rebound_commands
= Qt
;
3320 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3321 "Default keymap to use when reading from the minibuffer.");
3322 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3324 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3325 "Local keymap for the minibuffer when spaces are not allowed.");
3326 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3328 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3329 "Local keymap for minibuffer input with completion.");
3330 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3332 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3333 "Local keymap for minibuffer input with completion, for exact match.");
3334 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3336 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3337 "Alist of keymaps to use for minor modes.\n\
3338 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3339 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3340 If two active keymaps bind the same key, the keymap appearing earlier\n\
3341 in the list takes precedence.");
3342 Vminor_mode_map_alist
= Qnil
;
3344 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3345 "Alist of keymaps to use for minor modes, in current major mode.\n\
3346 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3347 used the same way (and before `minor-mode-map-alist'); however,\n\
3348 it is provided for major modes to bind locally.");
3349 Vminor_mode_overriding_map_alist
= Qnil
;
3351 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3352 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3353 This allows Emacs to recognize function keys sent from ASCII\n\
3354 terminals at any point in a key sequence.\n\
3356 The `read-key-sequence' function replaces any subsequence bound by\n\
3357 `function-key-map' with its binding. More precisely, when the active\n\
3358 keymaps have no binding for the current key sequence but\n\
3359 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3360 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3361 continues with the new sequence.\n\
3363 The events that come from bindings in `function-key-map' are not\n\
3364 themselves looked up in `function-key-map'.\n\
3366 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3367 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3368 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3369 key, typing `ESC O P x' would return [f1 x].");
3370 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3372 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3373 "Keymap of key translations that can override keymaps.\n\
3374 This keymap works like `function-key-map', but comes after that,\n\
3375 and applies even for keys that have ordinary bindings.");
3376 Vkey_translation_map
= Qnil
;
3378 Qsingle_key_description
= intern ("single-key-description");
3379 staticpro (&Qsingle_key_description
);
3381 Qkey_description
= intern ("key-description");
3382 staticpro (&Qkey_description
);
3384 Qkeymapp
= intern ("keymapp");
3385 staticpro (&Qkeymapp
);
3387 Qnon_ascii
= intern ("non-ascii");
3388 staticpro (&Qnon_ascii
);
3390 Qmenu_item
= intern ("menu-item");
3391 staticpro (&Qmenu_item
);
3393 where_is_cache_keymaps
= Qt
;
3394 where_is_cache
= Qnil
;
3395 staticpro (&where_is_cache
);
3396 staticpro (&where_is_cache_keymaps
);
3398 defsubr (&Skeymapp
);
3399 defsubr (&Skeymap_parent
);
3400 defsubr (&Sset_keymap_parent
);
3401 defsubr (&Smake_keymap
);
3402 defsubr (&Smake_sparse_keymap
);
3403 defsubr (&Scopy_keymap
);
3404 defsubr (&Skey_binding
);
3405 defsubr (&Slocal_key_binding
);
3406 defsubr (&Sglobal_key_binding
);
3407 defsubr (&Sminor_mode_key_binding
);
3408 defsubr (&Sdefine_key
);
3409 defsubr (&Slookup_key
);
3410 defsubr (&Sdefine_prefix_command
);
3411 defsubr (&Suse_global_map
);
3412 defsubr (&Suse_local_map
);
3413 defsubr (&Scurrent_local_map
);
3414 defsubr (&Scurrent_global_map
);
3415 defsubr (&Scurrent_minor_mode_maps
);
3416 defsubr (&Saccessible_keymaps
);
3417 defsubr (&Skey_description
);
3418 defsubr (&Sdescribe_vector
);
3419 defsubr (&Ssingle_key_description
);
3420 defsubr (&Stext_char_description
);
3421 defsubr (&Swhere_is_internal
);
3422 defsubr (&Sdescribe_bindings_internal
);
3423 defsubr (&Sapropos_internal
);
3429 initial_define_key (global_map
, 033, "ESC-prefix");
3430 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");