1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "termhooks.h"
31 #include "blockinput.h"
33 #include "intervals.h"
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
], *end
;
1966 end
= push_key_description (XUINT (key
), tem
, 1);
1968 nchars
= multibyte_chars_in_text (tem
, nbytes
);
1969 if (nchars
== nbytes
)
1970 string
= build_string (tem
);
1972 string
= make_multibyte_string (tem
, nchars
, nbytes
);
1976 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1978 if (NILP (no_angles
))
1981 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
1982 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
1983 return build_string (buffer
);
1986 return Fsymbol_name (key
);
1988 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1989 return Fcopy_sequence (key
);
1991 error ("KEY must be an integer, cons, symbol, or string");
1996 push_text_char_description (c
, p
)
1997 register unsigned int c
;
2009 *p
++ = c
+ 64; /* 'A' - 1 */
2021 /* This function cannot GC. */
2023 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2024 "Return a pretty description of file-character CHARACTER.\n\
2025 Control characters turn into \"^char\", etc.")
2027 Lisp_Object character
;
2029 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2030 unsigned char str
[6];
2033 CHECK_NUMBER (character
, 0);
2035 c
= XINT (character
);
2036 if (!SINGLE_BYTE_CHAR_P (c
))
2038 int len
= CHAR_STRING (c
, str
);
2040 return make_multibyte_string (str
, 1, len
);
2043 *push_text_char_description (c
& 0377, str
) = 0;
2045 return build_string (str
);
2048 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2051 ascii_sequence_p (seq
)
2055 int len
= XINT (Flength (seq
));
2057 for (i
= 0; i
< len
; i
++)
2059 Lisp_Object ii
, elt
;
2061 XSETFASTINT (ii
, i
);
2062 elt
= Faref (seq
, ii
);
2065 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2073 /* where-is - finding a command in a set of keymaps. */
2075 static Lisp_Object
where_is_internal_1 ();
2076 static void where_is_internal_2 ();
2078 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2079 Returns the first non-nil binding found in any of those maps. */
2082 shadow_lookup (shadow
, key
, flag
)
2083 Lisp_Object shadow
, key
, flag
;
2085 Lisp_Object tail
, value
;
2087 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2089 value
= Flookup_key (XCAR (tail
), key
, flag
);
2090 if (!NILP (value
) && !NATNUMP (value
))
2096 /* This function can GC if Flookup_key autoloads any keymaps. */
2099 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2100 Lisp_Object definition
, keymaps
;
2101 Lisp_Object firstonly
, noindirect
;
2103 Lisp_Object maps
= Qnil
;
2104 Lisp_Object found
, sequences
;
2105 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2106 /* 1 means ignore all menu bindings entirely. */
2107 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2110 while (CONSP (found
))
2114 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2115 found
= XCDR (found
);
2118 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2122 for (; !NILP (maps
); maps
= Fcdr (maps
))
2124 /* Key sequence to reach map, and the map that it reaches */
2125 register Lisp_Object
this, map
;
2127 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2128 [M-CHAR] sequences, check if last character of the sequence
2129 is the meta-prefix char. */
2133 this = Fcar (Fcar (maps
));
2134 map
= Fcdr (Fcar (maps
));
2135 last
= make_number (XINT (Flength (this)) - 1);
2136 last_is_meta
= (XINT (last
) >= 0
2137 && EQ (Faref (this, last
), meta_prefix_char
));
2139 /* if (nomenus && !ascii_sequence_p (this)) */
2140 if (nomenus
&& XINT (last
) >= 0
2141 && !INTEGERP (Faref (this, make_number (0))))
2142 /* If no menu entries should be returned, skip over the
2143 keymaps bound to `menu-bar' and `tool-bar' and other
2144 non-ascii prefixes like `C-down-mouse-2'. */
2151 /* Because the code we want to run on each binding is rather
2152 large, we don't want to have two separate loop bodies for
2153 sparse keymap bindings and tables; we want to iterate one
2154 loop body over both keymap and vector bindings.
2156 For this reason, if Fcar (map) is a vector, we don't
2157 advance map to the next element until i indicates that we
2158 have finished off the vector. */
2159 Lisp_Object elt
, key
, binding
;
2167 /* Set key and binding to the current key and binding, and
2168 advance map and i to the next binding. */
2171 Lisp_Object sequence
;
2173 /* In a vector, look at each element. */
2174 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2176 binding
= AREF (elt
, i
);
2177 XSETFASTINT (key
, i
);
2178 sequence
= where_is_internal_1 (binding
, key
, definition
,
2180 last
, nomenus
, last_is_meta
);
2181 if (!NILP (sequence
))
2182 sequences
= Fcons (sequence
, sequences
);
2185 else if (CHAR_TABLE_P (elt
))
2187 Lisp_Object indices
[3];
2190 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2191 Qnil
), /* Result accumulator. */
2192 Fcons (Fcons (this, last
),
2193 Fcons (make_number (nomenus
),
2194 make_number (last_is_meta
))));
2195 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2197 sequences
= XCDR (XCAR (args
));
2199 else if (CONSP (elt
))
2201 Lisp_Object sequence
;
2204 binding
= XCDR (elt
);
2206 sequence
= where_is_internal_1 (binding
, key
, definition
,
2208 last
, nomenus
, last_is_meta
);
2209 if (!NILP (sequence
))
2210 sequences
= Fcons (sequence
, sequences
);
2214 for (; ! NILP (sequences
); sequences
= XCDR (sequences
))
2216 Lisp_Object sequence
;
2218 sequence
= XCAR (sequences
);
2220 /* Verify that this key binding is not shadowed by another
2221 binding for the same key, before we say it exists.
2223 Mechanism: look for local definition of this key and if
2224 it is defined and does not match what we found then
2227 Either nil or number as value from Flookup_key
2229 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2232 /* It is a true unshadowed match. Record it, unless it's already
2233 been seen (as could happen when inheriting keymaps). */
2234 if (NILP (Fmember (sequence
, found
)))
2235 found
= Fcons (sequence
, found
);
2237 /* If firstonly is Qnon_ascii, then we can return the first
2238 binding we find. If firstonly is not Qnon_ascii but not
2239 nil, then we should return the first ascii-only binding
2241 if (EQ (firstonly
, Qnon_ascii
))
2242 RETURN_UNGCPRO (sequence
);
2243 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2244 RETURN_UNGCPRO (sequence
);
2251 found
= Fnreverse (found
);
2253 /* firstonly may have been t, but we may have gone all the way through
2254 the keymaps without finding an all-ASCII key sequence. So just
2255 return the best we could find. */
2256 if (! NILP (firstonly
))
2257 return Fcar (found
);
2262 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2263 "Return list of keys that invoke DEFINITION.\n\
2264 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2265 If KEYMAP is nil, search all the currently active keymaps.\n\
2266 If KEYMAP is a list of keymaps, search only those keymaps.\n\
2268 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2269 rather than a list of all possible key sequences.\n\
2270 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2271 no matter what it is.\n\
2272 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2273 and entirely reject menu bindings.\n\
2275 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2276 to other keymaps or slots. This makes it possible to search for an\n\
2277 indirect definition itself.")
2278 (definition
, keymap
, firstonly
, noindirect
)
2279 Lisp_Object definition
, keymap
;
2280 Lisp_Object firstonly
, noindirect
;
2282 Lisp_Object sequences
, keymaps
;
2283 /* 1 means ignore all menu bindings entirely. */
2284 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2287 /* Find the relevant keymaps. */
2288 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2290 else if (! NILP (keymap
))
2291 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2295 nconc2 (Fcurrent_minor_mode_maps (),
2296 Fcons (get_local_map (PT
, current_buffer
, Qkeymap
),
2297 Fcons (get_local_map (PT
, current_buffer
,
2299 Fcons (current_global_map
, Qnil
)))));
2301 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2302 We don't really need to check `keymap'. */
2303 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2307 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2309 /* Check heuristic-consistency of the cache. */
2310 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2311 where_is_cache
= Qnil
;
2313 if (NILP (where_is_cache
))
2315 /* We need to create the cache. */
2316 Lisp_Object args
[2];
2317 where_is_cache
= Fmake_hash_table (0, args
);
2318 where_is_cache_keymaps
= Qt
;
2320 /* Fill in the cache. */
2321 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2322 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2325 where_is_cache_keymaps
= keymaps
;
2328 /* We want to process definitions from the last to the first.
2329 Instead of consing, copy definitions to a vector and step
2330 over that vector. */
2331 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2332 n
= XINT (Flength (sequences
));
2333 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2334 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2335 defns
[i
++] = XCAR (sequences
);
2337 /* Verify that the key bindings are not shadowed. Note that
2338 the following can GC. */
2339 GCPRO2 (definition
, keymaps
);
2342 for (i
= n
- 1; i
>= 0; --i
)
2343 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2345 if (ascii_sequence_p (defns
[i
]))
2351 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2356 /* Kill the cache so that where_is_internal_1 doesn't think
2357 we're filling it up. */
2358 where_is_cache
= Qnil
;
2359 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2365 /* This is the function that Fwhere_is_internal calls using map_char_table.
2367 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2369 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2370 Since map_char_table doesn't really use the return value from this function,
2371 we the result append to RESULT, the slot in ARGS.
2373 This function can GC because it calls where_is_internal_1 which can
2377 where_is_internal_2 (args
, key
, binding
)
2378 Lisp_Object args
, key
, binding
;
2380 Lisp_Object definition
, noindirect
, this, last
;
2381 Lisp_Object result
, sequence
;
2382 int nomenus
, last_is_meta
;
2383 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2385 GCPRO3 (args
, key
, binding
);
2386 result
= XCDR (XCAR (args
));
2387 definition
= XCAR (XCAR (XCAR (args
)));
2388 noindirect
= XCDR (XCAR (XCAR (args
)));
2389 this = XCAR (XCAR (XCDR (args
)));
2390 last
= XCDR (XCAR (XCDR (args
)));
2391 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2392 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2394 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2395 this, last
, nomenus
, last_is_meta
);
2397 if (!NILP (sequence
))
2398 XCDR (XCAR (args
)) = Fcons (sequence
, result
);
2404 /* This function cannot GC. */
2407 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2408 nomenus
, last_is_meta
)
2409 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2410 int nomenus
, last_is_meta
;
2412 Lisp_Object sequence
;
2414 /* Search through indirections unless that's not wanted. */
2415 if (NILP (noindirect
))
2416 binding
= get_keyelt (binding
, 0);
2418 /* End this iteration if this element does not match
2421 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2422 || EQ (binding
, definition
)
2423 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2424 /* Doesn't match. */
2427 /* We have found a match. Construct the key sequence where we found it. */
2428 if (INTEGERP (key
) && last_is_meta
)
2430 sequence
= Fcopy_sequence (this);
2431 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2434 sequence
= append_key (this, key
);
2436 if (!NILP (where_is_cache
))
2438 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2439 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2446 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2448 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal
, Sdescribe_bindings_internal
, 0, 2, "",
2449 "Show a list of all defined keys, and their definitions.\n\
2450 We put that list in a buffer, and display the buffer.\n\
2452 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2453 \(Ordinarily these are omitted from the output.)\n\
2454 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2455 then we display only bindings that start with that prefix.")
2457 Lisp_Object menus
, prefix
;
2459 register Lisp_Object thisbuf
;
2460 XSETBUFFER (thisbuf
, current_buffer
);
2461 internal_with_output_to_temp_buffer ("*Help*",
2462 describe_buffer_bindings
,
2463 list3 (thisbuf
, prefix
, menus
));
2467 /* ARG is (BUFFER PREFIX MENU-FLAG). */
2470 describe_buffer_bindings (arg
)
2473 Lisp_Object descbuf
, prefix
, shadow
;
2475 register Lisp_Object start1
;
2476 struct gcpro gcpro1
;
2478 char *alternate_heading
2480 Keyboard translations:\n\n\
2481 You type Translation\n\
2482 -------- -----------\n";
2484 descbuf
= XCAR (arg
);
2486 prefix
= XCAR (arg
);
2488 nomenu
= NILP (XCAR (arg
));
2493 Fset_buffer (Vstandard_output
);
2495 /* Report on alternates for keys. */
2496 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2499 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2500 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2502 for (c
= 0; c
< translate_len
; c
++)
2503 if (translate
[c
] != c
)
2505 char buf
[KEY_DESCRIPTION_SIZE
];
2508 if (alternate_heading
)
2510 insert_string (alternate_heading
);
2511 alternate_heading
= 0;
2514 bufend
= push_key_description (translate
[c
], buf
, 1);
2515 insert (buf
, bufend
- buf
);
2516 Findent_to (make_number (16), make_number (1));
2517 bufend
= push_key_description (c
, buf
, 1);
2518 insert (buf
, bufend
- buf
);
2526 if (!NILP (Vkey_translation_map
))
2527 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2528 "Key translations", nomenu
, 1, 0);
2532 Lisp_Object
*modes
, *maps
;
2534 /* Temporarily switch to descbuf, so that we can get that buffer's
2535 minor modes correctly. */
2536 Fset_buffer (descbuf
);
2538 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2539 || !NILP (Voverriding_local_map
))
2542 nmaps
= current_minor_maps (&modes
, &maps
);
2543 Fset_buffer (Vstandard_output
);
2545 /* Print the minor mode maps. */
2546 for (i
= 0; i
< nmaps
; i
++)
2548 /* The title for a minor mode keymap
2549 is constructed at run time.
2550 We let describe_map_tree do the actual insertion
2551 because it takes care of other features when doing so. */
2554 if (!SYMBOLP (modes
[i
]))
2557 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2561 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2562 XSYMBOL (modes
[i
])->name
->size
);
2563 p
+= XSYMBOL (modes
[i
])->name
->size
;
2565 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2566 p
+= sizeof (" Minor Mode Bindings") - 1;
2569 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2570 shadow
= Fcons (maps
[i
], shadow
);
2574 /* Print the (major mode) local map. */
2575 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2576 start1
= current_kboard
->Voverriding_terminal_local_map
;
2577 else if (!NILP (Voverriding_local_map
))
2578 start1
= Voverriding_local_map
;
2580 start1
= XBUFFER (descbuf
)->keymap
;
2584 describe_map_tree (start1
, 1, shadow
, prefix
,
2585 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2586 shadow
= Fcons (start1
, shadow
);
2589 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2590 "\f\nGlobal Bindings", nomenu
, 0, 1);
2592 /* Print the function-key-map translations under this prefix. */
2593 if (!NILP (Vfunction_key_map
))
2594 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2595 "\f\nFunction key map translations", nomenu
, 1, 0);
2597 call0 (intern ("help-mode"));
2598 Fset_buffer (descbuf
);
2603 /* Insert a description of the key bindings in STARTMAP,
2604 followed by those of all maps reachable through STARTMAP.
2605 If PARTIAL is nonzero, omit certain "uninteresting" commands
2606 (such as `undefined').
2607 If SHADOW is non-nil, it is a list of maps;
2608 don't mention keys which would be shadowed by any of them.
2609 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2610 TITLE, if not 0, is a string to insert at the beginning.
2611 TITLE should not end with a colon or a newline; we supply that.
2612 If NOMENU is not 0, then omit menu-bar commands.
2614 If TRANSL is nonzero, the definitions are actually key translations
2615 so print strings and vectors differently.
2617 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2621 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2623 Lisp_Object startmap
, shadow
, prefix
;
2630 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2631 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2638 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2641 GCPRO3 (maps
, seen
, sub_shadows
);
2647 /* Delete from MAPS each element that is for the menu bar. */
2648 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2650 Lisp_Object elt
, prefix
, tem
;
2653 prefix
= Fcar (elt
);
2654 if (XVECTOR (prefix
)->size
>= 1)
2656 tem
= Faref (prefix
, make_number (0));
2657 if (EQ (tem
, Qmenu_bar
))
2658 maps
= Fdelq (elt
, maps
);
2663 if (!NILP (maps
) || always_title
)
2667 insert_string (title
);
2670 insert_string (" Starting With ");
2671 insert1 (Fkey_description (prefix
));
2673 insert_string (":\n");
2675 insert_string (key_heading
);
2679 for (; !NILP (maps
); maps
= Fcdr (maps
))
2681 register Lisp_Object elt
, prefix
, tail
;
2684 prefix
= Fcar (elt
);
2688 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2692 shmap
= XCAR (tail
);
2694 /* If the sequence by which we reach this keymap is zero-length,
2695 then the shadow map for this keymap is just SHADOW. */
2696 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2697 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2699 /* If the sequence by which we reach this keymap actually has
2700 some elements, then the sequence's definition in SHADOW is
2701 what we should use. */
2704 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2705 if (INTEGERP (shmap
))
2709 /* If shmap is not nil and not a keymap,
2710 it completely shadows this map, so don't
2711 describe this map at all. */
2712 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2716 sub_shadows
= Fcons (shmap
, sub_shadows
);
2719 /* Maps we have already listed in this loop shadow this map. */
2720 for (tail
= orig_maps
; ! EQ (tail
, maps
); tail
= XCDR (tail
))
2723 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2725 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2728 describe_map (Fcdr (elt
), prefix
,
2729 transl
? describe_translation
: describe_command
,
2730 partial
, sub_shadows
, &seen
, nomenu
);
2736 insert_string ("\n");
2741 static int previous_description_column
;
2744 describe_command (definition
)
2745 Lisp_Object definition
;
2747 register Lisp_Object tem1
;
2748 int column
= current_column ();
2749 int description_column
;
2751 /* If column 16 is no good, go to col 32;
2752 but don't push beyond that--go to next line instead. */
2756 description_column
= 32;
2758 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2759 description_column
= 32;
2761 description_column
= 16;
2763 Findent_to (make_number (description_column
), make_number (1));
2764 previous_description_column
= description_column
;
2766 if (SYMBOLP (definition
))
2768 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2770 insert_string ("\n");
2772 else if (STRINGP (definition
) || VECTORP (definition
))
2773 insert_string ("Keyboard Macro\n");
2774 else if (KEYMAPP (definition
))
2775 insert_string ("Prefix Command\n");
2777 insert_string ("??\n");
2781 describe_translation (definition
)
2782 Lisp_Object definition
;
2784 register Lisp_Object tem1
;
2786 Findent_to (make_number (16), make_number (1));
2788 if (SYMBOLP (definition
))
2790 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2792 insert_string ("\n");
2794 else if (STRINGP (definition
) || VECTORP (definition
))
2796 insert1 (Fkey_description (definition
));
2797 insert_string ("\n");
2799 else if (KEYMAPP (definition
))
2800 insert_string ("Prefix Command\n");
2802 insert_string ("??\n");
2805 /* Describe the contents of map MAP, assuming that this map itself is
2806 reached by the sequence of prefix keys KEYS (a string or vector).
2807 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2810 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2811 register Lisp_Object map
;
2813 void (*elt_describer
) P_ ((Lisp_Object
));
2819 Lisp_Object elt_prefix
;
2820 Lisp_Object tail
, definition
, event
;
2822 Lisp_Object suppress
;
2825 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2829 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2831 /* Call Fkey_description first, to avoid GC bug for the other string. */
2832 tem
= Fkey_description (keys
);
2833 elt_prefix
= concat2 (tem
, build_string (" "));
2839 suppress
= intern ("suppress-keymap");
2841 /* This vector gets used to present single keys to Flookup_key. Since
2842 that is done once per keymap element, we don't want to cons up a
2843 fresh vector every time. */
2844 kludge
= Fmake_vector (make_number (1), Qnil
);
2847 GCPRO3 (elt_prefix
, definition
, kludge
);
2849 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2853 if (VECTORP (XCAR (tail
))
2854 || CHAR_TABLE_P (XCAR (tail
)))
2855 describe_vector (XCAR (tail
),
2856 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2858 else if (CONSP (XCAR (tail
)))
2860 event
= XCAR (XCAR (tail
));
2862 /* Ignore bindings whose "keys" are not really valid events.
2863 (We get these in the frames and buffers menu.) */
2864 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2867 if (nomenu
&& EQ (event
, Qmenu_bar
))
2870 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2872 /* Don't show undefined commands or suppressed commands. */
2873 if (NILP (definition
)) continue;
2874 if (SYMBOLP (definition
) && partial
)
2876 tem
= Fget (definition
, suppress
);
2881 /* Don't show a command that isn't really visible
2882 because a local definition of the same key shadows it. */
2884 ASET (kludge
, 0, event
);
2887 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2888 if (!NILP (tem
)) continue;
2891 tem
= Flookup_key (map
, kludge
, Qt
);
2892 if (! EQ (tem
, definition
)) continue;
2896 previous_description_column
= 0;
2901 if (!NILP (elt_prefix
))
2902 insert1 (elt_prefix
);
2904 /* THIS gets the string to describe the character EVENT. */
2905 insert1 (Fsingle_key_description (event
, Qnil
));
2907 /* Print a description of the definition of this character.
2908 elt_describer will take care of spacing out far enough
2909 for alignment purposes. */
2910 (*elt_describer
) (definition
);
2912 else if (EQ (XCAR (tail
), Qkeymap
))
2914 /* The same keymap might be in the structure twice, if we're
2915 using an inherited keymap. So skip anything we've already
2917 tem
= Fassq (tail
, *seen
);
2918 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2920 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2928 describe_vector_princ (elt
)
2931 Findent_to (make_number (16), make_number (1));
2936 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2937 "Insert a description of contents of VECTOR.\n\
2938 This is text showing the elements of vector matched against indices.")
2942 int count
= specpdl_ptr
- specpdl
;
2944 specbind (Qstandard_output
, Fcurrent_buffer ());
2945 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2946 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2947 Qnil
, Qnil
, (int *)0, 0);
2949 return unbind_to (count
, Qnil
);
2952 /* Insert in the current buffer a description of the contents of VECTOR.
2953 We call ELT_DESCRIBER to insert the description of one value found
2956 ELT_PREFIX describes what "comes before" the keys or indices defined
2957 by this vector. This is a human-readable string whose size
2958 is not necessarily related to the situation.
2960 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2961 leads to this keymap.
2963 If the vector is a chartable, ELT_PREFIX is the vector
2964 of bytes that lead to the character set or portion of a character
2965 set described by this chartable.
2967 If PARTIAL is nonzero, it means do not mention suppressed commands
2968 (that assumes the vector is in a keymap).
2970 SHADOW is a list of keymaps that shadow this map.
2971 If it is non-nil, then we look up the key in those maps
2972 and we don't mention it now if it is defined by any of them.
2974 ENTIRE_MAP is the keymap in which this vector appears.
2975 If the definition in effect in the whole map does not match
2976 the one in this vector, we ignore this one.
2978 When describing a sub-char-table, INDICES is a list of
2979 indices at higher levels in this char-table,
2980 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2983 describe_vector (vector
, elt_prefix
, elt_describer
,
2984 partial
, shadow
, entire_map
,
2985 indices
, char_table_depth
)
2986 register Lisp_Object vector
;
2987 Lisp_Object elt_prefix
;
2988 void (*elt_describer
) P_ ((Lisp_Object
));
2991 Lisp_Object entire_map
;
2993 int char_table_depth
;
2995 Lisp_Object definition
;
2998 Lisp_Object suppress
;
3001 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3002 /* Range of elements to be handled. */
3004 /* A flag to tell if a leaf in this level of char-table is not a
3005 generic character (i.e. a complete multibyte character). */
3013 indices
= (int *) alloca (3 * sizeof (int));
3017 /* This vector gets used to present single keys to Flookup_key. Since
3018 that is done once per vector element, we don't want to cons up a
3019 fresh vector every time. */
3020 kludge
= Fmake_vector (make_number (1), Qnil
);
3021 GCPRO3 (elt_prefix
, definition
, kludge
);
3024 suppress
= intern ("suppress-keymap");
3026 if (CHAR_TABLE_P (vector
))
3028 if (char_table_depth
== 0)
3030 /* VECTOR is a top level char-table. */
3033 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3037 /* VECTOR is a sub char-table. */
3038 if (char_table_depth
>= 3)
3039 /* A char-table is never that deep. */
3040 error ("Too deep char table");
3043 = (CHARSET_VALID_P (indices
[0])
3044 && ((CHARSET_DIMENSION (indices
[0]) == 1
3045 && char_table_depth
== 1)
3046 || char_table_depth
== 2));
3048 /* Meaningful elements are from 32th to 127th. */
3050 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3055 /* This does the right thing for ordinary vectors. */
3059 to
= XVECTOR (vector
)->size
;
3062 for (i
= from
; i
< to
; i
++)
3066 if (CHAR_TABLE_P (vector
))
3068 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3071 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3072 && !CHARSET_DEFINED_P (i
- 128))
3076 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3079 definition
= get_keyelt (AREF (vector
, i
), 0);
3081 if (NILP (definition
)) continue;
3083 /* Don't mention suppressed commands. */
3084 if (SYMBOLP (definition
) && partial
)
3088 tem
= Fget (definition
, suppress
);
3090 if (!NILP (tem
)) continue;
3093 /* Set CHARACTER to the character this entry describes, if any.
3094 Also update *INDICES. */
3095 if (CHAR_TABLE_P (vector
))
3097 indices
[char_table_depth
] = i
;
3099 if (char_table_depth
== 0)
3102 indices
[0] = i
- 128;
3104 else if (complete_char
)
3106 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3114 /* If this binding is shadowed by some other map, ignore it. */
3115 if (!NILP (shadow
) && complete_char
)
3119 ASET (kludge
, 0, make_number (character
));
3120 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3122 if (!NILP (tem
)) continue;
3125 /* Ignore this definition if it is shadowed by an earlier
3126 one in the same keymap. */
3127 if (!NILP (entire_map
) && complete_char
)
3131 ASET (kludge
, 0, make_number (character
));
3132 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3134 if (! EQ (tem
, definition
))
3140 if (char_table_depth
== 0)
3145 /* For a sub char-table, show the depth by indentation.
3146 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3147 if (char_table_depth
> 0)
3148 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3150 /* Output the prefix that applies to every entry in this map. */
3151 if (!NILP (elt_prefix
))
3152 insert1 (elt_prefix
);
3154 /* Insert or describe the character this slot is for,
3155 or a description of what it is for. */
3156 if (SUB_CHAR_TABLE_P (vector
))
3159 insert_char (character
);
3162 /* We need an octal representation for this block of
3165 sprintf (work
, "(row %d)", i
);
3166 insert (work
, strlen (work
));
3169 else if (CHAR_TABLE_P (vector
))
3172 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3175 /* Print the information for this character set. */
3176 insert_string ("<");
3177 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3179 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3180 STRING_BYTES (XSTRING (tem2
)), 0);
3188 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3191 /* If we find a sub char-table within a char-table,
3192 scan it recursively; it defines the details for
3193 a character set or a portion of a character set. */
3194 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3197 describe_vector (definition
, elt_prefix
, elt_describer
,
3198 partial
, shadow
, entire_map
,
3199 indices
, char_table_depth
+ 1);
3205 /* Find all consecutive characters or rows that have the same
3206 definition. But, for elements of a top level char table, if
3207 they are for charsets, we had better describe one by one even
3208 if they have the same definition. */
3209 if (CHAR_TABLE_P (vector
))
3213 if (char_table_depth
== 0)
3214 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3216 while (i
+ 1 < limit
3217 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3219 && !NILP (Fequal (tem2
, definition
)))
3224 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3226 && !NILP (Fequal (tem2
, definition
)))
3230 /* If we have a range of more than one character,
3231 print where the range reaches to. */
3233 if (i
!= starting_i
)
3237 if (!NILP (elt_prefix
))
3238 insert1 (elt_prefix
);
3240 if (CHAR_TABLE_P (vector
))
3242 if (char_table_depth
== 0)
3244 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3246 else if (complete_char
)
3248 indices
[char_table_depth
] = i
;
3249 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3250 insert_char (character
);
3254 /* We need an octal representation for this block of
3257 sprintf (work
, "(row %d)", i
);
3258 insert (work
, strlen (work
));
3263 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3267 /* Print a description of the definition of this character.
3268 elt_describer will take care of spacing out far enough
3269 for alignment purposes. */
3270 (*elt_describer
) (definition
);
3273 /* For (sub) char-table, print `defalt' slot at last. */
3274 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3276 insert (" ", char_table_depth
* 2);
3277 insert_string ("<<default>>");
3278 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3284 /* Apropos - finding all symbols whose names match a regexp. */
3285 Lisp_Object apropos_predicate
;
3286 Lisp_Object apropos_accumulate
;
3289 apropos_accum (symbol
, string
)
3290 Lisp_Object symbol
, string
;
3292 register Lisp_Object tem
;
3294 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3295 if (!NILP (tem
) && !NILP (apropos_predicate
))
3296 tem
= call1 (apropos_predicate
, symbol
);
3298 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3301 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3302 "Show all symbols whose names contain match for REGEXP.\n\
3303 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3304 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3305 Return list of symbols found.")
3307 Lisp_Object regexp
, predicate
;
3309 struct gcpro gcpro1
, gcpro2
;
3310 CHECK_STRING (regexp
, 0);
3311 apropos_predicate
= predicate
;
3312 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3313 apropos_accumulate
= Qnil
;
3314 map_obarray (Vobarray
, apropos_accum
, regexp
);
3315 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3317 return apropos_accumulate
;
3323 Qkeymap
= intern ("keymap");
3324 staticpro (&Qkeymap
);
3326 /* Now we are ready to set up this property, so we can
3327 create char tables. */
3328 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3330 /* Initialize the keymaps standardly used.
3331 Each one is the value of a Lisp variable, and is also
3332 pointed to by a C variable */
3334 global_map
= Fmake_keymap (Qnil
);
3335 Fset (intern ("global-map"), global_map
);
3337 current_global_map
= global_map
;
3338 staticpro (&global_map
);
3339 staticpro (¤t_global_map
);
3341 meta_map
= Fmake_keymap (Qnil
);
3342 Fset (intern ("esc-map"), meta_map
);
3343 Ffset (intern ("ESC-prefix"), meta_map
);
3345 control_x_map
= Fmake_keymap (Qnil
);
3346 Fset (intern ("ctl-x-map"), control_x_map
);
3347 Ffset (intern ("Control-X-prefix"), control_x_map
);
3349 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3350 "List of commands given new key bindings recently.\n\
3351 This is used for internal purposes during Emacs startup;\n\
3352 don't alter it yourself.");
3353 Vdefine_key_rebound_commands
= Qt
;
3355 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3356 "Default keymap to use when reading from the minibuffer.");
3357 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3359 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3360 "Local keymap for the minibuffer when spaces are not allowed.");
3361 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3363 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3364 "Local keymap for minibuffer input with completion.");
3365 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3367 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3368 "Local keymap for minibuffer input with completion, for exact match.");
3369 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3371 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3372 "Alist of keymaps to use for minor modes.\n\
3373 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3374 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3375 If two active keymaps bind the same key, the keymap appearing earlier\n\
3376 in the list takes precedence.");
3377 Vminor_mode_map_alist
= Qnil
;
3379 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3380 "Alist of keymaps to use for minor modes, in current major mode.\n\
3381 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3382 used the same way (and before `minor-mode-map-alist'); however,\n\
3383 it is provided for major modes to bind locally.");
3384 Vminor_mode_overriding_map_alist
= Qnil
;
3386 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3387 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3388 This allows Emacs to recognize function keys sent from ASCII\n\
3389 terminals at any point in a key sequence.\n\
3391 The `read-key-sequence' function replaces any subsequence bound by\n\
3392 `function-key-map' with its binding. More precisely, when the active\n\
3393 keymaps have no binding for the current key sequence but\n\
3394 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3395 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3396 continues with the new sequence.\n\
3398 The events that come from bindings in `function-key-map' are not\n\
3399 themselves looked up in `function-key-map'.\n\
3401 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3402 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3403 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3404 key, typing `ESC O P x' would return [f1 x].");
3405 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3407 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3408 "Keymap of key translations that can override keymaps.\n\
3409 This keymap works like `function-key-map', but comes after that,\n\
3410 and applies even for keys that have ordinary bindings.");
3411 Vkey_translation_map
= Qnil
;
3413 Qsingle_key_description
= intern ("single-key-description");
3414 staticpro (&Qsingle_key_description
);
3416 Qkey_description
= intern ("key-description");
3417 staticpro (&Qkey_description
);
3419 Qkeymapp
= intern ("keymapp");
3420 staticpro (&Qkeymapp
);
3422 Qnon_ascii
= intern ("non-ascii");
3423 staticpro (&Qnon_ascii
);
3425 Qmenu_item
= intern ("menu-item");
3426 staticpro (&Qmenu_item
);
3428 where_is_cache_keymaps
= Qt
;
3429 where_is_cache
= Qnil
;
3430 staticpro (&where_is_cache
);
3431 staticpro (&where_is_cache_keymaps
);
3433 defsubr (&Skeymapp
);
3434 defsubr (&Skeymap_parent
);
3435 defsubr (&Sset_keymap_parent
);
3436 defsubr (&Smake_keymap
);
3437 defsubr (&Smake_sparse_keymap
);
3438 defsubr (&Scopy_keymap
);
3439 defsubr (&Skey_binding
);
3440 defsubr (&Slocal_key_binding
);
3441 defsubr (&Sglobal_key_binding
);
3442 defsubr (&Sminor_mode_key_binding
);
3443 defsubr (&Sdefine_key
);
3444 defsubr (&Slookup_key
);
3445 defsubr (&Sdefine_prefix_command
);
3446 defsubr (&Suse_global_map
);
3447 defsubr (&Suse_local_map
);
3448 defsubr (&Scurrent_local_map
);
3449 defsubr (&Scurrent_global_map
);
3450 defsubr (&Scurrent_minor_mode_maps
);
3451 defsubr (&Saccessible_keymaps
);
3452 defsubr (&Skey_description
);
3453 defsubr (&Sdescribe_vector
);
3454 defsubr (&Ssingle_key_description
);
3455 defsubr (&Stext_char_description
);
3456 defsubr (&Swhere_is_internal
);
3457 defsubr (&Sdescribe_bindings_internal
);
3458 defsubr (&Sapropos_internal
);
3464 initial_define_key (global_map
, 033, "ESC-prefix");
3465 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");