1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86,87,88,93,94,95,98,99 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 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))
36 #define KEYMAPP(m) (!NILP (Fkeymapp (m)))
38 /* The number of elements in keymap vectors. */
39 #define DENSE_TABLE_SIZE (0200)
41 /* Actually allocate storage for these variables */
43 Lisp_Object current_global_map
; /* Current global keymap */
45 Lisp_Object global_map
; /* default global key bindings */
47 Lisp_Object meta_map
; /* The keymap used for globally bound
48 ESC-prefixed default commands */
50 Lisp_Object control_x_map
; /* The keymap used for globally bound
51 C-x-prefixed default commands */
53 /* was MinibufLocalMap */
54 Lisp_Object Vminibuffer_local_map
;
55 /* The keymap used by the minibuf for local
56 bindings when spaces are allowed in the
59 /* was MinibufLocalNSMap */
60 Lisp_Object Vminibuffer_local_ns_map
;
61 /* The keymap used by the minibuf for local
62 bindings when spaces are not encouraged
65 /* keymap used for minibuffers when doing completion */
66 /* was MinibufLocalCompletionMap */
67 Lisp_Object Vminibuffer_local_completion_map
;
69 /* keymap used for minibuffers when doing completion and require a match */
70 /* was MinibufLocalMustMatchMap */
71 Lisp_Object Vminibuffer_local_must_match_map
;
73 /* Alist of minor mode variables and keymaps. */
74 Lisp_Object Vminor_mode_map_alist
;
76 /* Alist of major-mode-specific overrides for
77 minor mode variables and keymaps. */
78 Lisp_Object Vminor_mode_overriding_map_alist
;
80 /* Keymap mapping ASCII function key sequences onto their preferred forms.
81 Initialized by the terminal-specific lisp files. See DEFVAR for more
83 Lisp_Object Vfunction_key_map
;
85 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
86 Lisp_Object Vkey_translation_map
;
88 /* A list of all commands given new bindings since a certain time
89 when nil was stored here.
90 This is used to speed up recomputation of menu key equivalents
91 when Emacs starts up. t means don't record anything here. */
92 Lisp_Object Vdefine_key_rebound_commands
;
94 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
;
96 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
97 in a string key sequence is equivalent to prefixing with this
99 extern Lisp_Object meta_prefix_char
;
101 extern Lisp_Object Voverriding_local_map
;
103 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
104 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
106 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
107 static Lisp_Object describe_buffer_bindings
P_ ((Lisp_Object
));
108 static void describe_command
P_ ((Lisp_Object
));
109 static void describe_translation
P_ ((Lisp_Object
));
110 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
111 void (*) P_ ((Lisp_Object
)),
112 int, Lisp_Object
, Lisp_Object
*, int));
114 /* Keymap object support - constructors and predicates. */
116 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
117 "Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).\n\
118 CHARTABLE is a char-table that holds the bindings for the ASCII\n\
119 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
120 mouse events, and any other things that appear in the input stream.\n\
121 All entries in it are initially nil, meaning \"command undefined\".\n\n\
122 The optional arg STRING supplies a menu name for the keymap\n\
123 in case you use it as a menu with `x-popup-menu'.")
129 tail
= Fcons (string
, Qnil
);
132 return Fcons (Qkeymap
,
133 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
136 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
137 "Construct and return a new sparse-keymap list.\n\
138 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
139 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
140 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
141 Initially the alist is nil.\n\n\
142 The optional arg STRING supplies a menu name for the keymap\n\
143 in case you use it as a menu with `x-popup-menu'.")
148 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
149 return Fcons (Qkeymap
, Qnil
);
152 /* This function is used for installing the standard key bindings
153 at initialization time.
157 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
160 initial_define_key (keymap
, key
, defname
)
165 store_in_keymap (keymap
, make_number (key
), intern (defname
));
169 initial_define_lispy_key (keymap
, keyname
, defname
)
174 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
177 /* Define character fromchar in map frommap as an alias for character
178 tochar in map tomap. Subsequent redefinitions of the latter WILL
179 affect the former. */
183 synkey (frommap
, fromchar
, tomap
, tochar
)
184 struct Lisp_Vector
*frommap
, *tomap
;
185 int fromchar
, tochar
;
188 XSETVECTOR (v
, tomap
);
189 XSETFASTINT (c
, tochar
);
190 frommap
->contents
[fromchar
] = Fcons (v
, c
);
194 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
195 "Return t if OBJECT is a keymap.\n\
197 A keymap is a list (keymap . ALIST),\n\
198 or a symbol whose function definition is itself a keymap.\n\
199 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
200 a vector of densely packed bindings for small character codes\n\
201 is also allowed as an element.")
205 /* FIXME: Maybe this should return t for autoloaded keymaps? -sm */
206 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
209 /* Check that OBJECT is a keymap (after dereferencing through any
210 symbols). If it is, return it.
212 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
213 is an autoload form, do the autoload and try again.
214 If AUTOLOAD is nonzero, callers must assume GC is possible.
216 ERROR controls how we respond if OBJECT isn't a keymap.
217 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
219 Note that most of the time, we don't want to pursue autoloads.
220 Functions like Faccessible_keymaps which scan entire keymap trees
221 shouldn't load every autoloaded keymap. I'm not sure about this,
222 but it seems to me that only read_key_sequence, Flookup_key, and
223 Fdefine_key should cause keymaps to be autoloaded.
225 This function can GC when AUTOLOAD is non-zero, because it calls
226 do_autoload which can GC. */
229 get_keymap_1 (object
, error
, autoload
)
238 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
242 tem
= indirect_function (object
);
243 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
247 /* Should we do an autoload? Autoload forms for keymaps have
248 Qkeymap as their fifth element. */
252 && EQ (XCAR (tem
), Qautoload
))
256 tail
= Fnth (make_number (4), tem
);
257 if (EQ (tail
, Qkeymap
))
259 struct gcpro gcpro1
, gcpro2
;
261 GCPRO2 (tem
, object
);
262 do_autoload (tem
, object
);
271 wrong_type_argument (Qkeymapp
, object
);
276 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
277 If OBJECT doesn't denote a keymap at all, signal an error. */
282 return get_keymap_1 (object
, 1, 0);
285 /* Return the parent map of the keymap MAP, or nil if it has none.
286 We assume that MAP is a valid keymap. */
288 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
289 "Return the parent keymap of KEYMAP.")
295 keymap
= get_keymap_1 (keymap
, 1, 1);
297 /* Skip past the initial element `keymap'. */
298 list
= XCDR (keymap
);
299 for (; CONSP (list
); list
= XCDR (list
))
301 /* See if there is another `keymap'. */
310 /* Set the parent keymap of MAP to PARENT. */
312 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
313 "Modify KEYMAP to set its parent map to PARENT.\n\
314 PARENT should be nil or another keymap.")
316 Lisp_Object keymap
, parent
;
318 Lisp_Object list
, prev
;
322 keymap
= get_keymap_1 (keymap
, 1, 1);
329 parent
= get_keymap_1 (parent
, 1, 1);
331 /* Check for cycles. */
333 while (KEYMAPP (k
) && !EQ (keymap
, k
))
334 k
= Fkeymap_parent (k
);
336 error ("Cyclic keymap inheritance");
339 /* Skip past the initial element `keymap'. */
344 /* If there is a parent keymap here, replace it.
345 If we came to the end, add the parent in PREV. */
346 if (! CONSP (list
) || KEYMAPP (list
))
348 /* If we already have the right parent, return now
349 so that we avoid the loops below. */
350 if (EQ (XCDR (prev
), parent
))
351 RETURN_UNGCPRO (parent
);
353 XCDR (prev
) = parent
;
359 /* Scan through for submaps, and set their parents too. */
361 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
363 /* Stop the scan when we come to the parent. */
364 if (EQ (XCAR (list
), Qkeymap
))
367 /* If this element holds a prefix map, deal with it. */
368 if (CONSP (XCAR (list
))
369 && CONSP (XCDR (XCAR (list
))))
370 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
373 if (VECTORP (XCAR (list
)))
374 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
375 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
376 fix_submap_inheritance (keymap
, make_number (i
),
377 XVECTOR (XCAR (list
))->contents
[i
]);
379 if (CHAR_TABLE_P (XCAR (list
)))
381 Lisp_Object indices
[3];
383 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
),
388 RETURN_UNGCPRO (parent
);
391 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
392 if EVENT is also a prefix in MAP's parent,
393 make sure that SUBMAP inherits that definition as its own parent. */
396 fix_submap_inheritance (map
, event
, submap
)
397 Lisp_Object map
, event
, submap
;
399 Lisp_Object map_parent
, parent_entry
;
401 /* SUBMAP is a cons that we found as a key binding.
402 Discard the other things found in a menu key binding. */
406 /* May be an old format menu item */
407 if (STRINGP (XCAR (submap
)))
409 submap
= XCDR (submap
);
410 /* Also remove a menu help string, if any,
411 following the menu item name. */
412 if (CONSP (submap
) && STRINGP (XCAR (submap
)))
413 submap
= XCDR (submap
);
414 /* Also remove the sublist that caches key equivalences, if any. */
416 && CONSP (XCAR (submap
)))
419 carcar
= XCAR (XCAR (submap
));
420 if (NILP (carcar
) || VECTORP (carcar
))
421 submap
= XCDR (submap
);
425 /* Or a new format menu item */
426 else if (EQ (XCAR (submap
), Qmenu_item
)
427 && CONSP (XCDR (submap
)))
429 submap
= XCDR (XCDR (submap
));
431 submap
= XCAR (submap
);
435 /* If it isn't a keymap now, there's no work to do. */
437 || ! EQ (XCAR (submap
), Qkeymap
))
440 map_parent
= Fkeymap_parent (map
);
441 if (! NILP (map_parent
))
442 parent_entry
= access_keymap (map_parent
, event
, 0, 0);
446 /* If MAP's parent has something other than a keymap,
447 our own submap shadows it completely, so use nil as SUBMAP's parent. */
448 if (! (CONSP (parent_entry
) && EQ (XCAR (parent_entry
), Qkeymap
)))
451 if (! EQ (parent_entry
, submap
))
453 Lisp_Object submap_parent
;
454 submap_parent
= submap
;
458 tem
= Fkeymap_parent (submap_parent
);
459 if (EQ (tem
, parent_entry
))
462 && EQ (XCAR (tem
), Qkeymap
))
467 Fset_keymap_parent (submap_parent
, parent_entry
);
471 /* Look up IDX in MAP. IDX may be any sort of event.
472 Note that this does only one level of lookup; IDX must be a single
473 event, not a sequence.
475 If T_OK is non-zero, bindings for Qt are treated as default
476 bindings; any key left unmentioned by other tables and bindings is
477 given the binding of Qt.
479 If T_OK is zero, bindings for Qt are not treated specially.
481 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
484 access_keymap (map
, idx
, t_ok
, noinherit
)
493 /* If idx is a list (some sort of mouse click, perhaps?),
494 the index we want to use is the car of the list, which
495 ought to be a symbol. */
496 idx
= EVENT_HEAD (idx
);
498 /* If idx is a symbol, it might have modifiers, which need to
499 be put in the canonical order. */
501 idx
= reorder_modifiers (idx
);
502 else if (INTEGERP (idx
))
503 /* Clobber the high bits that can be present on a machine
504 with more than 24 bits of integer. */
505 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
509 Lisp_Object t_binding
;
512 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
516 binding
= XCAR (tail
);
517 if (SYMBOLP (binding
))
519 /* If NOINHERIT, stop finding prefix definitions
520 after we pass a second occurrence of the `keymap' symbol. */
521 if (noinherit
&& EQ (binding
, Qkeymap
) && ! EQ (tail
, map
))
524 else if (CONSP (binding
))
526 if (EQ (XCAR (binding
), idx
))
528 val
= XCDR (binding
);
529 if (noprefix
&& CONSP (val
) && EQ (XCAR (val
), Qkeymap
))
532 fix_submap_inheritance (map
, idx
, val
);
535 if (t_ok
&& EQ (XCAR (binding
), Qt
))
536 t_binding
= XCDR (binding
);
538 else if (VECTORP (binding
))
540 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
542 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
543 if (noprefix
&& CONSP (val
) && EQ (XCAR (val
), Qkeymap
))
546 fix_submap_inheritance (map
, idx
, val
);
550 else if (CHAR_TABLE_P (binding
))
552 /* Character codes with modifiers
553 are not included in a char-table.
554 All character codes without modifiers are included. */
557 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
558 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
560 val
= Faref (binding
, idx
);
561 if (noprefix
&& CONSP (val
) && EQ (XCAR (val
), Qkeymap
))
564 fix_submap_inheritance (map
, idx
, val
);
576 /* Given OBJECT which was found in a slot in a keymap,
577 trace indirect definitions to get the actual definition of that slot.
578 An indirect definition is a list of the form
579 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
580 and INDEX is the object to look up in KEYMAP to yield the definition.
582 Also if OBJECT has a menu string as the first element,
583 remove that. Also remove a menu help string as second element.
585 If AUTOLOAD is nonzero, load autoloadable keymaps
586 that are referred to with indirection. */
589 get_keyelt (object
, autoload
)
590 register Lisp_Object object
;
595 if (!(CONSP (object
)))
596 /* This is really the value. */
599 /* If the keymap contents looks like (keymap ...) or (lambda ...)
601 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
604 /* If the keymap contents looks like (menu-item name . DEFN)
605 or (menu-item name DEFN ...) then use DEFN.
606 This is a new format menu item. */
607 else if (EQ (XCAR (object
), Qmenu_item
))
609 if (CONSP (XCDR (object
)))
613 object
= XCDR (XCDR (object
));
616 object
= XCAR (object
);
618 /* If there's a `:filter FILTER', apply FILTER to the
619 menu-item's definition to get the real definition to
620 use. Temporarily inhibit GC while evaluating FILTER,
621 because not functions calling get_keyelt are prepared
623 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
624 if (EQ (XCAR (tem
), QCfilter
))
626 int count
= inhibit_garbage_collection ();
628 filter
= XCAR (XCDR (tem
));
629 filter
= list2 (filter
, list2 (Qquote
, object
));
630 object
= menu_item_eval_property (filter
);
631 unbind_to (count
, Qnil
);
640 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
641 Keymap alist elements like (CHAR MENUSTRING . DEFN)
642 will be used by HierarKey menus. */
643 else if (STRINGP (XCAR (object
)))
645 object
= XCDR (object
);
646 /* Also remove a menu help string, if any,
647 following the menu item name. */
648 if (CONSP (object
) && STRINGP (XCAR (object
)))
649 object
= XCDR (object
);
650 /* Also remove the sublist that caches key equivalences, if any. */
651 if (CONSP (object
) && CONSP (XCAR (object
)))
654 carcar
= XCAR (XCAR (object
));
655 if (NILP (carcar
) || VECTORP (carcar
))
656 object
= XCDR (object
);
660 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
665 map
= get_keymap_1 (Fcar_safe (object
), 0, autoload
);
673 if (INTEGERP (key
) && (XUINT (key
) & meta_modifier
))
675 object
= access_keymap (map
, meta_prefix_char
, 0, 0);
676 map
= get_keymap_1 (object
, 0, autoload
);
677 object
= access_keymap (map
, make_number (XINT (key
)
682 object
= access_keymap (map
, key
, 0, 0);
689 store_in_keymap (keymap
, idx
, def
)
691 register Lisp_Object idx
;
692 register Lisp_Object def
;
694 /* If we are preparing to dump, and DEF is a menu element
695 with a menu item indicator, copy it to ensure it is not pure. */
696 if (CONSP (def
) && PURE_P (def
)
697 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
698 def
= Fcons (XCAR (def
), XCDR (def
));
700 if (!CONSP (keymap
) || ! EQ (XCAR (keymap
), Qkeymap
))
701 error ("attempt to define a key in a non-keymap");
703 /* If idx is a list (some sort of mouse click, perhaps?),
704 the index we want to use is the car of the list, which
705 ought to be a symbol. */
706 idx
= EVENT_HEAD (idx
);
708 /* If idx is a symbol, it might have modifiers, which need to
709 be put in the canonical order. */
711 idx
= reorder_modifiers (idx
);
712 else if (INTEGERP (idx
))
713 /* Clobber the high bits that can be present on a machine
714 with more than 24 bits of integer. */
715 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
717 /* Scan the keymap for a binding of idx. */
721 /* The cons after which we should insert new bindings. If the
722 keymap has a table element, we record its position here, so new
723 bindings will go after it; this way, the table will stay
724 towards the front of the alist and character lookups in dense
725 keymaps will remain fast. Otherwise, this just points at the
726 front of the keymap. */
727 Lisp_Object insertion_point
;
729 insertion_point
= keymap
;
730 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
737 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (elt
)->size
)
739 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
742 insertion_point
= tail
;
744 else if (CHAR_TABLE_P (elt
))
746 /* Character codes with modifiers
747 are not included in a char-table.
748 All character codes without modifiers are included. */
751 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
752 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
754 Faset (elt
, idx
, def
);
757 insertion_point
= tail
;
759 else if (CONSP (elt
))
761 if (EQ (idx
, XCAR (elt
)))
767 else if (SYMBOLP (elt
))
769 /* If we find a 'keymap' symbol in the spine of KEYMAP,
770 then we must have found the start of a second keymap
771 being used as the tail of KEYMAP, and a binding for IDX
772 should be inserted before it. */
773 if (EQ (elt
, Qkeymap
))
781 /* We have scanned the entire keymap, and not found a binding for
782 IDX. Let's add one. */
783 XCDR (insertion_point
)
784 = Fcons (Fcons (idx
, def
), XCDR (insertion_point
));
791 copy_keymap_1 (chartable
, idx
, elt
)
792 Lisp_Object chartable
, idx
, elt
;
794 if (!SYMBOLP (elt
) && ! NILP (Fkeymapp (elt
)))
795 Faset (chartable
, idx
, Fcopy_keymap (elt
));
798 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
799 "Return a copy of the keymap KEYMAP.\n\
800 The copy starts out with the same definitions of KEYMAP,\n\
801 but changing either the copy or KEYMAP does not affect the other.\n\
802 Any key definitions that are subkeymaps are recursively copied.\n\
803 However, a key definition which is a symbol whose definition is a keymap\n\
808 register Lisp_Object copy
, tail
;
810 copy
= Fcopy_alist (get_keymap (keymap
));
812 for (tail
= copy
; CONSP (tail
); tail
= XCDR (tail
))
817 if (CHAR_TABLE_P (elt
))
819 Lisp_Object indices
[3];
821 elt
= Fcopy_sequence (elt
);
824 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
826 else if (VECTORP (elt
))
830 elt
= Fcopy_sequence (elt
);
833 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
834 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
835 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
836 XVECTOR (elt
)->contents
[i
]
837 = Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
839 else if (CONSP (elt
) && CONSP (XCDR (elt
)))
844 /* Is this a new format menu item. */
845 if (EQ (XCAR (tem
),Qmenu_item
))
847 /* Copy cell with menu-item marker. */
849 = Fcons (XCAR (tem
), XCDR (tem
));
854 /* Copy cell with menu-item name. */
856 = Fcons (XCAR (tem
), XCDR (tem
));
862 /* Copy cell with binding and if the binding is a keymap,
865 = Fcons (XCAR (tem
), XCDR (tem
));
868 if (!(SYMBOLP (tem
) || NILP (Fkeymapp (tem
))))
869 XCAR (elt
) = Fcopy_keymap (tem
);
871 if (CONSP (tem
) && CONSP (XCAR (tem
)))
872 /* Delete cache for key equivalences. */
873 XCDR (elt
) = XCDR (tem
);
878 /* It may be an old fomat menu item.
879 Skip the optional menu string.
881 if (STRINGP (XCAR (tem
)))
883 /* Copy the cell, since copy-alist didn't go this deep. */
885 = Fcons (XCAR (tem
), XCDR (tem
));
888 /* Also skip the optional menu help string. */
889 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
892 = Fcons (XCAR (tem
), XCDR (tem
));
896 /* There may also be a list that caches key equivalences.
897 Just delete it for the new keymap. */
899 && CONSP (XCAR (tem
))
900 && (NILP (XCAR (XCAR (tem
)))
901 || VECTORP (XCAR (XCAR (tem
)))))
902 XCDR (elt
) = XCDR (tem
);
905 && ! SYMBOLP (XCDR (elt
))
906 && ! NILP (Fkeymapp (XCDR (elt
))))
907 XCDR (elt
) = Fcopy_keymap (XCDR (elt
));
916 /* Simple Keymap mutators and accessors. */
918 /* GC is possible in this function if it autoloads a keymap. */
920 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
921 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
922 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
923 meaning a sequence of keystrokes and events.\n\
924 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
925 can be included if you use a vector.\n\
926 DEF is anything that can be a key's definition:\n\
927 nil (means key is undefined in this keymap),\n\
928 a command (a Lisp function suitable for interactive calling)\n\
929 a string (treated as a keyboard macro),\n\
930 a keymap (to define a prefix key),\n\
931 a symbol. When the key is looked up, the symbol will stand for its\n\
932 function definition, which should at that time be one of the above,\n\
933 or another symbol whose function definition is used, etc.\n\
934 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
935 (DEFN should be a valid definition in its own right),\n\
936 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
938 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
939 the front of KEYMAP.")
946 register Lisp_Object c
;
947 register Lisp_Object cmd
;
951 struct gcpro gcpro1
, gcpro2
, gcpro3
;
953 keymap
= get_keymap_1 (keymap
, 1, 1);
955 if (!VECTORP (key
) && !STRINGP (key
))
956 key
= wrong_type_argument (Qarrayp
, key
);
958 length
= XFASTINT (Flength (key
));
962 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
963 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
965 GCPRO3 (keymap
, key
, def
);
968 meta_bit
= meta_modifier
;
975 c
= Faref (key
, make_number (idx
));
977 if (CONSP (c
) && lucid_event_type_list_p (c
))
978 c
= Fevent_convert_list (c
);
981 && (XINT (c
) & meta_bit
)
984 c
= meta_prefix_char
;
990 XSETINT (c
, XINT (c
) & ~meta_bit
);
996 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
997 error ("Key sequence contains invalid events");
1000 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1002 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1), 1);
1004 /* If this key is undefined, make it a prefix. */
1006 cmd
= define_as_prefix (keymap
, c
);
1008 keymap
= get_keymap_1 (cmd
, 0, 1);
1010 /* We must use Fkey_description rather than just passing key to
1011 error; key might be a vector, not a string. */
1012 error ("Key sequence %s uses invalid prefix characters",
1013 XSTRING (Fkey_description (key
))->data
);
1017 /* Value is number if KEY is too long; NIL if valid but has no definition. */
1018 /* GC is possible in this function if it autoloads a keymap. */
1020 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1021 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
1022 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
1024 A number as value means KEY is \"too long\";\n\
1025 that is, characters or symbols in it except for the last one\n\
1026 fail to be a valid sequence of prefix characters in KEYMAP.\n\
1027 The number is how many characters at the front of KEY\n\
1028 it takes to reach a non-prefix command.\n\
1030 Normally, `lookup-key' ignores bindings for t, which act as default\n\
1031 bindings, used when nothing else in the keymap applies; this makes it\n\
1032 usable as a general function for probing keymaps. However, if the\n\
1033 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
1034 recognize the default bindings, just as `read-key-sequence' does.")
1035 (keymap
, key
, accept_default
)
1036 register Lisp_Object keymap
;
1038 Lisp_Object accept_default
;
1041 register Lisp_Object cmd
;
1042 register Lisp_Object c
;
1045 int t_ok
= ! NILP (accept_default
);
1047 struct gcpro gcpro1
;
1049 keymap
= get_keymap_1 (keymap
, 1, 1);
1051 if (!VECTORP (key
) && !STRINGP (key
))
1052 key
= wrong_type_argument (Qarrayp
, key
);
1054 length
= XFASTINT (Flength (key
));
1059 meta_bit
= meta_modifier
;
1068 c
= Faref (key
, make_number (idx
));
1070 if (CONSP (c
) && lucid_event_type_list_p (c
))
1071 c
= Fevent_convert_list (c
);
1074 && (XINT (c
) & meta_bit
)
1077 c
= meta_prefix_char
;
1083 XSETINT (c
, XINT (c
) & ~meta_bit
);
1089 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0), 1);
1091 RETURN_UNGCPRO (cmd
);
1093 keymap
= get_keymap_1 (cmd
, 0, 1);
1095 RETURN_UNGCPRO (make_number (idx
));
1101 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1102 Assume that currently it does not define C at all.
1103 Return the keymap. */
1106 define_as_prefix (keymap
, c
)
1107 Lisp_Object keymap
, c
;
1109 Lisp_Object inherit
, cmd
;
1111 cmd
= Fmake_sparse_keymap (Qnil
);
1112 /* If this key is defined as a prefix in an inherited keymap,
1113 make it a prefix in this map, and make its definition
1114 inherit the other prefix definition. */
1115 inherit
= access_keymap (keymap
, c
, 0, 0);
1117 /* This code is needed to do the right thing in the following case:
1118 keymap A inherits from B,
1119 you define KEY as a prefix in A,
1120 then later you define KEY as a prefix in B.
1121 We want the old prefix definition in A to inherit from that in B.
1122 It is hard to do that retroactively, so this code
1123 creates the prefix in B right away.
1125 But it turns out that this code causes problems immediately
1126 when the prefix in A is defined: it causes B to define KEY
1127 as a prefix with no subcommands.
1129 So I took out this code. */
1132 /* If there's an inherited keymap
1133 and it doesn't define this key,
1134 make it define this key. */
1137 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCDR (tail
))
1138 if (EQ (XCAR (tail
), Qkeymap
))
1142 inherit
= define_as_prefix (tail
, c
);
1146 cmd
= nconc2 (cmd
, inherit
);
1147 store_in_keymap (keymap
, c
, cmd
);
1152 /* Append a key to the end of a key sequence. We always make a vector. */
1155 append_key (key_sequence
, key
)
1156 Lisp_Object key_sequence
, key
;
1158 Lisp_Object args
[2];
1160 args
[0] = key_sequence
;
1162 args
[1] = Fcons (key
, Qnil
);
1163 return Fvconcat (2, args
);
1167 /* Global, local, and minor mode keymap stuff. */
1169 /* We can't put these variables inside current_minor_maps, since under
1170 some systems, static gets macro-defined to be the empty string.
1172 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1173 static int cmm_size
;
1175 /* Error handler used in current_minor_maps. */
1177 current_minor_maps_error ()
1182 /* Store a pointer to an array of the keymaps of the currently active
1183 minor modes in *buf, and return the number of maps it contains.
1185 This function always returns a pointer to the same buffer, and may
1186 free or reallocate it, so if you want to keep it for a long time or
1187 hand it out to lisp code, copy it. This procedure will be called
1188 for every key sequence read, so the nice lispy approach (return a
1189 new assoclist, list, what have you) for each invocation would
1190 result in a lot of consing over time.
1192 If we used xrealloc/xmalloc and ran out of memory, they would throw
1193 back to the command loop, which would try to read a key sequence,
1194 which would call this function again, resulting in an infinite
1195 loop. Instead, we'll use realloc/malloc and silently truncate the
1196 list, let the key sequence be read, and hope some other piece of
1197 code signals the error. */
1199 current_minor_maps (modeptr
, mapptr
)
1200 Lisp_Object
**modeptr
, **mapptr
;
1203 int list_number
= 0;
1204 Lisp_Object alist
, assoc
, var
, val
;
1205 Lisp_Object lists
[2];
1207 lists
[0] = Vminor_mode_overriding_map_alist
;
1208 lists
[1] = Vminor_mode_map_alist
;
1210 for (list_number
= 0; list_number
< 2; list_number
++)
1211 for (alist
= lists
[list_number
];
1213 alist
= XCDR (alist
))
1214 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1215 && (var
= XCAR (assoc
), SYMBOLP (var
))
1216 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1221 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1222 and also an entry in Vminor_mode_map_alist,
1223 ignore the latter. */
1224 if (list_number
== 1)
1226 val
= assq_no_quit (var
, lists
[0]);
1233 Lisp_Object
*newmodes
, *newmaps
;
1240 = (Lisp_Object
*) realloc (cmm_modes
,
1241 cmm_size
* sizeof (Lisp_Object
));
1243 = (Lisp_Object
*) realloc (cmm_maps
,
1244 cmm_size
* sizeof (Lisp_Object
));
1252 = (Lisp_Object
*) xmalloc (cmm_size
* sizeof (Lisp_Object
));
1254 = (Lisp_Object
*) xmalloc (cmm_size
* sizeof (Lisp_Object
));
1258 if (newmaps
&& newmodes
)
1260 cmm_modes
= newmodes
;
1267 /* Get the keymap definition--or nil if it is not defined. */
1268 temp
= internal_condition_case_1 (Findirect_function
,
1270 Qerror
, current_minor_maps_error
);
1274 cmm_maps
[i
] = temp
;
1279 if (modeptr
) *modeptr
= cmm_modes
;
1280 if (mapptr
) *mapptr
= cmm_maps
;
1284 /* GC is possible in this function if it autoloads a keymap. */
1286 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1287 "Return the binding for command KEY in current keymaps.\n\
1288 KEY is a string or vector, a sequence of keystrokes.\n\
1289 The binding is probably a symbol with a function definition.\n\
1291 Normally, `key-binding' ignores bindings for t, which act as default\n\
1292 bindings, used when nothing else in the keymap applies; this makes it\n\
1293 usable as a general function for probing keymaps. However, if the\n\
1294 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1295 recognize the default bindings, just as `read-key-sequence' does.")
1296 (key
, accept_default
)
1297 Lisp_Object key
, accept_default
;
1299 Lisp_Object
*maps
, value
;
1301 struct gcpro gcpro1
;
1305 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1307 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1308 key
, accept_default
);
1309 if (! NILP (value
) && !INTEGERP (value
))
1310 RETURN_UNGCPRO (value
);
1312 else if (!NILP (Voverriding_local_map
))
1314 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1315 if (! NILP (value
) && !INTEGERP (value
))
1316 RETURN_UNGCPRO (value
);
1322 nmaps
= current_minor_maps (0, &maps
);
1323 /* Note that all these maps are GCPRO'd
1324 in the places where we found them. */
1326 for (i
= 0; i
< nmaps
; i
++)
1327 if (! NILP (maps
[i
]))
1329 value
= Flookup_key (maps
[i
], key
, accept_default
);
1330 if (! NILP (value
) && !INTEGERP (value
))
1331 RETURN_UNGCPRO (value
);
1334 local
= get_local_map (PT
, current_buffer
, keymap
);
1337 value
= Flookup_key (local
, key
, accept_default
);
1338 if (! NILP (value
) && !INTEGERP (value
))
1339 RETURN_UNGCPRO (value
);
1342 local
= get_local_map (PT
, current_buffer
, local_map
);
1346 value
= Flookup_key (local
, key
, accept_default
);
1347 if (! NILP (value
) && !INTEGERP (value
))
1348 RETURN_UNGCPRO (value
);
1352 value
= Flookup_key (current_global_map
, key
, accept_default
);
1354 if (! NILP (value
) && !INTEGERP (value
))
1360 /* GC is possible in this function if it autoloads a keymap. */
1362 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1363 "Return the binding for command KEYS in current local keymap only.\n\
1364 KEYS is a string, a sequence of keystrokes.\n\
1365 The binding is probably a symbol with a function definition.\n\
1367 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1368 bindings; see the description of `lookup-key' for more details about this.")
1369 (keys
, accept_default
)
1370 Lisp_Object keys
, accept_default
;
1372 register Lisp_Object map
;
1373 map
= current_buffer
->keymap
;
1376 return Flookup_key (map
, keys
, accept_default
);
1379 /* GC is possible in this function if it autoloads a keymap. */
1381 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1382 "Return the binding for command KEYS in current global keymap only.\n\
1383 KEYS is a string, a sequence of keystrokes.\n\
1384 The binding is probably a symbol with a function definition.\n\
1385 This function's return values are the same as those of lookup-key\n\
1388 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1389 bindings; see the description of `lookup-key' for more details about this.")
1390 (keys
, accept_default
)
1391 Lisp_Object keys
, accept_default
;
1393 return Flookup_key (current_global_map
, keys
, accept_default
);
1396 /* GC is possible in this function if it autoloads a keymap. */
1398 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1399 "Find the visible minor mode bindings of KEY.\n\
1400 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1401 the symbol which names the minor mode binding KEY, and BINDING is\n\
1402 KEY's definition in that mode. In particular, if KEY has no\n\
1403 minor-mode bindings, return nil. If the first binding is a\n\
1404 non-prefix, all subsequent bindings will be omitted, since they would\n\
1405 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1406 that come after prefix bindings.\n\
1408 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1409 bindings; see the description of `lookup-key' for more details about this.")
1410 (key
, accept_default
)
1411 Lisp_Object key
, accept_default
;
1413 Lisp_Object
*modes
, *maps
;
1415 Lisp_Object binding
;
1417 struct gcpro gcpro1
, gcpro2
;
1419 nmaps
= current_minor_maps (&modes
, &maps
);
1420 /* Note that all these maps are GCPRO'd
1421 in the places where we found them. */
1424 GCPRO2 (key
, binding
);
1426 for (i
= j
= 0; i
< nmaps
; i
++)
1427 if (! NILP (maps
[i
])
1428 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1429 && !INTEGERP (binding
))
1431 if (! NILP (get_keymap (binding
)))
1432 maps
[j
++] = Fcons (modes
[i
], binding
);
1434 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1438 return Flist (j
, maps
);
1441 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1442 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1443 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1444 If a second optional argument MAPVAR is given, the map is stored as\n\
1445 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1447 The third optional argument NAME, if given, supplies a menu name\n\
1448 string for the map. This is required to use the keymap as a menu.")
1449 (command
, mapvar
, name
)
1450 Lisp_Object command
, mapvar
, name
;
1453 map
= Fmake_sparse_keymap (name
);
1454 Ffset (command
, map
);
1458 Fset (command
, map
);
1462 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1463 "Select KEYMAP as the global keymap.")
1467 keymap
= get_keymap (keymap
);
1468 current_global_map
= keymap
;
1473 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1474 "Select KEYMAP as the local keymap.\n\
1475 If KEYMAP is nil, that means no local keymap.")
1480 keymap
= get_keymap (keymap
);
1482 current_buffer
->keymap
= keymap
;
1487 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1488 "Return current buffer's local keymap, or nil if it has none.")
1491 return current_buffer
->keymap
;
1494 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1495 "Return the current global keymap.")
1498 return current_global_map
;
1501 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1502 "Return a list of keymaps for the minor modes of the current buffer.")
1506 int nmaps
= current_minor_maps (0, &maps
);
1508 return Flist (nmaps
, maps
);
1511 /* Help functions for describing and documenting keymaps. */
1513 static void accessible_keymaps_char_table ();
1515 /* This function cannot GC. */
1517 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1519 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1520 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1521 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1522 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1523 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1524 then the value includes only maps for prefixes that start with PREFIX.")
1526 Lisp_Object keymap
, prefix
;
1528 Lisp_Object maps
, good_maps
, tail
;
1531 /* no need for gcpro because we don't autoload any keymaps. */
1534 prefixlen
= XINT (Flength (prefix
));
1538 /* If a prefix was specified, start with the keymap (if any) for
1539 that prefix, so we don't waste time considering other prefixes. */
1541 tem
= Flookup_key (keymap
, prefix
, Qt
);
1542 /* Flookup_key may give us nil, or a number,
1543 if the prefix is not defined in this particular map.
1544 It might even give us a list that isn't a keymap. */
1545 tem
= get_keymap_1 (tem
, 0, 0);
1548 /* Convert PREFIX to a vector now, so that later on
1549 we don't have to deal with the possibility of a string. */
1550 if (STRINGP (prefix
))
1555 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1556 for (i
= 0, i_byte
= 0; i
< XSTRING (prefix
)->size
;)
1560 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1561 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1562 c
^= 0200 | meta_modifier
;
1563 XVECTOR (copy
)->contents
[i_before
] = make_number (c
);
1567 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1573 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1574 get_keymap (keymap
)),
1577 /* For each map in the list maps,
1578 look at any other maps it points to,
1579 and stick them at the end if they are not already in the list.
1581 This is a breadth-first traversal, where tail is the queue of
1582 nodes, and maps accumulates a list of all nodes visited. */
1584 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1586 register Lisp_Object thisseq
, thismap
;
1588 /* Does the current sequence end in the meta-prefix-char? */
1591 thisseq
= Fcar (Fcar (tail
));
1592 thismap
= Fcdr (Fcar (tail
));
1593 last
= make_number (XINT (Flength (thisseq
)) - 1);
1594 is_metized
= (XINT (last
) >= 0
1595 /* Don't metize the last char of PREFIX. */
1596 && XINT (last
) >= prefixlen
1597 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1599 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1603 elt
= XCAR (thismap
);
1607 if (CHAR_TABLE_P (elt
))
1609 Lisp_Object indices
[3];
1611 map_char_table (accessible_keymaps_char_table
, Qnil
,
1612 elt
, Fcons (maps
, Fcons (tail
, thisseq
)),
1615 else if (VECTORP (elt
))
1619 /* Vector keymap. Scan all the elements. */
1620 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1622 register Lisp_Object tem
;
1623 register Lisp_Object cmd
;
1625 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1626 if (NILP (cmd
)) continue;
1627 tem
= Fkeymapp (cmd
);
1630 cmd
= get_keymap (cmd
);
1631 /* Ignore keymaps that are already added to maps. */
1632 tem
= Frassq (cmd
, maps
);
1635 /* If the last key in thisseq is meta-prefix-char,
1636 turn it into a meta-ized keystroke. We know
1637 that the event we're about to append is an
1638 ascii keystroke since we're processing a
1642 int meta_bit
= meta_modifier
;
1643 tem
= Fcopy_sequence (thisseq
);
1645 Faset (tem
, last
, make_number (i
| meta_bit
));
1647 /* This new sequence is the same length as
1648 thisseq, so stick it in the list right
1651 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1655 tem
= append_key (thisseq
, make_number (i
));
1656 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1662 else if (CONSP (elt
))
1664 register Lisp_Object cmd
, tem
;
1666 cmd
= get_keyelt (XCDR (elt
), 0);
1667 /* Ignore definitions that aren't keymaps themselves. */
1668 tem
= Fkeymapp (cmd
);
1671 /* Ignore keymaps that have been seen already. */
1672 cmd
= get_keymap (cmd
);
1673 tem
= Frassq (cmd
, maps
);
1676 /* Let elt be the event defined by this map entry. */
1679 /* If the last key in thisseq is meta-prefix-char, and
1680 this entry is a binding for an ascii keystroke,
1681 turn it into a meta-ized keystroke. */
1682 if (is_metized
&& INTEGERP (elt
))
1684 Lisp_Object element
;
1687 tem
= Fvconcat (1, &element
);
1688 XSETFASTINT (XVECTOR (tem
)->contents
[XINT (last
)],
1689 XINT (elt
) | meta_modifier
);
1691 /* This new sequence is the same length as
1692 thisseq, so stick it in the list right
1695 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1699 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1710 /* Now find just the maps whose access prefixes start with PREFIX. */
1713 for (; CONSP (maps
); maps
= XCDR (maps
))
1715 Lisp_Object elt
, thisseq
;
1717 thisseq
= XCAR (elt
);
1718 /* The access prefix must be at least as long as PREFIX,
1719 and the first elements must match those of PREFIX. */
1720 if (XINT (Flength (thisseq
)) >= prefixlen
)
1723 for (i
= 0; i
< prefixlen
; i
++)
1726 XSETFASTINT (i1
, i
);
1727 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1731 good_maps
= Fcons (elt
, good_maps
);
1735 return Fnreverse (good_maps
);
1739 accessible_keymaps_char_table (args
, index
, cmd
)
1740 Lisp_Object args
, index
, cmd
;
1743 Lisp_Object maps
, tail
, thisseq
;
1749 tail
= XCAR (XCDR (args
));
1750 thisseq
= XCDR (XCDR (args
));
1752 tem
= Fkeymapp (cmd
);
1755 cmd
= get_keymap (cmd
);
1756 /* Ignore keymaps that are already added to maps. */
1757 tem
= Frassq (cmd
, maps
);
1760 tem
= append_key (thisseq
, index
);
1761 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1766 Lisp_Object Qsingle_key_description
, Qkey_description
;
1768 /* This function cannot GC. */
1770 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1771 "Return a pretty description of key-sequence KEYS.\n\
1772 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1773 spaces are put between sequence elements, etc.")
1780 Lisp_Object
*args
= NULL
;
1785 vector
= Fmake_vector (Flength (keys
), Qnil
);
1786 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1791 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1792 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1793 c
^= 0200 | meta_modifier
;
1794 XSETFASTINT (XVECTOR (vector
)->contents
[i_before
], c
);
1801 /* In effect, this computes
1802 (mapconcat 'single-key-description keys " ")
1803 but we shouldn't use mapconcat because it can do GC. */
1805 len
= XVECTOR (keys
)->size
;
1806 sep
= build_string (" ");
1807 /* This has one extra element at the end that we don't pass to Fconcat. */
1808 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1810 for (i
= 0; i
< len
; i
++)
1812 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
],
1814 args
[i
* 2 + 1] = sep
;
1817 else if (CONSP (keys
))
1819 /* In effect, this computes
1820 (mapconcat 'single-key-description keys " ")
1821 but we shouldn't use mapconcat because it can do GC. */
1823 len
= XFASTINT (Flength (keys
));
1824 sep
= build_string (" ");
1825 /* This has one extra element at the end that we don't pass to Fconcat. */
1826 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1828 for (i
= 0; i
< len
; i
++)
1830 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1831 args
[i
* 2 + 1] = sep
;
1836 keys
= wrong_type_argument (Qarrayp
, keys
);
1838 return Fconcat (len
* 2 - 1, args
);
1842 push_key_description (c
, p
)
1843 register unsigned int c
;
1848 /* Clear all the meaningless bits above the meta bit. */
1849 c
&= meta_modifier
| ~ - meta_modifier
;
1850 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1851 | meta_modifier
| shift_modifier
| super_modifier
);
1853 if (c
& alt_modifier
)
1859 if ((c
& ctrl_modifier
) != 0
1860 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1864 c
&= ~ctrl_modifier
;
1866 if (c
& hyper_modifier
)
1870 c
-= hyper_modifier
;
1872 if (c
& meta_modifier
)
1878 if (c
& shift_modifier
)
1882 c
-= shift_modifier
;
1884 if (c
& super_modifier
)
1888 c
-= super_modifier
;
1904 else if (c
== Ctl ('M'))
1912 /* `C-' already added above. */
1913 if (c
> 0 && c
<= Ctl ('Z'))
1932 || (NILP (current_buffer
->enable_multibyte_characters
)
1933 && SINGLE_BYTE_CHAR_P (c
)))
1937 if (! NILP (current_buffer
->enable_multibyte_characters
))
1938 c
= unibyte_char_to_multibyte (c
);
1940 if (NILP (current_buffer
->enable_multibyte_characters
)
1941 || SINGLE_BYTE_CHAR_P (c
)
1942 || ! char_valid_p (c
, 0))
1946 /* The biggest character code uses 19 bits. */
1947 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1949 if (c
>= (1 << bit_offset
))
1950 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1955 p
+= CHAR_STRING (c
, p
);
1962 /* This function cannot GC. */
1964 DEFUN ("single-key-description", Fsingle_key_description
,
1965 Ssingle_key_description
, 1, 2, 0,
1966 "Return a pretty description of command character KEY.\n\
1967 Control characters turn into C-whatever, etc.\n\
1968 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1969 around function keys and event symbols.")
1971 Lisp_Object key
, no_angles
;
1973 if (CONSP (key
) && lucid_event_type_list_p (key
))
1974 key
= Fevent_convert_list (key
);
1976 key
= EVENT_HEAD (key
);
1978 if (INTEGERP (key
)) /* Normal character */
1980 unsigned int charset
, c1
, c2
;
1981 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1983 if (SINGLE_BYTE_CHAR_P (without_bits
))
1986 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1989 && CHARSET_DEFINED_P (charset
)
1990 && ((c1
>= 0 && c1
< 32)
1991 || (c2
>= 0 && c2
< 32)))
1993 /* Handle a generic character. */
1995 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1996 CHECK_STRING (name
, 0);
1997 return concat2 (build_string ("Character set "), name
);
2001 char tem
[KEY_DESCRIPTION_SIZE
];
2003 *push_key_description (XUINT (key
), tem
) = 0;
2004 return build_string (tem
);
2007 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2009 if (NILP (no_angles
))
2012 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
2013 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
2014 return build_string (buffer
);
2017 return Fsymbol_name (key
);
2019 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2020 return Fcopy_sequence (key
);
2022 error ("KEY must be an integer, cons, symbol, or string");
2027 push_text_char_description (c
, p
)
2028 register unsigned int c
;
2040 *p
++ = c
+ 64; /* 'A' - 1 */
2052 /* This function cannot GC. */
2054 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2055 "Return a pretty description of file-character CHARACTER.\n\
2056 Control characters turn into \"^char\", etc.")
2058 Lisp_Object character
;
2060 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2061 unsigned char str
[6];
2064 CHECK_NUMBER (character
, 0);
2066 c
= XINT (character
);
2067 if (!SINGLE_BYTE_CHAR_P (c
))
2069 int len
= CHAR_STRING (c
, str
);
2071 return make_multibyte_string (str
, 1, len
);
2074 *push_text_char_description (c
& 0377, str
) = 0;
2076 return build_string (str
);
2079 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2082 ascii_sequence_p (seq
)
2086 int len
= XINT (Flength (seq
));
2088 for (i
= 0; i
< len
; i
++)
2090 Lisp_Object ii
, elt
;
2092 XSETFASTINT (ii
, i
);
2093 elt
= Faref (seq
, ii
);
2096 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2104 /* where-is - finding a command in a set of keymaps. */
2106 static Lisp_Object
where_is_internal_1 ();
2107 static void where_is_internal_2 ();
2109 /* This function can GC if Flookup_key autoloads any keymaps. */
2111 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2112 "Return list of keys that invoke DEFINITION.\n\
2113 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2114 If KEYMAP is nil, search all the currently active keymaps.\n\
2116 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2117 rather than a list of all possible key sequences.\n\
2118 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2119 no matter what it is.\n\
2120 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2121 and entirely reject menu bindings.\n\
2123 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2124 to other keymaps or slots. This makes it possible to search for an\n\
2125 indirect definition itself.")
2126 (definition
, xkeymap
, firstonly
, noindirect
)
2127 Lisp_Object definition
, xkeymap
;
2128 Lisp_Object firstonly
, noindirect
;
2131 Lisp_Object found
, sequences
;
2132 Lisp_Object keymap1
;
2133 int keymap_specified
= !NILP (xkeymap
);
2134 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2135 /* 1 means ignore all menu bindings entirely. */
2136 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2138 /* Find keymaps accessible from `keymap' or the current
2139 context. But don't muck with the value of `keymap',
2140 because `where_is_internal_1' uses it to check for
2141 shadowed bindings. */
2143 if (! keymap_specified
)
2144 keymap1
= get_local_map (PT
, current_buffer
, keymap
);
2146 if (!NILP (keymap1
))
2147 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap1
), Qnil
),
2148 Faccessible_keymaps (get_keymap (current_global_map
),
2153 if (! keymap_specified
)
2154 keymap1
= get_local_map (PT
, current_buffer
, local_map
);
2156 if (!NILP (keymap1
))
2157 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap1
), Qnil
),
2158 Faccessible_keymaps (get_keymap (current_global_map
),
2161 maps
= Faccessible_keymaps (get_keymap (current_global_map
), Qnil
);
2164 /* Put the minor mode keymaps on the front. */
2165 if (! keymap_specified
)
2168 minors
= Fnreverse (Fcurrent_minor_mode_maps ());
2169 while (!NILP (minors
))
2171 maps
= nconc2 (Faccessible_keymaps (get_keymap (XCAR (minors
)),
2174 minors
= XCDR (minors
);
2178 GCPRO5 (definition
, xkeymap
, maps
, found
, sequences
);
2182 for (; !NILP (maps
); maps
= Fcdr (maps
))
2184 /* Key sequence to reach map, and the map that it reaches */
2185 register Lisp_Object
this, map
;
2187 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2188 [M-CHAR] sequences, check if last character of the sequence
2189 is the meta-prefix char. */
2193 this = Fcar (Fcar (maps
));
2194 map
= Fcdr (Fcar (maps
));
2195 last
= make_number (XINT (Flength (this)) - 1);
2196 last_is_meta
= (XINT (last
) >= 0
2197 && EQ (Faref (this, last
), meta_prefix_char
));
2203 /* Because the code we want to run on each binding is rather
2204 large, we don't want to have two separate loop bodies for
2205 sparse keymap bindings and tables; we want to iterate one
2206 loop body over both keymap and vector bindings.
2208 For this reason, if Fcar (map) is a vector, we don't
2209 advance map to the next element until i indicates that we
2210 have finished off the vector. */
2211 Lisp_Object elt
, key
, binding
;
2219 /* Set key and binding to the current key and binding, and
2220 advance map and i to the next binding. */
2223 Lisp_Object sequence
;
2225 /* In a vector, look at each element. */
2226 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2228 binding
= XVECTOR (elt
)->contents
[i
];
2229 XSETFASTINT (key
, i
);
2230 sequence
= where_is_internal_1 (binding
, key
, definition
,
2231 noindirect
, xkeymap
, this,
2232 last
, nomenus
, last_is_meta
);
2233 if (!NILP (sequence
))
2234 sequences
= Fcons (sequence
, sequences
);
2237 else if (CHAR_TABLE_P (elt
))
2239 Lisp_Object indices
[3];
2242 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2243 Fcons (xkeymap
, Qnil
)),
2244 Fcons (Fcons (this, last
),
2245 Fcons (make_number (nomenus
),
2246 make_number (last_is_meta
))));
2247 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2249 sequences
= XCDR (XCDR (XCAR (args
)));
2251 else if (CONSP (elt
))
2253 Lisp_Object sequence
;
2256 binding
= XCDR (elt
);
2258 sequence
= where_is_internal_1 (binding
, key
, definition
,
2259 noindirect
, xkeymap
, this,
2260 last
, nomenus
, last_is_meta
);
2261 if (!NILP (sequence
))
2262 sequences
= Fcons (sequence
, sequences
);
2266 for (; ! NILP (sequences
); sequences
= XCDR (sequences
))
2268 Lisp_Object sequence
;
2270 sequence
= XCAR (sequences
);
2272 /* It is a true unshadowed match. Record it, unless it's already
2273 been seen (as could happen when inheriting keymaps). */
2274 if (NILP (Fmember (sequence
, found
)))
2275 found
= Fcons (sequence
, found
);
2277 /* If firstonly is Qnon_ascii, then we can return the first
2278 binding we find. If firstonly is not Qnon_ascii but not
2279 nil, then we should return the first ascii-only binding
2281 if (EQ (firstonly
, Qnon_ascii
))
2282 RETURN_UNGCPRO (sequence
);
2283 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2284 RETURN_UNGCPRO (sequence
);
2291 found
= Fnreverse (found
);
2293 /* firstonly may have been t, but we may have gone all the way through
2294 the keymaps without finding an all-ASCII key sequence. So just
2295 return the best we could find. */
2296 if (! NILP (firstonly
))
2297 return Fcar (found
);
2302 /* This is the function that Fwhere_is_internal calls using map_char_table.
2304 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2306 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2307 Since map_char_table doesn't really use the return value from this function,
2308 we the result append to RESULT, the slot in ARGS.
2310 This function can GC because it calls where_is_internal_1 which can
2314 where_is_internal_2 (args
, key
, binding
)
2315 Lisp_Object args
, key
, binding
;
2317 Lisp_Object definition
, noindirect
, keymap
, this, last
;
2318 Lisp_Object result
, sequence
;
2319 int nomenus
, last_is_meta
;
2320 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2322 GCPRO3 (args
, key
, binding
);
2323 result
= XCDR (XCDR (XCAR (args
)));
2324 definition
= XCAR (XCAR (XCAR (args
)));
2325 noindirect
= XCDR (XCAR (XCAR (args
)));
2326 keymap
= XCAR (XCDR (XCAR (args
)));
2327 this = XCAR (XCAR (XCDR (args
)));
2328 last
= XCDR (XCAR (XCDR (args
)));
2329 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2330 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2332 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
,
2333 this, last
, nomenus
, last_is_meta
);
2335 if (!NILP (sequence
))
2336 XCDR (XCDR (XCAR (args
))) = Fcons (sequence
, result
);
2342 /* This function can GC.because Flookup_key calls get_keymap_1 with
2343 non-zero argument AUTOLOAD. */
2346 where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
, this, last
,
2347 nomenus
, last_is_meta
)
2348 Lisp_Object binding
, key
, definition
, noindirect
, keymap
, this, last
;
2349 int nomenus
, last_is_meta
;
2351 Lisp_Object sequence
;
2352 int keymap_specified
= !NILP (keymap
);
2353 struct gcpro gcpro1
, gcpro2
;
2355 /* Search through indirections unless that's not wanted. */
2356 if (NILP (noindirect
))
2362 Lisp_Object map
, tem
;
2363 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
2364 map
= get_keymap_1 (Fcar_safe (definition
), 0, 0);
2365 tem
= Fkeymapp (map
);
2367 definition
= access_keymap (map
, Fcdr (definition
), 0, 0);
2371 /* If the contents are (menu-item ...) or (STRING ...), reject. */
2372 if (CONSP (definition
)
2373 && (EQ (XCAR (definition
),Qmenu_item
)
2374 || STRINGP (XCAR (definition
))))
2378 binding
= get_keyelt (binding
, 0);
2381 /* End this iteration if this element does not match
2384 if (CONSP (definition
))
2387 tem
= Fequal (binding
, definition
);
2392 if (!EQ (binding
, definition
))
2395 /* We have found a match.
2396 Construct the key sequence where we found it. */
2397 if (INTEGERP (key
) && last_is_meta
)
2399 sequence
= Fcopy_sequence (this);
2400 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2403 sequence
= append_key (this, key
);
2405 /* Verify that this key binding is not shadowed by another
2406 binding for the same key, before we say it exists.
2408 Mechanism: look for local definition of this key and if
2409 it is defined and does not match what we found then
2412 Either nil or number as value from Flookup_key
2414 GCPRO2 (sequence
, binding
);
2415 if (keymap_specified
)
2417 binding
= Flookup_key (keymap
, sequence
, Qnil
);
2418 if (!NILP (binding
) && !INTEGERP (binding
))
2420 if (CONSP (definition
))
2423 tem
= Fequal (binding
, definition
);
2425 RETURN_UNGCPRO (Qnil
);
2428 if (!EQ (binding
, definition
))
2429 RETURN_UNGCPRO (Qnil
);
2434 binding
= Fkey_binding (sequence
, Qnil
);
2435 if (!EQ (binding
, definition
))
2436 RETURN_UNGCPRO (Qnil
);
2439 RETURN_UNGCPRO (sequence
);
2442 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2444 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal
, Sdescribe_bindings_internal
, 0, 2, "",
2445 "Show a list of all defined keys, and their definitions.\n\
2446 We put that list in a buffer, and display the buffer.\n\
2448 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2449 \(Ordinarily these are omitted from the output.)\n\
2450 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2451 then we display only bindings that start with that prefix.")
2453 Lisp_Object menus
, prefix
;
2455 register Lisp_Object thisbuf
;
2456 XSETBUFFER (thisbuf
, current_buffer
);
2457 internal_with_output_to_temp_buffer ("*Help*",
2458 describe_buffer_bindings
,
2459 list3 (thisbuf
, prefix
, menus
));
2463 /* ARG is (BUFFER PREFIX MENU-FLAG). */
2466 describe_buffer_bindings (arg
)
2469 Lisp_Object descbuf
, prefix
, shadow
;
2471 register Lisp_Object start1
;
2472 struct gcpro gcpro1
;
2474 char *alternate_heading
2476 Keyboard translations:\n\n\
2477 You type Translation\n\
2478 -------- -----------\n";
2480 descbuf
= XCAR (arg
);
2482 prefix
= XCAR (arg
);
2484 nomenu
= NILP (XCAR (arg
));
2489 Fset_buffer (Vstandard_output
);
2491 /* Report on alternates for keys. */
2492 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2495 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2496 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2498 for (c
= 0; c
< translate_len
; c
++)
2499 if (translate
[c
] != c
)
2501 char buf
[KEY_DESCRIPTION_SIZE
];
2504 if (alternate_heading
)
2506 insert_string (alternate_heading
);
2507 alternate_heading
= 0;
2510 bufend
= push_key_description (translate
[c
], buf
);
2511 insert (buf
, bufend
- buf
);
2512 Findent_to (make_number (16), make_number (1));
2513 bufend
= push_key_description (c
, buf
);
2514 insert (buf
, bufend
- buf
);
2522 if (!NILP (Vkey_translation_map
))
2523 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2524 "Key translations", nomenu
, 1, 0);
2528 Lisp_Object
*modes
, *maps
;
2530 /* Temporarily switch to descbuf, so that we can get that buffer's
2531 minor modes correctly. */
2532 Fset_buffer (descbuf
);
2534 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2535 || !NILP (Voverriding_local_map
))
2538 nmaps
= current_minor_maps (&modes
, &maps
);
2539 Fset_buffer (Vstandard_output
);
2541 /* Print the minor mode maps. */
2542 for (i
= 0; i
< nmaps
; i
++)
2544 /* The title for a minor mode keymap
2545 is constructed at run time.
2546 We let describe_map_tree do the actual insertion
2547 because it takes care of other features when doing so. */
2550 if (!SYMBOLP (modes
[i
]))
2553 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2557 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2558 XSYMBOL (modes
[i
])->name
->size
);
2559 p
+= XSYMBOL (modes
[i
])->name
->size
;
2561 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2562 p
+= sizeof (" Minor Mode Bindings") - 1;
2565 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2566 shadow
= Fcons (maps
[i
], shadow
);
2570 /* Print the (major mode) local map. */
2571 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2572 start1
= current_kboard
->Voverriding_terminal_local_map
;
2573 else if (!NILP (Voverriding_local_map
))
2574 start1
= Voverriding_local_map
;
2576 start1
= XBUFFER (descbuf
)->keymap
;
2580 describe_map_tree (start1
, 1, shadow
, prefix
,
2581 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2582 shadow
= Fcons (start1
, shadow
);
2585 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2586 "\f\nGlobal Bindings", nomenu
, 0, 1);
2588 /* Print the function-key-map translations under this prefix. */
2589 if (!NILP (Vfunction_key_map
))
2590 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2591 "\f\nFunction key map translations", nomenu
, 1, 0);
2593 call0 (intern ("help-mode"));
2594 Fset_buffer (descbuf
);
2599 /* Insert a description of the key bindings in STARTMAP,
2600 followed by those of all maps reachable through STARTMAP.
2601 If PARTIAL is nonzero, omit certain "uninteresting" commands
2602 (such as `undefined').
2603 If SHADOW is non-nil, it is a list of maps;
2604 don't mention keys which would be shadowed by any of them.
2605 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2606 TITLE, if not 0, is a string to insert at the beginning.
2607 TITLE should not end with a colon or a newline; we supply that.
2608 If NOMENU is not 0, then omit menu-bar commands.
2610 If TRANSL is nonzero, the definitions are actually key translations
2611 so print strings and vectors differently.
2613 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2617 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2619 Lisp_Object startmap
, shadow
, prefix
;
2626 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2627 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2634 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2637 GCPRO3 (maps
, seen
, sub_shadows
);
2643 /* Delete from MAPS each element that is for the menu bar. */
2644 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2646 Lisp_Object elt
, prefix
, tem
;
2649 prefix
= Fcar (elt
);
2650 if (XVECTOR (prefix
)->size
>= 1)
2652 tem
= Faref (prefix
, make_number (0));
2653 if (EQ (tem
, Qmenu_bar
))
2654 maps
= Fdelq (elt
, maps
);
2659 if (!NILP (maps
) || always_title
)
2663 insert_string (title
);
2666 insert_string (" Starting With ");
2667 insert1 (Fkey_description (prefix
));
2669 insert_string (":\n");
2671 insert_string (key_heading
);
2675 for (; !NILP (maps
); maps
= Fcdr (maps
))
2677 register Lisp_Object elt
, prefix
, tail
;
2680 prefix
= Fcar (elt
);
2684 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2688 shmap
= XCAR (tail
);
2690 /* If the sequence by which we reach this keymap is zero-length,
2691 then the shadow map for this keymap is just SHADOW. */
2692 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2693 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2695 /* If the sequence by which we reach this keymap actually has
2696 some elements, then the sequence's definition in SHADOW is
2697 what we should use. */
2700 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2701 if (INTEGERP (shmap
))
2705 /* If shmap is not nil and not a keymap,
2706 it completely shadows this map, so don't
2707 describe this map at all. */
2708 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2712 sub_shadows
= Fcons (shmap
, sub_shadows
);
2715 /* Maps we have already listed in this loop shadow this map. */
2716 for (tail
= orig_maps
; ! EQ (tail
, maps
); tail
= XCDR (tail
))
2719 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2721 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2724 describe_map (Fcdr (elt
), prefix
,
2725 transl
? describe_translation
: describe_command
,
2726 partial
, sub_shadows
, &seen
, nomenu
);
2732 insert_string ("\n");
2737 static int previous_description_column
;
2740 describe_command (definition
)
2741 Lisp_Object definition
;
2743 register Lisp_Object tem1
;
2744 int column
= current_column ();
2745 int description_column
;
2747 /* If column 16 is no good, go to col 32;
2748 but don't push beyond that--go to next line instead. */
2752 description_column
= 32;
2754 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2755 description_column
= 32;
2757 description_column
= 16;
2759 Findent_to (make_number (description_column
), make_number (1));
2760 previous_description_column
= description_column
;
2762 if (SYMBOLP (definition
))
2764 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2766 insert_string ("\n");
2768 else if (STRINGP (definition
) || VECTORP (definition
))
2769 insert_string ("Keyboard Macro\n");
2772 tem1
= Fkeymapp (definition
);
2774 insert_string ("Prefix Command\n");
2776 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");
2801 tem1
= Fkeymapp (definition
);
2803 insert_string ("Prefix Command\n");
2805 insert_string ("??\n");
2809 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2810 Returns the first non-nil binding found in any of those maps. */
2813 shadow_lookup (shadow
, key
, flag
)
2814 Lisp_Object shadow
, key
, flag
;
2816 Lisp_Object tail
, value
;
2818 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2820 value
= Flookup_key (XCAR (tail
), key
, flag
);
2827 /* Describe the contents of map MAP, assuming that this map itself is
2828 reached by the sequence of prefix keys KEYS (a string or vector).
2829 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2832 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2833 register Lisp_Object map
;
2835 void (*elt_describer
) P_ ((Lisp_Object
));
2841 Lisp_Object elt_prefix
;
2842 Lisp_Object tail
, definition
, event
;
2844 Lisp_Object suppress
;
2847 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2851 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2853 /* Call Fkey_description first, to avoid GC bug for the other string. */
2854 tem
= Fkey_description (keys
);
2855 elt_prefix
= concat2 (tem
, build_string (" "));
2861 suppress
= intern ("suppress-keymap");
2863 /* This vector gets used to present single keys to Flookup_key. Since
2864 that is done once per keymap element, we don't want to cons up a
2865 fresh vector every time. */
2866 kludge
= Fmake_vector (make_number (1), Qnil
);
2869 GCPRO3 (elt_prefix
, definition
, kludge
);
2871 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2875 if (VECTORP (XCAR (tail
))
2876 || CHAR_TABLE_P (XCAR (tail
)))
2877 describe_vector (XCAR (tail
),
2878 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2880 else if (CONSP (XCAR (tail
)))
2882 event
= XCAR (XCAR (tail
));
2884 /* Ignore bindings whose "keys" are not really valid events.
2885 (We get these in the frames and buffers menu.) */
2886 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2889 if (nomenu
&& EQ (event
, Qmenu_bar
))
2892 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2894 /* Don't show undefined commands or suppressed commands. */
2895 if (NILP (definition
)) continue;
2896 if (SYMBOLP (definition
) && partial
)
2898 tem
= Fget (definition
, suppress
);
2903 /* Don't show a command that isn't really visible
2904 because a local definition of the same key shadows it. */
2906 XVECTOR (kludge
)->contents
[0] = event
;
2909 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2910 if (!NILP (tem
)) continue;
2913 tem
= Flookup_key (map
, kludge
, Qt
);
2914 if (! EQ (tem
, definition
)) continue;
2918 previous_description_column
= 0;
2923 if (!NILP (elt_prefix
))
2924 insert1 (elt_prefix
);
2926 /* THIS gets the string to describe the character EVENT. */
2927 insert1 (Fsingle_key_description (event
, Qnil
));
2929 /* Print a description of the definition of this character.
2930 elt_describer will take care of spacing out far enough
2931 for alignment purposes. */
2932 (*elt_describer
) (definition
);
2934 else if (EQ (XCAR (tail
), Qkeymap
))
2936 /* The same keymap might be in the structure twice, if we're
2937 using an inherited keymap. So skip anything we've already
2939 tem
= Fassq (tail
, *seen
);
2940 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2942 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2950 describe_vector_princ (elt
)
2953 Findent_to (make_number (16), make_number (1));
2958 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2959 "Insert a description of contents of VECTOR.\n\
2960 This is text showing the elements of vector matched against indices.")
2964 int count
= specpdl_ptr
- specpdl
;
2966 specbind (Qstandard_output
, Fcurrent_buffer ());
2967 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2968 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2969 Qnil
, Qnil
, (int *)0, 0);
2971 return unbind_to (count
, Qnil
);
2974 /* Insert in the current buffer a description of the contents of VECTOR.
2975 We call ELT_DESCRIBER to insert the description of one value found
2978 ELT_PREFIX describes what "comes before" the keys or indices defined
2979 by this vector. This is a human-readable string whose size
2980 is not necessarily related to the situation.
2982 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2983 leads to this keymap.
2985 If the vector is a chartable, ELT_PREFIX is the vector
2986 of bytes that lead to the character set or portion of a character
2987 set described by this chartable.
2989 If PARTIAL is nonzero, it means do not mention suppressed commands
2990 (that assumes the vector is in a keymap).
2992 SHADOW is a list of keymaps that shadow this map.
2993 If it is non-nil, then we look up the key in those maps
2994 and we don't mention it now if it is defined by any of them.
2996 ENTIRE_MAP is the keymap in which this vector appears.
2997 If the definition in effect in the whole map does not match
2998 the one in this vector, we ignore this one.
3000 When describing a sub-char-table, INDICES is a list of
3001 indices at higher levels in this char-table,
3002 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
3005 describe_vector (vector
, elt_prefix
, elt_describer
,
3006 partial
, shadow
, entire_map
,
3007 indices
, char_table_depth
)
3008 register Lisp_Object vector
;
3009 Lisp_Object elt_prefix
;
3010 void (*elt_describer
) P_ ((Lisp_Object
));
3013 Lisp_Object entire_map
;
3015 int char_table_depth
;
3017 Lisp_Object definition
;
3020 Lisp_Object suppress
;
3023 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3024 /* Range of elements to be handled. */
3026 /* A flag to tell if a leaf in this level of char-table is not a
3027 generic character (i.e. a complete multibyte character). */
3035 indices
= (int *) alloca (3 * sizeof (int));
3039 /* This vector gets used to present single keys to Flookup_key. Since
3040 that is done once per vector element, we don't want to cons up a
3041 fresh vector every time. */
3042 kludge
= Fmake_vector (make_number (1), Qnil
);
3043 GCPRO3 (elt_prefix
, definition
, kludge
);
3046 suppress
= intern ("suppress-keymap");
3048 if (CHAR_TABLE_P (vector
))
3050 if (char_table_depth
== 0)
3052 /* VECTOR is a top level char-table. */
3055 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3059 /* VECTOR is a sub char-table. */
3060 if (char_table_depth
>= 3)
3061 /* A char-table is never that deep. */
3062 error ("Too deep char table");
3065 = (CHARSET_VALID_P (indices
[0])
3066 && ((CHARSET_DIMENSION (indices
[0]) == 1
3067 && char_table_depth
== 1)
3068 || char_table_depth
== 2));
3070 /* Meaningful elements are from 32th to 127th. */
3072 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3077 /* This does the right thing for ordinary vectors. */
3081 to
= XVECTOR (vector
)->size
;
3084 for (i
= from
; i
< to
; i
++)
3088 if (CHAR_TABLE_P (vector
))
3090 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3093 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3094 && !CHARSET_DEFINED_P (i
- 128))
3098 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3101 definition
= get_keyelt (XVECTOR (vector
)->contents
[i
], 0);
3103 if (NILP (definition
)) continue;
3105 /* Don't mention suppressed commands. */
3106 if (SYMBOLP (definition
) && partial
)
3110 tem
= Fget (definition
, suppress
);
3112 if (!NILP (tem
)) continue;
3115 /* Set CHARACTER to the character this entry describes, if any.
3116 Also update *INDICES. */
3117 if (CHAR_TABLE_P (vector
))
3119 indices
[char_table_depth
] = i
;
3121 if (char_table_depth
== 0)
3124 indices
[0] = i
- 128;
3126 else if (complete_char
)
3128 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3136 /* If this binding is shadowed by some other map, ignore it. */
3137 if (!NILP (shadow
) && complete_char
)
3141 XVECTOR (kludge
)->contents
[0] = make_number (character
);
3142 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3144 if (!NILP (tem
)) continue;
3147 /* Ignore this definition if it is shadowed by an earlier
3148 one in the same keymap. */
3149 if (!NILP (entire_map
) && complete_char
)
3153 XVECTOR (kludge
)->contents
[0] = make_number (character
);
3154 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3156 if (! EQ (tem
, definition
))
3162 if (char_table_depth
== 0)
3167 /* For a sub char-table, show the depth by indentation.
3168 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3169 if (char_table_depth
> 0)
3170 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3172 /* Output the prefix that applies to every entry in this map. */
3173 if (!NILP (elt_prefix
))
3174 insert1 (elt_prefix
);
3176 /* Insert or describe the character this slot is for,
3177 or a description of what it is for. */
3178 if (SUB_CHAR_TABLE_P (vector
))
3181 insert_char (character
);
3184 /* We need an octal representation for this block of
3187 sprintf (work
, "(row %d)", i
);
3188 insert (work
, strlen (work
));
3191 else if (CHAR_TABLE_P (vector
))
3194 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3197 /* Print the information for this character set. */
3198 insert_string ("<");
3199 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3201 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3202 STRING_BYTES (XSTRING (tem2
)), 0);
3210 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3213 /* If we find a sub char-table within a char-table,
3214 scan it recursively; it defines the details for
3215 a character set or a portion of a character set. */
3216 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3219 describe_vector (definition
, elt_prefix
, elt_describer
,
3220 partial
, shadow
, entire_map
,
3221 indices
, char_table_depth
+ 1);
3227 /* Find all consecutive characters or rows that have the same
3228 definition. But, for elements of a top level char table, if
3229 they are for charsets, we had better describe one by one even
3230 if they have the same definition. */
3231 if (CHAR_TABLE_P (vector
))
3235 if (char_table_depth
== 0)
3236 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3238 while (i
+ 1 < limit
3239 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3241 && !NILP (Fequal (tem2
, definition
)))
3246 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+ 1], 0),
3248 && !NILP (Fequal (tem2
, definition
)))
3252 /* If we have a range of more than one character,
3253 print where the range reaches to. */
3255 if (i
!= starting_i
)
3259 if (!NILP (elt_prefix
))
3260 insert1 (elt_prefix
);
3262 if (CHAR_TABLE_P (vector
))
3264 if (char_table_depth
== 0)
3266 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3268 else if (complete_char
)
3270 indices
[char_table_depth
] = i
;
3271 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3272 insert_char (character
);
3276 /* We need an octal representation for this block of
3279 sprintf (work
, "(row %d)", i
);
3280 insert (work
, strlen (work
));
3285 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3289 /* Print a description of the definition of this character.
3290 elt_describer will take care of spacing out far enough
3291 for alignment purposes. */
3292 (*elt_describer
) (definition
);
3295 /* For (sub) char-table, print `defalt' slot at last. */
3296 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3298 insert (" ", char_table_depth
* 2);
3299 insert_string ("<<default>>");
3300 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3306 /* Apropos - finding all symbols whose names match a regexp. */
3307 Lisp_Object apropos_predicate
;
3308 Lisp_Object apropos_accumulate
;
3311 apropos_accum (symbol
, string
)
3312 Lisp_Object symbol
, string
;
3314 register Lisp_Object tem
;
3316 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3317 if (!NILP (tem
) && !NILP (apropos_predicate
))
3318 tem
= call1 (apropos_predicate
, symbol
);
3320 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3323 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3324 "Show all symbols whose names contain match for REGEXP.\n\
3325 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3326 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3327 Return list of symbols found.")
3329 Lisp_Object regexp
, predicate
;
3331 struct gcpro gcpro1
, gcpro2
;
3332 CHECK_STRING (regexp
, 0);
3333 apropos_predicate
= predicate
;
3334 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3335 apropos_accumulate
= Qnil
;
3336 map_obarray (Vobarray
, apropos_accum
, regexp
);
3337 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3339 return apropos_accumulate
;
3345 Qkeymap
= intern ("keymap");
3346 staticpro (&Qkeymap
);
3348 /* Now we are ready to set up this property, so we can
3349 create char tables. */
3350 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3352 /* Initialize the keymaps standardly used.
3353 Each one is the value of a Lisp variable, and is also
3354 pointed to by a C variable */
3356 global_map
= Fmake_keymap (Qnil
);
3357 Fset (intern ("global-map"), global_map
);
3359 current_global_map
= global_map
;
3360 staticpro (&global_map
);
3361 staticpro (¤t_global_map
);
3363 meta_map
= Fmake_keymap (Qnil
);
3364 Fset (intern ("esc-map"), meta_map
);
3365 Ffset (intern ("ESC-prefix"), meta_map
);
3367 control_x_map
= Fmake_keymap (Qnil
);
3368 Fset (intern ("ctl-x-map"), control_x_map
);
3369 Ffset (intern ("Control-X-prefix"), control_x_map
);
3371 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3372 "List of commands given new key bindings recently.\n\
3373 This is used for internal purposes during Emacs startup;\n\
3374 don't alter it yourself.");
3375 Vdefine_key_rebound_commands
= Qt
;
3377 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3378 "Default keymap to use when reading from the minibuffer.");
3379 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3381 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3382 "Local keymap for the minibuffer when spaces are not allowed.");
3383 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3385 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3386 "Local keymap for minibuffer input with completion.");
3387 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3389 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3390 "Local keymap for minibuffer input with completion, for exact match.");
3391 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3393 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3394 "Alist of keymaps to use for minor modes.\n\
3395 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3396 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3397 If two active keymaps bind the same key, the keymap appearing earlier\n\
3398 in the list takes precedence.");
3399 Vminor_mode_map_alist
= Qnil
;
3401 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3402 "Alist of keymaps to use for minor modes, in current major mode.\n\
3403 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3404 used the same way (and before `minor-mode-map-alist'); however,\n\
3405 it is provided for major modes to bind locally.");
3406 Vminor_mode_overriding_map_alist
= Qnil
;
3408 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3409 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3410 This allows Emacs to recognize function keys sent from ASCII\n\
3411 terminals at any point in a key sequence.\n\
3413 The `read-key-sequence' function replaces any subsequence bound by\n\
3414 `function-key-map' with its binding. More precisely, when the active\n\
3415 keymaps have no binding for the current key sequence but\n\
3416 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3417 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3418 continues with the new sequence.\n\
3420 The events that come from bindings in `function-key-map' are not\n\
3421 themselves looked up in `function-key-map'.\n\
3423 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3424 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3425 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3426 key, typing `ESC O P x' would return [f1 x].");
3427 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3429 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3430 "Keymap of key translations that can override keymaps.\n\
3431 This keymap works like `function-key-map', but comes after that,\n\
3432 and applies even for keys that have ordinary bindings.");
3433 Vkey_translation_map
= Qnil
;
3435 Qsingle_key_description
= intern ("single-key-description");
3436 staticpro (&Qsingle_key_description
);
3438 Qkey_description
= intern ("key-description");
3439 staticpro (&Qkey_description
);
3441 Qkeymapp
= intern ("keymapp");
3442 staticpro (&Qkeymapp
);
3444 Qnon_ascii
= intern ("non-ascii");
3445 staticpro (&Qnon_ascii
);
3447 Qmenu_item
= intern ("menu-item");
3448 staticpro (&Qmenu_item
);
3450 defsubr (&Skeymapp
);
3451 defsubr (&Skeymap_parent
);
3452 defsubr (&Sset_keymap_parent
);
3453 defsubr (&Smake_keymap
);
3454 defsubr (&Smake_sparse_keymap
);
3455 defsubr (&Scopy_keymap
);
3456 defsubr (&Skey_binding
);
3457 defsubr (&Slocal_key_binding
);
3458 defsubr (&Sglobal_key_binding
);
3459 defsubr (&Sminor_mode_key_binding
);
3460 defsubr (&Sdefine_key
);
3461 defsubr (&Slookup_key
);
3462 defsubr (&Sdefine_prefix_command
);
3463 defsubr (&Suse_global_map
);
3464 defsubr (&Suse_local_map
);
3465 defsubr (&Scurrent_local_map
);
3466 defsubr (&Scurrent_global_map
);
3467 defsubr (&Scurrent_minor_mode_maps
);
3468 defsubr (&Saccessible_keymaps
);
3469 defsubr (&Skey_description
);
3470 defsubr (&Sdescribe_vector
);
3471 defsubr (&Ssingle_key_description
);
3472 defsubr (&Stext_char_description
);
3473 defsubr (&Swhere_is_internal
);
3474 defsubr (&Sdescribe_bindings_internal
);
3475 defsubr (&Sapropos_internal
);
3481 initial_define_key (global_map
, 033, "ESC-prefix");
3482 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");