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 /* Alist of elements like (DEL . "\d"). */
95 static Lisp_Object exclude_keys
;
97 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
98 in a string key sequence is equivalent to prefixing with this
100 extern Lisp_Object meta_prefix_char
;
102 extern Lisp_Object Voverriding_local_map
;
104 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
105 static Lisp_Object where_is_cache
;
106 /* Which keymaps are reverse-stored in the cache. */
107 static Lisp_Object where_is_cache_keymaps
;
109 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
110 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
112 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
113 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
114 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
115 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
116 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
117 int, Lisp_Object
, Lisp_Object
*, int));
118 static void silly_event_symbol_error
P_ ((Lisp_Object
));
120 /* Keymap object support - constructors and predicates. */
122 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
123 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
124 CHARTABLE is a char-table that holds the bindings for the ASCII
125 characters. ALIST is an assoc-list which holds bindings for function keys,
126 mouse events, and any other things that appear in the input stream.
127 All entries in it are initially nil, meaning "command undefined".
129 The optional arg STRING supplies a menu name for the keymap
130 in case you use it as a menu with `x-popup-menu'. */)
136 tail
= Fcons (string
, Qnil
);
139 return Fcons (Qkeymap
,
140 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
143 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
144 doc
: /* Construct and return a new sparse keymap.
145 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
146 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
147 which binds the function key or mouse event SYMBOL to DEFINITION.
148 Initially the alist is nil.
150 The optional arg STRING supplies a menu name for the keymap
151 in case you use it as a menu with `x-popup-menu'. */)
156 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
157 return Fcons (Qkeymap
, Qnil
);
160 /* This function is used for installing the standard key bindings
161 at initialization time.
165 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
168 initial_define_key (keymap
, key
, defname
)
173 store_in_keymap (keymap
, make_number (key
), intern (defname
));
177 initial_define_lispy_key (keymap
, keyname
, defname
)
182 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
185 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
186 doc
: /* Return t if OBJECT is a keymap.
188 A keymap is a list (keymap . ALIST),
189 or a symbol whose function definition is itself a keymap.
190 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
191 a vector of densely packed bindings for small character codes
192 is also allowed as an element. */)
196 return (KEYMAPP (object
) ? Qt
: Qnil
);
199 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
200 doc
: /* Return the prompt-string of a keymap MAP.
201 If non-nil, the prompt is shown in the echo-area
202 when reading a key-sequence to be looked-up in this keymap. */)
208 register Lisp_Object tem
;
217 /* Check that OBJECT is a keymap (after dereferencing through any
218 symbols). If it is, return it.
220 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
221 is an autoload form, do the autoload and try again.
222 If AUTOLOAD is nonzero, callers must assume GC is possible.
224 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
225 is zero as well), return Qt.
227 ERROR controls how we respond if OBJECT isn't a keymap.
228 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
230 Note that most of the time, we don't want to pursue autoloads.
231 Functions like Faccessible_keymaps which scan entire keymap trees
232 shouldn't load every autoloaded keymap. I'm not sure about this,
233 but it seems to me that only read_key_sequence, Flookup_key, and
234 Fdefine_key should cause keymaps to be autoloaded.
236 This function can GC when AUTOLOAD is non-zero, because it calls
237 do_autoload which can GC. */
240 get_keymap (object
, error
, autoload
)
249 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
252 tem
= indirect_function (object
);
255 if (EQ (XCAR (tem
), Qkeymap
))
258 /* Should we do an autoload? Autoload forms for keymaps have
259 Qkeymap as their fifth element. */
260 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
))
264 tail
= Fnth (make_number (4), tem
);
265 if (EQ (tail
, Qkeymap
))
269 struct gcpro gcpro1
, gcpro2
;
271 GCPRO2 (tem
, object
);
272 do_autoload (tem
, object
);
285 wrong_type_argument (Qkeymapp
, object
);
289 /* Return the parent map of the keymap MAP, or nil if it has none.
290 We assume that MAP is a valid keymap. */
292 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
293 doc
: /* Return the parent keymap of KEYMAP. */)
299 keymap
= get_keymap (keymap
, 1, 1);
301 /* Skip past the initial element `keymap'. */
302 list
= XCDR (keymap
);
303 for (; CONSP (list
); list
= XCDR (list
))
305 /* See if there is another `keymap'. */
310 return get_keymap (list
, 0, 1);
314 /* Check whether MAP is one of MAPS parents. */
316 keymap_memberp (map
, maps
)
317 Lisp_Object map
, maps
;
319 if (NILP (map
)) return 0;
320 while (KEYMAPP (maps
) && !EQ (map
, maps
))
321 maps
= Fkeymap_parent (maps
);
322 return (EQ (map
, maps
));
325 /* Set the parent keymap of MAP to PARENT. */
327 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
328 doc
: /* Modify KEYMAP to set its parent map to PARENT.
329 PARENT should be nil or another keymap. */)
331 Lisp_Object keymap
, parent
;
333 Lisp_Object list
, prev
;
337 /* Force a keymap flush for the next call to where-is.
338 Since this can be called from within where-is, we don't set where_is_cache
339 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
340 be changed during where-is, while where_is_cache_keymaps is only used at
341 the very beginning of where-is and can thus be changed here without any
343 This is a very minor correctness (rather than safety) issue. */
344 where_is_cache_keymaps
= Qt
;
346 keymap
= get_keymap (keymap
, 1, 1);
351 parent
= get_keymap (parent
, 1, 1);
353 /* Check for cycles. */
354 if (keymap_memberp (keymap
, parent
))
355 error ("Cyclic keymap inheritance");
358 /* Skip past the initial element `keymap'. */
363 /* If there is a parent keymap here, replace it.
364 If we came to the end, add the parent in PREV. */
365 if (!CONSP (list
) || KEYMAPP (list
))
367 /* If we already have the right parent, return now
368 so that we avoid the loops below. */
369 if (EQ (XCDR (prev
), parent
))
370 RETURN_UNGCPRO (parent
);
372 XSETCDR (prev
, parent
);
378 /* Scan through for submaps, and set their parents too. */
380 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
382 /* Stop the scan when we come to the parent. */
383 if (EQ (XCAR (list
), Qkeymap
))
386 /* If this element holds a prefix map, deal with it. */
387 if (CONSP (XCAR (list
))
388 && CONSP (XCDR (XCAR (list
))))
389 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
392 if (VECTORP (XCAR (list
)))
393 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
394 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
395 fix_submap_inheritance (keymap
, make_number (i
),
396 XVECTOR (XCAR (list
))->contents
[i
]);
398 if (CHAR_TABLE_P (XCAR (list
)))
400 Lisp_Object indices
[3];
402 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
),
407 RETURN_UNGCPRO (parent
);
410 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
411 if EVENT is also a prefix in MAP's parent,
412 make sure that SUBMAP inherits that definition as its own parent. */
415 fix_submap_inheritance (map
, event
, submap
)
416 Lisp_Object map
, event
, submap
;
418 Lisp_Object map_parent
, parent_entry
;
420 /* SUBMAP is a cons that we found as a key binding.
421 Discard the other things found in a menu key binding. */
423 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
425 /* If it isn't a keymap now, there's no work to do. */
429 map_parent
= Fkeymap_parent (map
);
430 if (!NILP (map_parent
))
432 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
436 /* If MAP's parent has something other than a keymap,
437 our own submap shadows it completely. */
438 if (!CONSP (parent_entry
))
441 if (! EQ (parent_entry
, submap
))
443 Lisp_Object submap_parent
;
444 submap_parent
= submap
;
449 tem
= Fkeymap_parent (submap_parent
);
453 if (keymap_memberp (tem
, parent_entry
))
454 /* Fset_keymap_parent could create a cycle. */
461 Fset_keymap_parent (submap_parent
, parent_entry
);
465 /* Look up IDX in MAP. IDX may be any sort of event.
466 Note that this does only one level of lookup; IDX must be a single
467 event, not a sequence.
469 If T_OK is non-zero, bindings for Qt are treated as default
470 bindings; any key left unmentioned by other tables and bindings is
471 given the binding of Qt.
473 If T_OK is zero, bindings for Qt are not treated specially.
475 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
478 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
487 /* Qunbound in VAL means we have found no binding yet. */
490 /* If idx is a list (some sort of mouse click, perhaps?),
491 the index we want to use is the car of the list, which
492 ought to be a symbol. */
493 idx
= EVENT_HEAD (idx
);
495 /* If idx is a symbol, it might have modifiers, which need to
496 be put in the canonical order. */
498 idx
= reorder_modifiers (idx
);
499 else if (INTEGERP (idx
))
500 /* Clobber the high bits that can be present on a machine
501 with more than 24 bits of integer. */
502 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
504 /* Handle the special meta -> esc mapping. */
505 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
507 /* See if there is a meta-map. If there's none, there is
508 no binding for IDX, unless a default binding exists in MAP. */
509 Lisp_Object meta_map
=
510 get_keymap (access_keymap (map
, meta_prefix_char
,
511 t_ok
, noinherit
, autoload
),
513 if (CONSP (meta_map
))
516 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
519 /* Set IDX to t, so that we only find a default binding. */
522 /* We know there is no binding. */
529 /* t_binding is where we put a default binding that applies,
530 to use in case we do not find a binding specifically
531 for this key sequence. */
533 Lisp_Object t_binding
;
536 /* If `t_ok' is 2, both `t' and generic-char bindings are accepted.
537 If it is 1, only generic-char bindings are accepted.
538 Otherwise, neither are. */
541 for (tail
= XCDR (map
);
543 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
548 binding
= XCAR (tail
);
549 if (SYMBOLP (binding
))
551 /* If NOINHERIT, stop finding prefix definitions
552 after we pass a second occurrence of the `keymap' symbol. */
553 if (noinherit
&& EQ (binding
, Qkeymap
))
556 else if (CONSP (binding
))
558 Lisp_Object key
= XCAR (binding
);
561 val
= XCDR (binding
);
564 && (XINT (idx
) & CHAR_MODIFIER_MASK
) == 0
566 && (XINT (key
) & CHAR_MODIFIER_MASK
) == 0
567 && !SINGLE_BYTE_CHAR_P (XINT (idx
))
568 && !SINGLE_BYTE_CHAR_P (XINT (key
))
569 && CHAR_VALID_P (XINT (key
), 1)
570 && !CHAR_VALID_P (XINT (key
), 0)
571 && (CHAR_CHARSET (XINT (key
))
572 == CHAR_CHARSET (XINT (idx
))))
574 /* KEY is the generic character of the charset of IDX.
575 Use KEY's binding if there isn't a binding for IDX
577 t_binding
= XCDR (binding
);
580 else if (t_ok
> 1 && EQ (key
, Qt
))
582 t_binding
= XCDR (binding
);
586 else if (VECTORP (binding
))
588 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
589 val
= AREF (binding
, XFASTINT (idx
));
591 else if (CHAR_TABLE_P (binding
))
593 /* Character codes with modifiers
594 are not included in a char-table.
595 All character codes without modifiers are included. */
596 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
598 val
= Faref (binding
, idx
);
599 /* `nil' has a special meaning for char-tables, so
600 we use something else to record an explicitly
607 /* If we found a binding, clean it up and return it. */
608 if (!EQ (val
, Qunbound
))
611 /* A Qt binding is just like an explicit nil binding
612 (i.e. it shadows any parent binding but not bindings in
613 keymaps of lower precedence). */
615 val
= get_keyelt (val
, autoload
);
617 fix_submap_inheritance (map
, idx
, val
);
623 return get_keyelt (t_binding
, autoload
);
627 /* Given OBJECT which was found in a slot in a keymap,
628 trace indirect definitions to get the actual definition of that slot.
629 An indirect definition is a list of the form
630 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
631 and INDEX is the object to look up in KEYMAP to yield the definition.
633 Also if OBJECT has a menu string as the first element,
634 remove that. Also remove a menu help string as second element.
636 If AUTOLOAD is nonzero, load autoloadable keymaps
637 that are referred to with indirection. */
640 get_keyelt (object
, autoload
)
641 register Lisp_Object object
;
646 if (!(CONSP (object
)))
647 /* This is really the value. */
650 /* If the keymap contents looks like (keymap ...) or (lambda ...)
652 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
655 /* If the keymap contents looks like (menu-item name . DEFN)
656 or (menu-item name DEFN ...) then use DEFN.
657 This is a new format menu item. */
658 else if (EQ (XCAR (object
), Qmenu_item
))
660 if (CONSP (XCDR (object
)))
664 object
= XCDR (XCDR (object
));
667 object
= XCAR (object
);
669 /* If there's a `:filter FILTER', apply FILTER to the
670 menu-item's definition to get the real definition to
672 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
673 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
676 filter
= XCAR (XCDR (tem
));
677 filter
= list2 (filter
, list2 (Qquote
, object
));
678 object
= menu_item_eval_property (filter
);
687 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
688 Keymap alist elements like (CHAR MENUSTRING . DEFN)
689 will be used by HierarKey menus. */
690 else if (STRINGP (XCAR (object
)))
692 object
= XCDR (object
);
693 /* Also remove a menu help string, if any,
694 following the menu item name. */
695 if (CONSP (object
) && STRINGP (XCAR (object
)))
696 object
= XCDR (object
);
697 /* Also remove the sublist that caches key equivalences, if any. */
698 if (CONSP (object
) && CONSP (XCAR (object
)))
701 carcar
= XCAR (XCAR (object
));
702 if (NILP (carcar
) || VECTORP (carcar
))
703 object
= XCDR (object
);
707 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
711 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
712 return (!CONSP (map
) ? object
/* Invalid keymap */
713 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
719 store_in_keymap (keymap
, idx
, def
)
721 register Lisp_Object idx
;
722 register Lisp_Object def
;
724 /* Flush any reverse-map cache. */
725 where_is_cache
= Qnil
;
726 where_is_cache_keymaps
= Qt
;
728 /* If we are preparing to dump, and DEF is a menu element
729 with a menu item indicator, copy it to ensure it is not pure. */
730 if (CONSP (def
) && PURE_P (def
)
731 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
732 def
= Fcons (XCAR (def
), XCDR (def
));
734 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
735 error ("attempt to define a key in a non-keymap");
737 /* If idx is a list (some sort of mouse click, perhaps?),
738 the index we want to use is the car of the list, which
739 ought to be a symbol. */
740 idx
= EVENT_HEAD (idx
);
742 /* If idx is a symbol, it might have modifiers, which need to
743 be put in the canonical order. */
745 idx
= reorder_modifiers (idx
);
746 else if (INTEGERP (idx
))
747 /* Clobber the high bits that can be present on a machine
748 with more than 24 bits of integer. */
749 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
751 /* Scan the keymap for a binding of idx. */
755 /* The cons after which we should insert new bindings. If the
756 keymap has a table element, we record its position here, so new
757 bindings will go after it; this way, the table will stay
758 towards the front of the alist and character lookups in dense
759 keymaps will remain fast. Otherwise, this just points at the
760 front of the keymap. */
761 Lisp_Object insertion_point
;
763 insertion_point
= keymap
;
764 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
771 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
773 ASET (elt
, XFASTINT (idx
), def
);
776 insertion_point
= tail
;
778 else if (CHAR_TABLE_P (elt
))
780 /* Character codes with modifiers
781 are not included in a char-table.
782 All character codes without modifiers are included. */
783 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
786 /* `nil' has a special meaning for char-tables, so
787 we use something else to record an explicitly
789 NILP (def
) ? Qt
: def
);
792 insertion_point
= tail
;
794 else if (CONSP (elt
))
796 if (EQ (idx
, XCAR (elt
)))
802 else if (EQ (elt
, Qkeymap
))
803 /* If we find a 'keymap' symbol in the spine of KEYMAP,
804 then we must have found the start of a second keymap
805 being used as the tail of KEYMAP, and a binding for IDX
806 should be inserted before it. */
813 /* We have scanned the entire keymap, and not found a binding for
814 IDX. Let's add one. */
815 XSETCDR (insertion_point
,
816 Fcons (Fcons (idx
, def
), XCDR (insertion_point
)));
822 EXFUN (Fcopy_keymap
, 1);
825 copy_keymap_1 (chartable
, idx
, elt
)
826 Lisp_Object chartable
, idx
, elt
;
828 if (CONSP (elt
) && EQ (XCAR (elt
), Qkeymap
))
829 Faset (chartable
, idx
, Fcopy_keymap (elt
));
832 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
833 doc
: /* Return a copy of the keymap KEYMAP.
834 The copy starts out with the same definitions of KEYMAP,
835 but changing either the copy or KEYMAP does not affect the other.
836 Any key definitions that are subkeymaps are recursively copied.
837 However, a key definition which is a symbol whose definition is a keymap
842 /* FIXME: This doesn't properly copy menu-items in vectors. */
843 /* FIXME: This also copies the parent keymap. */
845 register Lisp_Object copy
, tail
;
847 copy
= Fcopy_alist (get_keymap (keymap
, 1, 0));
849 for (tail
= copy
; CONSP (tail
); tail
= XCDR (tail
))
854 if (CHAR_TABLE_P (elt
))
856 Lisp_Object indices
[3];
858 elt
= Fcopy_sequence (elt
);
861 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
863 else if (VECTORP (elt
))
867 elt
= Fcopy_sequence (elt
);
870 for (i
= 0; i
< ASIZE (elt
); i
++)
871 if (CONSP (AREF (elt
, i
)) && EQ (XCAR (AREF (elt
, i
)), Qkeymap
))
872 ASET (elt
, i
, Fcopy_keymap (AREF (elt
, i
)));
874 else if (CONSP (elt
) && CONSP (XCDR (elt
)))
879 /* Is this a new format menu item. */
880 if (EQ (XCAR (tem
),Qmenu_item
))
882 /* Copy cell with menu-item marker. */
884 Fcons (XCAR (tem
), XCDR (tem
)));
889 /* Copy cell with menu-item name. */
891 Fcons (XCAR (tem
), XCDR (tem
)));
897 /* Copy cell with binding and if the binding is a keymap,
900 Fcons (XCAR (tem
), XCDR (tem
)));
903 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
904 XSETCAR (elt
, Fcopy_keymap (tem
));
906 if (CONSP (tem
) && CONSP (XCAR (tem
)))
907 /* Delete cache for key equivalences. */
908 XSETCDR (elt
, XCDR (tem
));
913 /* It may be an old fomat menu item.
914 Skip the optional menu string.
916 if (STRINGP (XCAR (tem
)))
918 /* Copy the cell, since copy-alist didn't go this deep. */
920 Fcons (XCAR (tem
), XCDR (tem
)));
923 /* Also skip the optional menu help string. */
924 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
927 Fcons (XCAR (tem
), XCDR (tem
)));
931 /* There may also be a list that caches key equivalences.
932 Just delete it for the new keymap. */
934 && CONSP (XCAR (tem
))
935 && (NILP (XCAR (XCAR (tem
)))
936 || VECTORP (XCAR (XCAR (tem
)))))
937 XSETCDR (elt
, XCDR (tem
));
940 && CONSP (XCDR (elt
))
941 && EQ (XCAR (XCDR (elt
)), Qkeymap
))
942 XSETCDR (elt
, Fcopy_keymap (XCDR (elt
)));
951 /* Simple Keymap mutators and accessors. */
953 /* GC is possible in this function if it autoloads a keymap. */
955 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
956 doc
: /* Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.
957 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters
958 meaning a sequence of keystrokes and events.
959 Non-ASCII characters with codes above 127 (such as ISO Latin-1)
960 can be included if you use a vector.
961 DEF is anything that can be a key's definition:
962 nil (means key is undefined in this keymap),
963 a command (a Lisp function suitable for interactive calling)
964 a string (treated as a keyboard macro),
965 a keymap (to define a prefix key),
966 a symbol. When the key is looked up, the symbol will stand for its
967 function definition, which should at that time be one of the above,
968 or another symbol whose function definition is used, etc.
969 a cons (STRING . DEFN), meaning that DEFN is the definition
970 (DEFN should be a valid definition in its own right),
971 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.
973 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at
974 the front of KEYMAP. */)
981 register Lisp_Object c
;
982 register Lisp_Object cmd
;
986 struct gcpro gcpro1
, gcpro2
, gcpro3
;
988 keymap
= get_keymap (keymap
, 1, 1);
990 if (!VECTORP (key
) && !STRINGP (key
))
991 key
= wrong_type_argument (Qarrayp
, key
);
993 length
= XFASTINT (Flength (key
));
997 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
998 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1000 GCPRO3 (keymap
, key
, def
);
1003 meta_bit
= meta_modifier
;
1010 c
= Faref (key
, make_number (idx
));
1012 if (CONSP (c
) && lucid_event_type_list_p (c
))
1013 c
= Fevent_convert_list (c
);
1016 silly_event_symbol_error (c
);
1019 && (XINT (c
) & meta_bit
)
1022 c
= meta_prefix_char
;
1028 XSETINT (c
, XINT (c
) & ~meta_bit
);
1034 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1035 error ("Key sequence contains invalid event");
1038 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1040 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1042 /* If this key is undefined, make it a prefix. */
1044 cmd
= define_as_prefix (keymap
, c
);
1046 keymap
= get_keymap (cmd
, 0, 1);
1047 if (!CONSP (keymap
))
1048 /* We must use Fkey_description rather than just passing key to
1049 error; key might be a vector, not a string. */
1050 error ("Key sequence %s uses invalid prefix characters",
1051 XSTRING (Fkey_description (key
))->data
);
1055 /* Value is number if KEY is too long; nil if valid but has no definition. */
1056 /* GC is possible in this function if it autoloads a keymap. */
1058 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1059 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1060 nil means undefined. See doc of `define-key' for kinds of definitions.
1062 A number as value means KEY is "too long";
1063 that is, characters or symbols in it except for the last one
1064 fail to be a valid sequence of prefix characters in KEYMAP.
1065 The number is how many characters at the front of KEY
1066 it takes to reach a non-prefix command.
1068 Normally, `lookup-key' ignores bindings for t, which act as default
1069 bindings, used when nothing else in the keymap applies; this makes it
1070 usable as a general function for probing keymaps. However, if the
1071 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1072 recognize the default bindings, just as `read-key-sequence' does. */)
1073 (keymap
, key
, accept_default
)
1074 register Lisp_Object keymap
;
1076 Lisp_Object accept_default
;
1079 register Lisp_Object cmd
;
1080 register Lisp_Object c
;
1082 int t_ok
= !NILP (accept_default
);
1083 struct gcpro gcpro1
;
1085 keymap
= get_keymap (keymap
, 1, 1);
1087 if (!VECTORP (key
) && !STRINGP (key
))
1088 key
= wrong_type_argument (Qarrayp
, key
);
1090 length
= XFASTINT (Flength (key
));
1099 c
= Faref (key
, make_number (idx
++));
1101 if (CONSP (c
) && lucid_event_type_list_p (c
))
1102 c
= Fevent_convert_list (c
);
1104 /* Turn the 8th bit of string chars into a meta modifier. */
1105 if (XINT (c
) & 0x80 && STRINGP (key
))
1106 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1108 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1109 error ("Key sequence contains invalid event");
1111 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1113 RETURN_UNGCPRO (cmd
);
1115 keymap
= get_keymap (cmd
, 0, 1);
1116 if (!CONSP (keymap
))
1117 RETURN_UNGCPRO (make_number (idx
));
1123 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1124 Assume that currently it does not define C at all.
1125 Return the keymap. */
1128 define_as_prefix (keymap
, c
)
1129 Lisp_Object keymap
, c
;
1133 cmd
= Fmake_sparse_keymap (Qnil
);
1134 /* If this key is defined as a prefix in an inherited keymap,
1135 make it a prefix in this map, and make its definition
1136 inherit the other prefix definition. */
1137 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1138 store_in_keymap (keymap
, c
, cmd
);
1143 /* Append a key to the end of a key sequence. We always make a vector. */
1146 append_key (key_sequence
, key
)
1147 Lisp_Object key_sequence
, key
;
1149 Lisp_Object args
[2];
1151 args
[0] = key_sequence
;
1153 args
[1] = Fcons (key
, Qnil
);
1154 return Fvconcat (2, args
);
1157 /* Given a event type C which is a symbol,
1158 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1161 silly_event_symbol_error (c
)
1164 Lisp_Object parsed
, base
, name
, assoc
;
1167 parsed
= parse_modifiers (c
);
1168 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1169 base
= XCAR (parsed
);
1170 name
= Fsymbol_name (base
);
1171 /* This alist includes elements such as ("RET" . "\\r"). */
1172 assoc
= Fassoc (name
, exclude_keys
);
1176 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1178 Lisp_Object keystring
;
1179 if (modifiers
& alt_modifier
)
1180 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1181 if (modifiers
& ctrl_modifier
)
1182 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1183 if (modifiers
& hyper_modifier
)
1184 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1185 if (modifiers
& meta_modifier
)
1186 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1187 if (modifiers
& shift_modifier
)
1188 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1189 if (modifiers
& super_modifier
)
1190 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1193 c
= reorder_modifiers (c
);
1194 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1196 error ((modifiers
& ~meta_modifier
1197 ? "To bind the key %s, use [?%s], not [%s]"
1198 : "To bind the key %s, use \"%s\", not [%s]"),
1199 XSYMBOL (c
)->name
->data
, XSTRING (keystring
)->data
,
1200 XSYMBOL (c
)->name
->data
);
1204 /* Global, local, and minor mode keymap stuff. */
1206 /* We can't put these variables inside current_minor_maps, since under
1207 some systems, static gets macro-defined to be the empty string.
1209 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1210 static int cmm_size
;
1212 /* Error handler used in current_minor_maps. */
1214 current_minor_maps_error ()
1219 /* Store a pointer to an array of the keymaps of the currently active
1220 minor modes in *buf, and return the number of maps it contains.
1222 This function always returns a pointer to the same buffer, and may
1223 free or reallocate it, so if you want to keep it for a long time or
1224 hand it out to lisp code, copy it. This procedure will be called
1225 for every key sequence read, so the nice lispy approach (return a
1226 new assoclist, list, what have you) for each invocation would
1227 result in a lot of consing over time.
1229 If we used xrealloc/xmalloc and ran out of memory, they would throw
1230 back to the command loop, which would try to read a key sequence,
1231 which would call this function again, resulting in an infinite
1232 loop. Instead, we'll use realloc/malloc and silently truncate the
1233 list, let the key sequence be read, and hope some other piece of
1234 code signals the error. */
1236 current_minor_maps (modeptr
, mapptr
)
1237 Lisp_Object
**modeptr
, **mapptr
;
1240 int list_number
= 0;
1241 Lisp_Object alist
, assoc
, var
, val
;
1242 Lisp_Object lists
[2];
1244 lists
[0] = Vminor_mode_overriding_map_alist
;
1245 lists
[1] = Vminor_mode_map_alist
;
1247 for (list_number
= 0; list_number
< 2; list_number
++)
1248 for (alist
= lists
[list_number
];
1250 alist
= XCDR (alist
))
1251 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1252 && (var
= XCAR (assoc
), SYMBOLP (var
))
1253 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1258 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1259 and also an entry in Vminor_mode_map_alist,
1260 ignore the latter. */
1261 if (list_number
== 1)
1263 val
= assq_no_quit (var
, lists
[0]);
1270 Lisp_Object
*newmodes
, *newmaps
;
1272 /* Use malloc/realloc here. See the comment above
1279 = (Lisp_Object
*) realloc (cmm_modes
,
1280 cmm_size
* sizeof *newmodes
);
1282 = (Lisp_Object
*) realloc (cmm_maps
,
1283 cmm_size
* sizeof *newmaps
);
1291 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmodes
);
1293 = (Lisp_Object
*) malloc (cmm_size
* sizeof *newmaps
);
1298 cmm_modes
= newmodes
;
1302 if (newmodes
== NULL
|| newmaps
== NULL
)
1306 /* Get the keymap definition--or nil if it is not defined. */
1307 temp
= internal_condition_case_1 (Findirect_function
,
1309 Qerror
, current_minor_maps_error
);
1313 cmm_maps
[i
] = temp
;
1318 if (modeptr
) *modeptr
= cmm_modes
;
1319 if (mapptr
) *mapptr
= cmm_maps
;
1323 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1325 doc
: /* Return a list of the currently active keymaps.
1326 OLP if non-nil indicates that we should obey `overriding-local-map' and
1327 `overriding-terminal-local-map'. */)
1331 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1335 if (!NILP (Voverriding_local_map
))
1336 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1337 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1338 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1340 if (NILP (XCDR (keymaps
)))
1346 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1348 keymaps
= Fcons (local
, keymaps
);
1350 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1352 keymaps
= Fcons (local
, keymaps
);
1354 nmaps
= current_minor_maps (0, &maps
);
1356 for (i
= --nmaps
; i
>= 0; i
--)
1357 if (!NILP (maps
[i
]))
1358 keymaps
= Fcons (maps
[i
], keymaps
);
1364 /* GC is possible in this function if it autoloads a keymap. */
1366 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1367 doc
: /* Return the binding for command KEY in current keymaps.
1368 KEY is a string or vector, a sequence of keystrokes.
1369 The binding is probably a symbol with a function definition.
1371 Normally, `key-binding' ignores bindings for t, which act as default
1372 bindings, used when nothing else in the keymap applies; this makes it
1373 usable as a general function for probing keymaps. However, if the
1374 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1375 recognize the default bindings, just as `read-key-sequence' does. */)
1376 (key
, accept_default
)
1377 Lisp_Object key
, accept_default
;
1379 Lisp_Object
*maps
, value
;
1381 struct gcpro gcpro1
;
1385 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1387 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1388 key
, accept_default
);
1389 if (! NILP (value
) && !INTEGERP (value
))
1390 RETURN_UNGCPRO (value
);
1392 else if (!NILP (Voverriding_local_map
))
1394 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1395 if (! NILP (value
) && !INTEGERP (value
))
1396 RETURN_UNGCPRO (value
);
1402 nmaps
= current_minor_maps (0, &maps
);
1403 /* Note that all these maps are GCPRO'd
1404 in the places where we found them. */
1406 for (i
= 0; i
< nmaps
; i
++)
1407 if (! NILP (maps
[i
]))
1409 value
= Flookup_key (maps
[i
], key
, accept_default
);
1410 if (! NILP (value
) && !INTEGERP (value
))
1411 RETURN_UNGCPRO (value
);
1414 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1417 value
= Flookup_key (local
, key
, accept_default
);
1418 if (! NILP (value
) && !INTEGERP (value
))
1419 RETURN_UNGCPRO (value
);
1422 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1426 value
= Flookup_key (local
, key
, accept_default
);
1427 if (! NILP (value
) && !INTEGERP (value
))
1428 RETURN_UNGCPRO (value
);
1432 value
= Flookup_key (current_global_map
, key
, accept_default
);
1434 if (! NILP (value
) && !INTEGERP (value
))
1440 /* GC is possible in this function if it autoloads a keymap. */
1442 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1443 doc
: /* Return the binding for command KEYS in current local keymap only.
1444 KEYS is a string, a sequence of keystrokes.
1445 The binding is probably a symbol with a function definition.
1447 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1448 bindings; see the description of `lookup-key' for more details about this. */)
1449 (keys
, accept_default
)
1450 Lisp_Object keys
, accept_default
;
1452 register Lisp_Object map
;
1453 map
= current_buffer
->keymap
;
1456 return Flookup_key (map
, keys
, accept_default
);
1459 /* GC is possible in this function if it autoloads a keymap. */
1461 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1462 doc
: /* Return the binding for command KEYS in current global keymap only.
1463 KEYS is a string, a sequence of keystrokes.
1464 The binding is probably a symbol with a function definition.
1465 This function's return values are the same as those of lookup-key
1468 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1469 bindings; see the description of `lookup-key' for more details about this. */)
1470 (keys
, accept_default
)
1471 Lisp_Object keys
, accept_default
;
1473 return Flookup_key (current_global_map
, keys
, accept_default
);
1476 /* GC is possible in this function if it autoloads a keymap. */
1478 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1479 doc
: /* Find the visible minor mode bindings of KEY.
1480 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the
1481 the symbol which names the minor mode binding KEY, and BINDING is
1482 KEY's definition in that mode. In particular, if KEY has no
1483 minor-mode bindings, return nil. If the first binding is a
1484 non-prefix, all subsequent bindings will be omitted, since they would
1485 be ignored. Similarly, the list doesn't include non-prefix bindings
1486 that come after prefix bindings.
1488 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1489 bindings; see the description of `lookup-key' for more details about this. */)
1490 (key
, accept_default
)
1491 Lisp_Object key
, accept_default
;
1493 Lisp_Object
*modes
, *maps
;
1495 Lisp_Object binding
;
1497 struct gcpro gcpro1
, gcpro2
;
1499 nmaps
= current_minor_maps (&modes
, &maps
);
1500 /* Note that all these maps are GCPRO'd
1501 in the places where we found them. */
1504 GCPRO2 (key
, binding
);
1506 for (i
= j
= 0; i
< nmaps
; i
++)
1508 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1509 && !INTEGERP (binding
))
1511 if (KEYMAPP (binding
))
1512 maps
[j
++] = Fcons (modes
[i
], binding
);
1514 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1518 return Flist (j
, maps
);
1521 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1522 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1523 A new sparse keymap is stored as COMMAND's function definition and its value.
1524 If a second optional argument MAPVAR is given, the map is stored as
1525 its value instead of as COMMAND's value; but COMMAND is still defined
1527 The third optional argument NAME, if given, supplies a menu name
1528 string for the map. This is required to use the keymap as a menu. */)
1529 (command
, mapvar
, name
)
1530 Lisp_Object command
, mapvar
, name
;
1533 map
= Fmake_sparse_keymap (name
);
1534 Ffset (command
, map
);
1538 Fset (command
, map
);
1542 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1543 doc
: /* Select KEYMAP as the global keymap. */)
1547 keymap
= get_keymap (keymap
, 1, 1);
1548 current_global_map
= keymap
;
1553 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1554 doc
: /* Select KEYMAP as the local keymap.
1555 If KEYMAP is nil, that means no local keymap. */)
1560 keymap
= get_keymap (keymap
, 1, 1);
1562 current_buffer
->keymap
= keymap
;
1567 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1568 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1571 return current_buffer
->keymap
;
1574 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1575 doc
: /* Return the current global keymap. */)
1578 return current_global_map
;
1581 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1582 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1586 int nmaps
= current_minor_maps (0, &maps
);
1588 return Flist (nmaps
, maps
);
1591 /* Help functions for describing and documenting keymaps. */
1595 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1596 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1597 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1601 cmd
= get_keyelt (cmd
, 0);
1605 tem
= get_keymap (cmd
, 0, 0);
1609 /* Ignore keymaps that are already added to maps. */
1610 tem
= Frassq (cmd
, maps
);
1613 /* If the last key in thisseq is meta-prefix-char,
1614 turn it into a meta-ized keystroke. We know
1615 that the event we're about to append is an
1616 ascii keystroke since we're processing a
1620 int meta_bit
= meta_modifier
;
1621 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1622 tem
= Fcopy_sequence (thisseq
);
1624 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1626 /* This new sequence is the same length as
1627 thisseq, so stick it in the list right
1630 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1634 tem
= append_key (thisseq
, key
);
1635 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1642 accessible_keymaps_char_table (args
, index
, cmd
)
1643 Lisp_Object args
, index
, cmd
;
1645 accessible_keymaps_1 (index
, cmd
,
1649 XINT (XCDR (XCAR (args
))));
1652 /* This function cannot GC. */
1654 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1656 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1657 Returns a list of elements of the form (KEYS . MAP), where the sequence
1658 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1659 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1660 An optional argument PREFIX, if non-nil, should be a key sequence;
1661 then the value includes only maps for prefixes that start with PREFIX. */)
1663 Lisp_Object keymap
, prefix
;
1665 Lisp_Object maps
, good_maps
, tail
;
1668 /* no need for gcpro because we don't autoload any keymaps. */
1671 prefixlen
= XINT (Flength (prefix
));
1675 /* If a prefix was specified, start with the keymap (if any) for
1676 that prefix, so we don't waste time considering other prefixes. */
1678 tem
= Flookup_key (keymap
, prefix
, Qt
);
1679 /* Flookup_key may give us nil, or a number,
1680 if the prefix is not defined in this particular map.
1681 It might even give us a list that isn't a keymap. */
1682 tem
= get_keymap (tem
, 0, 0);
1685 /* Convert PREFIX to a vector now, so that later on
1686 we don't have to deal with the possibility of a string. */
1687 if (STRINGP (prefix
))
1692 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1693 for (i
= 0, i_byte
= 0; i
< XSTRING (prefix
)->size
;)
1697 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1698 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1699 c
^= 0200 | meta_modifier
;
1700 ASET (copy
, i_before
, make_number (c
));
1704 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1710 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1711 get_keymap (keymap
, 1, 0)),
1714 /* For each map in the list maps,
1715 look at any other maps it points to,
1716 and stick them at the end if they are not already in the list.
1718 This is a breadth-first traversal, where tail is the queue of
1719 nodes, and maps accumulates a list of all nodes visited. */
1721 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1723 register Lisp_Object thisseq
, thismap
;
1725 /* Does the current sequence end in the meta-prefix-char? */
1728 thisseq
= Fcar (Fcar (tail
));
1729 thismap
= Fcdr (Fcar (tail
));
1730 last
= make_number (XINT (Flength (thisseq
)) - 1);
1731 is_metized
= (XINT (last
) >= 0
1732 /* Don't metize the last char of PREFIX. */
1733 && XINT (last
) >= prefixlen
1734 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1736 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1740 elt
= XCAR (thismap
);
1744 if (CHAR_TABLE_P (elt
))
1746 Lisp_Object indices
[3];
1748 map_char_table (accessible_keymaps_char_table
, Qnil
,
1749 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1750 Fcons (tail
, thisseq
)),
1753 else if (VECTORP (elt
))
1757 /* Vector keymap. Scan all the elements. */
1758 for (i
= 0; i
< ASIZE (elt
); i
++)
1759 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1760 maps
, tail
, thisseq
, is_metized
);
1763 else if (CONSP (elt
))
1764 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
1765 maps
, tail
, thisseq
,
1766 is_metized
&& INTEGERP (XCAR (elt
)));
1774 /* Now find just the maps whose access prefixes start with PREFIX. */
1777 for (; CONSP (maps
); maps
= XCDR (maps
))
1779 Lisp_Object elt
, thisseq
;
1781 thisseq
= XCAR (elt
);
1782 /* The access prefix must be at least as long as PREFIX,
1783 and the first elements must match those of PREFIX. */
1784 if (XINT (Flength (thisseq
)) >= prefixlen
)
1787 for (i
= 0; i
< prefixlen
; i
++)
1790 XSETFASTINT (i1
, i
);
1791 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1795 good_maps
= Fcons (elt
, good_maps
);
1799 return Fnreverse (good_maps
);
1802 Lisp_Object Qsingle_key_description
, Qkey_description
;
1804 /* This function cannot GC. */
1806 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1807 doc
: /* Return a pretty description of key-sequence KEYS.
1808 Control characters turn into "C-foo" sequences, meta into "M-foo"
1809 spaces are put between sequence elements, etc. */)
1816 Lisp_Object
*args
= NULL
;
1821 vector
= Fmake_vector (Flength (keys
), Qnil
);
1822 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1827 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1828 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1829 c
^= 0200 | meta_modifier
;
1830 XSETFASTINT (AREF (vector
, i_before
), c
);
1837 /* In effect, this computes
1838 (mapconcat 'single-key-description keys " ")
1839 but we shouldn't use mapconcat because it can do GC. */
1841 len
= XVECTOR (keys
)->size
;
1842 sep
= build_string (" ");
1843 /* This has one extra element at the end that we don't pass to Fconcat. */
1844 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1846 for (i
= 0; i
< len
; i
++)
1848 args
[i
* 2] = Fsingle_key_description (AREF (keys
, i
), Qnil
);
1849 args
[i
* 2 + 1] = sep
;
1852 else if (CONSP (keys
))
1854 /* In effect, this computes
1855 (mapconcat 'single-key-description keys " ")
1856 but we shouldn't use mapconcat because it can do GC. */
1858 len
= XFASTINT (Flength (keys
));
1859 sep
= build_string (" ");
1860 /* This has one extra element at the end that we don't pass to Fconcat. */
1861 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1863 for (i
= 0; i
< len
; i
++)
1865 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1866 args
[i
* 2 + 1] = sep
;
1871 keys
= wrong_type_argument (Qarrayp
, keys
);
1874 return empty_string
;
1875 return Fconcat (len
* 2 - 1, args
);
1879 push_key_description (c
, p
, force_multibyte
)
1880 register unsigned int c
;
1882 int force_multibyte
;
1886 /* Clear all the meaningless bits above the meta bit. */
1887 c
&= meta_modifier
| ~ - meta_modifier
;
1888 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1889 | meta_modifier
| shift_modifier
| super_modifier
);
1891 if (c
& alt_modifier
)
1897 if ((c
& ctrl_modifier
) != 0
1898 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1902 c
&= ~ctrl_modifier
;
1904 if (c
& hyper_modifier
)
1908 c
-= hyper_modifier
;
1910 if (c
& meta_modifier
)
1916 if (c
& shift_modifier
)
1920 c
-= shift_modifier
;
1922 if (c
& super_modifier
)
1926 c
-= super_modifier
;
1942 else if (c
== Ctl ('M'))
1950 /* `C-' already added above. */
1951 if (c
> 0 && c
<= Ctl ('Z'))
1970 || (NILP (current_buffer
->enable_multibyte_characters
)
1971 && SINGLE_BYTE_CHAR_P (c
)
1972 && !force_multibyte
))
1978 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
1980 if (force_multibyte
&& valid_p
)
1982 if (SINGLE_BYTE_CHAR_P (c
))
1983 c
= unibyte_char_to_multibyte (c
);
1984 p
+= CHAR_STRING (c
, p
);
1986 else if (NILP (current_buffer
->enable_multibyte_characters
)
1991 /* The biggest character code uses 19 bits. */
1992 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1994 if (c
>= (1 << bit_offset
))
1995 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1999 p
+= CHAR_STRING (c
, p
);
2005 /* This function cannot GC. */
2007 DEFUN ("single-key-description", Fsingle_key_description
,
2008 Ssingle_key_description
, 1, 2, 0,
2009 doc
: /* Return a pretty description of command character KEY.
2010 Control characters turn into C-whatever, etc.
2011 Optional argument NO-ANGLES non-nil means don't put angle brackets
2012 around function keys and event symbols. */)
2014 Lisp_Object key
, no_angles
;
2016 if (CONSP (key
) && lucid_event_type_list_p (key
))
2017 key
= Fevent_convert_list (key
);
2019 key
= EVENT_HEAD (key
);
2021 if (INTEGERP (key
)) /* Normal character */
2023 unsigned int charset
, c1
, c2
;
2024 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
2026 if (SINGLE_BYTE_CHAR_P (without_bits
))
2029 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
2032 && CHARSET_DEFINED_P (charset
)
2033 && ((c1
>= 0 && c1
< 32)
2034 || (c2
>= 0 && c2
< 32)))
2036 /* Handle a generic character. */
2038 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
2039 CHECK_STRING (name
);
2040 return concat2 (build_string ("Character set "), name
);
2044 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
2048 end
= push_key_description (XUINT (key
), tem
, 1);
2050 nchars
= multibyte_chars_in_text (tem
, nbytes
);
2051 if (nchars
== nbytes
)
2054 string
= build_string (tem
);
2057 string
= make_multibyte_string (tem
, nchars
, nbytes
);
2061 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2063 if (NILP (no_angles
))
2066 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
2067 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
2068 return build_string (buffer
);
2071 return Fsymbol_name (key
);
2073 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2074 return Fcopy_sequence (key
);
2076 error ("KEY must be an integer, cons, symbol, or string");
2081 push_text_char_description (c
, p
)
2082 register unsigned int c
;
2094 *p
++ = c
+ 64; /* 'A' - 1 */
2106 /* This function cannot GC. */
2108 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2109 doc
: /* Return a pretty description of file-character CHARACTER.
2110 Control characters turn into "^char", etc. */)
2112 Lisp_Object character
;
2114 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2115 unsigned char str
[6];
2118 CHECK_NUMBER (character
);
2120 c
= XINT (character
);
2121 if (!SINGLE_BYTE_CHAR_P (c
))
2123 int len
= CHAR_STRING (c
, str
);
2125 return make_multibyte_string (str
, 1, len
);
2128 *push_text_char_description (c
& 0377, str
) = 0;
2130 return build_string (str
);
2133 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2136 ascii_sequence_p (seq
)
2140 int len
= XINT (Flength (seq
));
2142 for (i
= 0; i
< len
; i
++)
2144 Lisp_Object ii
, elt
;
2146 XSETFASTINT (ii
, i
);
2147 elt
= Faref (seq
, ii
);
2150 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2158 /* where-is - finding a command in a set of keymaps. */
2160 static Lisp_Object
where_is_internal_1 ();
2161 static void where_is_internal_2 ();
2163 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2164 Returns the first non-nil binding found in any of those maps. */
2167 shadow_lookup (shadow
, key
, flag
)
2168 Lisp_Object shadow
, key
, flag
;
2170 Lisp_Object tail
, value
;
2172 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2174 value
= Flookup_key (XCAR (tail
), key
, flag
);
2175 if (!NILP (value
) && !NATNUMP (value
))
2181 /* This function can GC if Flookup_key autoloads any keymaps. */
2184 where_is_internal (definition
, keymaps
, firstonly
, noindirect
)
2185 Lisp_Object definition
, keymaps
;
2186 Lisp_Object firstonly
, noindirect
;
2188 Lisp_Object maps
= Qnil
;
2189 Lisp_Object found
, sequences
;
2190 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2191 /* 1 means ignore all menu bindings entirely. */
2192 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2195 while (CONSP (found
))
2199 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2200 found
= XCDR (found
);
2203 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2207 for (; !NILP (maps
); maps
= Fcdr (maps
))
2209 /* Key sequence to reach map, and the map that it reaches */
2210 register Lisp_Object
this, map
;
2212 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2213 [M-CHAR] sequences, check if last character of the sequence
2214 is the meta-prefix char. */
2218 this = Fcar (Fcar (maps
));
2219 map
= Fcdr (Fcar (maps
));
2220 last
= make_number (XINT (Flength (this)) - 1);
2221 last_is_meta
= (XINT (last
) >= 0
2222 && EQ (Faref (this, last
), meta_prefix_char
));
2224 /* if (nomenus && !ascii_sequence_p (this)) */
2225 if (nomenus
&& XINT (last
) >= 0
2226 && !INTEGERP (Faref (this, make_number (0))))
2227 /* If no menu entries should be returned, skip over the
2228 keymaps bound to `menu-bar' and `tool-bar' and other
2229 non-ascii prefixes like `C-down-mouse-2'. */
2236 /* Because the code we want to run on each binding is rather
2237 large, we don't want to have two separate loop bodies for
2238 sparse keymap bindings and tables; we want to iterate one
2239 loop body over both keymap and vector bindings.
2241 For this reason, if Fcar (map) is a vector, we don't
2242 advance map to the next element until i indicates that we
2243 have finished off the vector. */
2244 Lisp_Object elt
, key
, binding
;
2252 /* Set key and binding to the current key and binding, and
2253 advance map and i to the next binding. */
2256 Lisp_Object sequence
;
2258 /* In a vector, look at each element. */
2259 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2261 binding
= AREF (elt
, i
);
2262 XSETFASTINT (key
, i
);
2263 sequence
= where_is_internal_1 (binding
, key
, definition
,
2265 last
, nomenus
, last_is_meta
);
2266 if (!NILP (sequence
))
2267 sequences
= Fcons (sequence
, sequences
);
2270 else if (CHAR_TABLE_P (elt
))
2272 Lisp_Object indices
[3];
2275 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2276 Qnil
), /* Result accumulator. */
2277 Fcons (Fcons (this, last
),
2278 Fcons (make_number (nomenus
),
2279 make_number (last_is_meta
))));
2280 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2282 sequences
= XCDR (XCAR (args
));
2284 else if (CONSP (elt
))
2286 Lisp_Object sequence
;
2289 binding
= XCDR (elt
);
2291 sequence
= where_is_internal_1 (binding
, key
, definition
,
2293 last
, nomenus
, last_is_meta
);
2294 if (!NILP (sequence
))
2295 sequences
= Fcons (sequence
, sequences
);
2299 for (; !NILP (sequences
); sequences
= XCDR (sequences
))
2301 Lisp_Object sequence
;
2303 sequence
= XCAR (sequences
);
2305 /* Verify that this key binding is not shadowed by another
2306 binding for the same key, before we say it exists.
2308 Mechanism: look for local definition of this key and if
2309 it is defined and does not match what we found then
2312 Either nil or number as value from Flookup_key
2314 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2317 /* It is a true unshadowed match. Record it, unless it's already
2318 been seen (as could happen when inheriting keymaps). */
2319 if (NILP (Fmember (sequence
, found
)))
2320 found
= Fcons (sequence
, found
);
2322 /* If firstonly is Qnon_ascii, then we can return the first
2323 binding we find. If firstonly is not Qnon_ascii but not
2324 nil, then we should return the first ascii-only binding
2326 if (EQ (firstonly
, Qnon_ascii
))
2327 RETURN_UNGCPRO (sequence
);
2328 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2329 RETURN_UNGCPRO (sequence
);
2336 found
= Fnreverse (found
);
2338 /* firstonly may have been t, but we may have gone all the way through
2339 the keymaps without finding an all-ASCII key sequence. So just
2340 return the best we could find. */
2341 if (!NILP (firstonly
))
2342 return Fcar (found
);
2347 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2348 doc
: /* Return list of keys that invoke DEFINITION.
2349 If KEYMAP is non-nil, search only KEYMAP and the global keymap.
2350 If KEYMAP is nil, search all the currently active keymaps.
2351 If KEYMAP is a list of keymaps, search only those keymaps.
2353 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2354 rather than a list of all possible key sequences.
2355 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2356 no matter what it is.
2357 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,
2358 and entirely reject menu bindings.
2360 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2361 to other keymaps or slots. This makes it possible to search for an
2362 indirect definition itself. */)
2363 (definition
, keymap
, firstonly
, noindirect
)
2364 Lisp_Object definition
, keymap
;
2365 Lisp_Object firstonly
, noindirect
;
2367 Lisp_Object sequences
, keymaps
;
2368 /* 1 means ignore all menu bindings entirely. */
2369 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2372 /* Find the relevant keymaps. */
2373 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2375 else if (!NILP (keymap
))
2376 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2378 keymaps
= Fcurrent_active_maps (Qnil
);
2380 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2381 We don't really need to check `keymap'. */
2382 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2386 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2388 /* Check heuristic-consistency of the cache. */
2389 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2390 where_is_cache
= Qnil
;
2392 if (NILP (where_is_cache
))
2394 /* We need to create the cache. */
2395 Lisp_Object args
[2];
2396 where_is_cache
= Fmake_hash_table (0, args
);
2397 where_is_cache_keymaps
= Qt
;
2399 /* Fill in the cache. */
2400 GCPRO4 (definition
, keymaps
, firstonly
, noindirect
);
2401 where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2404 where_is_cache_keymaps
= keymaps
;
2407 /* We want to process definitions from the last to the first.
2408 Instead of consing, copy definitions to a vector and step
2409 over that vector. */
2410 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2411 n
= XINT (Flength (sequences
));
2412 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2413 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2414 defns
[i
++] = XCAR (sequences
);
2416 /* Verify that the key bindings are not shadowed. Note that
2417 the following can GC. */
2418 GCPRO2 (definition
, keymaps
);
2421 for (i
= n
- 1; i
>= 0; --i
)
2422 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2424 if (ascii_sequence_p (defns
[i
]))
2430 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2435 /* Kill the cache so that where_is_internal_1 doesn't think
2436 we're filling it up. */
2437 where_is_cache
= Qnil
;
2438 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
);
2444 /* This is the function that Fwhere_is_internal calls using map_char_table.
2446 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2448 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2449 Since map_char_table doesn't really use the return value from this function,
2450 we the result append to RESULT, the slot in ARGS.
2452 This function can GC because it calls where_is_internal_1 which can
2456 where_is_internal_2 (args
, key
, binding
)
2457 Lisp_Object args
, key
, binding
;
2459 Lisp_Object definition
, noindirect
, this, last
;
2460 Lisp_Object result
, sequence
;
2461 int nomenus
, last_is_meta
;
2462 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2464 GCPRO3 (args
, key
, binding
);
2465 result
= XCDR (XCAR (args
));
2466 definition
= XCAR (XCAR (XCAR (args
)));
2467 noindirect
= XCDR (XCAR (XCAR (args
)));
2468 this = XCAR (XCAR (XCDR (args
)));
2469 last
= XCDR (XCAR (XCDR (args
)));
2470 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2471 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2473 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2474 this, last
, nomenus
, last_is_meta
);
2476 if (!NILP (sequence
))
2477 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2483 /* This function cannot GC. */
2486 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2487 nomenus
, last_is_meta
)
2488 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2489 int nomenus
, last_is_meta
;
2491 Lisp_Object sequence
;
2493 /* Search through indirections unless that's not wanted. */
2494 if (NILP (noindirect
))
2495 binding
= get_keyelt (binding
, 0);
2497 /* End this iteration if this element does not match
2500 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2501 || EQ (binding
, definition
)
2502 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2503 /* Doesn't match. */
2506 /* We have found a match. Construct the key sequence where we found it. */
2507 if (INTEGERP (key
) && last_is_meta
)
2509 sequence
= Fcopy_sequence (this);
2510 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2513 sequence
= append_key (this, key
);
2515 if (!NILP (where_is_cache
))
2517 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2518 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2525 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2527 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2528 doc
: /* Insert the list of all defined keys and their definitions.
2529 The list is inserted in the current buffer, while the bindings are
2530 looked up in BUFFER.
2531 The optional argument PREFIX, if non-nil, should be a key sequence;
2532 then we display only bindings that start with that prefix.
2533 The optional argument MENUS, if non-nil, says to mention menu bindings.
2534 \(Ordinarily these are omitted from the output.) */)
2535 (buffer
, prefix
, menus
)
2536 Lisp_Object buffer
, prefix
, menus
;
2538 Lisp_Object outbuf
, shadow
;
2539 int nomenu
= NILP (menus
);
2540 register Lisp_Object start1
;
2541 struct gcpro gcpro1
;
2543 char *alternate_heading
2545 Keyboard translations:\n\n\
2546 You type Translation\n\
2547 -------- -----------\n";
2552 outbuf
= Fcurrent_buffer ();
2554 /* Report on alternates for keys. */
2555 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2558 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2559 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2561 for (c
= 0; c
< translate_len
; c
++)
2562 if (translate
[c
] != c
)
2564 char buf
[KEY_DESCRIPTION_SIZE
];
2567 if (alternate_heading
)
2569 insert_string (alternate_heading
);
2570 alternate_heading
= 0;
2573 bufend
= push_key_description (translate
[c
], buf
, 1);
2574 insert (buf
, bufend
- buf
);
2575 Findent_to (make_number (16), make_number (1));
2576 bufend
= push_key_description (c
, buf
, 1);
2577 insert (buf
, bufend
- buf
);
2585 if (!NILP (Vkey_translation_map
))
2586 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2587 "Key translations", nomenu
, 1, 0);
2590 /* Print the (major mode) local map. */
2592 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2593 start1
= current_kboard
->Voverriding_terminal_local_map
;
2594 else if (!NILP (Voverriding_local_map
))
2595 start1
= Voverriding_local_map
;
2599 describe_map_tree (start1
, 1, shadow
, prefix
,
2600 "\f\nOverriding Bindings", nomenu
, 0, 0);
2601 shadow
= Fcons (start1
, shadow
);
2605 /* Print the minor mode and major mode keymaps. */
2607 Lisp_Object
*modes
, *maps
;
2609 /* Temporarily switch to `buffer', so that we can get that buffer's
2610 minor modes correctly. */
2611 Fset_buffer (buffer
);
2613 nmaps
= current_minor_maps (&modes
, &maps
);
2614 Fset_buffer (outbuf
);
2616 /* Print the minor mode maps. */
2617 for (i
= 0; i
< nmaps
; i
++)
2619 /* The title for a minor mode keymap
2620 is constructed at run time.
2621 We let describe_map_tree do the actual insertion
2622 because it takes care of other features when doing so. */
2625 if (!SYMBOLP (modes
[i
]))
2628 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2632 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2633 XSYMBOL (modes
[i
])->name
->size
);
2634 p
+= XSYMBOL (modes
[i
])->name
->size
;
2636 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2637 p
+= sizeof (" Minor Mode Bindings") - 1;
2640 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2641 shadow
= Fcons (maps
[i
], shadow
);
2644 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2645 XBUFFER (buffer
), Qkeymap
);
2648 describe_map_tree (start1
, 1, shadow
, prefix
,
2649 "\f\nChar Property Bindings", nomenu
, 0, 0);
2650 shadow
= Fcons (start1
, shadow
);
2653 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2654 XBUFFER (buffer
), Qlocal_map
);
2657 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
2658 describe_map_tree (start1
, 1, shadow
, prefix
,
2659 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2661 describe_map_tree (start1
, 1, shadow
, prefix
,
2662 "\f\nChar Property Bindings", nomenu
, 0, 0);
2664 shadow
= Fcons (start1
, shadow
);
2668 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2669 "\f\nGlobal Bindings", nomenu
, 0, 1);
2671 /* Print the function-key-map translations under this prefix. */
2672 if (!NILP (Vfunction_key_map
))
2673 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2674 "\f\nFunction key map translations", nomenu
, 1, 0);
2680 /* Insert a description of the key bindings in STARTMAP,
2681 followed by those of all maps reachable through STARTMAP.
2682 If PARTIAL is nonzero, omit certain "uninteresting" commands
2683 (such as `undefined').
2684 If SHADOW is non-nil, it is a list of maps;
2685 don't mention keys which would be shadowed by any of them.
2686 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2687 TITLE, if not 0, is a string to insert at the beginning.
2688 TITLE should not end with a colon or a newline; we supply that.
2689 If NOMENU is not 0, then omit menu-bar commands.
2691 If TRANSL is nonzero, the definitions are actually key translations
2692 so print strings and vectors differently.
2694 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2698 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2700 Lisp_Object startmap
, shadow
, prefix
;
2707 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2708 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2715 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2718 GCPRO3 (maps
, seen
, sub_shadows
);
2724 /* Delete from MAPS each element that is for the menu bar. */
2725 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2727 Lisp_Object elt
, prefix
, tem
;
2730 prefix
= Fcar (elt
);
2731 if (XVECTOR (prefix
)->size
>= 1)
2733 tem
= Faref (prefix
, make_number (0));
2734 if (EQ (tem
, Qmenu_bar
))
2735 maps
= Fdelq (elt
, maps
);
2740 if (!NILP (maps
) || always_title
)
2744 insert_string (title
);
2747 insert_string (" Starting With ");
2748 insert1 (Fkey_description (prefix
));
2750 insert_string (":\n");
2752 insert_string (key_heading
);
2756 for (; !NILP (maps
); maps
= Fcdr (maps
))
2758 register Lisp_Object elt
, prefix
, tail
;
2761 prefix
= Fcar (elt
);
2765 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2769 shmap
= XCAR (tail
);
2771 /* If the sequence by which we reach this keymap is zero-length,
2772 then the shadow map for this keymap is just SHADOW. */
2773 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2774 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2776 /* If the sequence by which we reach this keymap actually has
2777 some elements, then the sequence's definition in SHADOW is
2778 what we should use. */
2781 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2782 if (INTEGERP (shmap
))
2786 /* If shmap is not nil and not a keymap,
2787 it completely shadows this map, so don't
2788 describe this map at all. */
2789 if (!NILP (shmap
) && !KEYMAPP (shmap
))
2793 sub_shadows
= Fcons (shmap
, sub_shadows
);
2796 /* Maps we have already listed in this loop shadow this map. */
2797 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
2800 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2802 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2805 describe_map (Fcdr (elt
), prefix
,
2806 transl
? describe_translation
: describe_command
,
2807 partial
, sub_shadows
, &seen
, nomenu
);
2813 insert_string ("\n");
2818 static int previous_description_column
;
2821 describe_command (definition
, args
)
2822 Lisp_Object definition
, args
;
2824 register Lisp_Object tem1
;
2825 int column
= current_column ();
2826 int description_column
;
2828 /* If column 16 is no good, go to col 32;
2829 but don't push beyond that--go to next line instead. */
2833 description_column
= 32;
2835 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2836 description_column
= 32;
2838 description_column
= 16;
2840 Findent_to (make_number (description_column
), make_number (1));
2841 previous_description_column
= description_column
;
2843 if (SYMBOLP (definition
))
2845 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2847 insert_string ("\n");
2849 else if (STRINGP (definition
) || VECTORP (definition
))
2850 insert_string ("Keyboard Macro\n");
2851 else if (KEYMAPP (definition
))
2852 insert_string ("Prefix Command\n");
2854 insert_string ("??\n");
2858 describe_translation (definition
, args
)
2859 Lisp_Object definition
, args
;
2861 register Lisp_Object tem1
;
2863 Findent_to (make_number (16), make_number (1));
2865 if (SYMBOLP (definition
))
2867 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2869 insert_string ("\n");
2871 else if (STRINGP (definition
) || VECTORP (definition
))
2873 insert1 (Fkey_description (definition
));
2874 insert_string ("\n");
2876 else if (KEYMAPP (definition
))
2877 insert_string ("Prefix Command\n");
2879 insert_string ("??\n");
2882 /* Describe the contents of map MAP, assuming that this map itself is
2883 reached by the sequence of prefix keys KEYS (a string or vector).
2884 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2887 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2888 register Lisp_Object map
;
2890 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
2896 Lisp_Object elt_prefix
;
2897 Lisp_Object tail
, definition
, event
;
2899 Lisp_Object suppress
;
2902 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2906 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2908 /* Call Fkey_description first, to avoid GC bug for the other string. */
2909 tem
= Fkey_description (keys
);
2910 elt_prefix
= concat2 (tem
, build_string (" "));
2916 suppress
= intern ("suppress-keymap");
2918 /* This vector gets used to present single keys to Flookup_key. Since
2919 that is done once per keymap element, we don't want to cons up a
2920 fresh vector every time. */
2921 kludge
= Fmake_vector (make_number (1), Qnil
);
2924 GCPRO3 (elt_prefix
, definition
, kludge
);
2926 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2930 if (VECTORP (XCAR (tail
))
2931 || CHAR_TABLE_P (XCAR (tail
)))
2932 describe_vector (XCAR (tail
),
2933 elt_prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
2935 else if (CONSP (XCAR (tail
)))
2937 event
= XCAR (XCAR (tail
));
2939 /* Ignore bindings whose "keys" are not really valid events.
2940 (We get these in the frames and buffers menu.) */
2941 if (!(SYMBOLP (event
) || INTEGERP (event
)))
2944 if (nomenu
&& EQ (event
, Qmenu_bar
))
2947 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2949 /* Don't show undefined commands or suppressed commands. */
2950 if (NILP (definition
)) continue;
2951 if (SYMBOLP (definition
) && partial
)
2953 tem
= Fget (definition
, suppress
);
2958 /* Don't show a command that isn't really visible
2959 because a local definition of the same key shadows it. */
2961 ASET (kludge
, 0, event
);
2964 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2965 if (!NILP (tem
)) continue;
2968 tem
= Flookup_key (map
, kludge
, Qt
);
2969 if (!EQ (tem
, definition
)) continue;
2973 previous_description_column
= 0;
2978 if (!NILP (elt_prefix
))
2979 insert1 (elt_prefix
);
2981 /* THIS gets the string to describe the character EVENT. */
2982 insert1 (Fsingle_key_description (event
, Qnil
));
2984 /* Print a description of the definition of this character.
2985 elt_describer will take care of spacing out far enough
2986 for alignment purposes. */
2987 (*elt_describer
) (definition
, Qnil
);
2989 else if (EQ (XCAR (tail
), Qkeymap
))
2991 /* The same keymap might be in the structure twice, if we're
2992 using an inherited keymap. So skip anything we've already
2994 tem
= Fassq (tail
, *seen
);
2995 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2997 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
3005 describe_vector_princ (elt
, fun
)
3006 Lisp_Object elt
, fun
;
3008 Findent_to (make_number (16), make_number (1));
3013 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3014 doc
: /* Insert a description of contents of VECTOR.
3015 This is text showing the elements of vector matched against indices. */)
3017 Lisp_Object vector
, describer
;
3019 int count
= specpdl_ptr
- specpdl
;
3020 if (NILP (describer
))
3021 describer
= intern ("princ");
3022 specbind (Qstandard_output
, Fcurrent_buffer ());
3023 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3024 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3025 Qnil
, Qnil
, (int *)0, 0);
3027 return unbind_to (count
, Qnil
);
3030 /* Insert in the current buffer a description of the contents of VECTOR.
3031 We call ELT_DESCRIBER to insert the description of one value found
3034 ELT_PREFIX describes what "comes before" the keys or indices defined
3035 by this vector. This is a human-readable string whose size
3036 is not necessarily related to the situation.
3038 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3039 leads to this keymap.
3041 If the vector is a chartable, ELT_PREFIX is the vector
3042 of bytes that lead to the character set or portion of a character
3043 set described by this chartable.
3045 If PARTIAL is nonzero, it means do not mention suppressed commands
3046 (that assumes the vector is in a keymap).
3048 SHADOW is a list of keymaps that shadow this map.
3049 If it is non-nil, then we look up the key in those maps
3050 and we don't mention it now if it is defined by any of them.
3052 ENTIRE_MAP is the keymap in which this vector appears.
3053 If the definition in effect in the whole map does not match
3054 the one in this vector, we ignore this one.
3056 When describing a sub-char-table, INDICES is a list of
3057 indices at higher levels in this char-table,
3058 and CHAR_TABLE_DEPTH says how many levels down we have gone.
3060 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3063 describe_vector (vector
, elt_prefix
, args
, elt_describer
,
3064 partial
, shadow
, entire_map
,
3065 indices
, char_table_depth
)
3066 register Lisp_Object vector
;
3067 Lisp_Object elt_prefix
, args
;
3068 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3071 Lisp_Object entire_map
;
3073 int char_table_depth
;
3075 Lisp_Object definition
;
3078 Lisp_Object suppress
;
3081 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3082 /* Range of elements to be handled. */
3084 /* A flag to tell if a leaf in this level of char-table is not a
3085 generic character (i.e. a complete multibyte character). */
3093 indices
= (int *) alloca (3 * sizeof (int));
3097 /* This vector gets used to present single keys to Flookup_key. Since
3098 that is done once per vector element, we don't want to cons up a
3099 fresh vector every time. */
3100 kludge
= Fmake_vector (make_number (1), Qnil
);
3101 GCPRO3 (elt_prefix
, definition
, kludge
);
3104 suppress
= intern ("suppress-keymap");
3106 if (CHAR_TABLE_P (vector
))
3108 if (char_table_depth
== 0)
3110 /* VECTOR is a top level char-table. */
3113 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3117 /* VECTOR is a sub char-table. */
3118 if (char_table_depth
>= 3)
3119 /* A char-table is never that deep. */
3120 error ("Too deep char table");
3123 = (CHARSET_VALID_P (indices
[0])
3124 && ((CHARSET_DIMENSION (indices
[0]) == 1
3125 && char_table_depth
== 1)
3126 || char_table_depth
== 2));
3128 /* Meaningful elements are from 32th to 127th. */
3130 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3135 /* This does the right thing for ordinary vectors. */
3139 to
= XVECTOR (vector
)->size
;
3142 for (i
= from
; i
< to
; i
++)
3146 if (CHAR_TABLE_P (vector
))
3148 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3151 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3152 && !CHARSET_DEFINED_P (i
- 128))
3156 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3159 definition
= get_keyelt (AREF (vector
, i
), 0);
3161 if (NILP (definition
)) continue;
3163 /* Don't mention suppressed commands. */
3164 if (SYMBOLP (definition
) && partial
)
3168 tem
= Fget (definition
, suppress
);
3170 if (!NILP (tem
)) continue;
3173 /* Set CHARACTER to the character this entry describes, if any.
3174 Also update *INDICES. */
3175 if (CHAR_TABLE_P (vector
))
3177 indices
[char_table_depth
] = i
;
3179 if (char_table_depth
== 0)
3182 indices
[0] = i
- 128;
3184 else if (complete_char
)
3186 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3194 /* If this binding is shadowed by some other map, ignore it. */
3195 if (!NILP (shadow
) && complete_char
)
3199 ASET (kludge
, 0, make_number (character
));
3200 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3202 if (!NILP (tem
)) continue;
3205 /* Ignore this definition if it is shadowed by an earlier
3206 one in the same keymap. */
3207 if (!NILP (entire_map
) && complete_char
)
3211 ASET (kludge
, 0, make_number (character
));
3212 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3214 if (!EQ (tem
, definition
))
3220 if (char_table_depth
== 0)
3225 /* For a sub char-table, show the depth by indentation.
3226 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3227 if (char_table_depth
> 0)
3228 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3230 /* Output the prefix that applies to every entry in this map. */
3231 if (!NILP (elt_prefix
))
3232 insert1 (elt_prefix
);
3234 /* Insert or describe the character this slot is for,
3235 or a description of what it is for. */
3236 if (SUB_CHAR_TABLE_P (vector
))
3239 insert_char (character
);
3242 /* We need an octal representation for this block of
3245 sprintf (work
, "(row %d)", i
);
3246 insert (work
, strlen (work
));
3249 else if (CHAR_TABLE_P (vector
))
3252 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3255 /* Print the information for this character set. */
3256 insert_string ("<");
3257 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3259 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3260 STRING_BYTES (XSTRING (tem2
)), 0);
3268 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3271 /* If we find a sub char-table within a char-table,
3272 scan it recursively; it defines the details for
3273 a character set or a portion of a character set. */
3274 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3277 describe_vector (definition
, elt_prefix
, args
, elt_describer
,
3278 partial
, shadow
, entire_map
,
3279 indices
, char_table_depth
+ 1);
3285 /* Find all consecutive characters or rows that have the same
3286 definition. But, for elements of a top level char table, if
3287 they are for charsets, we had better describe one by one even
3288 if they have the same definition. */
3289 if (CHAR_TABLE_P (vector
))
3293 if (char_table_depth
== 0)
3294 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3296 while (i
+ 1 < limit
3297 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3299 && !NILP (Fequal (tem2
, definition
)))
3304 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3306 && !NILP (Fequal (tem2
, definition
)))
3310 /* If we have a range of more than one character,
3311 print where the range reaches to. */
3313 if (i
!= starting_i
)
3317 if (!NILP (elt_prefix
))
3318 insert1 (elt_prefix
);
3320 if (CHAR_TABLE_P (vector
))
3322 if (char_table_depth
== 0)
3324 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3326 else if (complete_char
)
3328 indices
[char_table_depth
] = i
;
3329 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3330 insert_char (character
);
3334 /* We need an octal representation for this block of
3337 sprintf (work
, "(row %d)", i
);
3338 insert (work
, strlen (work
));
3343 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3347 /* Print a description of the definition of this character.
3348 elt_describer will take care of spacing out far enough
3349 for alignment purposes. */
3350 (*elt_describer
) (definition
, args
);
3353 /* For (sub) char-table, print `defalt' slot at last. */
3354 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3356 insert (" ", char_table_depth
* 2);
3357 insert_string ("<<default>>");
3358 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3364 /* Apropos - finding all symbols whose names match a regexp. */
3365 Lisp_Object apropos_predicate
;
3366 Lisp_Object apropos_accumulate
;
3369 apropos_accum (symbol
, string
)
3370 Lisp_Object symbol
, string
;
3372 register Lisp_Object tem
;
3374 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3375 if (!NILP (tem
) && !NILP (apropos_predicate
))
3376 tem
= call1 (apropos_predicate
, symbol
);
3378 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3381 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3382 doc
: /* Show all symbols whose names contain match for REGEXP.
3383 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3384 for each symbol and a symbol is mentioned only if that returns non-nil.
3385 Return list of symbols found. */)
3387 Lisp_Object regexp
, predicate
;
3389 struct gcpro gcpro1
, gcpro2
;
3390 CHECK_STRING (regexp
);
3391 apropos_predicate
= predicate
;
3392 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3393 apropos_accumulate
= Qnil
;
3394 map_obarray (Vobarray
, apropos_accum
, regexp
);
3395 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3397 return apropos_accumulate
;
3403 Qkeymap
= intern ("keymap");
3404 staticpro (&Qkeymap
);
3406 /* Now we are ready to set up this property, so we can
3407 create char tables. */
3408 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3410 /* Initialize the keymaps standardly used.
3411 Each one is the value of a Lisp variable, and is also
3412 pointed to by a C variable */
3414 global_map
= Fmake_keymap (Qnil
);
3415 Fset (intern ("global-map"), global_map
);
3417 current_global_map
= global_map
;
3418 staticpro (&global_map
);
3419 staticpro (¤t_global_map
);
3421 meta_map
= Fmake_keymap (Qnil
);
3422 Fset (intern ("esc-map"), meta_map
);
3423 Ffset (intern ("ESC-prefix"), meta_map
);
3425 control_x_map
= Fmake_keymap (Qnil
);
3426 Fset (intern ("ctl-x-map"), control_x_map
);
3427 Ffset (intern ("Control-X-prefix"), control_x_map
);
3430 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3431 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3432 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3433 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3434 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3436 staticpro (&exclude_keys
);
3438 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3439 doc
: /* List of commands given new key bindings recently.
3440 This is used for internal purposes during Emacs startup;
3441 don't alter it yourself. */);
3442 Vdefine_key_rebound_commands
= Qt
;
3444 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3445 doc
: /* Default keymap to use when reading from the minibuffer. */);
3446 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3448 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3449 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3450 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3451 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3453 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3454 doc
: /* Local keymap for minibuffer input with completion. */);
3455 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3456 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3458 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3459 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3460 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3461 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3462 Vminibuffer_local_completion_map
);
3464 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3465 doc
: /* Alist of keymaps to use for minor modes.
3466 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3467 key sequences and look up bindings iff VARIABLE's value is non-nil.
3468 If two active keymaps bind the same key, the keymap appearing earlier
3469 in the list takes precedence. */);
3470 Vminor_mode_map_alist
= Qnil
;
3472 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3473 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3474 This variable is a alist just like `minor-mode-map-alist', and it is
3475 used the same way (and before `minor-mode-map-alist'); however,
3476 it is provided for major modes to bind locally. */);
3477 Vminor_mode_overriding_map_alist
= Qnil
;
3479 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3480 doc
: /* Keymap mapping ASCII function key sequences onto their preferred forms.
3481 This allows Emacs to recognize function keys sent from ASCII
3482 terminals at any point in a key sequence.
3484 The `read-key-sequence' function replaces any subsequence bound by
3485 `function-key-map' with its binding. More precisely, when the active
3486 keymaps have no binding for the current key sequence but
3487 `function-key-map' binds a suffix of the sequence to a vector or string,
3488 `read-key-sequence' replaces the matching suffix with its binding, and
3489 continues with the new sequence.
3491 The events that come from bindings in `function-key-map' are not
3492 themselves looked up in `function-key-map'.
3494 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3495 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3496 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3497 key, typing `ESC O P x' would return [f1 x]. */);
3498 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3500 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3501 doc
: /* Keymap of key translations that can override keymaps.
3502 This keymap works like `function-key-map', but comes after that,
3503 and applies even for keys that have ordinary bindings. */);
3504 Vkey_translation_map
= Qnil
;
3506 Qsingle_key_description
= intern ("single-key-description");
3507 staticpro (&Qsingle_key_description
);
3509 Qkey_description
= intern ("key-description");
3510 staticpro (&Qkey_description
);
3512 Qkeymapp
= intern ("keymapp");
3513 staticpro (&Qkeymapp
);
3515 Qnon_ascii
= intern ("non-ascii");
3516 staticpro (&Qnon_ascii
);
3518 Qmenu_item
= intern ("menu-item");
3519 staticpro (&Qmenu_item
);
3521 where_is_cache_keymaps
= Qt
;
3522 where_is_cache
= Qnil
;
3523 staticpro (&where_is_cache
);
3524 staticpro (&where_is_cache_keymaps
);
3526 defsubr (&Skeymapp
);
3527 defsubr (&Skeymap_parent
);
3528 defsubr (&Skeymap_prompt
);
3529 defsubr (&Sset_keymap_parent
);
3530 defsubr (&Smake_keymap
);
3531 defsubr (&Smake_sparse_keymap
);
3532 defsubr (&Scopy_keymap
);
3533 defsubr (&Skey_binding
);
3534 defsubr (&Slocal_key_binding
);
3535 defsubr (&Sglobal_key_binding
);
3536 defsubr (&Sminor_mode_key_binding
);
3537 defsubr (&Sdefine_key
);
3538 defsubr (&Slookup_key
);
3539 defsubr (&Sdefine_prefix_command
);
3540 defsubr (&Suse_global_map
);
3541 defsubr (&Suse_local_map
);
3542 defsubr (&Scurrent_local_map
);
3543 defsubr (&Scurrent_global_map
);
3544 defsubr (&Scurrent_minor_mode_maps
);
3545 defsubr (&Scurrent_active_maps
);
3546 defsubr (&Saccessible_keymaps
);
3547 defsubr (&Skey_description
);
3548 defsubr (&Sdescribe_vector
);
3549 defsubr (&Ssingle_key_description
);
3550 defsubr (&Stext_char_description
);
3551 defsubr (&Swhere_is_internal
);
3552 defsubr (&Sdescribe_buffer_bindings
);
3553 defsubr (&Sapropos_internal
);
3559 initial_define_key (global_map
, 033, "ESC-prefix");
3560 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");