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"
36 /* The number of elements in keymap vectors. */
37 #define DENSE_TABLE_SIZE (0200)
39 /* Actually allocate storage for these variables */
41 Lisp_Object current_global_map
; /* Current global keymap */
43 Lisp_Object global_map
; /* default global key bindings */
45 Lisp_Object meta_map
; /* The keymap used for globally bound
46 ESC-prefixed default commands */
48 Lisp_Object control_x_map
; /* The keymap used for globally bound
49 C-x-prefixed default commands */
51 /* was MinibufLocalMap */
52 Lisp_Object Vminibuffer_local_map
;
53 /* The keymap used by the minibuf for local
54 bindings when spaces are allowed in the
57 /* was MinibufLocalNSMap */
58 Lisp_Object Vminibuffer_local_ns_map
;
59 /* The keymap used by the minibuf for local
60 bindings when spaces are not encouraged
63 /* keymap used for minibuffers when doing completion */
64 /* was MinibufLocalCompletionMap */
65 Lisp_Object Vminibuffer_local_completion_map
;
67 /* keymap used for minibuffers when doing completion and require a match */
68 /* was MinibufLocalMustMatchMap */
69 Lisp_Object Vminibuffer_local_must_match_map
;
71 /* Alist of minor mode variables and keymaps. */
72 Lisp_Object Vminor_mode_map_alist
;
74 /* Alist of major-mode-specific overrides for
75 minor mode variables and keymaps. */
76 Lisp_Object Vminor_mode_overriding_map_alist
;
78 /* Keymap mapping ASCII function key sequences onto their preferred forms.
79 Initialized by the terminal-specific lisp files. See DEFVAR for more
81 Lisp_Object Vfunction_key_map
;
83 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
84 Lisp_Object Vkey_translation_map
;
86 /* A list of all commands given new bindings since a certain time
87 when nil was stored here.
88 This is used to speed up recomputation of menu key equivalents
89 when Emacs starts up. t means don't record anything here. */
90 Lisp_Object Vdefine_key_rebound_commands
;
92 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
;
94 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
95 in a string key sequence is equivalent to prefixing with this
97 extern Lisp_Object meta_prefix_char
;
99 extern Lisp_Object Voverriding_local_map
;
101 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
102 static Lisp_Object where_is_cache
;
103 /* Which keymaps are reverse-stored in the cache. */
104 static Lisp_Object where_is_cache_keymaps
;
106 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
107 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
109 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
110 static void describe_command
P_ ((Lisp_Object
));
111 static void describe_translation
P_ ((Lisp_Object
));
112 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
113 void (*) P_ ((Lisp_Object
)),
114 int, Lisp_Object
, Lisp_Object
*, int));
116 /* Keymap object support - constructors and predicates. */
118 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
119 "Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).\n\
120 CHARTABLE is a char-table that holds the bindings for the ASCII\n\
121 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
122 mouse events, and any other things that appear in the input stream.\n\
123 All entries in it are initially nil, meaning \"command undefined\".\n\n\
124 The optional arg STRING supplies a menu name for the keymap\n\
125 in case you use it as a menu with `x-popup-menu'.")
131 tail
= Fcons (string
, Qnil
);
134 return Fcons (Qkeymap
,
135 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
138 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
139 "Construct and return a new sparse keymap.\n\
140 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
141 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
142 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
143 Initially the alist is nil.\n\n\
144 The optional arg STRING supplies a menu name for the keymap\n\
145 in case you use it as a menu with `x-popup-menu'.")
150 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
151 return Fcons (Qkeymap
, Qnil
);
154 /* This function is used for installing the standard key bindings
155 at initialization time.
159 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
162 initial_define_key (keymap
, key
, defname
)
167 store_in_keymap (keymap
, make_number (key
), intern (defname
));
171 initial_define_lispy_key (keymap
, keyname
, defname
)
176 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
179 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
180 "Return t if OBJECT is a keymap.\n\
182 A keymap is a list (keymap . ALIST),\n\
183 or a symbol whose function definition is itself a keymap.\n\
184 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
185 a vector of densely packed bindings for small character codes\n\
186 is also allowed as an element.")
190 return (KEYMAPP (object
) ? Qt
: Qnil
);
193 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
194 "Return the prompt-string of a keymap MAP.\n\
195 If non-nil, the prompt is shown in the echo-area\n\
196 when reading a key-sequence to be looked-up in this keymap.")
202 register Lisp_Object tem
;
211 /* Check that OBJECT is a keymap (after dereferencing through any
212 symbols). If it is, return it.
214 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
215 is an autoload form, do the autoload and try again.
216 If AUTOLOAD is nonzero, callers must assume GC is possible.
218 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
219 is zero as well), return Qt.
221 ERROR controls how we respond if OBJECT isn't a keymap.
222 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
224 Note that most of the time, we don't want to pursue autoloads.
225 Functions like Faccessible_keymaps which scan entire keymap trees
226 shouldn't load every autoloaded keymap. I'm not sure about this,
227 but it seems to me that only read_key_sequence, Flookup_key, and
228 Fdefine_key should cause keymaps to be autoloaded.
230 This function can GC when AUTOLOAD is non-zero, because it calls
231 do_autoload which can GC. */
234 get_keymap (object
, error
, autoload
)
243 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
246 tem
= indirect_function (object
);
249 if (EQ (XCAR (tem
), Qkeymap
))
252 /* Should we do an autoload? Autoload forms for keymaps have
253 Qkeymap as their fifth element. */
254 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
))
258 tail
= Fnth (make_number (4), tem
);
259 if (EQ (tail
, Qkeymap
))
263 struct gcpro gcpro1
, gcpro2
;
265 GCPRO2 (tem
, object
);
266 do_autoload (tem
, object
);
279 wrong_type_argument (Qkeymapp
, object
);
283 /* Return the parent map of the keymap MAP, or nil if it has none.
284 We assume that MAP is a valid keymap. */
286 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
287 "Return the parent keymap of KEYMAP.")
293 keymap
= get_keymap (keymap
, 1, 1);
295 /* Skip past the initial element `keymap'. */
296 list
= XCDR (keymap
);
297 for (; CONSP (list
); list
= XCDR (list
))
299 /* See if there is another `keymap'. */
304 return get_keymap (list
, 0, 1);
308 /* Check whether MAP is one of MAPS parents. */
310 keymap_memberp (map
, maps
)
311 Lisp_Object map
, maps
;
313 if (NILP (map
)) return 0;
314 while (KEYMAPP (maps
) && !EQ (map
, maps
))
315 maps
= Fkeymap_parent (maps
);
316 return (EQ (map
, maps
));
319 /* Set the parent keymap of MAP to PARENT. */
321 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
322 "Modify KEYMAP to set its parent map to PARENT.\n\
323 PARENT should be nil or another keymap.")
325 Lisp_Object keymap
, parent
;
327 Lisp_Object list
, prev
;
331 /* Force a keymap flush for the next call to where-is.
332 Since this can be called from within where-is, we don't set where_is_cache
333 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
334 be changed during where-is, while where_is_cache_keymaps is only used at
335 the very beginning of where-is and can thus be changed here without any
337 This is a very minor correctness (rather than safety) issue. */
338 where_is_cache_keymaps
= Qt
;
340 keymap
= get_keymap (keymap
, 1, 1);
345 parent
= get_keymap (parent
, 1, 1);
347 /* Check for cycles. */
348 if (keymap_memberp (keymap
, parent
))
349 error ("Cyclic keymap inheritance");
352 /* Skip past the initial element `keymap'. */
357 /* If there is a parent keymap here, replace it.
358 If we came to the end, add the parent in PREV. */
359 if (!CONSP (list
) || KEYMAPP (list
))
361 /* If we already have the right parent, return now
362 so that we avoid the loops below. */
363 if (EQ (XCDR (prev
), parent
))
364 RETURN_UNGCPRO (parent
);
366 XCDR (prev
) = parent
;
372 /* Scan through for submaps, and set their parents too. */
374 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
376 /* Stop the scan when we come to the parent. */
377 if (EQ (XCAR (list
), Qkeymap
))
380 /* If this element holds a prefix map, deal with it. */
381 if (CONSP (XCAR (list
))
382 && CONSP (XCDR (XCAR (list
))))
383 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
386 if (VECTORP (XCAR (list
)))
387 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
388 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
389 fix_submap_inheritance (keymap
, make_number (i
),
390 XVECTOR (XCAR (list
))->contents
[i
]);
392 if (CHAR_TABLE_P (XCAR (list
)))
394 Lisp_Object indices
[3];
396 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
),
401 RETURN_UNGCPRO (parent
);
404 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
405 if EVENT is also a prefix in MAP's parent,
406 make sure that SUBMAP inherits that definition as its own parent. */
409 fix_submap_inheritance (map
, event
, submap
)
410 Lisp_Object map
, event
, submap
;
412 Lisp_Object map_parent
, parent_entry
;
414 /* SUBMAP is a cons that we found as a key binding.
415 Discard the other things found in a menu key binding. */
417 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
419 /* If it isn't a keymap now, there's no work to do. */
423 map_parent
= Fkeymap_parent (map
);
424 if (!NILP (map_parent
))
426 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
430 /* If MAP's parent has something other than a keymap,
431 our own submap shadows it completely. */
432 if (!CONSP (parent_entry
))
435 if (! EQ (parent_entry
, submap
))
437 Lisp_Object submap_parent
;
438 submap_parent
= submap
;
443 tem
= Fkeymap_parent (submap_parent
);
447 if (keymap_memberp (tem
, parent_entry
))
448 /* Fset_keymap_parent could create a cycle. */
455 Fset_keymap_parent (submap_parent
, parent_entry
);
459 /* Look up IDX in MAP. IDX may be any sort of event.
460 Note that this does only one level of lookup; IDX must be a single
461 event, not a sequence.
463 If T_OK is non-zero, bindings for Qt are treated as default
464 bindings; any key left unmentioned by other tables and bindings is
465 given the binding of Qt.
467 If T_OK is zero, bindings for Qt are not treated specially.
469 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
472 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
482 /* If idx is a list (some sort of mouse click, perhaps?),
483 the index we want to use is the car of the list, which
484 ought to be a symbol. */
485 idx
= EVENT_HEAD (idx
);
487 /* If idx is a symbol, it might have modifiers, which need to
488 be put in the canonical order. */
490 idx
= reorder_modifiers (idx
);
491 else if (INTEGERP (idx
))
492 /* Clobber the high bits that can be present on a machine
493 with more than 24 bits of integer. */
494 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
496 /* Handle the special meta -> esc mapping. */
497 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
499 /* See if there is a meta-map. If there's none, there is
500 no binding for IDX, unless a default binding exists in MAP. */
501 Lisp_Object meta_map
=
502 get_keymap (access_keymap (map
, meta_prefix_char
,
503 t_ok
, noinherit
, autoload
),
505 if (CONSP (meta_map
))
508 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
511 /* Set IDX to t, so that we only find a default binding. */
514 /* We know there is no binding. */
520 Lisp_Object t_binding
;
521 Lisp_Object generic_binding
;
524 generic_binding
= Qnil
;
526 for (tail
= XCDR (map
);
528 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
533 binding
= XCAR (tail
);
534 if (SYMBOLP (binding
))
536 /* If NOINHERIT, stop finding prefix definitions
537 after we pass a second occurrence of the `keymap' symbol. */
538 if (noinherit
&& EQ (binding
, Qkeymap
))
541 else if (CONSP (binding
))
543 Lisp_Object key
= XCAR (binding
);
548 val
= XCDR (binding
);
549 if (noprefix
&& KEYMAPP (val
))
552 fix_submap_inheritance (map
, idx
, val
);
553 return get_keyelt (val
, autoload
);
555 else if (INTEGERP (idx
)
556 && (XINT (idx
) & CHAR_MODIFIER_MASK
) == 0
558 && (XINT (key
) & CHAR_MODIFIER_MASK
) == 0
559 && !SINGLE_BYTE_CHAR_P (XINT (idx
))
560 && !SINGLE_BYTE_CHAR_P (XINT (key
))
561 && CHAR_VALID_P (XINT (key
), 1)
562 && !CHAR_VALID_P (XINT (key
), 0)
563 && (CHAR_CHARSET (XINT (key
))
564 == CHAR_CHARSET (XINT (idx
))))
566 /* KEY is the generic character of the charset of IDX.
567 Use KEY's binding if there isn't a binding for IDX
569 generic_binding
= XCDR (binding
);
571 else if (t_ok
&& EQ (XCAR (binding
), Qt
))
572 t_binding
= XCDR (binding
);
574 else if (VECTORP (binding
))
576 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
578 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
579 if (noprefix
&& KEYMAPP (val
))
582 fix_submap_inheritance (map
, idx
, val
);
583 return get_keyelt (val
, autoload
);
586 else if (CHAR_TABLE_P (binding
))
588 /* Character codes with modifiers
589 are not included in a char-table.
590 All character codes without modifiers are included. */
592 && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
594 val
= Faref (binding
, idx
);
595 if (noprefix
&& KEYMAPP (val
))
598 fix_submap_inheritance (map
, idx
, val
);
599 return get_keyelt (val
, autoload
);
606 if (!NILP (generic_binding
))
607 return get_keyelt (generic_binding
, autoload
);
609 return get_keyelt (t_binding
, autoload
);
613 /* Given OBJECT which was found in a slot in a keymap,
614 trace indirect definitions to get the actual definition of that slot.
615 An indirect definition is a list of the form
616 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
617 and INDEX is the object to look up in KEYMAP to yield the definition.
619 Also if OBJECT has a menu string as the first element,
620 remove that. Also remove a menu help string as second element.
622 If AUTOLOAD is nonzero, load autoloadable keymaps
623 that are referred to with indirection. */
626 get_keyelt (object
, autoload
)
627 register Lisp_Object object
;
632 if (!(CONSP (object
)))
633 /* This is really the value. */
636 /* If the keymap contents looks like (keymap ...) or (lambda ...)
638 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
641 /* If the keymap contents looks like (menu-item name . DEFN)
642 or (menu-item name DEFN ...) then use DEFN.
643 This is a new format menu item. */
644 else if (EQ (XCAR (object
), Qmenu_item
))
646 if (CONSP (XCDR (object
)))
650 object
= XCDR (XCDR (object
));
653 object
= XCAR (object
);
655 /* If there's a `:filter FILTER', apply FILTER to the
656 menu-item's definition to get the real definition to
658 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
659 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
662 filter
= XCAR (XCDR (tem
));
663 filter
= list2 (filter
, list2 (Qquote
, object
));
664 object
= menu_item_eval_property (filter
);
673 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
674 Keymap alist elements like (CHAR MENUSTRING . DEFN)
675 will be used by HierarKey menus. */
676 else if (STRINGP (XCAR (object
)))
678 object
= XCDR (object
);
679 /* Also remove a menu help string, if any,
680 following the menu item name. */
681 if (CONSP (object
) && STRINGP (XCAR (object
)))
682 object
= XCDR (object
);
683 /* Also remove the sublist that caches key equivalences, if any. */
684 if (CONSP (object
) && CONSP (XCAR (object
)))
687 carcar
= XCAR (XCAR (object
));
688 if (NILP (carcar
) || VECTORP (carcar
))
689 object
= XCDR (object
);
693 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
697 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
698 return (!CONSP (map
) ? object
/* Invalid keymap */
699 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
705 store_in_keymap (keymap
, idx
, def
)
707 register Lisp_Object idx
;
708 register Lisp_Object def
;
710 /* Flush any reverse-map cache. */
711 where_is_cache
= Qnil
;
712 where_is_cache_keymaps
= Qt
;
714 /* If we are preparing to dump, and DEF is a menu element
715 with a menu item indicator, copy it to ensure it is not pure. */
716 if (CONSP (def
) && PURE_P (def
)
717 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
718 def
= Fcons (XCAR (def
), XCDR (def
));
720 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
721 error ("attempt to define a key in a non-keymap");
723 /* If idx is a list (some sort of mouse click, perhaps?),
724 the index we want to use is the car of the list, which
725 ought to be a symbol. */
726 idx
= EVENT_HEAD (idx
);
728 /* If idx is a symbol, it might have modifiers, which need to
729 be put in the canonical order. */
731 idx
= reorder_modifiers (idx
);
732 else if (INTEGERP (idx
))
733 /* Clobber the high bits that can be present on a machine
734 with more than 24 bits of integer. */
735 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
737 /* Scan the keymap for a binding of idx. */
741 /* The cons after which we should insert new bindings. If the
742 keymap has a table element, we record its position here, so new
743 bindings will go after it; this way, the table will stay
744 towards the front of the alist and character lookups in dense
745 keymaps will remain fast. Otherwise, this just points at the
746 front of the keymap. */
747 Lisp_Object insertion_point
;
749 insertion_point
= keymap
;
750 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
757 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
759 ASET (elt
, XFASTINT (idx
), def
);
762 insertion_point
= tail
;
764 else if (CHAR_TABLE_P (elt
))
766 /* Character codes with modifiers
767 are not included in a char-table.
768 All character codes without modifiers are included. */
771 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
772 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
774 Faset (elt
, idx
, def
);
777 insertion_point
= tail
;
779 else if (CONSP (elt
))
781 if (EQ (idx
, XCAR (elt
)))
787 else if (EQ (elt
, Qkeymap
))
788 /* If we find a 'keymap' symbol in the spine of KEYMAP,
789 then we must have found the start of a second keymap
790 being used as the tail of KEYMAP, and a binding for IDX
791 should be inserted before it. */
798 /* We have scanned the entire keymap, and not found a binding for
799 IDX. Let's add one. */
800 XCDR (insertion_point
)
801 = Fcons (Fcons (idx
, def
), XCDR (insertion_point
));
807 EXFUN (Fcopy_keymap
, 1);
810 copy_keymap_1 (chartable
, idx
, elt
)
811 Lisp_Object chartable
, idx
, elt
;
813 if (CONSP (elt
) && EQ (XCAR (elt
), Qkeymap
))
814 Faset (chartable
, idx
, Fcopy_keymap (elt
));
817 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
818 "Return a copy of the keymap KEYMAP.\n\
819 The copy starts out with the same definitions of KEYMAP,\n\
820 but changing either the copy or KEYMAP does not affect the other.\n\
821 Any key definitions that are subkeymaps are recursively copied.\n\
822 However, a key definition which is a symbol whose definition is a keymap\n\
827 /* FIXME: This doesn't properly copy menu-items in vectors. */
828 /* FIXME: This also copies the parent keymap. */
830 register Lisp_Object copy
, tail
;
832 copy
= Fcopy_alist (get_keymap (keymap
, 1, 0));
834 for (tail
= copy
; CONSP (tail
); tail
= XCDR (tail
))
839 if (CHAR_TABLE_P (elt
))
841 Lisp_Object indices
[3];
843 elt
= Fcopy_sequence (elt
);
846 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
848 else if (VECTORP (elt
))
852 elt
= Fcopy_sequence (elt
);
855 for (i
= 0; i
< ASIZE (elt
); i
++)
856 if (CONSP (AREF (elt
, i
)) && EQ (XCAR (AREF (elt
, i
)), Qkeymap
))
857 ASET (elt
, i
, Fcopy_keymap (AREF (elt
, i
)));
859 else if (CONSP (elt
) && CONSP (XCDR (elt
)))
864 /* Is this a new format menu item. */
865 if (EQ (XCAR (tem
),Qmenu_item
))
867 /* Copy cell with menu-item marker. */
869 = Fcons (XCAR (tem
), XCDR (tem
));
874 /* Copy cell with menu-item name. */
876 = Fcons (XCAR (tem
), XCDR (tem
));
882 /* Copy cell with binding and if the binding is a keymap,
885 = Fcons (XCAR (tem
), XCDR (tem
));
888 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
889 XCAR (elt
) = Fcopy_keymap (tem
);
891 if (CONSP (tem
) && CONSP (XCAR (tem
)))
892 /* Delete cache for key equivalences. */
893 XCDR (elt
) = XCDR (tem
);
898 /* It may be an old fomat menu item.
899 Skip the optional menu string.
901 if (STRINGP (XCAR (tem
)))
903 /* Copy the cell, since copy-alist didn't go this deep. */
905 = Fcons (XCAR (tem
), XCDR (tem
));
908 /* Also skip the optional menu help string. */
909 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
912 = Fcons (XCAR (tem
), XCDR (tem
));
916 /* There may also be a list that caches key equivalences.
917 Just delete it for the new keymap. */
919 && CONSP (XCAR (tem
))
920 && (NILP (XCAR (XCAR (tem
)))
921 || VECTORP (XCAR (XCAR (tem
)))))
922 XCDR (elt
) = XCDR (tem
);
925 && CONSP (XCDR (elt
))
926 && EQ (XCAR (XCDR (elt
)), Qkeymap
))
927 XCDR (elt
) = Fcopy_keymap (XCDR (elt
));
936 /* Simple Keymap mutators and accessors. */
938 /* GC is possible in this function if it autoloads a keymap. */
940 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
941 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
942 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
943 meaning a sequence of keystrokes and events.\n\
944 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
945 can be included if you use a vector.\n\
946 DEF is anything that can be a key's definition:\n\
947 nil (means key is undefined in this keymap),\n\
948 a command (a Lisp function suitable for interactive calling)\n\
949 a string (treated as a keyboard macro),\n\
950 a keymap (to define a prefix key),\n\
951 a symbol. When the key is looked up, the symbol will stand for its\n\
952 function definition, which should at that time be one of the above,\n\
953 or another symbol whose function definition is used, etc.\n\
954 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
955 (DEFN should be a valid definition in its own right),\n\
956 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
958 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
959 the front of KEYMAP.")
966 register Lisp_Object c
;
967 register Lisp_Object cmd
;
971 struct gcpro gcpro1
, gcpro2
, gcpro3
;
973 keymap
= get_keymap (keymap
, 1, 1);
975 if (!VECTORP (key
) && !STRINGP (key
))
976 key
= wrong_type_argument (Qarrayp
, key
);
978 length
= XFASTINT (Flength (key
));
982 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
983 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
985 GCPRO3 (keymap
, key
, def
);
988 meta_bit
= meta_modifier
;
995 c
= Faref (key
, make_number (idx
));
997 if (CONSP (c
) && lucid_event_type_list_p (c
))
998 c
= Fevent_convert_list (c
);
1001 && (XINT (c
) & meta_bit
)
1004 c
= meta_prefix_char
;
1010 XSETINT (c
, XINT (c
) & ~meta_bit
);
1016 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1017 error ("Key sequence contains invalid events");
1020 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1022 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1024 /* If this key is undefined, make it a prefix. */
1026 cmd
= define_as_prefix (keymap
, c
);
1028 keymap
= get_keymap (cmd
, 0, 1);
1029 if (!CONSP (keymap
))
1030 /* We must use Fkey_description rather than just passing key to
1031 error; key might be a vector, not a string. */
1032 error ("Key sequence %s uses invalid prefix characters",
1033 XSTRING (Fkey_description (key
))->data
);
1037 /* Value is number if KEY is too long; NIL if valid but has no definition. */
1038 /* GC is possible in this function if it autoloads a keymap. */
1040 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1041 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
1042 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
1044 A number as value means KEY is \"too long\";\n\
1045 that is, characters or symbols in it except for the last one\n\
1046 fail to be a valid sequence of prefix characters in KEYMAP.\n\
1047 The number is how many characters at the front of KEY\n\
1048 it takes to reach a non-prefix command.\n\
1050 Normally, `lookup-key' ignores bindings for t, which act as default\n\
1051 bindings, used when nothing else in the keymap applies; this makes it\n\
1052 usable as a general function for probing keymaps. However, if the\n\
1053 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
1054 recognize the default bindings, just as `read-key-sequence' does.")
1055 (keymap
, key
, accept_default
)
1056 register Lisp_Object keymap
;
1058 Lisp_Object accept_default
;
1061 register Lisp_Object cmd
;
1062 register Lisp_Object c
;
1064 int t_ok
= !NILP (accept_default
);
1065 struct gcpro gcpro1
;
1067 keymap
= get_keymap (keymap
, 1, 1);
1069 if (!VECTORP (key
) && !STRINGP (key
))
1070 key
= wrong_type_argument (Qarrayp
, key
);
1072 length
= XFASTINT (Flength (key
));
1081 c
= Faref (key
, make_number (idx
++));
1083 if (CONSP (c
) && lucid_event_type_list_p (c
))
1084 c
= Fevent_convert_list (c
);
1086 /* Turn the 8th bit of string chars into a meta modifier. */
1087 if (XINT (c
) & 0x80 && STRINGP (key
))
1088 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1090 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1092 RETURN_UNGCPRO (cmd
);
1094 keymap
= get_keymap (cmd
, 0, 1);
1095 if (!CONSP (keymap
))
1096 RETURN_UNGCPRO (make_number (idx
));
1102 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1103 Assume that currently it does not define C at all.
1104 Return the keymap. */
1107 define_as_prefix (keymap
, c
)
1108 Lisp_Object keymap
, c
;
1112 cmd
= Fmake_sparse_keymap (Qnil
);
1113 /* If this key is defined as a prefix in an inherited keymap,
1114 make it a prefix in this map, and make its definition
1115 inherit the other prefix definition. */
1116 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1117 store_in_keymap (keymap
, c
, cmd
);
1122 /* Append a key to the end of a key sequence. We always make a vector. */
1125 append_key (key_sequence
, key
)
1126 Lisp_Object key_sequence
, key
;
1128 Lisp_Object args
[2];
1130 args
[0] = key_sequence
;
1132 args
[1] = Fcons (key
, Qnil
);
1133 return Fvconcat (2, args
);
1137 /* Global, local, and minor mode keymap stuff. */
1139 /* We can't put these variables inside current_minor_maps, since under
1140 some systems, static gets macro-defined to be the empty string.
1142 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1143 static int cmm_size
;
1145 /* Error handler used in current_minor_maps. */
1147 current_minor_maps_error ()
1152 /* Store a pointer to an array of the keymaps of the currently active
1153 minor modes in *buf, and return the number of maps it contains.
1155 This function always returns a pointer to the same buffer, and may
1156 free or reallocate it, so if you want to keep it for a long time or
1157 hand it out to lisp code, copy it. This procedure will be called
1158 for every key sequence read, so the nice lispy approach (return a
1159 new assoclist, list, what have you) for each invocation would
1160 result in a lot of consing over time.
1162 If we used xrealloc/xmalloc and ran out of memory, they would throw
1163 back to the command loop, which would try to read a key sequence,
1164 which would call this function again, resulting in an infinite
1165 loop. Instead, we'll use realloc/malloc and silently truncate the
1166 list, let the key sequence be read, and hope some other piece of
1167 code signals the error. */
1169 current_minor_maps (modeptr
, mapptr
)
1170 Lisp_Object
**modeptr
, **mapptr
;
1173 int list_number
= 0;
1174 Lisp_Object alist
, assoc
, var
, val
;
1175 Lisp_Object lists
[2];
1177 lists
[0] = Vminor_mode_overriding_map_alist
;
1178 lists
[1] = Vminor_mode_map_alist
;
1180 for (list_number
= 0; list_number
< 2; list_number
++)
1181 for (alist
= lists
[list_number
];
1183 alist
= XCDR (alist
))
1184 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1185 && (var
= XCAR (assoc
), SYMBOLP (var
))
1186 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1191 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1192 and also an entry in Vminor_mode_map_alist,
1193 ignore the latter. */
1194 if (list_number
== 1)
1196 val
= assq_no_quit (var
, lists
[0]);
1203 Lisp_Object
*newmodes
, *newmaps
;
1205 /* Use malloc/realloc here. See the comment above
1212 = (Lisp_Object
*) realloc (cmm_modes
,
1213 cmm_size
* sizeof *newmodes
);
1215 = (Lisp_Object
*) realloc (cmm_maps
,
1216 cmm_size
* sizeof *newmaps
);
1224 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmodes
);
1226 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmaps
);
1231 cmm_modes
= newmodes
;
1235 if (newmodes
== NULL
|| newmaps
== NULL
)
1239 /* Get the keymap definition--or nil if it is not defined. */
1240 temp
= internal_condition_case_1 (Findirect_function
,
1242 Qerror
, current_minor_maps_error
);
1246 cmm_maps
[i
] = temp
;
1251 if (modeptr
) *modeptr
= cmm_modes
;
1252 if (mapptr
) *mapptr
= cmm_maps
;
1256 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1258 "Return a list of the currently active keymaps.\n\
1259 OLP if non-nil indicates that we should obey `overriding-local-map' and\n\
1260 `overriding-terminal-local-map'.")
1264 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1268 if (!NILP (Voverriding_local_map
))
1269 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1270 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1271 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1273 if (NILP (XCDR (keymaps
)))
1279 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1281 keymaps
= Fcons (local
, keymaps
);
1283 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1285 keymaps
= Fcons (local
, keymaps
);
1287 nmaps
= current_minor_maps (0, &maps
);
1289 for (i
= --nmaps
; i
>= 0; i
--)
1290 if (!NILP (maps
[i
]))
1291 keymaps
= Fcons (maps
[i
], keymaps
);
1297 /* GC is possible in this function if it autoloads a keymap. */
1299 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1300 "Return the binding for command KEY in current keymaps.\n\
1301 KEY is a string or vector, a sequence of keystrokes.\n\
1302 The binding is probably a symbol with a function definition.\n\
1304 Normally, `key-binding' ignores bindings for t, which act as default\n\
1305 bindings, used when nothing else in the keymap applies; this makes it\n\
1306 usable as a general function for probing keymaps. However, if the\n\
1307 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1308 recognize the default bindings, just as `read-key-sequence' does.")
1309 (key
, accept_default
)
1310 Lisp_Object key
, accept_default
;
1312 Lisp_Object
*maps
, value
;
1314 struct gcpro gcpro1
;
1318 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1320 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1321 key
, accept_default
);
1322 if (! NILP (value
) && !INTEGERP (value
))
1323 RETURN_UNGCPRO (value
);
1325 else if (!NILP (Voverriding_local_map
))
1327 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1328 if (! NILP (value
) && !INTEGERP (value
))
1329 RETURN_UNGCPRO (value
);
1335 nmaps
= current_minor_maps (0, &maps
);
1336 /* Note that all these maps are GCPRO'd
1337 in the places where we found them. */
1339 for (i
= 0; i
< nmaps
; i
++)
1340 if (! NILP (maps
[i
]))
1342 value
= Flookup_key (maps
[i
], key
, accept_default
);
1343 if (! NILP (value
) && !INTEGERP (value
))
1344 RETURN_UNGCPRO (value
);
1347 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1350 value
= Flookup_key (local
, key
, accept_default
);
1351 if (! NILP (value
) && !INTEGERP (value
))
1352 RETURN_UNGCPRO (value
);
1355 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1359 value
= Flookup_key (local
, key
, accept_default
);
1360 if (! NILP (value
) && !INTEGERP (value
))
1361 RETURN_UNGCPRO (value
);
1365 value
= Flookup_key (current_global_map
, key
, accept_default
);
1367 if (! NILP (value
) && !INTEGERP (value
))
1373 /* GC is possible in this function if it autoloads a keymap. */
1375 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1376 "Return the binding for command KEYS in current local keymap only.\n\
1377 KEYS is a string, a sequence of keystrokes.\n\
1378 The binding is probably a symbol with a function definition.\n\
1380 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1381 bindings; see the description of `lookup-key' for more details about this.")
1382 (keys
, accept_default
)
1383 Lisp_Object keys
, accept_default
;
1385 register Lisp_Object map
;
1386 map
= current_buffer
->keymap
;
1389 return Flookup_key (map
, keys
, accept_default
);
1392 /* GC is possible in this function if it autoloads a keymap. */
1394 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1395 "Return the binding for command KEYS in current global keymap only.\n\
1396 KEYS is a string, a sequence of keystrokes.\n\
1397 The binding is probably a symbol with a function definition.\n\
1398 This function's return values are the same as those of lookup-key\n\
1401 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1402 bindings; see the description of `lookup-key' for more details about this.")
1403 (keys
, accept_default
)
1404 Lisp_Object keys
, accept_default
;
1406 return Flookup_key (current_global_map
, keys
, accept_default
);
1409 /* GC is possible in this function if it autoloads a keymap. */
1411 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1412 "Find the visible minor mode bindings of KEY.\n\
1413 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1414 the symbol which names the minor mode binding KEY, and BINDING is\n\
1415 KEY's definition in that mode. In particular, if KEY has no\n\
1416 minor-mode bindings, return nil. If the first binding is a\n\
1417 non-prefix, all subsequent bindings will be omitted, since they would\n\
1418 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1419 that come after prefix bindings.\n\
1421 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1422 bindings; see the description of `lookup-key' for more details about this.")
1423 (key
, accept_default
)
1424 Lisp_Object key
, accept_default
;
1426 Lisp_Object
*modes
, *maps
;
1428 Lisp_Object binding
;
1430 struct gcpro gcpro1
, gcpro2
;
1432 nmaps
= current_minor_maps (&modes
, &maps
);
1433 /* Note that all these maps are GCPRO'd
1434 in the places where we found them. */
1437 GCPRO2 (key
, binding
);
1439 for (i
= j
= 0; i
< nmaps
; i
++)
1441 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1442 && !INTEGERP (binding
))
1444 if (KEYMAPP (binding
))
1445 maps
[j
++] = Fcons (modes
[i
], binding
);
1447 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1451 return Flist (j
, maps
);
1454 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1455 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1456 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1457 If a second optional argument MAPVAR is given, the map is stored as\n\
1458 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1460 The third optional argument NAME, if given, supplies a menu name\n\
1461 string for the map. This is required to use the keymap as a menu.")
1462 (command
, mapvar
, name
)
1463 Lisp_Object command
, mapvar
, name
;
1466 map
= Fmake_sparse_keymap (name
);
1467 Ffset (command
, map
);
1471 Fset (command
, map
);
1475 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1476 "Select KEYMAP as the global keymap.")
1480 keymap
= get_keymap (keymap
, 1, 1);
1481 current_global_map
= keymap
;
1486 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1487 "Select KEYMAP as the local keymap.\n\
1488 If KEYMAP is nil, that means no local keymap.")
1493 keymap
= get_keymap (keymap
, 1, 1);
1495 current_buffer
->keymap
= keymap
;
1500 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1501 "Return current buffer's local keymap, or nil if it has none.")
1504 return current_buffer
->keymap
;
1507 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1508 "Return the current global keymap.")
1511 return current_global_map
;
1514 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1515 "Return a list of keymaps for the minor modes of the current buffer.")
1519 int nmaps
= current_minor_maps (0, &maps
);
1521 return Flist (nmaps
, maps
);
1524 /* Help functions for describing and documenting keymaps. */
1528 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1529 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1530 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1534 cmd
= get_keyelt (cmd
, 0);
1538 tem
= get_keymap (cmd
, 0, 0);
1542 /* Ignore keymaps that are already added to maps. */
1543 tem
= Frassq (cmd
, maps
);
1546 /* If the last key in thisseq is meta-prefix-char,
1547 turn it into a meta-ized keystroke. We know
1548 that the event we're about to append is an
1549 ascii keystroke since we're processing a
1553 int meta_bit
= meta_modifier
;
1554 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1555 tem
= Fcopy_sequence (thisseq
);
1557 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1559 /* This new sequence is the same length as
1560 thisseq, so stick it in the list right
1563 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1567 tem
= append_key (thisseq
, key
);
1568 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1575 accessible_keymaps_char_table (args
, index
, cmd
)
1576 Lisp_Object args
, index
, cmd
;
1578 accessible_keymaps_1 (index
, cmd
,
1582 XINT (XCDR (XCAR (args
))));
1585 /* This function cannot GC. */
1587 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1589 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1590 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1591 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1592 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1593 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1594 then the value includes only maps for prefixes that start with PREFIX.")
1596 Lisp_Object keymap
, prefix
;
1598 Lisp_Object maps
, good_maps
, tail
;
1601 /* no need for gcpro because we don't autoload any keymaps. */
1604 prefixlen
= XINT (Flength (prefix
));
1608 /* If a prefix was specified, start with the keymap (if any) for
1609 that prefix, so we don't waste time considering other prefixes. */
1611 tem
= Flookup_key (keymap
, prefix
, Qt
);
1612 /* Flookup_key may give us nil, or a number,
1613 if the prefix is not defined in this particular map.
1614 It might even give us a list that isn't a keymap. */
1615 tem
= get_keymap (tem
, 0, 0);
1618 /* Convert PREFIX to a vector now, so that later on
1619 we don't have to deal with the possibility of a string. */
1620 if (STRINGP (prefix
))
1625 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1626 for (i
= 0, i_byte
= 0; i
< XSTRING (prefix
)->size
;)
1630 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1631 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1632 c
^= 0200 | meta_modifier
;
1633 ASET (copy
, i_before
, make_number (c
));
1637 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1643 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1644 get_keymap (keymap
, 1, 0)),
1647 /* For each map in the list maps,
1648 look at any other maps it points to,
1649 and stick them at the end if they are not already in the list.
1651 This is a breadth-first traversal, where tail is the queue of
1652 nodes, and maps accumulates a list of all nodes visited. */
1654 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1656 register Lisp_Object thisseq
, thismap
;
1658 /* Does the current sequence end in the meta-prefix-char? */
1661 thisseq
= Fcar (Fcar (tail
));
1662 thismap
= Fcdr (Fcar (tail
));
1663 last
= make_number (XINT (Flength (thisseq
)) - 1);
1664 is_metized
= (XINT (last
) >= 0
1665 /* Don't metize the last char of PREFIX. */
1666 && XINT (last
) >= prefixlen
1667 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1669 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1673 elt
= XCAR (thismap
);
1677 if (CHAR_TABLE_P (elt
))
1679 Lisp_Object indices
[3];
1681 map_char_table (accessible_keymaps_char_table
, Qnil
,
1682 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1683 Fcons (tail
, thisseq
)),
1686 else if (VECTORP (elt
))
1690 /* Vector keymap. Scan all the elements. */
1691 for (i
= 0; i
< ASIZE (elt
); i
++)
1692 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1693 maps
, tail
, thisseq
, is_metized
);
1696 else if (CONSP (elt
))
1697 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
1698 maps
, tail
, thisseq
,
1699 is_metized
&& INTEGERP (XCAR (elt
)));
1707 /* Now find just the maps whose access prefixes start with PREFIX. */
1710 for (; CONSP (maps
); maps
= XCDR (maps
))
1712 Lisp_Object elt
, thisseq
;
1714 thisseq
= XCAR (elt
);
1715 /* The access prefix must be at least as long as PREFIX,
1716 and the first elements must match those of PREFIX. */
1717 if (XINT (Flength (thisseq
)) >= prefixlen
)
1720 for (i
= 0; i
< prefixlen
; i
++)
1723 XSETFASTINT (i1
, i
);
1724 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1728 good_maps
= Fcons (elt
, good_maps
);
1732 return Fnreverse (good_maps
);
1735 Lisp_Object Qsingle_key_description
, Qkey_description
;
1737 /* This function cannot GC. */
1739 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1740 "Return a pretty description of key-sequence KEYS.\n\
1741 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1742 spaces are put between sequence elements, etc.")
1749 Lisp_Object
*args
= NULL
;
1754 vector
= Fmake_vector (Flength (keys
), Qnil
);
1755 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1760 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1761 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1762 c
^= 0200 | meta_modifier
;
1763 XSETFASTINT (AREF (vector
, i_before
), c
);
1770 /* In effect, this computes
1771 (mapconcat 'single-key-description keys " ")
1772 but we shouldn't use mapconcat because it can do GC. */
1774 len
= XVECTOR (keys
)->size
;
1775 sep
= build_string (" ");
1776 /* This has one extra element at the end that we don't pass to Fconcat. */
1777 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1779 for (i
= 0; i
< len
; i
++)
1781 args
[i
* 2] = Fsingle_key_description (AREF (keys
, i
), Qnil
);
1782 args
[i
* 2 + 1] = sep
;
1785 else if (CONSP (keys
))
1787 /* In effect, this computes
1788 (mapconcat 'single-key-description keys " ")
1789 but we shouldn't use mapconcat because it can do GC. */
1791 len
= XFASTINT (Flength (keys
));
1792 sep
= build_string (" ");
1793 /* This has one extra element at the end that we don't pass to Fconcat. */
1794 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1796 for (i
= 0; i
< len
; i
++)
1798 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1799 args
[i
* 2 + 1] = sep
;
1804 keys
= wrong_type_argument (Qarrayp
, keys
);
1807 return empty_string
;
1808 return Fconcat (len
* 2 - 1, args
);
1812 push_key_description (c
, p
, force_multibyte
)
1813 register unsigned int c
;
1815 int force_multibyte
;
1819 /* Clear all the meaningless bits above the meta bit. */
1820 c
&= meta_modifier
| ~ - meta_modifier
;
1821 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1822 | meta_modifier
| shift_modifier
| super_modifier
);
1824 if (c
& alt_modifier
)
1830 if ((c
& ctrl_modifier
) != 0
1831 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1835 c
&= ~ctrl_modifier
;
1837 if (c
& hyper_modifier
)
1841 c
-= hyper_modifier
;
1843 if (c
& meta_modifier
)
1849 if (c
& shift_modifier
)
1853 c
-= shift_modifier
;
1855 if (c
& super_modifier
)
1859 c
-= super_modifier
;
1875 else if (c
== Ctl ('M'))
1883 /* `C-' already added above. */
1884 if (c
> 0 && c
<= Ctl ('Z'))
1903 || (NILP (current_buffer
->enable_multibyte_characters
)
1904 && SINGLE_BYTE_CHAR_P (c
)
1905 && !force_multibyte
))
1911 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
1913 if (force_multibyte
&& valid_p
)
1915 if (SINGLE_BYTE_CHAR_P (c
))
1916 c
= unibyte_char_to_multibyte (c
);
1917 p
+= CHAR_STRING (c
, p
);
1919 else if (NILP (current_buffer
->enable_multibyte_characters
)
1924 /* The biggest character code uses 19 bits. */
1925 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1927 if (c
>= (1 << bit_offset
))
1928 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1932 p
+= CHAR_STRING (c
, p
);
1938 /* This function cannot GC. */
1940 DEFUN ("single-key-description", Fsingle_key_description
,
1941 Ssingle_key_description
, 1, 2, 0,
1942 "Return a pretty description of command character KEY.\n\
1943 Control characters turn into C-whatever, etc.\n\
1944 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1945 around function keys and event symbols.")
1947 Lisp_Object key
, no_angles
;
1949 if (CONSP (key
) && lucid_event_type_list_p (key
))
1950 key
= Fevent_convert_list (key
);
1952 key
= EVENT_HEAD (key
);
1954 if (INTEGERP (key
)) /* Normal character */
1956 unsigned int charset
, c1
, c2
;
1957 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1959 if (SINGLE_BYTE_CHAR_P (without_bits
))
1962 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1965 && CHARSET_DEFINED_P (charset
)
1966 && ((c1
>= 0 && c1
< 32)
1967 || (c2
>= 0 && c2
< 32)))
1969 /* Handle a generic character. */
1971 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1972 CHECK_STRING (name
, 0);
1973 return concat2 (build_string ("Character set "), name
);
1977 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
1981 end
= push_key_description (XUINT (key
), tem
, 1);
1983 nchars
= multibyte_chars_in_text (tem
, nbytes
);
1984 if (nchars
== nbytes
)
1987 string
= build_string (tem
);
1990 string
= make_multibyte_string (tem
, nchars
, nbytes
);
1994 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1996 if (NILP (no_angles
))
1999 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
2000 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
2001 return build_string (buffer
);
2004 return Fsymbol_name (key
);
2006 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2007 return Fcopy_sequence (key
);
2009 error ("KEY must be an integer, cons, symbol, or string");
2014 push_text_char_description (c
, p
)
2015 register unsigned int c
;
2027 *p
++ = c
+ 64; /* 'A' - 1 */
2039 /* This function cannot GC. */
2041 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2042 "Return a pretty description of file-character CHARACTER.\n\
2043 Control characters turn into \"^char\", etc.")
2045 Lisp_Object character
;
2047 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2048 unsigned char str
[6];
2051 CHECK_NUMBER (character
, 0);
2053 c
= XINT (character
);
2054 if (!SINGLE_BYTE_CHAR_P (c
))
2056 int len
= CHAR_STRING (c
, str
);
2058 return make_multibyte_string (str
, 1, len
);
2061 *push_text_char_description (c
& 0377, str
) = 0;
2063 return build_string (str
);
2066 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2069 ascii_sequence_p (seq
)
2073 int len
= XINT (Flength (seq
));
2075 for (i
= 0; i
< len
; i
++)
2077 Lisp_Object ii
, elt
;
2079 XSETFASTINT (ii
, i
);
2080 elt
= Faref (seq
, ii
);
2083 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2091 /* where-is - finding a command in a set of keymaps. */
2093 static Lisp_Object
where_is_internal_1 ();
2094 static void where_is_internal_2 ();
2096 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2097 Returns the first non-nil binding found in any of those maps. */
2100 shadow_lookup (shadow
, key
, flag
)
2101 Lisp_Object shadow
, key
, flag
;
2103 Lisp_Object tail
, value
;
2105 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2107 value
= Flookup_key (XCAR (tail
), key
, flag
);
2108 if (!NILP (value
) && !NATNUMP (value
))
2114 /* This function can GC if Flookup_key autoloads any keymaps. */
2117 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2118 Lisp_Object definition
, keymaps
;
2119 Lisp_Object firstonly
, noindirect
;
2121 Lisp_Object maps
= Qnil
;
2122 Lisp_Object found
, sequences
;
2123 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2124 /* 1 means ignore all menu bindings entirely. */
2125 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2128 while (CONSP (found
))
2132 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2133 found
= XCDR (found
);
2136 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2140 for (; !NILP (maps
); maps
= Fcdr (maps
))
2142 /* Key sequence to reach map, and the map that it reaches */
2143 register Lisp_Object
this, map
;
2145 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2146 [M-CHAR] sequences, check if last character of the sequence
2147 is the meta-prefix char. */
2151 this = Fcar (Fcar (maps
));
2152 map
= Fcdr (Fcar (maps
));
2153 last
= make_number (XINT (Flength (this)) - 1);
2154 last_is_meta
= (XINT (last
) >= 0
2155 && EQ (Faref (this, last
), meta_prefix_char
));
2157 /* if (nomenus && !ascii_sequence_p (this)) */
2158 if (nomenus
&& XINT (last
) >= 0
2159 && !INTEGERP (Faref (this, make_number (0))))
2160 /* If no menu entries should be returned, skip over the
2161 keymaps bound to `menu-bar' and `tool-bar' and other
2162 non-ascii prefixes like `C-down-mouse-2'. */
2169 /* Because the code we want to run on each binding is rather
2170 large, we don't want to have two separate loop bodies for
2171 sparse keymap bindings and tables; we want to iterate one
2172 loop body over both keymap and vector bindings.
2174 For this reason, if Fcar (map) is a vector, we don't
2175 advance map to the next element until i indicates that we
2176 have finished off the vector. */
2177 Lisp_Object elt
, key
, binding
;
2185 /* Set key and binding to the current key and binding, and
2186 advance map and i to the next binding. */
2189 Lisp_Object sequence
;
2191 /* In a vector, look at each element. */
2192 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2194 binding
= AREF (elt
, i
);
2195 XSETFASTINT (key
, i
);
2196 sequence
= where_is_internal_1 (binding
, key
, definition
,
2198 last
, nomenus
, last_is_meta
);
2199 if (!NILP (sequence
))
2200 sequences
= Fcons (sequence
, sequences
);
2203 else if (CHAR_TABLE_P (elt
))
2205 Lisp_Object indices
[3];
2208 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2209 Qnil
), /* Result accumulator. */
2210 Fcons (Fcons (this, last
),
2211 Fcons (make_number (nomenus
),
2212 make_number (last_is_meta
))));
2213 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2215 sequences
= XCDR (XCAR (args
));
2217 else if (CONSP (elt
))
2219 Lisp_Object sequence
;
2222 binding
= XCDR (elt
);
2224 sequence
= where_is_internal_1 (binding
, key
, definition
,
2226 last
, nomenus
, last_is_meta
);
2227 if (!NILP (sequence
))
2228 sequences
= Fcons (sequence
, sequences
);
2232 for (; !NILP (sequences
); sequences
= XCDR (sequences
))
2234 Lisp_Object sequence
;
2236 sequence
= XCAR (sequences
);
2238 /* Verify that this key binding is not shadowed by another
2239 binding for the same key, before we say it exists.
2241 Mechanism: look for local definition of this key and if
2242 it is defined and does not match what we found then
2245 Either nil or number as value from Flookup_key
2247 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2250 /* It is a true unshadowed match. Record it, unless it's already
2251 been seen (as could happen when inheriting keymaps). */
2252 if (NILP (Fmember (sequence
, found
)))
2253 found
= Fcons (sequence
, found
);
2255 /* If firstonly is Qnon_ascii, then we can return the first
2256 binding we find. If firstonly is not Qnon_ascii but not
2257 nil, then we should return the first ascii-only binding
2259 if (EQ (firstonly
, Qnon_ascii
))
2260 RETURN_UNGCPRO (sequence
);
2261 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2262 RETURN_UNGCPRO (sequence
);
2269 found
= Fnreverse (found
);
2271 /* firstonly may have been t, but we may have gone all the way through
2272 the keymaps without finding an all-ASCII key sequence. So just
2273 return the best we could find. */
2274 if (!NILP (firstonly
))
2275 return Fcar (found
);
2280 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2281 "Return list of keys that invoke DEFINITION.\n\
2282 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2283 If KEYMAP is nil, search all the currently active keymaps.\n\
2284 If KEYMAP is a list of keymaps, search only those keymaps.\n\
2286 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2287 rather than a list of all possible key sequences.\n\
2288 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2289 no matter what it is.\n\
2290 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2291 and entirely reject menu bindings.\n\
2293 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2294 to other keymaps or slots. This makes it possible to search for an\n\
2295 indirect definition itself.")
2296 (definition
, keymap
, firstonly
, noindirect
)
2297 Lisp_Object definition
, keymap
;
2298 Lisp_Object firstonly
, noindirect
;
2300 Lisp_Object sequences
, keymaps
;
2301 /* 1 means ignore all menu bindings entirely. */
2302 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2305 /* Find the relevant keymaps. */
2306 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2308 else if (!NILP (keymap
))
2309 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2311 keymaps
= Fcurrent_active_maps (Qnil
);
2313 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2314 We don't really need to check `keymap'. */
2315 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2319 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2321 /* Check heuristic-consistency of the cache. */
2322 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2323 where_is_cache
= Qnil
;
2325 if (NILP (where_is_cache
))
2327 /* We need to create the cache. */
2328 Lisp_Object args
[2];
2329 where_is_cache
= Fmake_hash_table (0, args
);
2330 where_is_cache_keymaps
= Qt
;
2332 /* Fill in the cache. */
2333 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2334 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2337 where_is_cache_keymaps
= keymaps
;
2340 /* We want to process definitions from the last to the first.
2341 Instead of consing, copy definitions to a vector and step
2342 over that vector. */
2343 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2344 n
= XINT (Flength (sequences
));
2345 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2346 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2347 defns
[i
++] = XCAR (sequences
);
2349 /* Verify that the key bindings are not shadowed. Note that
2350 the following can GC. */
2351 GCPRO2 (definition
, keymaps
);
2354 for (i
= n
- 1; i
>= 0; --i
)
2355 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2357 if (ascii_sequence_p (defns
[i
]))
2363 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2368 /* Kill the cache so that where_is_internal_1 doesn't think
2369 we're filling it up. */
2370 where_is_cache
= Qnil
;
2371 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2377 /* This is the function that Fwhere_is_internal calls using map_char_table.
2379 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2381 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2382 Since map_char_table doesn't really use the return value from this function,
2383 we the result append to RESULT, the slot in ARGS.
2385 This function can GC because it calls where_is_internal_1 which can
2389 where_is_internal_2 (args
, key
, binding
)
2390 Lisp_Object args
, key
, binding
;
2392 Lisp_Object definition
, noindirect
, this, last
;
2393 Lisp_Object result
, sequence
;
2394 int nomenus
, last_is_meta
;
2395 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2397 GCPRO3 (args
, key
, binding
);
2398 result
= XCDR (XCAR (args
));
2399 definition
= XCAR (XCAR (XCAR (args
)));
2400 noindirect
= XCDR (XCAR (XCAR (args
)));
2401 this = XCAR (XCAR (XCDR (args
)));
2402 last
= XCDR (XCAR (XCDR (args
)));
2403 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2404 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2406 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2407 this, last
, nomenus
, last_is_meta
);
2409 if (!NILP (sequence
))
2410 XCDR (XCAR (args
)) = Fcons (sequence
, result
);
2416 /* This function cannot GC. */
2419 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2420 nomenus
, last_is_meta
)
2421 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2422 int nomenus
, last_is_meta
;
2424 Lisp_Object sequence
;
2426 /* Search through indirections unless that's not wanted. */
2427 if (NILP (noindirect
))
2428 binding
= get_keyelt (binding
, 0);
2430 /* End this iteration if this element does not match
2433 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2434 || EQ (binding
, definition
)
2435 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2436 /* Doesn't match. */
2439 /* We have found a match. Construct the key sequence where we found it. */
2440 if (INTEGERP (key
) && last_is_meta
)
2442 sequence
= Fcopy_sequence (this);
2443 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2446 sequence
= append_key (this, key
);
2448 if (!NILP (where_is_cache
))
2450 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2451 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2458 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2460 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2461 "Insert the list of all defined keys and their definitions.\n\
2462 The list is inserted in the current buffer, while the bindings are\n\
2463 looked up in BUFFER.\n\
2464 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2465 then we display only bindings that start with that prefix.\n\
2466 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2467 \(Ordinarily these are omitted from the output.)")
2468 (buffer
, prefix
, menus
)
2469 Lisp_Object buffer
, prefix
, menus
;
2471 Lisp_Object outbuf
, shadow
;
2472 int nomenu
= NILP (menus
);
2473 register Lisp_Object start1
;
2474 struct gcpro gcpro1
;
2476 char *alternate_heading
2478 Keyboard translations:\n\n\
2479 You type Translation\n\
2480 -------- -----------\n";
2485 outbuf
= Fcurrent_buffer();
2487 /* Report on alternates for keys. */
2488 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2491 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2492 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2494 for (c
= 0; c
< translate_len
; c
++)
2495 if (translate
[c
] != c
)
2497 char buf
[KEY_DESCRIPTION_SIZE
];
2500 if (alternate_heading
)
2502 insert_string (alternate_heading
);
2503 alternate_heading
= 0;
2506 bufend
= push_key_description (translate
[c
], buf
, 1);
2507 insert (buf
, bufend
- buf
);
2508 Findent_to (make_number (16), make_number (1));
2509 bufend
= push_key_description (c
, buf
, 1);
2510 insert (buf
, bufend
- buf
);
2518 if (!NILP (Vkey_translation_map
))
2519 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2520 "Key translations", nomenu
, 1, 0);
2524 Lisp_Object
*modes
, *maps
;
2526 /* Temporarily switch to `buffer', so that we can get that buffer's
2527 minor modes correctly. */
2528 Fset_buffer (buffer
);
2530 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2531 || !NILP (Voverriding_local_map
))
2534 nmaps
= current_minor_maps (&modes
, &maps
);
2535 Fset_buffer (outbuf
);
2537 /* Print the minor mode maps. */
2538 for (i
= 0; i
< nmaps
; i
++)
2540 /* The title for a minor mode keymap
2541 is constructed at run time.
2542 We let describe_map_tree do the actual insertion
2543 because it takes care of other features when doing so. */
2546 if (!SYMBOLP (modes
[i
]))
2549 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2553 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2554 XSYMBOL (modes
[i
])->name
->size
);
2555 p
+= XSYMBOL (modes
[i
])->name
->size
;
2557 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2558 p
+= sizeof (" Minor Mode Bindings") - 1;
2561 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2562 shadow
= Fcons (maps
[i
], shadow
);
2566 /* Print the (major mode) local map. */
2567 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2568 start1
= current_kboard
->Voverriding_terminal_local_map
;
2569 else if (!NILP (Voverriding_local_map
))
2570 start1
= Voverriding_local_map
;
2572 start1
= XBUFFER (buffer
)->keymap
;
2576 describe_map_tree (start1
, 1, shadow
, prefix
,
2577 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2578 shadow
= Fcons (start1
, shadow
);
2581 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2582 "\f\nGlobal Bindings", nomenu
, 0, 1);
2584 /* Print the function-key-map translations under this prefix. */
2585 if (!NILP (Vfunction_key_map
))
2586 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2587 "\f\nFunction key map translations", nomenu
, 1, 0);
2593 /* Insert a description of the key bindings in STARTMAP,
2594 followed by those of all maps reachable through STARTMAP.
2595 If PARTIAL is nonzero, omit certain "uninteresting" commands
2596 (such as `undefined').
2597 If SHADOW is non-nil, it is a list of maps;
2598 don't mention keys which would be shadowed by any of them.
2599 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2600 TITLE, if not 0, is a string to insert at the beginning.
2601 TITLE should not end with a colon or a newline; we supply that.
2602 If NOMENU is not 0, then omit menu-bar commands.
2604 If TRANSL is nonzero, the definitions are actually key translations
2605 so print strings and vectors differently.
2607 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2611 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2613 Lisp_Object startmap
, shadow
, prefix
;
2620 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2621 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2628 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2631 GCPRO3 (maps
, seen
, sub_shadows
);
2637 /* Delete from MAPS each element that is for the menu bar. */
2638 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2640 Lisp_Object elt
, prefix
, tem
;
2643 prefix
= Fcar (elt
);
2644 if (XVECTOR (prefix
)->size
>= 1)
2646 tem
= Faref (prefix
, make_number (0));
2647 if (EQ (tem
, Qmenu_bar
))
2648 maps
= Fdelq (elt
, maps
);
2653 if (!NILP (maps
) || always_title
)
2657 insert_string (title
);
2660 insert_string (" Starting With ");
2661 insert1 (Fkey_description (prefix
));
2663 insert_string (":\n");
2665 insert_string (key_heading
);
2669 for (; !NILP (maps
); maps
= Fcdr (maps
))
2671 register Lisp_Object elt
, prefix
, tail
;
2674 prefix
= Fcar (elt
);
2678 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2682 shmap
= XCAR (tail
);
2684 /* If the sequence by which we reach this keymap is zero-length,
2685 then the shadow map for this keymap is just SHADOW. */
2686 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2687 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2689 /* If the sequence by which we reach this keymap actually has
2690 some elements, then the sequence's definition in SHADOW is
2691 what we should use. */
2694 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2695 if (INTEGERP (shmap
))
2699 /* If shmap is not nil and not a keymap,
2700 it completely shadows this map, so don't
2701 describe this map at all. */
2702 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2706 sub_shadows
= Fcons (shmap
, sub_shadows
);
2709 /* Maps we have already listed in this loop shadow this map. */
2710 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
2713 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2715 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2718 describe_map (Fcdr (elt
), prefix
,
2719 transl
? describe_translation
: describe_command
,
2720 partial
, sub_shadows
, &seen
, nomenu
);
2726 insert_string ("\n");
2731 static int previous_description_column
;
2734 describe_command (definition
)
2735 Lisp_Object definition
;
2737 register Lisp_Object tem1
;
2738 int column
= current_column ();
2739 int description_column
;
2741 /* If column 16 is no good, go to col 32;
2742 but don't push beyond that--go to next line instead. */
2746 description_column
= 32;
2748 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2749 description_column
= 32;
2751 description_column
= 16;
2753 Findent_to (make_number (description_column
), make_number (1));
2754 previous_description_column
= description_column
;
2756 if (SYMBOLP (definition
))
2758 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2760 insert_string ("\n");
2762 else if (STRINGP (definition
) || VECTORP (definition
))
2763 insert_string ("Keyboard Macro\n");
2764 else if (KEYMAPP (definition
))
2765 insert_string ("Prefix Command\n");
2767 insert_string ("??\n");
2771 describe_translation (definition
)
2772 Lisp_Object definition
;
2774 register Lisp_Object tem1
;
2776 Findent_to (make_number (16), make_number (1));
2778 if (SYMBOLP (definition
))
2780 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2782 insert_string ("\n");
2784 else if (STRINGP (definition
) || VECTORP (definition
))
2786 insert1 (Fkey_description (definition
));
2787 insert_string ("\n");
2789 else if (KEYMAPP (definition
))
2790 insert_string ("Prefix Command\n");
2792 insert_string ("??\n");
2795 /* Describe the contents of map MAP, assuming that this map itself is
2796 reached by the sequence of prefix keys KEYS (a string or vector).
2797 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2800 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2801 register Lisp_Object map
;
2803 void (*elt_describer
) P_ ((Lisp_Object
));
2809 Lisp_Object elt_prefix
;
2810 Lisp_Object tail
, definition
, event
;
2812 Lisp_Object suppress
;
2815 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2819 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2821 /* Call Fkey_description first, to avoid GC bug for the other string. */
2822 tem
= Fkey_description (keys
);
2823 elt_prefix
= concat2 (tem
, build_string (" "));
2829 suppress
= intern ("suppress-keymap");
2831 /* This vector gets used to present single keys to Flookup_key. Since
2832 that is done once per keymap element, we don't want to cons up a
2833 fresh vector every time. */
2834 kludge
= Fmake_vector (make_number (1), Qnil
);
2837 GCPRO3 (elt_prefix
, definition
, kludge
);
2839 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2843 if (VECTORP (XCAR (tail
))
2844 || CHAR_TABLE_P (XCAR (tail
)))
2845 describe_vector (XCAR (tail
),
2846 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2848 else if (CONSP (XCAR (tail
)))
2850 event
= XCAR (XCAR (tail
));
2852 /* Ignore bindings whose "keys" are not really valid events.
2853 (We get these in the frames and buffers menu.) */
2854 if (!(SYMBOLP (event
) || INTEGERP (event
)))
2857 if (nomenu
&& EQ (event
, Qmenu_bar
))
2860 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2862 /* Don't show undefined commands or suppressed commands. */
2863 if (NILP (definition
)) continue;
2864 if (SYMBOLP (definition
) && partial
)
2866 tem
= Fget (definition
, suppress
);
2871 /* Don't show a command that isn't really visible
2872 because a local definition of the same key shadows it. */
2874 ASET (kludge
, 0, event
);
2877 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2878 if (!NILP (tem
)) continue;
2881 tem
= Flookup_key (map
, kludge
, Qt
);
2882 if (!EQ (tem
, definition
)) continue;
2886 previous_description_column
= 0;
2891 if (!NILP (elt_prefix
))
2892 insert1 (elt_prefix
);
2894 /* THIS gets the string to describe the character EVENT. */
2895 insert1 (Fsingle_key_description (event
, Qnil
));
2897 /* Print a description of the definition of this character.
2898 elt_describer will take care of spacing out far enough
2899 for alignment purposes. */
2900 (*elt_describer
) (definition
);
2902 else if (EQ (XCAR (tail
), Qkeymap
))
2904 /* The same keymap might be in the structure twice, if we're
2905 using an inherited keymap. So skip anything we've already
2907 tem
= Fassq (tail
, *seen
);
2908 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2910 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2918 describe_vector_princ (elt
)
2921 Findent_to (make_number (16), make_number (1));
2926 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2927 "Insert a description of contents of VECTOR.\n\
2928 This is text showing the elements of vector matched against indices.")
2932 int count
= specpdl_ptr
- specpdl
;
2934 specbind (Qstandard_output
, Fcurrent_buffer ());
2935 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2936 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2937 Qnil
, Qnil
, (int *)0, 0);
2939 return unbind_to (count
, Qnil
);
2942 /* Insert in the current buffer a description of the contents of VECTOR.
2943 We call ELT_DESCRIBER to insert the description of one value found
2946 ELT_PREFIX describes what "comes before" the keys or indices defined
2947 by this vector. This is a human-readable string whose size
2948 is not necessarily related to the situation.
2950 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2951 leads to this keymap.
2953 If the vector is a chartable, ELT_PREFIX is the vector
2954 of bytes that lead to the character set or portion of a character
2955 set described by this chartable.
2957 If PARTIAL is nonzero, it means do not mention suppressed commands
2958 (that assumes the vector is in a keymap).
2960 SHADOW is a list of keymaps that shadow this map.
2961 If it is non-nil, then we look up the key in those maps
2962 and we don't mention it now if it is defined by any of them.
2964 ENTIRE_MAP is the keymap in which this vector appears.
2965 If the definition in effect in the whole map does not match
2966 the one in this vector, we ignore this one.
2968 When describing a sub-char-table, INDICES is a list of
2969 indices at higher levels in this char-table,
2970 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2973 describe_vector (vector
, elt_prefix
, elt_describer
,
2974 partial
, shadow
, entire_map
,
2975 indices
, char_table_depth
)
2976 register Lisp_Object vector
;
2977 Lisp_Object elt_prefix
;
2978 void (*elt_describer
) P_ ((Lisp_Object
));
2981 Lisp_Object entire_map
;
2983 int char_table_depth
;
2985 Lisp_Object definition
;
2988 Lisp_Object suppress
;
2991 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2992 /* Range of elements to be handled. */
2994 /* A flag to tell if a leaf in this level of char-table is not a
2995 generic character (i.e. a complete multibyte character). */
3003 indices
= (int *) alloca (3 * sizeof (int));
3007 /* This vector gets used to present single keys to Flookup_key. Since
3008 that is done once per vector element, we don't want to cons up a
3009 fresh vector every time. */
3010 kludge
= Fmake_vector (make_number (1), Qnil
);
3011 GCPRO3 (elt_prefix
, definition
, kludge
);
3014 suppress
= intern ("suppress-keymap");
3016 if (CHAR_TABLE_P (vector
))
3018 if (char_table_depth
== 0)
3020 /* VECTOR is a top level char-table. */
3023 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3027 /* VECTOR is a sub char-table. */
3028 if (char_table_depth
>= 3)
3029 /* A char-table is never that deep. */
3030 error ("Too deep char table");
3033 = (CHARSET_VALID_P (indices
[0])
3034 && ((CHARSET_DIMENSION (indices
[0]) == 1
3035 && char_table_depth
== 1)
3036 || char_table_depth
== 2));
3038 /* Meaningful elements are from 32th to 127th. */
3040 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3045 /* This does the right thing for ordinary vectors. */
3049 to
= XVECTOR (vector
)->size
;
3052 for (i
= from
; i
< to
; i
++)
3056 if (CHAR_TABLE_P (vector
))
3058 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3061 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3062 && !CHARSET_DEFINED_P (i
- 128))
3066 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3069 definition
= get_keyelt (AREF (vector
, i
), 0);
3071 if (NILP (definition
)) continue;
3073 /* Don't mention suppressed commands. */
3074 if (SYMBOLP (definition
) && partial
)
3078 tem
= Fget (definition
, suppress
);
3080 if (!NILP (tem
)) continue;
3083 /* Set CHARACTER to the character this entry describes, if any.
3084 Also update *INDICES. */
3085 if (CHAR_TABLE_P (vector
))
3087 indices
[char_table_depth
] = i
;
3089 if (char_table_depth
== 0)
3092 indices
[0] = i
- 128;
3094 else if (complete_char
)
3096 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3104 /* If this binding is shadowed by some other map, ignore it. */
3105 if (!NILP (shadow
) && complete_char
)
3109 ASET (kludge
, 0, make_number (character
));
3110 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3112 if (!NILP (tem
)) continue;
3115 /* Ignore this definition if it is shadowed by an earlier
3116 one in the same keymap. */
3117 if (!NILP (entire_map
) && complete_char
)
3121 ASET (kludge
, 0, make_number (character
));
3122 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3124 if (!EQ (tem
, definition
))
3130 if (char_table_depth
== 0)
3135 /* For a sub char-table, show the depth by indentation.
3136 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3137 if (char_table_depth
> 0)
3138 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3140 /* Output the prefix that applies to every entry in this map. */
3141 if (!NILP (elt_prefix
))
3142 insert1 (elt_prefix
);
3144 /* Insert or describe the character this slot is for,
3145 or a description of what it is for. */
3146 if (SUB_CHAR_TABLE_P (vector
))
3149 insert_char (character
);
3152 /* We need an octal representation for this block of
3155 sprintf (work
, "(row %d)", i
);
3156 insert (work
, strlen (work
));
3159 else if (CHAR_TABLE_P (vector
))
3162 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3165 /* Print the information for this character set. */
3166 insert_string ("<");
3167 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3169 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3170 STRING_BYTES (XSTRING (tem2
)), 0);
3178 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3181 /* If we find a sub char-table within a char-table,
3182 scan it recursively; it defines the details for
3183 a character set or a portion of a character set. */
3184 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3187 describe_vector (definition
, elt_prefix
, elt_describer
,
3188 partial
, shadow
, entire_map
,
3189 indices
, char_table_depth
+ 1);
3195 /* Find all consecutive characters or rows that have the same
3196 definition. But, for elements of a top level char table, if
3197 they are for charsets, we had better describe one by one even
3198 if they have the same definition. */
3199 if (CHAR_TABLE_P (vector
))
3203 if (char_table_depth
== 0)
3204 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3206 while (i
+ 1 < limit
3207 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3209 && !NILP (Fequal (tem2
, definition
)))
3214 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3216 && !NILP (Fequal (tem2
, definition
)))
3220 /* If we have a range of more than one character,
3221 print where the range reaches to. */
3223 if (i
!= starting_i
)
3227 if (!NILP (elt_prefix
))
3228 insert1 (elt_prefix
);
3230 if (CHAR_TABLE_P (vector
))
3232 if (char_table_depth
== 0)
3234 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3236 else if (complete_char
)
3238 indices
[char_table_depth
] = i
;
3239 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3240 insert_char (character
);
3244 /* We need an octal representation for this block of
3247 sprintf (work
, "(row %d)", i
);
3248 insert (work
, strlen (work
));
3253 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3257 /* Print a description of the definition of this character.
3258 elt_describer will take care of spacing out far enough
3259 for alignment purposes. */
3260 (*elt_describer
) (definition
);
3263 /* For (sub) char-table, print `defalt' slot at last. */
3264 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3266 insert (" ", char_table_depth
* 2);
3267 insert_string ("<<default>>");
3268 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3274 /* Apropos - finding all symbols whose names match a regexp. */
3275 Lisp_Object apropos_predicate
;
3276 Lisp_Object apropos_accumulate
;
3279 apropos_accum (symbol
, string
)
3280 Lisp_Object symbol
, string
;
3282 register Lisp_Object tem
;
3284 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3285 if (!NILP (tem
) && !NILP (apropos_predicate
))
3286 tem
= call1 (apropos_predicate
, symbol
);
3288 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3291 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3292 "Show all symbols whose names contain match for REGEXP.\n\
3293 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3294 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3295 Return list of symbols found.")
3297 Lisp_Object regexp
, predicate
;
3299 struct gcpro gcpro1
, gcpro2
;
3300 CHECK_STRING (regexp
, 0);
3301 apropos_predicate
= predicate
;
3302 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3303 apropos_accumulate
= Qnil
;
3304 map_obarray (Vobarray
, apropos_accum
, regexp
);
3305 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3307 return apropos_accumulate
;
3313 Qkeymap
= intern ("keymap");
3314 staticpro (&Qkeymap
);
3316 /* Now we are ready to set up this property, so we can
3317 create char tables. */
3318 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3320 /* Initialize the keymaps standardly used.
3321 Each one is the value of a Lisp variable, and is also
3322 pointed to by a C variable */
3324 global_map
= Fmake_keymap (Qnil
);
3325 Fset (intern ("global-map"), global_map
);
3327 current_global_map
= global_map
;
3328 staticpro (&global_map
);
3329 staticpro (¤t_global_map
);
3331 meta_map
= Fmake_keymap (Qnil
);
3332 Fset (intern ("esc-map"), meta_map
);
3333 Ffset (intern ("ESC-prefix"), meta_map
);
3335 control_x_map
= Fmake_keymap (Qnil
);
3336 Fset (intern ("ctl-x-map"), control_x_map
);
3337 Ffset (intern ("Control-X-prefix"), control_x_map
);
3339 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3340 "List of commands given new key bindings recently.\n\
3341 This is used for internal purposes during Emacs startup;\n\
3342 don't alter it yourself.");
3343 Vdefine_key_rebound_commands
= Qt
;
3345 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3346 "Default keymap to use when reading from the minibuffer.");
3347 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3349 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3350 "Local keymap for the minibuffer when spaces are not allowed.");
3351 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3352 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3354 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3355 "Local keymap for minibuffer input with completion.");
3356 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3357 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3359 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3360 "Local keymap for minibuffer input with completion, for exact match.");
3361 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3362 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3363 Vminibuffer_local_completion_map
);
3365 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3366 "Alist of keymaps to use for minor modes.\n\
3367 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3368 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3369 If two active keymaps bind the same key, the keymap appearing earlier\n\
3370 in the list takes precedence.");
3371 Vminor_mode_map_alist
= Qnil
;
3373 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3374 "Alist of keymaps to use for minor modes, in current major mode.\n\
3375 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3376 used the same way (and before `minor-mode-map-alist'); however,\n\
3377 it is provided for major modes to bind locally.");
3378 Vminor_mode_overriding_map_alist
= Qnil
;
3380 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3381 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3382 This allows Emacs to recognize function keys sent from ASCII\n\
3383 terminals at any point in a key sequence.\n\
3385 The `read-key-sequence' function replaces any subsequence bound by\n\
3386 `function-key-map' with its binding. More precisely, when the active\n\
3387 keymaps have no binding for the current key sequence but\n\
3388 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3389 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3390 continues with the new sequence.\n\
3392 The events that come from bindings in `function-key-map' are not\n\
3393 themselves looked up in `function-key-map'.\n\
3395 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3396 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3397 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3398 key, typing `ESC O P x' would return [f1 x].");
3399 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3401 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3402 "Keymap of key translations that can override keymaps.\n\
3403 This keymap works like `function-key-map', but comes after that,\n\
3404 and applies even for keys that have ordinary bindings.");
3405 Vkey_translation_map
= Qnil
;
3407 Qsingle_key_description
= intern ("single-key-description");
3408 staticpro (&Qsingle_key_description
);
3410 Qkey_description
= intern ("key-description");
3411 staticpro (&Qkey_description
);
3413 Qkeymapp
= intern ("keymapp");
3414 staticpro (&Qkeymapp
);
3416 Qnon_ascii
= intern ("non-ascii");
3417 staticpro (&Qnon_ascii
);
3419 Qmenu_item
= intern ("menu-item");
3420 staticpro (&Qmenu_item
);
3422 where_is_cache_keymaps
= Qt
;
3423 where_is_cache
= Qnil
;
3424 staticpro (&where_is_cache
);
3425 staticpro (&where_is_cache_keymaps
);
3427 defsubr (&Skeymapp
);
3428 defsubr (&Skeymap_parent
);
3429 defsubr (&Skeymap_prompt
);
3430 defsubr (&Sset_keymap_parent
);
3431 defsubr (&Smake_keymap
);
3432 defsubr (&Smake_sparse_keymap
);
3433 defsubr (&Scopy_keymap
);
3434 defsubr (&Skey_binding
);
3435 defsubr (&Slocal_key_binding
);
3436 defsubr (&Sglobal_key_binding
);
3437 defsubr (&Sminor_mode_key_binding
);
3438 defsubr (&Sdefine_key
);
3439 defsubr (&Slookup_key
);
3440 defsubr (&Sdefine_prefix_command
);
3441 defsubr (&Suse_global_map
);
3442 defsubr (&Suse_local_map
);
3443 defsubr (&Scurrent_local_map
);
3444 defsubr (&Scurrent_global_map
);
3445 defsubr (&Scurrent_minor_mode_maps
);
3446 defsubr (&Scurrent_active_maps
);
3447 defsubr (&Saccessible_keymaps
);
3448 defsubr (&Skey_description
);
3449 defsubr (&Sdescribe_vector
);
3450 defsubr (&Ssingle_key_description
);
3451 defsubr (&Stext_char_description
);
3452 defsubr (&Swhere_is_internal
);
3453 defsubr (&Sdescribe_buffer_bindings
);
3454 defsubr (&Sapropos_internal
);
3460 initial_define_key (global_map
, 033, "ESC-prefix");
3461 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");