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
, make_number (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
;
1675 cmd
= get_keyelt (cmd
, 0);
1679 maps
= XCAR (XCAR (args
));
1680 is_metized
= XINT (XCDR (XCAR (args
)));
1681 tail
= XCAR (XCDR (args
));
1682 thisseq
= XCDR (XCDR (args
));
1684 tem
= get_keymap (cmd
, 0, 0);
1688 /* Ignore keymaps that are already added to maps. */
1689 tem
= Frassq (cmd
, maps
);
1692 /* If the last key in thisseq is meta-prefix-char,
1693 turn it into a meta-ized keystroke. We know
1694 that the event we're about to append is an
1695 ascii keystroke since we're processing a
1699 int meta_bit
= meta_modifier
;
1700 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1701 tem
= Fcopy_sequence (thisseq
);
1703 Faset (tem
, last
, make_number (XINT (index
) | meta_bit
));
1705 /* This new sequence is the same length as
1706 thisseq, so stick it in the list right
1709 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1713 tem
= append_key (thisseq
, index
);
1714 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1720 Lisp_Object Qsingle_key_description
, Qkey_description
;
1722 /* This function cannot GC. */
1724 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1725 "Return a pretty description of key-sequence KEYS.\n\
1726 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1727 spaces are put between sequence elements, etc.")
1734 Lisp_Object
*args
= NULL
;
1739 vector
= Fmake_vector (Flength (keys
), Qnil
);
1740 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1745 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1746 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1747 c
^= 0200 | meta_modifier
;
1748 XSETFASTINT (AREF (vector
, i_before
), c
);
1755 /* In effect, this computes
1756 (mapconcat 'single-key-description keys " ")
1757 but we shouldn't use mapconcat because it can do GC. */
1759 len
= XVECTOR (keys
)->size
;
1760 sep
= build_string (" ");
1761 /* This has one extra element at the end that we don't pass to Fconcat. */
1762 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1764 for (i
= 0; i
< len
; i
++)
1766 args
[i
* 2] = Fsingle_key_description (AREF (keys
, i
), Qnil
);
1767 args
[i
* 2 + 1] = sep
;
1770 else if (CONSP (keys
))
1772 /* In effect, this computes
1773 (mapconcat 'single-key-description keys " ")
1774 but we shouldn't use mapconcat because it can do GC. */
1776 len
= XFASTINT (Flength (keys
));
1777 sep
= build_string (" ");
1778 /* This has one extra element at the end that we don't pass to Fconcat. */
1779 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1781 for (i
= 0; i
< len
; i
++)
1783 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1784 args
[i
* 2 + 1] = sep
;
1789 keys
= wrong_type_argument (Qarrayp
, keys
);
1792 return build_string ("");
1793 return Fconcat (len
* 2 - 1, args
);
1797 push_key_description (c
, p
, force_multibyte
)
1798 register unsigned int c
;
1800 int force_multibyte
;
1804 /* Clear all the meaningless bits above the meta bit. */
1805 c
&= meta_modifier
| ~ - meta_modifier
;
1806 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1807 | meta_modifier
| shift_modifier
| super_modifier
);
1809 if (c
& alt_modifier
)
1815 if ((c
& ctrl_modifier
) != 0
1816 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1820 c
&= ~ctrl_modifier
;
1822 if (c
& hyper_modifier
)
1826 c
-= hyper_modifier
;
1828 if (c
& meta_modifier
)
1834 if (c
& shift_modifier
)
1838 c
-= shift_modifier
;
1840 if (c
& super_modifier
)
1844 c
-= super_modifier
;
1860 else if (c
== Ctl ('M'))
1868 /* `C-' already added above. */
1869 if (c
> 0 && c
<= Ctl ('Z'))
1888 || (NILP (current_buffer
->enable_multibyte_characters
)
1889 && SINGLE_BYTE_CHAR_P (c
)
1890 && !force_multibyte
))
1896 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
1898 if (force_multibyte
&& valid_p
)
1900 if (SINGLE_BYTE_CHAR_P (c
))
1901 c
= unibyte_char_to_multibyte (c
);
1902 p
+= CHAR_STRING (c
, p
);
1904 else if (NILP (current_buffer
->enable_multibyte_characters
)
1909 /* The biggest character code uses 19 bits. */
1910 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1912 if (c
>= (1 << bit_offset
))
1913 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1917 p
+= CHAR_STRING (c
, p
);
1923 /* This function cannot GC. */
1925 DEFUN ("single-key-description", Fsingle_key_description
,
1926 Ssingle_key_description
, 1, 2, 0,
1927 "Return a pretty description of command character KEY.\n\
1928 Control characters turn into C-whatever, etc.\n\
1929 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1930 around function keys and event symbols.")
1932 Lisp_Object key
, no_angles
;
1934 if (CONSP (key
) && lucid_event_type_list_p (key
))
1935 key
= Fevent_convert_list (key
);
1937 key
= EVENT_HEAD (key
);
1939 if (INTEGERP (key
)) /* Normal character */
1941 unsigned int charset
, c1
, c2
;
1942 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1944 if (SINGLE_BYTE_CHAR_P (without_bits
))
1947 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1950 && CHARSET_DEFINED_P (charset
)
1951 && ((c1
>= 0 && c1
< 32)
1952 || (c2
>= 0 && c2
< 32)))
1954 /* Handle a generic character. */
1956 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1957 CHECK_STRING (name
, 0);
1958 return concat2 (build_string ("Character set "), name
);
1962 char tem
[KEY_DESCRIPTION_SIZE
];
1964 *push_key_description (XUINT (key
), tem
, 1) = 0;
1965 return build_string (tem
);
1968 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1970 if (NILP (no_angles
))
1973 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
1974 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
1975 return build_string (buffer
);
1978 return Fsymbol_name (key
);
1980 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1981 return Fcopy_sequence (key
);
1983 error ("KEY must be an integer, cons, symbol, or string");
1988 push_text_char_description (c
, p
)
1989 register unsigned int c
;
2001 *p
++ = c
+ 64; /* 'A' - 1 */
2013 /* This function cannot GC. */
2015 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2016 "Return a pretty description of file-character CHARACTER.\n\
2017 Control characters turn into \"^char\", etc.")
2019 Lisp_Object character
;
2021 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2022 unsigned char str
[6];
2025 CHECK_NUMBER (character
, 0);
2027 c
= XINT (character
);
2028 if (!SINGLE_BYTE_CHAR_P (c
))
2030 int len
= CHAR_STRING (c
, str
);
2032 return make_multibyte_string (str
, 1, len
);
2035 *push_text_char_description (c
& 0377, str
) = 0;
2037 return build_string (str
);
2040 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2043 ascii_sequence_p (seq
)
2047 int len
= XINT (Flength (seq
));
2049 for (i
= 0; i
< len
; i
++)
2051 Lisp_Object ii
, elt
;
2053 XSETFASTINT (ii
, i
);
2054 elt
= Faref (seq
, ii
);
2057 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2065 /* where-is - finding a command in a set of keymaps. */
2067 static Lisp_Object
where_is_internal_1 ();
2068 static void where_is_internal_2 ();
2070 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2071 Returns the first non-nil binding found in any of those maps. */
2074 shadow_lookup (shadow
, key
, flag
)
2075 Lisp_Object shadow
, key
, flag
;
2077 Lisp_Object tail
, value
;
2079 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2081 value
= Flookup_key (XCAR (tail
), key
, flag
);
2082 if (!NILP (value
) && !NATNUMP (value
))
2088 /* This function can GC if Flookup_key autoloads any keymaps. */
2091 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2092 Lisp_Object definition
, keymaps
;
2093 Lisp_Object firstonly
, noindirect
;
2095 Lisp_Object maps
= Qnil
;
2096 Lisp_Object found
, sequences
;
2097 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2098 /* 1 means ignore all menu bindings entirely. */
2099 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2102 while (CONSP (found
))
2106 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2107 found
= XCDR (found
);
2110 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2114 for (; !NILP (maps
); maps
= Fcdr (maps
))
2116 /* Key sequence to reach map, and the map that it reaches */
2117 register Lisp_Object
this, map
;
2119 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2120 [M-CHAR] sequences, check if last character of the sequence
2121 is the meta-prefix char. */
2125 this = Fcar (Fcar (maps
));
2126 map
= Fcdr (Fcar (maps
));
2127 last
= make_number (XINT (Flength (this)) - 1);
2128 last_is_meta
= (XINT (last
) >= 0
2129 && EQ (Faref (this, last
), meta_prefix_char
));
2131 /* if (nomenus && !ascii_sequence_p (this)) */
2132 if (nomenus
&& XINT (last
) >= 0
2133 && !INTEGERP (Faref (this, make_number (0))))
2134 /* If no menu entries should be returned, skip over the
2135 keymaps bound to `menu-bar' and `tool-bar' and other
2136 non-ascii prefixes like `C-down-mouse-2'. */
2143 /* Because the code we want to run on each binding is rather
2144 large, we don't want to have two separate loop bodies for
2145 sparse keymap bindings and tables; we want to iterate one
2146 loop body over both keymap and vector bindings.
2148 For this reason, if Fcar (map) is a vector, we don't
2149 advance map to the next element until i indicates that we
2150 have finished off the vector. */
2151 Lisp_Object elt
, key
, binding
;
2159 /* Set key and binding to the current key and binding, and
2160 advance map and i to the next binding. */
2163 Lisp_Object sequence
;
2165 /* In a vector, look at each element. */
2166 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2168 binding
= AREF (elt
, i
);
2169 XSETFASTINT (key
, i
);
2170 sequence
= where_is_internal_1 (binding
, key
, definition
,
2172 last
, nomenus
, last_is_meta
);
2173 if (!NILP (sequence
))
2174 sequences
= Fcons (sequence
, sequences
);
2177 else if (CHAR_TABLE_P (elt
))
2179 Lisp_Object indices
[3];
2182 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2183 Qnil
), /* Result accumulator. */
2184 Fcons (Fcons (this, last
),
2185 Fcons (make_number (nomenus
),
2186 make_number (last_is_meta
))));
2187 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2189 sequences
= XCDR (XCAR (args
));
2191 else if (CONSP (elt
))
2193 Lisp_Object sequence
;
2196 binding
= XCDR (elt
);
2198 sequence
= where_is_internal_1 (binding
, key
, definition
,
2200 last
, nomenus
, last_is_meta
);
2201 if (!NILP (sequence
))
2202 sequences
= Fcons (sequence
, sequences
);
2206 for (; ! NILP (sequences
); sequences
= XCDR (sequences
))
2208 Lisp_Object sequence
;
2210 sequence
= XCAR (sequences
);
2212 /* Verify that this key binding is not shadowed by another
2213 binding for the same key, before we say it exists.
2215 Mechanism: look for local definition of this key and if
2216 it is defined and does not match what we found then
2219 Either nil or number as value from Flookup_key
2221 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2224 /* It is a true unshadowed match. Record it, unless it's already
2225 been seen (as could happen when inheriting keymaps). */
2226 if (NILP (Fmember (sequence
, found
)))
2227 found
= Fcons (sequence
, found
);
2229 /* If firstonly is Qnon_ascii, then we can return the first
2230 binding we find. If firstonly is not Qnon_ascii but not
2231 nil, then we should return the first ascii-only binding
2233 if (EQ (firstonly
, Qnon_ascii
))
2234 RETURN_UNGCPRO (sequence
);
2235 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2236 RETURN_UNGCPRO (sequence
);
2243 found
= Fnreverse (found
);
2245 /* firstonly may have been t, but we may have gone all the way through
2246 the keymaps without finding an all-ASCII key sequence. So just
2247 return the best we could find. */
2248 if (! NILP (firstonly
))
2249 return Fcar (found
);
2254 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2255 "Return list of keys that invoke DEFINITION.\n\
2256 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2257 If KEYMAP is nil, search all the currently active keymaps.\n\
2258 If KEYMAP is a list of keymaps, search only those keymaps.\n\
2260 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2261 rather than a list of all possible key sequences.\n\
2262 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2263 no matter what it is.\n\
2264 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2265 and entirely reject menu bindings.\n\
2267 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2268 to other keymaps or slots. This makes it possible to search for an\n\
2269 indirect definition itself.")
2270 (definition
, keymap
, firstonly
, noindirect
)
2271 Lisp_Object definition
, keymap
;
2272 Lisp_Object firstonly
, noindirect
;
2274 Lisp_Object sequences
, keymaps
;
2275 /* 1 means ignore all menu bindings entirely. */
2276 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2279 /* Find the relevant keymaps. */
2280 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2282 else if (! NILP (keymap
))
2283 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2287 nconc2 (Fcurrent_minor_mode_maps (),
2288 Fcons (get_local_map (PT
, current_buffer
, Qkeymap
),
2289 Fcons (get_local_map (PT
, current_buffer
,
2291 Fcons (current_global_map
, Qnil
)))));
2293 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2294 We don't really need to check `keymap'. */
2295 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2299 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2301 /* Check heuristic-consistency of the cache. */
2302 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2303 where_is_cache
= Qnil
;
2305 if (NILP (where_is_cache
))
2307 /* We need to create the cache. */
2308 Lisp_Object args
[2];
2309 where_is_cache
= Fmake_hash_table (0, args
);
2310 where_is_cache_keymaps
= Qt
;
2312 /* Fill in the cache. */
2313 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2314 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2317 where_is_cache_keymaps
= keymaps
;
2320 /* We want to process definitions from the last to the first.
2321 Instead of consing, copy definitions to a vector and step
2322 over that vector. */
2323 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2324 n
= XINT (Flength (sequences
));
2325 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2326 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2327 defns
[i
++] = XCAR (sequences
);
2329 /* Verify that the key bindings are not shadowed. Note that
2330 the following can GC. */
2331 GCPRO2 (definition
, keymaps
);
2334 for (i
= n
- 1; i
>= 0; --i
)
2335 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2337 if (ascii_sequence_p (defns
[i
]))
2343 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2348 /* Kill the cache so that where_is_internal_1 doesn't think
2349 we're filling it up. */
2350 where_is_cache
= Qnil
;
2351 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2357 /* This is the function that Fwhere_is_internal calls using map_char_table.
2359 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2361 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2362 Since map_char_table doesn't really use the return value from this function,
2363 we the result append to RESULT, the slot in ARGS.
2365 This function can GC because it calls where_is_internal_1 which can
2369 where_is_internal_2 (args
, key
, binding
)
2370 Lisp_Object args
, key
, binding
;
2372 Lisp_Object definition
, noindirect
, this, last
;
2373 Lisp_Object result
, sequence
;
2374 int nomenus
, last_is_meta
;
2375 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2377 GCPRO3 (args
, key
, binding
);
2378 result
= XCDR (XCAR (args
));
2379 definition
= XCAR (XCAR (XCAR (args
)));
2380 noindirect
= XCDR (XCAR (XCAR (args
)));
2381 this = XCAR (XCAR (XCDR (args
)));
2382 last
= XCDR (XCAR (XCDR (args
)));
2383 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2384 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2386 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2387 this, last
, nomenus
, last_is_meta
);
2389 if (!NILP (sequence
))
2390 XCDR (XCAR (args
)) = Fcons (sequence
, result
);
2396 /* This function cannot GC. */
2399 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2400 nomenus
, last_is_meta
)
2401 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2402 int nomenus
, last_is_meta
;
2404 Lisp_Object sequence
;
2406 /* Search through indirections unless that's not wanted. */
2407 if (NILP (noindirect
))
2408 binding
= get_keyelt (binding
, 0);
2410 /* End this iteration if this element does not match
2413 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2414 || EQ (binding
, definition
)
2415 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2416 /* Doesn't match. */
2419 /* We have found a match. Construct the key sequence where we found it. */
2420 if (INTEGERP (key
) && last_is_meta
)
2422 sequence
= Fcopy_sequence (this);
2423 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2426 sequence
= append_key (this, key
);
2428 if (!NILP (where_is_cache
))
2430 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2431 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2438 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2440 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal
, Sdescribe_bindings_internal
, 0, 2, "",
2441 "Show a list of all defined keys, and their definitions.\n\
2442 We put that list in a buffer, and display the buffer.\n\
2444 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2445 \(Ordinarily these are omitted from the output.)\n\
2446 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2447 then we display only bindings that start with that prefix.")
2449 Lisp_Object menus
, prefix
;
2451 register Lisp_Object thisbuf
;
2452 XSETBUFFER (thisbuf
, current_buffer
);
2453 internal_with_output_to_temp_buffer ("*Help*",
2454 describe_buffer_bindings
,
2455 list3 (thisbuf
, prefix
, menus
));
2459 /* ARG is (BUFFER PREFIX MENU-FLAG). */
2462 describe_buffer_bindings (arg
)
2465 Lisp_Object descbuf
, prefix
, shadow
;
2467 register Lisp_Object start1
;
2468 struct gcpro gcpro1
;
2470 char *alternate_heading
2472 Keyboard translations:\n\n\
2473 You type Translation\n\
2474 -------- -----------\n";
2476 descbuf
= XCAR (arg
);
2478 prefix
= XCAR (arg
);
2480 nomenu
= NILP (XCAR (arg
));
2485 Fset_buffer (Vstandard_output
);
2487 /* Report on alternates for keys. */
2488 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2491 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2492 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2494 for (c
= 0; c
< translate_len
; c
++)
2495 if (translate
[c
] != c
)
2497 char buf
[KEY_DESCRIPTION_SIZE
];
2500 if (alternate_heading
)
2502 insert_string (alternate_heading
);
2503 alternate_heading
= 0;
2506 bufend
= push_key_description (translate
[c
], buf
, 1);
2507 insert (buf
, bufend
- buf
);
2508 Findent_to (make_number (16), make_number (1));
2509 bufend
= push_key_description (c
, buf
, 1);
2510 insert (buf
, bufend
- buf
);
2518 if (!NILP (Vkey_translation_map
))
2519 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2520 "Key translations", nomenu
, 1, 0);
2524 Lisp_Object
*modes
, *maps
;
2526 /* Temporarily switch to descbuf, so that we can get that buffer's
2527 minor modes correctly. */
2528 Fset_buffer (descbuf
);
2530 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2531 || !NILP (Voverriding_local_map
))
2534 nmaps
= current_minor_maps (&modes
, &maps
);
2535 Fset_buffer (Vstandard_output
);
2537 /* Print the minor mode maps. */
2538 for (i
= 0; i
< nmaps
; i
++)
2540 /* The title for a minor mode keymap
2541 is constructed at run time.
2542 We let describe_map_tree do the actual insertion
2543 because it takes care of other features when doing so. */
2546 if (!SYMBOLP (modes
[i
]))
2549 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2553 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2554 XSYMBOL (modes
[i
])->name
->size
);
2555 p
+= XSYMBOL (modes
[i
])->name
->size
;
2557 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2558 p
+= sizeof (" Minor Mode Bindings") - 1;
2561 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2562 shadow
= Fcons (maps
[i
], shadow
);
2566 /* Print the (major mode) local map. */
2567 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2568 start1
= current_kboard
->Voverriding_terminal_local_map
;
2569 else if (!NILP (Voverriding_local_map
))
2570 start1
= Voverriding_local_map
;
2572 start1
= XBUFFER (descbuf
)->keymap
;
2576 describe_map_tree (start1
, 1, shadow
, prefix
,
2577 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2578 shadow
= Fcons (start1
, shadow
);
2581 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2582 "\f\nGlobal Bindings", nomenu
, 0, 1);
2584 /* Print the function-key-map translations under this prefix. */
2585 if (!NILP (Vfunction_key_map
))
2586 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2587 "\f\nFunction key map translations", nomenu
, 1, 0);
2589 call0 (intern ("help-mode"));
2590 Fset_buffer (descbuf
);
2595 /* Insert a description of the key bindings in STARTMAP,
2596 followed by those of all maps reachable through STARTMAP.
2597 If PARTIAL is nonzero, omit certain "uninteresting" commands
2598 (such as `undefined').
2599 If SHADOW is non-nil, it is a list of maps;
2600 don't mention keys which would be shadowed by any of them.
2601 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2602 TITLE, if not 0, is a string to insert at the beginning.
2603 TITLE should not end with a colon or a newline; we supply that.
2604 If NOMENU is not 0, then omit menu-bar commands.
2606 If TRANSL is nonzero, the definitions are actually key translations
2607 so print strings and vectors differently.
2609 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2613 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2615 Lisp_Object startmap
, shadow
, prefix
;
2622 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2623 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2630 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2633 GCPRO3 (maps
, seen
, sub_shadows
);
2639 /* Delete from MAPS each element that is for the menu bar. */
2640 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2642 Lisp_Object elt
, prefix
, tem
;
2645 prefix
= Fcar (elt
);
2646 if (XVECTOR (prefix
)->size
>= 1)
2648 tem
= Faref (prefix
, make_number (0));
2649 if (EQ (tem
, Qmenu_bar
))
2650 maps
= Fdelq (elt
, maps
);
2655 if (!NILP (maps
) || always_title
)
2659 insert_string (title
);
2662 insert_string (" Starting With ");
2663 insert1 (Fkey_description (prefix
));
2665 insert_string (":\n");
2667 insert_string (key_heading
);
2671 for (; !NILP (maps
); maps
= Fcdr (maps
))
2673 register Lisp_Object elt
, prefix
, tail
;
2676 prefix
= Fcar (elt
);
2680 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2684 shmap
= XCAR (tail
);
2686 /* If the sequence by which we reach this keymap is zero-length,
2687 then the shadow map for this keymap is just SHADOW. */
2688 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2689 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2691 /* If the sequence by which we reach this keymap actually has
2692 some elements, then the sequence's definition in SHADOW is
2693 what we should use. */
2696 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2697 if (INTEGERP (shmap
))
2701 /* If shmap is not nil and not a keymap,
2702 it completely shadows this map, so don't
2703 describe this map at all. */
2704 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2708 sub_shadows
= Fcons (shmap
, sub_shadows
);
2711 /* Maps we have already listed in this loop shadow this map. */
2712 for (tail
= orig_maps
; ! EQ (tail
, maps
); tail
= XCDR (tail
))
2715 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2717 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2720 describe_map (Fcdr (elt
), prefix
,
2721 transl
? describe_translation
: describe_command
,
2722 partial
, sub_shadows
, &seen
, nomenu
);
2728 insert_string ("\n");
2733 static int previous_description_column
;
2736 describe_command (definition
)
2737 Lisp_Object definition
;
2739 register Lisp_Object tem1
;
2740 int column
= current_column ();
2741 int description_column
;
2743 /* If column 16 is no good, go to col 32;
2744 but don't push beyond that--go to next line instead. */
2748 description_column
= 32;
2750 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2751 description_column
= 32;
2753 description_column
= 16;
2755 Findent_to (make_number (description_column
), make_number (1));
2756 previous_description_column
= description_column
;
2758 if (SYMBOLP (definition
))
2760 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2762 insert_string ("\n");
2764 else if (STRINGP (definition
) || VECTORP (definition
))
2765 insert_string ("Keyboard Macro\n");
2766 else if (KEYMAPP (definition
))
2767 insert_string ("Prefix Command\n");
2769 insert_string ("??\n");
2773 describe_translation (definition
)
2774 Lisp_Object definition
;
2776 register Lisp_Object tem1
;
2778 Findent_to (make_number (16), make_number (1));
2780 if (SYMBOLP (definition
))
2782 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2784 insert_string ("\n");
2786 else if (STRINGP (definition
) || VECTORP (definition
))
2788 insert1 (Fkey_description (definition
));
2789 insert_string ("\n");
2791 else if (KEYMAPP (definition
))
2792 insert_string ("Prefix Command\n");
2794 insert_string ("??\n");
2797 /* Describe the contents of map MAP, assuming that this map itself is
2798 reached by the sequence of prefix keys KEYS (a string or vector).
2799 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2802 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2803 register Lisp_Object map
;
2805 void (*elt_describer
) P_ ((Lisp_Object
));
2811 Lisp_Object elt_prefix
;
2812 Lisp_Object tail
, definition
, event
;
2814 Lisp_Object suppress
;
2817 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2821 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2823 /* Call Fkey_description first, to avoid GC bug for the other string. */
2824 tem
= Fkey_description (keys
);
2825 elt_prefix
= concat2 (tem
, build_string (" "));
2831 suppress
= intern ("suppress-keymap");
2833 /* This vector gets used to present single keys to Flookup_key. Since
2834 that is done once per keymap element, we don't want to cons up a
2835 fresh vector every time. */
2836 kludge
= Fmake_vector (make_number (1), Qnil
);
2839 GCPRO3 (elt_prefix
, definition
, kludge
);
2841 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2845 if (VECTORP (XCAR (tail
))
2846 || CHAR_TABLE_P (XCAR (tail
)))
2847 describe_vector (XCAR (tail
),
2848 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2850 else if (CONSP (XCAR (tail
)))
2852 event
= XCAR (XCAR (tail
));
2854 /* Ignore bindings whose "keys" are not really valid events.
2855 (We get these in the frames and buffers menu.) */
2856 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2859 if (nomenu
&& EQ (event
, Qmenu_bar
))
2862 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2864 /* Don't show undefined commands or suppressed commands. */
2865 if (NILP (definition
)) continue;
2866 if (SYMBOLP (definition
) && partial
)
2868 tem
= Fget (definition
, suppress
);
2873 /* Don't show a command that isn't really visible
2874 because a local definition of the same key shadows it. */
2876 ASET (kludge
, 0, event
);
2879 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2880 if (!NILP (tem
)) continue;
2883 tem
= Flookup_key (map
, kludge
, Qt
);
2884 if (! EQ (tem
, definition
)) continue;
2888 previous_description_column
= 0;
2893 if (!NILP (elt_prefix
))
2894 insert1 (elt_prefix
);
2896 /* THIS gets the string to describe the character EVENT. */
2897 insert1 (Fsingle_key_description (event
, Qnil
));
2899 /* Print a description of the definition of this character.
2900 elt_describer will take care of spacing out far enough
2901 for alignment purposes. */
2902 (*elt_describer
) (definition
);
2904 else if (EQ (XCAR (tail
), Qkeymap
))
2906 /* The same keymap might be in the structure twice, if we're
2907 using an inherited keymap. So skip anything we've already
2909 tem
= Fassq (tail
, *seen
);
2910 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2912 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2920 describe_vector_princ (elt
)
2923 Findent_to (make_number (16), make_number (1));
2928 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2929 "Insert a description of contents of VECTOR.\n\
2930 This is text showing the elements of vector matched against indices.")
2934 int count
= specpdl_ptr
- specpdl
;
2936 specbind (Qstandard_output
, Fcurrent_buffer ());
2937 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2938 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2939 Qnil
, Qnil
, (int *)0, 0);
2941 return unbind_to (count
, Qnil
);
2944 /* Insert in the current buffer a description of the contents of VECTOR.
2945 We call ELT_DESCRIBER to insert the description of one value found
2948 ELT_PREFIX describes what "comes before" the keys or indices defined
2949 by this vector. This is a human-readable string whose size
2950 is not necessarily related to the situation.
2952 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2953 leads to this keymap.
2955 If the vector is a chartable, ELT_PREFIX is the vector
2956 of bytes that lead to the character set or portion of a character
2957 set described by this chartable.
2959 If PARTIAL is nonzero, it means do not mention suppressed commands
2960 (that assumes the vector is in a keymap).
2962 SHADOW is a list of keymaps that shadow this map.
2963 If it is non-nil, then we look up the key in those maps
2964 and we don't mention it now if it is defined by any of them.
2966 ENTIRE_MAP is the keymap in which this vector appears.
2967 If the definition in effect in the whole map does not match
2968 the one in this vector, we ignore this one.
2970 When describing a sub-char-table, INDICES is a list of
2971 indices at higher levels in this char-table,
2972 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2975 describe_vector (vector
, elt_prefix
, elt_describer
,
2976 partial
, shadow
, entire_map
,
2977 indices
, char_table_depth
)
2978 register Lisp_Object vector
;
2979 Lisp_Object elt_prefix
;
2980 void (*elt_describer
) P_ ((Lisp_Object
));
2983 Lisp_Object entire_map
;
2985 int char_table_depth
;
2987 Lisp_Object definition
;
2990 Lisp_Object suppress
;
2993 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2994 /* Range of elements to be handled. */
2996 /* A flag to tell if a leaf in this level of char-table is not a
2997 generic character (i.e. a complete multibyte character). */
3005 indices
= (int *) alloca (3 * sizeof (int));
3009 /* This vector gets used to present single keys to Flookup_key. Since
3010 that is done once per vector element, we don't want to cons up a
3011 fresh vector every time. */
3012 kludge
= Fmake_vector (make_number (1), Qnil
);
3013 GCPRO3 (elt_prefix
, definition
, kludge
);
3016 suppress
= intern ("suppress-keymap");
3018 if (CHAR_TABLE_P (vector
))
3020 if (char_table_depth
== 0)
3022 /* VECTOR is a top level char-table. */
3025 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3029 /* VECTOR is a sub char-table. */
3030 if (char_table_depth
>= 3)
3031 /* A char-table is never that deep. */
3032 error ("Too deep char table");
3035 = (CHARSET_VALID_P (indices
[0])
3036 && ((CHARSET_DIMENSION (indices
[0]) == 1
3037 && char_table_depth
== 1)
3038 || char_table_depth
== 2));
3040 /* Meaningful elements are from 32th to 127th. */
3042 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3047 /* This does the right thing for ordinary vectors. */
3051 to
= XVECTOR (vector
)->size
;
3054 for (i
= from
; i
< to
; i
++)
3058 if (CHAR_TABLE_P (vector
))
3060 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3063 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3064 && !CHARSET_DEFINED_P (i
- 128))
3068 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3071 definition
= get_keyelt (AREF (vector
, i
), 0);
3073 if (NILP (definition
)) continue;
3075 /* Don't mention suppressed commands. */
3076 if (SYMBOLP (definition
) && partial
)
3080 tem
= Fget (definition
, suppress
);
3082 if (!NILP (tem
)) continue;
3085 /* Set CHARACTER to the character this entry describes, if any.
3086 Also update *INDICES. */
3087 if (CHAR_TABLE_P (vector
))
3089 indices
[char_table_depth
] = i
;
3091 if (char_table_depth
== 0)
3094 indices
[0] = i
- 128;
3096 else if (complete_char
)
3098 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3106 /* If this binding is shadowed by some other map, ignore it. */
3107 if (!NILP (shadow
) && complete_char
)
3111 ASET (kludge
, 0, make_number (character
));
3112 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3114 if (!NILP (tem
)) continue;
3117 /* Ignore this definition if it is shadowed by an earlier
3118 one in the same keymap. */
3119 if (!NILP (entire_map
) && complete_char
)
3123 ASET (kludge
, 0, make_number (character
));
3124 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3126 if (! EQ (tem
, definition
))
3132 if (char_table_depth
== 0)
3137 /* For a sub char-table, show the depth by indentation.
3138 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3139 if (char_table_depth
> 0)
3140 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3142 /* Output the prefix that applies to every entry in this map. */
3143 if (!NILP (elt_prefix
))
3144 insert1 (elt_prefix
);
3146 /* Insert or describe the character this slot is for,
3147 or a description of what it is for. */
3148 if (SUB_CHAR_TABLE_P (vector
))
3151 insert_char (character
);
3154 /* We need an octal representation for this block of
3157 sprintf (work
, "(row %d)", i
);
3158 insert (work
, strlen (work
));
3161 else if (CHAR_TABLE_P (vector
))
3164 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3167 /* Print the information for this character set. */
3168 insert_string ("<");
3169 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3171 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3172 STRING_BYTES (XSTRING (tem2
)), 0);
3180 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3183 /* If we find a sub char-table within a char-table,
3184 scan it recursively; it defines the details for
3185 a character set or a portion of a character set. */
3186 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3189 describe_vector (definition
, elt_prefix
, elt_describer
,
3190 partial
, shadow
, entire_map
,
3191 indices
, char_table_depth
+ 1);
3197 /* Find all consecutive characters or rows that have the same
3198 definition. But, for elements of a top level char table, if
3199 they are for charsets, we had better describe one by one even
3200 if they have the same definition. */
3201 if (CHAR_TABLE_P (vector
))
3205 if (char_table_depth
== 0)
3206 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3208 while (i
+ 1 < limit
3209 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3211 && !NILP (Fequal (tem2
, definition
)))
3216 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3218 && !NILP (Fequal (tem2
, definition
)))
3222 /* If we have a range of more than one character,
3223 print where the range reaches to. */
3225 if (i
!= starting_i
)
3229 if (!NILP (elt_prefix
))
3230 insert1 (elt_prefix
);
3232 if (CHAR_TABLE_P (vector
))
3234 if (char_table_depth
== 0)
3236 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3238 else if (complete_char
)
3240 indices
[char_table_depth
] = i
;
3241 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3242 insert_char (character
);
3246 /* We need an octal representation for this block of
3249 sprintf (work
, "(row %d)", i
);
3250 insert (work
, strlen (work
));
3255 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3259 /* Print a description of the definition of this character.
3260 elt_describer will take care of spacing out far enough
3261 for alignment purposes. */
3262 (*elt_describer
) (definition
);
3265 /* For (sub) char-table, print `defalt' slot at last. */
3266 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3268 insert (" ", char_table_depth
* 2);
3269 insert_string ("<<default>>");
3270 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3276 /* Apropos - finding all symbols whose names match a regexp. */
3277 Lisp_Object apropos_predicate
;
3278 Lisp_Object apropos_accumulate
;
3281 apropos_accum (symbol
, string
)
3282 Lisp_Object symbol
, string
;
3284 register Lisp_Object tem
;
3286 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3287 if (!NILP (tem
) && !NILP (apropos_predicate
))
3288 tem
= call1 (apropos_predicate
, symbol
);
3290 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3293 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3294 "Show all symbols whose names contain match for REGEXP.\n\
3295 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3296 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3297 Return list of symbols found.")
3299 Lisp_Object regexp
, predicate
;
3301 struct gcpro gcpro1
, gcpro2
;
3302 CHECK_STRING (regexp
, 0);
3303 apropos_predicate
= predicate
;
3304 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3305 apropos_accumulate
= Qnil
;
3306 map_obarray (Vobarray
, apropos_accum
, regexp
);
3307 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3309 return apropos_accumulate
;
3315 Qkeymap
= intern ("keymap");
3316 staticpro (&Qkeymap
);
3318 /* Now we are ready to set up this property, so we can
3319 create char tables. */
3320 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3322 /* Initialize the keymaps standardly used.
3323 Each one is the value of a Lisp variable, and is also
3324 pointed to by a C variable */
3326 global_map
= Fmake_keymap (Qnil
);
3327 Fset (intern ("global-map"), global_map
);
3329 current_global_map
= global_map
;
3330 staticpro (&global_map
);
3331 staticpro (¤t_global_map
);
3333 meta_map
= Fmake_keymap (Qnil
);
3334 Fset (intern ("esc-map"), meta_map
);
3335 Ffset (intern ("ESC-prefix"), meta_map
);
3337 control_x_map
= Fmake_keymap (Qnil
);
3338 Fset (intern ("ctl-x-map"), control_x_map
);
3339 Ffset (intern ("Control-X-prefix"), control_x_map
);
3341 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3342 "List of commands given new key bindings recently.\n\
3343 This is used for internal purposes during Emacs startup;\n\
3344 don't alter it yourself.");
3345 Vdefine_key_rebound_commands
= Qt
;
3347 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3348 "Default keymap to use when reading from the minibuffer.");
3349 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3351 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3352 "Local keymap for the minibuffer when spaces are not allowed.");
3353 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3355 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3356 "Local keymap for minibuffer input with completion.");
3357 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3359 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3360 "Local keymap for minibuffer input with completion, for exact match.");
3361 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3363 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3364 "Alist of keymaps to use for minor modes.\n\
3365 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3366 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3367 If two active keymaps bind the same key, the keymap appearing earlier\n\
3368 in the list takes precedence.");
3369 Vminor_mode_map_alist
= Qnil
;
3371 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3372 "Alist of keymaps to use for minor modes, in current major mode.\n\
3373 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3374 used the same way (and before `minor-mode-map-alist'); however,\n\
3375 it is provided for major modes to bind locally.");
3376 Vminor_mode_overriding_map_alist
= Qnil
;
3378 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3379 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3380 This allows Emacs to recognize function keys sent from ASCII\n\
3381 terminals at any point in a key sequence.\n\
3383 The `read-key-sequence' function replaces any subsequence bound by\n\
3384 `function-key-map' with its binding. More precisely, when the active\n\
3385 keymaps have no binding for the current key sequence but\n\
3386 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3387 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3388 continues with the new sequence.\n\
3390 The events that come from bindings in `function-key-map' are not\n\
3391 themselves looked up in `function-key-map'.\n\
3393 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3394 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3395 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3396 key, typing `ESC O P x' would return [f1 x].");
3397 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3399 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3400 "Keymap of key translations that can override keymaps.\n\
3401 This keymap works like `function-key-map', but comes after that,\n\
3402 and applies even for keys that have ordinary bindings.");
3403 Vkey_translation_map
= Qnil
;
3405 Qsingle_key_description
= intern ("single-key-description");
3406 staticpro (&Qsingle_key_description
);
3408 Qkey_description
= intern ("key-description");
3409 staticpro (&Qkey_description
);
3411 Qkeymapp
= intern ("keymapp");
3412 staticpro (&Qkeymapp
);
3414 Qnon_ascii
= intern ("non-ascii");
3415 staticpro (&Qnon_ascii
);
3417 Qmenu_item
= intern ("menu-item");
3418 staticpro (&Qmenu_item
);
3420 where_is_cache_keymaps
= Qt
;
3421 where_is_cache
= Qnil
;
3422 staticpro (&where_is_cache
);
3423 staticpro (&where_is_cache_keymaps
);
3425 defsubr (&Skeymapp
);
3426 defsubr (&Skeymap_parent
);
3427 defsubr (&Sset_keymap_parent
);
3428 defsubr (&Smake_keymap
);
3429 defsubr (&Smake_sparse_keymap
);
3430 defsubr (&Scopy_keymap
);
3431 defsubr (&Skey_binding
);
3432 defsubr (&Slocal_key_binding
);
3433 defsubr (&Sglobal_key_binding
);
3434 defsubr (&Sminor_mode_key_binding
);
3435 defsubr (&Sdefine_key
);
3436 defsubr (&Slookup_key
);
3437 defsubr (&Sdefine_prefix_command
);
3438 defsubr (&Suse_global_map
);
3439 defsubr (&Suse_local_map
);
3440 defsubr (&Scurrent_local_map
);
3441 defsubr (&Scurrent_global_map
);
3442 defsubr (&Scurrent_minor_mode_maps
);
3443 defsubr (&Saccessible_keymaps
);
3444 defsubr (&Skey_description
);
3445 defsubr (&Sdescribe_vector
);
3446 defsubr (&Ssingle_key_description
);
3447 defsubr (&Stext_char_description
);
3448 defsubr (&Swhere_is_internal
);
3449 defsubr (&Sdescribe_bindings_internal
);
3450 defsubr (&Sapropos_internal
);
3456 initial_define_key (global_map
, 033, "ESC-prefix");
3457 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");