1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000, 01, 2004
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. */
28 #include "character.h"
31 #include "termhooks.h"
32 #include "blockinput.h"
34 #include "intervals.h"
37 /* The number of elements in keymap vectors. */
38 #define DENSE_TABLE_SIZE (0200)
40 /* Actually allocate storage for these variables */
42 Lisp_Object current_global_map
; /* Current global keymap */
44 Lisp_Object global_map
; /* default global key bindings */
46 Lisp_Object meta_map
; /* The keymap used for globally bound
47 ESC-prefixed default commands */
49 Lisp_Object control_x_map
; /* The keymap used for globally bound
50 C-x-prefixed default commands */
52 /* was MinibufLocalMap */
53 Lisp_Object Vminibuffer_local_map
;
54 /* The keymap used by the minibuf for local
55 bindings when spaces are allowed in the
58 /* was MinibufLocalNSMap */
59 Lisp_Object Vminibuffer_local_ns_map
;
60 /* The keymap used by the minibuf for local
61 bindings when spaces are not encouraged
64 /* keymap used for minibuffers when doing completion */
65 /* was MinibufLocalCompletionMap */
66 Lisp_Object Vminibuffer_local_completion_map
;
68 /* keymap used for minibuffers when doing completion and require a match */
69 /* was MinibufLocalMustMatchMap */
70 Lisp_Object Vminibuffer_local_must_match_map
;
72 /* Alist of minor mode variables and keymaps. */
73 Lisp_Object Vminor_mode_map_alist
;
75 /* Alist of major-mode-specific overrides for
76 minor mode variables and keymaps. */
77 Lisp_Object Vminor_mode_overriding_map_alist
;
79 /* List of emulation mode keymap alists. */
80 Lisp_Object Vemulation_mode_map_alists
;
82 /* Keymap mapping ASCII function key sequences onto their preferred forms.
83 Initialized by the terminal-specific lisp files. See DEFVAR for more
85 Lisp_Object Vfunction_key_map
;
87 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
88 Lisp_Object Vkey_translation_map
;
90 /* A list of all commands given new bindings since a certain time
91 when nil was stored here.
92 This is used to speed up recomputation of menu key equivalents
93 when Emacs starts up. t means don't record anything here. */
94 Lisp_Object Vdefine_key_rebound_commands
;
96 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
98 /* Alist of elements like (DEL . "\d"). */
99 static Lisp_Object exclude_keys
;
101 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
102 static Lisp_Object command_remapping_vector
;
104 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
105 in a string key sequence is equivalent to prefixing with this
107 extern Lisp_Object meta_prefix_char
;
109 extern Lisp_Object Voverriding_local_map
;
111 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
112 static Lisp_Object where_is_cache
;
113 /* Which keymaps are reverse-stored in the cache. */
114 static Lisp_Object where_is_cache_keymaps
;
116 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
117 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
119 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
120 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
121 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
122 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
123 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
124 int, Lisp_Object
, Lisp_Object
*, int));
125 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
126 void (*) (Lisp_Object
, Lisp_Object
), int,
127 Lisp_Object
, Lisp_Object
, int *, int, int));
128 static void silly_event_symbol_error
P_ ((Lisp_Object
));
130 /* Keymap object support - constructors and predicates. */
132 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
133 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
134 CHARTABLE is a char-table that holds the bindings for all characters
135 without modifiers. All entries in it are initially nil, meaning
136 "command undefined". ALIST is an assoc-list which holds bindings for
137 function keys, mouse events, and any other things that appear in the
138 input stream. Initially, ALIST is nil.
140 The optional arg STRING supplies a menu name for the keymap
141 in case you use it as a menu with `x-popup-menu'. */)
147 tail
= Fcons (string
, Qnil
);
150 return Fcons (Qkeymap
,
151 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
154 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
155 doc
: /* Construct and return a new sparse keymap.
156 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
157 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
158 which binds the function key or mouse event SYMBOL to DEFINITION.
159 Initially the alist is nil.
161 The optional arg STRING supplies a menu name for the keymap
162 in case you use it as a menu with `x-popup-menu'. */)
167 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
168 return Fcons (Qkeymap
, Qnil
);
171 /* This function is used for installing the standard key bindings
172 at initialization time.
176 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
179 initial_define_key (keymap
, key
, defname
)
184 store_in_keymap (keymap
, make_number (key
), intern (defname
));
188 initial_define_lispy_key (keymap
, keyname
, defname
)
193 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
196 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
197 doc
: /* Return t if OBJECT is a keymap.
199 A keymap is a list (keymap . ALIST),
200 or a symbol whose function definition is itself a keymap.
201 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
202 a vector of densely packed bindings for small character codes
203 is also allowed as an element. */)
207 return (KEYMAPP (object
) ? Qt
: Qnil
);
210 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
211 doc
: /* Return the prompt-string of a keymap MAP.
212 If non-nil, the prompt is shown in the echo-area
213 when reading a key-sequence to be looked-up in this keymap. */)
219 register Lisp_Object tem
;
228 /* Check that OBJECT is a keymap (after dereferencing through any
229 symbols). If it is, return it.
231 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
232 is an autoload form, do the autoload and try again.
233 If AUTOLOAD is nonzero, callers must assume GC is possible.
235 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
236 is zero as well), return Qt.
238 ERROR controls how we respond if OBJECT isn't a keymap.
239 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
241 Note that most of the time, we don't want to pursue autoloads.
242 Functions like Faccessible_keymaps which scan entire keymap trees
243 shouldn't load every autoloaded keymap. I'm not sure about this,
244 but it seems to me that only read_key_sequence, Flookup_key, and
245 Fdefine_key should cause keymaps to be autoloaded.
247 This function can GC when AUTOLOAD is non-zero, because it calls
248 do_autoload which can GC. */
251 get_keymap (object
, error
, autoload
)
260 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
263 tem
= indirect_function (object
);
266 if (EQ (XCAR (tem
), Qkeymap
))
269 /* Should we do an autoload? Autoload forms for keymaps have
270 Qkeymap as their fifth element. */
271 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
276 tail
= Fnth (make_number (4), tem
);
277 if (EQ (tail
, Qkeymap
))
281 struct gcpro gcpro1
, gcpro2
;
283 GCPRO2 (tem
, object
);
284 do_autoload (tem
, object
);
297 wrong_type_argument (Qkeymapp
, object
);
301 /* Return the parent map of KEYMAP, or nil if it has none.
302 We assume that KEYMAP is a valid keymap. */
305 keymap_parent (keymap
, autoload
)
311 keymap
= get_keymap (keymap
, 1, autoload
);
313 /* Skip past the initial element `keymap'. */
314 list
= XCDR (keymap
);
315 for (; CONSP (list
); list
= XCDR (list
))
317 /* See if there is another `keymap'. */
322 return get_keymap (list
, 0, autoload
);
325 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
326 doc
: /* Return the parent keymap of KEYMAP. */)
330 return keymap_parent (keymap
, 1);
333 /* Check whether MAP is one of MAPS parents. */
335 keymap_memberp (map
, maps
)
336 Lisp_Object map
, maps
;
338 if (NILP (map
)) return 0;
339 while (KEYMAPP (maps
) && !EQ (map
, maps
))
340 maps
= keymap_parent (maps
, 0);
341 return (EQ (map
, maps
));
344 /* Set the parent keymap of MAP to PARENT. */
346 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
347 doc
: /* Modify KEYMAP to set its parent map to PARENT.
348 Return PARENT. PARENT should be nil or another keymap. */)
350 Lisp_Object keymap
, parent
;
352 Lisp_Object list
, prev
;
353 struct gcpro gcpro1
, gcpro2
;
356 /* Force a keymap flush for the next call to where-is.
357 Since this can be called from within where-is, we don't set where_is_cache
358 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
359 be changed during where-is, while where_is_cache_keymaps is only used at
360 the very beginning of where-is and can thus be changed here without any
362 This is a very minor correctness (rather than safety) issue. */
363 where_is_cache_keymaps
= Qt
;
365 GCPRO2 (keymap
, parent
);
366 keymap
= get_keymap (keymap
, 1, 1);
370 parent
= get_keymap (parent
, 1, 1);
372 /* Check for cycles. */
373 if (keymap_memberp (keymap
, parent
))
374 error ("Cyclic keymap inheritance");
377 /* Skip past the initial element `keymap'. */
382 /* If there is a parent keymap here, replace it.
383 If we came to the end, add the parent in PREV. */
384 if (!CONSP (list
) || KEYMAPP (list
))
386 /* If we already have the right parent, return now
387 so that we avoid the loops below. */
388 if (EQ (XCDR (prev
), parent
))
389 RETURN_UNGCPRO (parent
);
391 XSETCDR (prev
, parent
);
397 /* Scan through for submaps, and set their parents too. */
399 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
401 /* Stop the scan when we come to the parent. */
402 if (EQ (XCAR (list
), Qkeymap
))
405 /* If this element holds a prefix map, deal with it. */
406 if (CONSP (XCAR (list
))
407 && CONSP (XCDR (XCAR (list
))))
408 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
411 if (VECTORP (XCAR (list
)))
412 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
413 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
414 fix_submap_inheritance (keymap
, make_number (i
),
415 XVECTOR (XCAR (list
))->contents
[i
]);
417 if (CHAR_TABLE_P (XCAR (list
)))
419 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
423 RETURN_UNGCPRO (parent
);
426 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
427 if EVENT is also a prefix in MAP's parent,
428 make sure that SUBMAP inherits that definition as its own parent. */
431 fix_submap_inheritance (map
, event
, submap
)
432 Lisp_Object map
, event
, submap
;
434 Lisp_Object map_parent
, parent_entry
;
436 /* SUBMAP is a cons that we found as a key binding.
437 Discard the other things found in a menu key binding. */
439 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
441 /* If it isn't a keymap now, there's no work to do. */
445 map_parent
= keymap_parent (map
, 0);
446 if (!NILP (map_parent
))
448 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
452 /* If MAP's parent has something other than a keymap,
453 our own submap shadows it completely. */
454 if (!CONSP (parent_entry
))
457 if (! EQ (parent_entry
, submap
))
459 Lisp_Object submap_parent
;
460 submap_parent
= submap
;
465 tem
= keymap_parent (submap_parent
, 0);
469 if (keymap_memberp (tem
, parent_entry
))
470 /* Fset_keymap_parent could create a cycle. */
477 Fset_keymap_parent (submap_parent
, parent_entry
);
481 /* Look up IDX in MAP. IDX may be any sort of event.
482 Note that this does only one level of lookup; IDX must be a single
483 event, not a sequence.
485 If T_OK is non-zero, bindings for Qt are treated as default
486 bindings; any key left unmentioned by other tables and bindings is
487 given the binding of Qt.
489 If T_OK is zero, bindings for Qt are not treated specially.
491 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
494 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
503 /* Qunbound in VAL means we have found no binding yet. */
506 /* If idx is a list (some sort of mouse click, perhaps?),
507 the index we want to use is the car of the list, which
508 ought to be a symbol. */
509 idx
= EVENT_HEAD (idx
);
511 /* If idx is a symbol, it might have modifiers, which need to
512 be put in the canonical order. */
514 idx
= reorder_modifiers (idx
);
515 else if (INTEGERP (idx
))
516 /* Clobber the high bits that can be present on a machine
517 with more than 24 bits of integer. */
518 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
520 /* Handle the special meta -> esc mapping. */
521 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
523 /* See if there is a meta-map. If there's none, there is
524 no binding for IDX, unless a default binding exists in MAP. */
526 Lisp_Object meta_map
;
528 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
529 t_ok
, noinherit
, autoload
),
532 if (CONSP (meta_map
))
535 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
538 /* Set IDX to t, so that we only find a default binding. */
541 /* We know there is no binding. */
545 /* t_binding is where we put a default binding that applies,
546 to use in case we do not find a binding specifically
547 for this key sequence. */
550 Lisp_Object t_binding
= Qnil
;
551 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
553 GCPRO4 (map
, tail
, idx
, t_binding
);
555 /* If `t_ok' is 2, both `t' is accepted. */
558 for (tail
= XCDR (map
);
560 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
565 binding
= XCAR (tail
);
566 if (SYMBOLP (binding
))
568 /* If NOINHERIT, stop finding prefix definitions
569 after we pass a second occurrence of the `keymap' symbol. */
570 if (noinherit
&& EQ (binding
, Qkeymap
))
571 RETURN_UNGCPRO (Qnil
);
573 else if (CONSP (binding
))
575 Lisp_Object key
= XCAR (binding
);
578 val
= XCDR (binding
);
579 else if (t_ok
> 1 && EQ (key
, Qt
))
581 t_binding
= XCDR (binding
);
585 else if (VECTORP (binding
))
587 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
588 val
= AREF (binding
, XFASTINT (idx
));
590 else if (CHAR_TABLE_P (binding
))
592 /* Character codes with modifiers
593 are not included in a char-table.
594 All character codes without modifiers are included. */
595 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
597 val
= Faref (binding
, idx
);
598 /* `nil' has a special meaning for char-tables, so
599 we use something else to record an explicitly
606 /* If we found a binding, clean it up and return it. */
607 if (!EQ (val
, Qunbound
))
610 /* A Qt binding is just like an explicit nil binding
611 (i.e. it shadows any parent binding but not bindings in
612 keymaps of lower precedence). */
614 val
= get_keyelt (val
, autoload
);
616 fix_submap_inheritance (map
, idx
, val
);
617 RETURN_UNGCPRO (val
);
622 return get_keyelt (t_binding
, autoload
);
627 map_keymap_item (fun
, args
, key
, val
, data
)
628 map_keymap_function_t fun
;
629 Lisp_Object args
, key
, val
;
632 /* We should maybe try to detect bindings shadowed by previous
633 ones and things like that. */
636 (*fun
) (key
, val
, args
, data
);
640 map_keymap_char_table_item (args
, key
, val
)
641 Lisp_Object args
, key
, val
;
645 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
647 map_keymap_item (fun
, XCDR (args
), key
, val
,
648 XSAVE_VALUE (XCAR (args
))->pointer
);
652 /* Call FUN for every binding in MAP.
653 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA).
654 AUTOLOAD if non-zero means that we can autoload keymaps if necessary. */
656 map_keymap (map
, fun
, args
, data
, autoload
)
657 map_keymap_function_t fun
;
658 Lisp_Object map
, args
;
662 struct gcpro gcpro1
, gcpro2
, gcpro3
;
665 GCPRO3 (map
, args
, tail
);
666 map
= get_keymap (map
, 1, autoload
);
667 for (tail
= (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
668 CONSP (tail
) || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
));
671 Lisp_Object binding
= XCAR (tail
);
674 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
675 else if (VECTORP (binding
))
677 /* Loop over the char values represented in the vector. */
678 int len
= ASIZE (binding
);
680 for (c
= 0; c
< len
; c
++)
682 Lisp_Object character
;
683 XSETFASTINT (character
, c
);
684 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
687 else if (CHAR_TABLE_P (binding
))
689 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
690 Fcons (make_save_value (fun
, 0),
691 Fcons (make_save_value (data
, 0),
699 map_keymap_call (key
, val
, fun
, dummy
)
700 Lisp_Object key
, val
, fun
;
703 call2 (fun
, key
, val
);
706 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 2, 0,
707 doc
: /* Call FUNCTION for every binding in KEYMAP.
708 FUNCTION is called with two arguments: the event and its binding.
709 If KEYMAP has a parent, the parent's bindings are included as well.
710 This works recursively: if the parent has itself a parent, then the
711 grandparent's bindings are also included and so on. */)
713 Lisp_Object function
, keymap
;
715 if (INTEGERP (function
))
716 /* We have to stop integers early since map_keymap gives them special
718 Fsignal (Qinvalid_function
, Fcons (function
, Qnil
));
719 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
723 /* Given OBJECT which was found in a slot in a keymap,
724 trace indirect definitions to get the actual definition of that slot.
725 An indirect definition is a list of the form
726 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
727 and INDEX is the object to look up in KEYMAP to yield the definition.
729 Also if OBJECT has a menu string as the first element,
730 remove that. Also remove a menu help string as second element.
732 If AUTOLOAD is nonzero, load autoloadable keymaps
733 that are referred to with indirection. */
736 get_keyelt (object
, autoload
)
742 if (!(CONSP (object
)))
743 /* This is really the value. */
746 /* If the keymap contents looks like (keymap ...) or (lambda ...)
748 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
751 /* If the keymap contents looks like (menu-item name . DEFN)
752 or (menu-item name DEFN ...) then use DEFN.
753 This is a new format menu item. */
754 else if (EQ (XCAR (object
), Qmenu_item
))
756 if (CONSP (XCDR (object
)))
760 object
= XCDR (XCDR (object
));
763 object
= XCAR (object
);
765 /* If there's a `:filter FILTER', apply FILTER to the
766 menu-item's definition to get the real definition to
768 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
769 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
772 filter
= XCAR (XCDR (tem
));
773 filter
= list2 (filter
, list2 (Qquote
, object
));
774 object
= menu_item_eval_property (filter
);
779 /* Invalid keymap. */
783 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
784 Keymap alist elements like (CHAR MENUSTRING . DEFN)
785 will be used by HierarKey menus. */
786 else if (STRINGP (XCAR (object
)))
788 object
= XCDR (object
);
789 /* Also remove a menu help string, if any,
790 following the menu item name. */
791 if (CONSP (object
) && STRINGP (XCAR (object
)))
792 object
= XCDR (object
);
793 /* Also remove the sublist that caches key equivalences, if any. */
794 if (CONSP (object
) && CONSP (XCAR (object
)))
797 carcar
= XCAR (XCAR (object
));
798 if (NILP (carcar
) || VECTORP (carcar
))
799 object
= XCDR (object
);
803 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
809 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
811 return (!CONSP (map
) ? object
/* Invalid keymap */
812 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
818 store_in_keymap (keymap
, idx
, def
)
820 register Lisp_Object idx
;
821 register Lisp_Object def
;
823 /* Flush any reverse-map cache. */
824 where_is_cache
= Qnil
;
825 where_is_cache_keymaps
= Qt
;
827 /* If we are preparing to dump, and DEF is a menu element
828 with a menu item indicator, copy it to ensure it is not pure. */
829 if (CONSP (def
) && PURE_P (def
)
830 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
831 def
= Fcons (XCAR (def
), XCDR (def
));
833 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
834 error ("attempt to define a key in a non-keymap");
836 /* If idx is a cons, and the car part is a character, idx must be of
837 the form (FROM-CHAR . TO-CHAR). */
838 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
839 CHECK_CHARACTER_CDR (idx
);
841 /* If idx is a list (some sort of mouse click, perhaps?),
842 the index we want to use is the car of the list, which
843 ought to be a symbol. */
844 idx
= EVENT_HEAD (idx
);
846 /* If idx is a symbol, it might have modifiers, which need to
847 be put in the canonical order. */
849 idx
= reorder_modifiers (idx
);
850 else if (INTEGERP (idx
))
851 /* Clobber the high bits that can be present on a machine
852 with more than 24 bits of integer. */
853 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
855 /* Scan the keymap for a binding of idx. */
859 /* The cons after which we should insert new bindings. If the
860 keymap has a table element, we record its position here, so new
861 bindings will go after it; this way, the table will stay
862 towards the front of the alist and character lookups in dense
863 keymaps will remain fast. Otherwise, this just points at the
864 front of the keymap. */
865 Lisp_Object insertion_point
;
867 insertion_point
= keymap
;
868 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
875 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
877 ASET (elt
, XFASTINT (idx
), def
);
880 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
882 int from
= XFASTINT (XCAR (idx
));
883 int to
= XFASTINT (XCDR (idx
));
885 if (to
>= ASIZE (elt
))
886 to
= ASIZE (elt
) - 1;
887 for (; from
<= to
; from
++)
888 ASET (elt
, from
, def
);
889 if (to
== XFASTINT (XCDR (idx
)))
890 /* We have defined all keys in IDX. */
893 insertion_point
= tail
;
895 else if (CHAR_TABLE_P (elt
))
897 /* Character codes with modifiers
898 are not included in a char-table.
899 All character codes without modifiers are included. */
900 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
903 /* `nil' has a special meaning for char-tables, so
904 we use something else to record an explicitly
906 NILP (def
) ? Qt
: def
);
909 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
911 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
914 insertion_point
= tail
;
916 else if (CONSP (elt
))
918 if (EQ (idx
, XCAR (elt
)))
923 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
925 int from
= XFASTINT (XCAR (idx
));
926 int to
= XFASTINT (XCDR (idx
));
928 if (from
<= XFASTINT (XCAR (elt
))
929 && to
>= XFASTINT (XCAR (elt
)))
937 else if (EQ (elt
, Qkeymap
))
938 /* If we find a 'keymap' symbol in the spine of KEYMAP,
939 then we must have found the start of a second keymap
940 being used as the tail of KEYMAP, and a binding for IDX
941 should be inserted before it. */
948 /* We have scanned the entire keymap, and not found a binding for
949 IDX. Let's add one. */
953 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
955 /* IDX specifies a range of characters, and not all of them
956 were handled yet, which means this keymap doesn't have a
957 char-table. So, we insert a char-table now. */
958 elt
= Fmake_char_table (Qkeymap
, Qnil
);
959 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
962 elt
= Fcons (idx
, def
);
963 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
970 EXFUN (Fcopy_keymap
, 1);
973 copy_keymap_item (elt
)
976 Lisp_Object res
, tem
;
983 /* Is this a new format menu item. */
984 if (EQ (XCAR (tem
), Qmenu_item
))
986 /* Copy cell with menu-item marker. */
987 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
991 /* Copy cell with menu-item name. */
992 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
998 /* Copy cell with binding and if the binding is a keymap,
1000 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1003 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1004 XSETCAR (elt
, Fcopy_keymap (tem
));
1006 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1007 /* Delete cache for key equivalences. */
1008 XSETCDR (elt
, XCDR (tem
));
1013 /* It may be an old fomat menu item.
1014 Skip the optional menu string. */
1015 if (STRINGP (XCAR (tem
)))
1017 /* Copy the cell, since copy-alist didn't go this deep. */
1018 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1020 /* Also skip the optional menu help string. */
1021 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1023 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1027 /* There may also be a list that caches key equivalences.
1028 Just delete it for the new keymap. */
1030 && CONSP (XCAR (tem
))
1031 && (NILP (XCAR (XCAR (tem
)))
1032 || VECTORP (XCAR (XCAR (tem
)))))
1034 XSETCDR (elt
, XCDR (tem
));
1037 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1038 XSETCDR (elt
, Fcopy_keymap (tem
));
1040 else if (EQ (XCAR (tem
), Qkeymap
))
1041 res
= Fcopy_keymap (elt
);
1047 copy_keymap_1 (chartable
, idx
, elt
)
1048 Lisp_Object chartable
, idx
, elt
;
1050 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1053 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1054 doc
: /* Return a copy of the keymap KEYMAP.
1055 The copy starts out with the same definitions of KEYMAP,
1056 but changing either the copy or KEYMAP does not affect the other.
1057 Any key definitions that are subkeymaps are recursively copied.
1058 However, a key definition which is a symbol whose definition is a keymap
1063 register Lisp_Object copy
, tail
;
1064 keymap
= get_keymap (keymap
, 1, 0);
1065 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1066 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1068 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1070 Lisp_Object elt
= XCAR (keymap
);
1071 if (CHAR_TABLE_P (elt
))
1073 elt
= Fcopy_sequence (elt
);
1074 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1076 else if (VECTORP (elt
))
1079 elt
= Fcopy_sequence (elt
);
1080 for (i
= 0; i
< ASIZE (elt
); i
++)
1081 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1083 else if (CONSP (elt
))
1084 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1085 XSETCDR (tail
, Fcons (elt
, Qnil
));
1087 keymap
= XCDR (keymap
);
1089 XSETCDR (tail
, keymap
);
1093 /* Simple Keymap mutators and accessors. */
1095 /* GC is possible in this function if it autoloads a keymap. */
1097 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1098 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1101 KEY is a string or a vector of symbols and characters meaning a
1102 sequence of keystrokes and events. Non-ASCII characters with codes
1103 above 127 (such as ISO Latin-1) can be included if you use a vector.
1104 Using [t] for KEY creates a default definition, which applies to any
1105 event type that has no other definition in this keymap.
1107 DEF is anything that can be a key's definition:
1108 nil (means key is undefined in this keymap),
1109 a command (a Lisp function suitable for interactive calling),
1110 a string (treated as a keyboard macro),
1111 a keymap (to define a prefix key),
1112 a symbol (when the key is looked up, the symbol will stand for its
1113 function definition, which should at that time be one of the above,
1114 or another symbol whose function definition is used, etc.),
1115 a cons (STRING . DEFN), meaning that DEFN is the definition
1116 (DEFN should be a valid definition in its own right),
1117 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP.
1119 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1120 binding is altered. If there is no binding for KEY, the new pair
1121 binding KEY to DEF is added at the front of KEYMAP. */)
1128 register Lisp_Object c
;
1129 register Lisp_Object cmd
;
1133 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1135 GCPRO3 (keymap
, key
, def
);
1136 keymap
= get_keymap (keymap
, 1, 1);
1138 if (!VECTORP (key
) && !STRINGP (key
))
1139 key
= wrong_type_argument (Qarrayp
, key
);
1141 length
= XFASTINT (Flength (key
));
1143 RETURN_UNGCPRO (Qnil
);
1145 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1146 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1148 meta_bit
= VECTORP (key
) ? meta_modifier
: 0x80;
1153 c
= Faref (key
, make_number (idx
));
1157 /* C may be a Lucid style event type list or a cons (FROM .
1158 TO) specifying a range of characters. */
1159 if (lucid_event_type_list_p (c
))
1160 c
= Fevent_convert_list (c
);
1161 else if (CHARACTERP (XCAR (c
)))
1162 CHECK_CHARACTER_CDR (c
);
1166 silly_event_symbol_error (c
);
1169 && (XINT (c
) & meta_bit
)
1172 c
= meta_prefix_char
;
1178 XSETINT (c
, XINT (c
) & ~meta_bit
);
1184 if (!INTEGERP (c
) && !SYMBOLP (c
)
1186 /* If C is a range, it must be a leaf. */
1187 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1188 error ("Key sequence contains invalid event");
1191 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1193 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1195 /* If this key is undefined, make it a prefix. */
1197 cmd
= define_as_prefix (keymap
, c
);
1199 keymap
= get_keymap (cmd
, 0, 1);
1200 if (!CONSP (keymap
))
1201 /* We must use Fkey_description rather than just passing key to
1202 error; key might be a vector, not a string. */
1203 error ("Key sequence %s uses invalid prefix characters",
1204 SDATA (Fkey_description (key
, Qnil
)));
1208 /* This function may GC (it calls Fkey_binding). */
1210 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 1, 0,
1211 doc
: /* Return the remapping for command COMMAND in current keymaps.
1212 Returns nil if COMMAND is not remapped (or not a symbol). */)
1214 Lisp_Object command
;
1216 if (!SYMBOLP (command
))
1219 ASET (command_remapping_vector
, 1, command
);
1220 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
);
1223 /* Value is number if KEY is too long; nil if valid but has no definition. */
1224 /* GC is possible in this function if it autoloads a keymap. */
1226 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1227 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1228 nil means undefined. See doc of `define-key' for kinds of definitions.
1230 A number as value means KEY is "too long";
1231 that is, characters or symbols in it except for the last one
1232 fail to be a valid sequence of prefix characters in KEYMAP.
1233 The number is how many characters at the front of KEY
1234 it takes to reach a non-prefix command.
1236 Normally, `lookup-key' ignores bindings for t, which act as default
1237 bindings, used when nothing else in the keymap applies; this makes it
1238 usable as a general function for probing keymaps. However, if the
1239 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1240 recognize the default bindings, just as `read-key-sequence' does. */)
1241 (keymap
, key
, accept_default
)
1244 Lisp_Object accept_default
;
1247 register Lisp_Object cmd
;
1248 register Lisp_Object c
;
1250 int t_ok
= !NILP (accept_default
);
1251 struct gcpro gcpro1
, gcpro2
;
1253 GCPRO2 (keymap
, key
);
1254 keymap
= get_keymap (keymap
, 1, 1);
1256 if (!VECTORP (key
) && !STRINGP (key
))
1257 key
= wrong_type_argument (Qarrayp
, key
);
1259 length
= XFASTINT (Flength (key
));
1261 RETURN_UNGCPRO (keymap
);
1266 c
= Faref (key
, make_number (idx
++));
1268 if (CONSP (c
) && lucid_event_type_list_p (c
))
1269 c
= Fevent_convert_list (c
);
1271 /* Turn the 8th bit of string chars into a meta modifier. */
1272 if (XINT (c
) & 0x80 && STRINGP (key
))
1273 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1275 /* Allow string since binding for `menu-bar-select-buffer'
1276 includes the buffer name in the key sequence. */
1277 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1278 error ("Key sequence contains invalid event");
1280 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1282 RETURN_UNGCPRO (cmd
);
1284 keymap
= get_keymap (cmd
, 0, 1);
1285 if (!CONSP (keymap
))
1286 RETURN_UNGCPRO (make_number (idx
));
1292 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1293 Assume that currently it does not define C at all.
1294 Return the keymap. */
1297 define_as_prefix (keymap
, c
)
1298 Lisp_Object keymap
, c
;
1302 cmd
= Fmake_sparse_keymap (Qnil
);
1303 /* If this key is defined as a prefix in an inherited keymap,
1304 make it a prefix in this map, and make its definition
1305 inherit the other prefix definition. */
1306 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1307 store_in_keymap (keymap
, c
, cmd
);
1312 /* Append a key to the end of a key sequence. We always make a vector. */
1315 append_key (key_sequence
, key
)
1316 Lisp_Object key_sequence
, key
;
1318 Lisp_Object args
[2];
1320 args
[0] = key_sequence
;
1322 args
[1] = Fcons (key
, Qnil
);
1323 return Fvconcat (2, args
);
1326 /* Given a event type C which is a symbol,
1327 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1330 silly_event_symbol_error (c
)
1333 Lisp_Object parsed
, base
, name
, assoc
;
1336 parsed
= parse_modifiers (c
);
1337 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1338 base
= XCAR (parsed
);
1339 name
= Fsymbol_name (base
);
1340 /* This alist includes elements such as ("RET" . "\\r"). */
1341 assoc
= Fassoc (name
, exclude_keys
);
1345 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1347 Lisp_Object keystring
;
1348 if (modifiers
& alt_modifier
)
1349 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1350 if (modifiers
& ctrl_modifier
)
1351 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1352 if (modifiers
& hyper_modifier
)
1353 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1354 if (modifiers
& meta_modifier
)
1355 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1356 if (modifiers
& shift_modifier
)
1357 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1358 if (modifiers
& super_modifier
)
1359 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1362 c
= reorder_modifiers (c
);
1363 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1365 error ((modifiers
& ~meta_modifier
1366 ? "To bind the key %s, use [?%s], not [%s]"
1367 : "To bind the key %s, use \"%s\", not [%s]"),
1368 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1369 SDATA (SYMBOL_NAME (c
)));
1373 /* Global, local, and minor mode keymap stuff. */
1375 /* We can't put these variables inside current_minor_maps, since under
1376 some systems, static gets macro-defined to be the empty string.
1378 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1379 static int cmm_size
= 0;
1381 /* Error handler used in current_minor_maps. */
1383 current_minor_maps_error ()
1388 /* Store a pointer to an array of the keymaps of the currently active
1389 minor modes in *buf, and return the number of maps it contains.
1391 This function always returns a pointer to the same buffer, and may
1392 free or reallocate it, so if you want to keep it for a long time or
1393 hand it out to lisp code, copy it. This procedure will be called
1394 for every key sequence read, so the nice lispy approach (return a
1395 new assoclist, list, what have you) for each invocation would
1396 result in a lot of consing over time.
1398 If we used xrealloc/xmalloc and ran out of memory, they would throw
1399 back to the command loop, which would try to read a key sequence,
1400 which would call this function again, resulting in an infinite
1401 loop. Instead, we'll use realloc/malloc and silently truncate the
1402 list, let the key sequence be read, and hope some other piece of
1403 code signals the error. */
1405 current_minor_maps (modeptr
, mapptr
)
1406 Lisp_Object
**modeptr
, **mapptr
;
1409 int list_number
= 0;
1410 Lisp_Object alist
, assoc
, var
, val
;
1411 Lisp_Object emulation_alists
;
1412 Lisp_Object lists
[2];
1414 emulation_alists
= Vemulation_mode_map_alists
;
1415 lists
[0] = Vminor_mode_overriding_map_alist
;
1416 lists
[1] = Vminor_mode_map_alist
;
1418 for (list_number
= 0; list_number
< 2; list_number
++)
1420 if (CONSP (emulation_alists
))
1422 alist
= XCAR (emulation_alists
);
1423 emulation_alists
= XCDR (emulation_alists
);
1424 if (SYMBOLP (alist
))
1425 alist
= find_symbol_value (alist
);
1429 alist
= lists
[list_number
];
1431 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1432 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1433 && (var
= XCAR (assoc
), SYMBOLP (var
))
1434 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1439 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1440 and also an entry in Vminor_mode_map_alist,
1441 ignore the latter. */
1442 if (list_number
== 1)
1444 val
= assq_no_quit (var
, lists
[0]);
1451 int newsize
, allocsize
;
1452 Lisp_Object
*newmodes
, *newmaps
;
1454 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1455 allocsize
= newsize
* sizeof *newmodes
;
1457 /* Use malloc here. See the comment above this function.
1458 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1460 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1465 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1468 cmm_modes
= newmodes
;
1471 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1476 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1483 if (newmodes
== NULL
|| newmaps
== NULL
)
1488 /* Get the keymap definition--or nil if it is not defined. */
1489 temp
= internal_condition_case_1 (Findirect_function
,
1491 Qerror
, current_minor_maps_error
);
1495 cmm_maps
[i
] = temp
;
1501 if (modeptr
) *modeptr
= cmm_modes
;
1502 if (mapptr
) *mapptr
= cmm_maps
;
1506 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1508 doc
: /* Return a list of the currently active keymaps.
1509 OLP if non-nil indicates that we should obey `overriding-local-map' and
1510 `overriding-terminal-local-map'. */)
1514 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1518 if (!NILP (Voverriding_local_map
))
1519 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1520 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1521 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1523 if (NILP (XCDR (keymaps
)))
1529 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1531 keymaps
= Fcons (local
, keymaps
);
1533 nmaps
= current_minor_maps (0, &maps
);
1535 for (i
= --nmaps
; i
>= 0; i
--)
1536 if (!NILP (maps
[i
]))
1537 keymaps
= Fcons (maps
[i
], keymaps
);
1539 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1541 keymaps
= Fcons (local
, keymaps
);
1547 /* GC is possible in this function if it autoloads a keymap. */
1549 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 3, 0,
1550 doc
: /* Return the binding for command KEY in current keymaps.
1551 KEY is a string or vector, a sequence of keystrokes.
1552 The binding is probably a symbol with a function definition.
1554 Normally, `key-binding' ignores bindings for t, which act as default
1555 bindings, used when nothing else in the keymap applies; this makes it
1556 usable as a general function for probing keymaps. However, if the
1557 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1558 recognize the default bindings, just as `read-key-sequence' does.
1560 Like the normal command loop, `key-binding' will remap the command
1561 resulting from looking up KEY by looking up the command in the
1562 current keymaps. However, if the optional third argument NO-REMAP
1563 is non-nil, `key-binding' returns the unmapped command. */)
1564 (key
, accept_default
, no_remap
)
1565 Lisp_Object key
, accept_default
, no_remap
;
1567 Lisp_Object
*maps
, value
;
1569 struct gcpro gcpro1
;
1573 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1575 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1576 key
, accept_default
);
1577 if (! NILP (value
) && !INTEGERP (value
))
1580 else if (!NILP (Voverriding_local_map
))
1582 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1583 if (! NILP (value
) && !INTEGERP (value
))
1590 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1593 value
= Flookup_key (local
, key
, accept_default
);
1594 if (! NILP (value
) && !INTEGERP (value
))
1598 nmaps
= current_minor_maps (0, &maps
);
1599 /* Note that all these maps are GCPRO'd
1600 in the places where we found them. */
1602 for (i
= 0; i
< nmaps
; i
++)
1603 if (! NILP (maps
[i
]))
1605 value
= Flookup_key (maps
[i
], key
, accept_default
);
1606 if (! NILP (value
) && !INTEGERP (value
))
1610 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1613 value
= Flookup_key (local
, key
, accept_default
);
1614 if (! NILP (value
) && !INTEGERP (value
))
1619 value
= Flookup_key (current_global_map
, key
, accept_default
);
1623 if (NILP (value
) || INTEGERP (value
))
1626 /* If the result of the ordinary keymap lookup is an interactive
1627 command, look for a key binding (ie. remapping) for that command. */
1629 if (NILP (no_remap
) && SYMBOLP (value
))
1632 if (value1
= Fcommand_remapping (value
), !NILP (value1
))
1639 /* GC is possible in this function if it autoloads a keymap. */
1641 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1642 doc
: /* Return the binding for command KEYS in current local keymap only.
1643 KEYS is a string or vector, a sequence of keystrokes.
1644 The binding is probably a symbol with a function definition.
1646 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1647 bindings; see the description of `lookup-key' for more details about this. */)
1648 (keys
, accept_default
)
1649 Lisp_Object keys
, accept_default
;
1651 register Lisp_Object map
;
1652 map
= current_buffer
->keymap
;
1655 return Flookup_key (map
, keys
, accept_default
);
1658 /* GC is possible in this function if it autoloads a keymap. */
1660 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1661 doc
: /* Return the binding for command KEYS in current global keymap only.
1662 KEYS is a string or vector, a sequence of keystrokes.
1663 The binding is probably a symbol with a function definition.
1664 This function's return values are the same as those of `lookup-key'
1667 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1668 bindings; see the description of `lookup-key' for more details about this. */)
1669 (keys
, accept_default
)
1670 Lisp_Object keys
, accept_default
;
1672 return Flookup_key (current_global_map
, keys
, accept_default
);
1675 /* GC is possible in this function if it autoloads a keymap. */
1677 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1678 doc
: /* Find the visible minor mode bindings of KEY.
1679 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the
1680 the symbol which names the minor mode binding KEY, and BINDING is
1681 KEY's definition in that mode. In particular, if KEY has no
1682 minor-mode bindings, return nil. If the first binding is a
1683 non-prefix, all subsequent bindings will be omitted, since they would
1684 be ignored. Similarly, the list doesn't include non-prefix bindings
1685 that come after prefix bindings.
1687 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1688 bindings; see the description of `lookup-key' for more details about this. */)
1689 (key
, accept_default
)
1690 Lisp_Object key
, accept_default
;
1692 Lisp_Object
*modes
, *maps
;
1694 Lisp_Object binding
;
1696 struct gcpro gcpro1
, gcpro2
;
1698 nmaps
= current_minor_maps (&modes
, &maps
);
1699 /* Note that all these maps are GCPRO'd
1700 in the places where we found them. */
1703 GCPRO2 (key
, binding
);
1705 for (i
= j
= 0; i
< nmaps
; i
++)
1707 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1708 && !INTEGERP (binding
))
1710 if (KEYMAPP (binding
))
1711 maps
[j
++] = Fcons (modes
[i
], binding
);
1713 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1717 return Flist (j
, maps
);
1720 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1721 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1722 A new sparse keymap is stored as COMMAND's function definition and its value.
1723 If a second optional argument MAPVAR is given, the map is stored as
1724 its value instead of as COMMAND's value; but COMMAND is still defined
1726 The third optional argument NAME, if given, supplies a menu name
1727 string for the map. This is required to use the keymap as a menu.
1728 This function returns COMMAND. */)
1729 (command
, mapvar
, name
)
1730 Lisp_Object command
, mapvar
, name
;
1733 map
= Fmake_sparse_keymap (name
);
1734 Ffset (command
, map
);
1738 Fset (command
, map
);
1742 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1743 doc
: /* Select KEYMAP as the global keymap. */)
1747 keymap
= get_keymap (keymap
, 1, 1);
1748 current_global_map
= keymap
;
1753 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1754 doc
: /* Select KEYMAP as the local keymap.
1755 If KEYMAP is nil, that means no local keymap. */)
1760 keymap
= get_keymap (keymap
, 1, 1);
1762 current_buffer
->keymap
= keymap
;
1767 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1768 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1771 return current_buffer
->keymap
;
1774 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1775 doc
: /* Return the current global keymap. */)
1778 return current_global_map
;
1781 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1782 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1786 int nmaps
= current_minor_maps (0, &maps
);
1788 return Flist (nmaps
, maps
);
1791 /* Help functions for describing and documenting keymaps. */
1795 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1796 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1797 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1801 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
1805 /* Look for and break cycles. */
1806 while (!NILP (tem
= Frassq (cmd
, maps
)))
1808 Lisp_Object prefix
= XCAR (tem
);
1809 int lim
= XINT (Flength (XCAR (tem
)));
1810 if (lim
<= XINT (Flength (thisseq
)))
1811 { /* This keymap was already seen with a smaller prefix. */
1813 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
1814 Faref (thisseq
, make_number (i
))))
1817 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1820 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1821 but maybe `cmd' occurs again further down in `maps', so keep
1823 maps
= XCDR (Fmemq (tem
, maps
));
1826 /* If the last key in thisseq is meta-prefix-char,
1827 turn it into a meta-ized keystroke. We know
1828 that the event we're about to append is an
1829 ascii keystroke since we're processing a
1833 int meta_bit
= meta_modifier
;
1834 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1835 tem
= Fcopy_sequence (thisseq
);
1837 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1839 /* This new sequence is the same length as
1840 thisseq, so stick it in the list right
1843 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1847 tem
= append_key (thisseq
, key
);
1848 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1853 accessible_keymaps_char_table (args
, index
, cmd
)
1854 Lisp_Object args
, index
, cmd
;
1856 accessible_keymaps_1 (index
, cmd
,
1860 XINT (XCDR (XCAR (args
))));
1863 /* This function cannot GC. */
1865 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1867 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1868 Returns a list of elements of the form (KEYS . MAP), where the sequence
1869 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1870 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1871 An optional argument PREFIX, if non-nil, should be a key sequence;
1872 then the value includes only maps for prefixes that start with PREFIX. */)
1874 Lisp_Object keymap
, prefix
;
1876 Lisp_Object maps
, tail
;
1879 /* no need for gcpro because we don't autoload any keymaps. */
1882 prefixlen
= XINT (Flength (prefix
));
1886 /* If a prefix was specified, start with the keymap (if any) for
1887 that prefix, so we don't waste time considering other prefixes. */
1889 tem
= Flookup_key (keymap
, prefix
, Qt
);
1890 /* Flookup_key may give us nil, or a number,
1891 if the prefix is not defined in this particular map.
1892 It might even give us a list that isn't a keymap. */
1893 tem
= get_keymap (tem
, 0, 0);
1896 /* Convert PREFIX to a vector now, so that later on
1897 we don't have to deal with the possibility of a string. */
1898 if (STRINGP (prefix
))
1903 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
1904 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
1908 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1909 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1910 c
^= 0200 | meta_modifier
;
1911 ASET (copy
, i_before
, make_number (c
));
1915 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1921 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1922 get_keymap (keymap
, 1, 0)),
1925 /* For each map in the list maps,
1926 look at any other maps it points to,
1927 and stick them at the end if they are not already in the list.
1929 This is a breadth-first traversal, where tail is the queue of
1930 nodes, and maps accumulates a list of all nodes visited. */
1932 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1934 register Lisp_Object thisseq
, thismap
;
1936 /* Does the current sequence end in the meta-prefix-char? */
1939 thisseq
= Fcar (Fcar (tail
));
1940 thismap
= Fcdr (Fcar (tail
));
1941 last
= make_number (XINT (Flength (thisseq
)) - 1);
1942 is_metized
= (XINT (last
) >= 0
1943 /* Don't metize the last char of PREFIX. */
1944 && XINT (last
) >= prefixlen
1945 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1947 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1951 elt
= XCAR (thismap
);
1955 if (CHAR_TABLE_P (elt
))
1957 map_char_table (accessible_keymaps_char_table
, Qnil
,
1958 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1959 Fcons (tail
, thisseq
)));
1961 else if (VECTORP (elt
))
1965 /* Vector keymap. Scan all the elements. */
1966 for (i
= 0; i
< ASIZE (elt
); i
++)
1967 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1968 maps
, tail
, thisseq
, is_metized
);
1971 else if (CONSP (elt
))
1972 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
1973 maps
, tail
, thisseq
,
1974 is_metized
&& INTEGERP (XCAR (elt
)));
1982 Lisp_Object Qsingle_key_description
, Qkey_description
;
1984 /* This function cannot GC. */
1986 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
1987 doc
: /* Return a pretty description of key-sequence KEYS.
1988 Optional arg PREFIX is the sequence of keys leading up to KEYS.
1989 Control characters turn into "C-foo" sequences, meta into "M-foo",
1990 spaces are put between sequence elements, etc. */)
1992 Lisp_Object keys
, prefix
;
1997 int size
= XINT (Flength (keys
));
1999 Lisp_Object sep
= build_string (" ");
2004 size
+= XINT (Flength (prefix
));
2006 /* This has one extra element at the end that we don't pass to Fconcat. */
2007 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2009 /* In effect, this computes
2010 (mapconcat 'single-key-description keys " ")
2011 but we shouldn't use mapconcat because it can do GC. */
2015 list
= prefix
, prefix
= Qnil
;
2016 else if (!NILP (keys
))
2017 list
= keys
, keys
= Qnil
;
2022 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2026 return empty_string
;
2027 return Fconcat (len
- 1, args
);
2031 size
= SCHARS (list
);
2032 else if (VECTORP (list
))
2033 size
= XVECTOR (list
)->size
;
2034 else if (CONSP (list
))
2035 size
= XINT (Flength (list
));
2037 wrong_type_argument (Qarrayp
, list
);
2046 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2047 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2048 c
^= 0200 | meta_modifier
;
2049 XSETFASTINT (key
, c
);
2051 else if (VECTORP (list
))
2053 key
= AREF (list
, i
++);
2065 || EQ (key
, meta_prefix_char
)
2066 || (XINT (key
) & meta_modifier
))
2068 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2070 if (EQ (key
, meta_prefix_char
))
2074 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2077 else if (EQ (key
, meta_prefix_char
))
2082 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2090 push_key_description (c
, p
, force_multibyte
)
2091 register unsigned int c
;
2093 int force_multibyte
;
2097 /* Clear all the meaningless bits above the meta bit. */
2098 c
&= meta_modifier
| ~ - meta_modifier
;
2099 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2100 | meta_modifier
| shift_modifier
| super_modifier
);
2102 if (c
& alt_modifier
)
2108 if ((c
& ctrl_modifier
) != 0
2109 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2113 c
&= ~ctrl_modifier
;
2115 if (c
& hyper_modifier
)
2119 c
-= hyper_modifier
;
2121 if (c
& meta_modifier
)
2127 if (c
& shift_modifier
)
2131 c
-= shift_modifier
;
2133 if (c
& super_modifier
)
2137 c
-= super_modifier
;
2153 else if (c
== Ctl ('M'))
2161 /* `C-' already added above. */
2162 if (c
> 0 && c
<= Ctl ('Z'))
2181 || (NILP (current_buffer
->enable_multibyte_characters
)
2182 && SINGLE_BYTE_CHAR_P (c
)
2183 && !force_multibyte
))
2187 else if (CHARACTERP (make_number (c
)))
2189 if (NILP (current_buffer
->enable_multibyte_characters
)
2190 && ! force_multibyte
)
2191 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2193 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2199 /* The biggest character code uses 22 bits. */
2200 for (bit_offset
= 21; bit_offset
>= 0; bit_offset
-= 3)
2202 if (c
>= (1 << bit_offset
))
2203 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
2210 /* This function cannot GC. */
2212 DEFUN ("single-key-description", Fsingle_key_description
,
2213 Ssingle_key_description
, 1, 2, 0,
2214 doc
: /* Return a pretty description of command character KEY.
2215 Control characters turn into C-whatever, etc.
2216 Optional argument NO-ANGLES non-nil means don't put angle brackets
2217 around function keys and event symbols. */)
2219 Lisp_Object key
, no_angles
;
2221 if (CONSP (key
) && lucid_event_type_list_p (key
))
2222 key
= Fevent_convert_list (key
);
2224 key
= EVENT_HEAD (key
);
2226 if (INTEGERP (key
)) /* Normal character */
2228 char tem
[KEY_DESCRIPTION_SIZE
];
2230 *push_key_description (XUINT (key
), tem
, 1) = 0;
2231 return build_string (tem
);
2233 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2235 if (NILP (no_angles
))
2238 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2239 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2240 return build_string (buffer
);
2243 return Fsymbol_name (key
);
2245 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2246 return Fcopy_sequence (key
);
2248 error ("KEY must be an integer, cons, symbol, or string");
2253 push_text_char_description (c
, p
)
2254 register unsigned int c
;
2266 *p
++ = c
+ 64; /* 'A' - 1 */
2278 /* This function cannot GC. */
2280 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2281 doc
: /* Return a pretty description of file-character CHARACTER.
2282 Control characters turn into "^char", etc. This differs from
2283 `single-key-description' which turns them into "C-char".
2284 Also, this function recognizes the 2**7 bit as the Meta character,
2285 whereas `single-key-description' uses the 2**27 bit for Meta.
2286 See Info node `(elisp)Describing Characters' for examples. */)
2288 Lisp_Object character
;
2290 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2291 unsigned char str
[6];
2294 CHECK_NUMBER (character
);
2296 c
= XINT (character
);
2297 if (!ASCII_CHAR_P (c
))
2299 int len
= CHAR_STRING (c
, str
);
2301 return make_multibyte_string (str
, 1, len
);
2304 *push_text_char_description (c
& 0377, str
) = 0;
2306 return build_string (str
);
2309 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2312 ascii_sequence_p (seq
)
2316 int len
= XINT (Flength (seq
));
2318 for (i
= 0; i
< len
; i
++)
2320 Lisp_Object ii
, elt
;
2322 XSETFASTINT (ii
, i
);
2323 elt
= Faref (seq
, ii
);
2326 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2334 /* where-is - finding a command in a set of keymaps. */
2336 static Lisp_Object
where_is_internal ();
2337 static Lisp_Object
where_is_internal_1 ();
2338 static void where_is_internal_2 ();
2340 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2341 Returns the first non-nil binding found in any of those maps. */
2344 shadow_lookup (shadow
, key
, flag
)
2345 Lisp_Object shadow
, key
, flag
;
2347 Lisp_Object tail
, value
;
2349 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2351 value
= Flookup_key (XCAR (tail
), key
, flag
);
2352 if (!NILP (value
) && !NATNUMP (value
))
2358 static Lisp_Object Vmouse_events
;
2360 /* This function can GC if Flookup_key autoloads any keymaps. */
2363 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2364 Lisp_Object definition
, keymaps
;
2365 Lisp_Object firstonly
, noindirect
, no_remap
;
2367 Lisp_Object maps
= Qnil
;
2368 Lisp_Object found
, sequences
;
2369 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2370 /* 1 means ignore all menu bindings entirely. */
2371 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2373 /* If this command is remapped, then it has no key bindings
2375 if (NILP (no_remap
) && SYMBOLP (definition
))
2378 if (tem
= Fcommand_remapping (definition
), !NILP (tem
))
2383 while (CONSP (found
))
2387 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2388 found
= XCDR (found
);
2391 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2395 for (; !NILP (maps
); maps
= Fcdr (maps
))
2397 /* Key sequence to reach map, and the map that it reaches */
2398 register Lisp_Object
this, map
, tem
;
2400 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2401 [M-CHAR] sequences, check if last character of the sequence
2402 is the meta-prefix char. */
2406 this = Fcar (Fcar (maps
));
2407 map
= Fcdr (Fcar (maps
));
2408 last
= make_number (XINT (Flength (this)) - 1);
2409 last_is_meta
= (XINT (last
) >= 0
2410 && EQ (Faref (this, last
), meta_prefix_char
));
2412 /* if (nomenus && !ascii_sequence_p (this)) */
2413 if (nomenus
&& XINT (last
) >= 0
2414 && SYMBOLP (tem
= Faref (this, make_number (0)))
2415 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2416 /* If no menu entries should be returned, skip over the
2417 keymaps bound to `menu-bar' and `tool-bar' and other
2418 non-ascii prefixes like `C-down-mouse-2'. */
2425 /* Because the code we want to run on each binding is rather
2426 large, we don't want to have two separate loop bodies for
2427 sparse keymap bindings and tables; we want to iterate one
2428 loop body over both keymap and vector bindings.
2430 For this reason, if Fcar (map) is a vector, we don't
2431 advance map to the next element until i indicates that we
2432 have finished off the vector. */
2433 Lisp_Object elt
, key
, binding
;
2441 /* Set key and binding to the current key and binding, and
2442 advance map and i to the next binding. */
2445 Lisp_Object sequence
;
2447 /* In a vector, look at each element. */
2448 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2450 binding
= AREF (elt
, i
);
2451 XSETFASTINT (key
, i
);
2452 sequence
= where_is_internal_1 (binding
, key
, definition
,
2454 last
, nomenus
, last_is_meta
);
2455 if (!NILP (sequence
))
2456 sequences
= Fcons (sequence
, sequences
);
2459 else if (CHAR_TABLE_P (elt
))
2463 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2464 Qnil
), /* Result accumulator. */
2465 Fcons (Fcons (this, last
),
2466 Fcons (make_number (nomenus
),
2467 make_number (last_is_meta
))));
2468 map_char_table (where_is_internal_2
, Qnil
, elt
, args
);
2469 sequences
= XCDR (XCAR (args
));
2471 else if (CONSP (elt
))
2473 Lisp_Object sequence
;
2476 binding
= XCDR (elt
);
2478 sequence
= where_is_internal_1 (binding
, key
, definition
,
2480 last
, nomenus
, last_is_meta
);
2481 if (!NILP (sequence
))
2482 sequences
= Fcons (sequence
, sequences
);
2486 while (!NILP (sequences
))
2488 Lisp_Object sequence
, remapped
, function
;
2490 sequence
= XCAR (sequences
);
2491 sequences
= XCDR (sequences
);
2493 /* If the current sequence is a command remapping with
2494 format [remap COMMAND], find the key sequences
2495 which run COMMAND, and use those sequences instead. */
2498 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2499 && EQ (AREF (sequence
, 0), Qremap
)
2500 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2502 Lisp_Object remapped1
;
2504 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2505 if (CONSP (remapped1
))
2507 /* Verify that this key binding actually maps to the
2508 remapped command (see below). */
2509 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2511 sequence
= XCAR (remapped1
);
2512 remapped
= XCDR (remapped1
);
2513 goto record_sequence
;
2517 /* Verify that this key binding is not shadowed by another
2518 binding for the same key, before we say it exists.
2520 Mechanism: look for local definition of this key and if
2521 it is defined and does not match what we found then
2524 Either nil or number as value from Flookup_key
2526 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2530 /* It is a true unshadowed match. Record it, unless it's already
2531 been seen (as could happen when inheriting keymaps). */
2532 if (NILP (Fmember (sequence
, found
)))
2533 found
= Fcons (sequence
, found
);
2535 /* If firstonly is Qnon_ascii, then we can return the first
2536 binding we find. If firstonly is not Qnon_ascii but not
2537 nil, then we should return the first ascii-only binding
2539 if (EQ (firstonly
, Qnon_ascii
))
2540 RETURN_UNGCPRO (sequence
);
2541 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2542 RETURN_UNGCPRO (sequence
);
2544 if (CONSP (remapped
))
2546 sequence
= XCAR (remapped
);
2547 remapped
= XCDR (remapped
);
2548 goto record_sequence
;
2556 found
= Fnreverse (found
);
2558 /* firstonly may have been t, but we may have gone all the way through
2559 the keymaps without finding an all-ASCII key sequence. So just
2560 return the best we could find. */
2561 if (!NILP (firstonly
))
2562 return Fcar (found
);
2567 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2568 doc
: /* Return list of keys that invoke DEFINITION.
2569 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2570 If KEYMAP is nil, search all the currently active keymaps.
2571 If KEYMAP is a list of keymaps, search only those keymaps.
2573 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2574 rather than a list of all possible key sequences.
2575 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2576 no matter what it is.
2577 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2578 \(or their meta variants) and entirely reject menu bindings.
2580 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2581 to other keymaps or slots. This makes it possible to search for an
2582 indirect definition itself.
2584 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2585 that invoke a command which is remapped to DEFINITION, but include the
2586 remapped command in the returned list. */)
2587 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2588 Lisp_Object definition
, keymap
;
2589 Lisp_Object firstonly
, noindirect
, no_remap
;
2591 Lisp_Object sequences
, keymaps
;
2592 /* 1 means ignore all menu bindings entirely. */
2593 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2596 /* Find the relevant keymaps. */
2597 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2599 else if (!NILP (keymap
))
2600 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2602 keymaps
= Fcurrent_active_maps (Qnil
);
2604 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2605 We don't really need to check `keymap'. */
2606 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2610 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2612 /* Check heuristic-consistency of the cache. */
2613 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2614 where_is_cache
= Qnil
;
2616 if (NILP (where_is_cache
))
2618 /* We need to create the cache. */
2619 Lisp_Object args
[2];
2620 where_is_cache
= Fmake_hash_table (0, args
);
2621 where_is_cache_keymaps
= Qt
;
2623 /* Fill in the cache. */
2624 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2625 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2628 where_is_cache_keymaps
= keymaps
;
2631 /* We want to process definitions from the last to the first.
2632 Instead of consing, copy definitions to a vector and step
2633 over that vector. */
2634 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2635 n
= XINT (Flength (sequences
));
2636 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2637 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2638 defns
[i
++] = XCAR (sequences
);
2640 /* Verify that the key bindings are not shadowed. Note that
2641 the following can GC. */
2642 GCPRO2 (definition
, keymaps
);
2645 for (i
= n
- 1; i
>= 0; --i
)
2646 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2648 if (ascii_sequence_p (defns
[i
]))
2654 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2659 /* Kill the cache so that where_is_internal_1 doesn't think
2660 we're filling it up. */
2661 where_is_cache
= Qnil
;
2662 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2668 /* This is the function that Fwhere_is_internal calls using map_char_table.
2670 (((DEFINITION . NOINDIRECT) . RESULT)
2672 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2673 Since map_char_table doesn't really use the return value from this function,
2674 we the result append to RESULT, the slot in ARGS.
2676 KEY may be a cons (FROM . TO) where both FROM and TO are integers
2677 (i.e. character events).
2679 This function can GC because it calls where_is_internal_1 which can
2683 where_is_internal_2 (args
, key
, binding
)
2684 Lisp_Object args
, key
, binding
;
2686 Lisp_Object definition
, noindirect
, this, last
;
2687 Lisp_Object result
, sequence
;
2688 int nomenus
, last_is_meta
;
2689 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2691 GCPRO3 (args
, key
, binding
);
2692 definition
= XCAR (XCAR (XCAR (args
)));
2693 noindirect
= XCDR (XCAR (XCAR (args
)));
2694 this = XCAR (XCAR (XCDR (args
)));
2695 last
= XCDR (XCAR (XCDR (args
)));
2696 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2697 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2700 if (CONSP (key
) && INTEGERP (XCAR (key
)) && INTEGERP (XCDR (key
)))
2702 /* Try all ASCII characters. Try also non-ASCII characters but
2703 only the first and last one because trying all of them is
2704 extremely memory and time consuming.
2706 Fixme: Perhaps it should be allowed to store a cons directly
2707 in RESULT. -- handa@m17n.org */
2708 int from
= XINT (XCAR (key
)), to
= XINT (XCDR (key
));
2711 for (; from
<= to
; to
--)
2713 k
= make_number (to
);
2714 sequence
= where_is_internal_1 (binding
, k
, definition
, noindirect
,
2715 this, last
, nomenus
, last_is_meta
);
2716 if (!NILP (sequence
))
2717 result
= Fcons (sequence
, result
);
2724 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2725 this, last
, nomenus
, last_is_meta
);
2726 if (!NILP (sequence
))
2727 result
= Fcons (sequence
, Qnil
);
2730 if (! NILP (result
))
2731 nconc2 (XCAR (args
), result
);
2737 /* This function cannot GC. */
2740 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2741 nomenus
, last_is_meta
)
2742 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2743 int nomenus
, last_is_meta
;
2745 Lisp_Object sequence
;
2747 /* Search through indirections unless that's not wanted. */
2748 if (NILP (noindirect
))
2749 binding
= get_keyelt (binding
, 0);
2751 /* End this iteration if this element does not match
2754 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2755 || EQ (binding
, definition
)
2756 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2757 /* Doesn't match. */
2760 /* We have found a match. Construct the key sequence where we found it. */
2761 if (INTEGERP (key
) && last_is_meta
)
2763 sequence
= Fcopy_sequence (this);
2764 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2767 sequence
= append_key (this, key
);
2769 if (!NILP (where_is_cache
))
2771 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2772 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2779 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2781 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2782 doc
: /* Insert the list of all defined keys and their definitions.
2783 The list is inserted in the current buffer, while the bindings are
2784 looked up in BUFFER.
2785 The optional argument PREFIX, if non-nil, should be a key sequence;
2786 then we display only bindings that start with that prefix.
2787 The optional argument MENUS, if non-nil, says to mention menu bindings.
2788 \(Ordinarily these are omitted from the output.) */)
2789 (buffer
, prefix
, menus
)
2790 Lisp_Object buffer
, prefix
, menus
;
2792 Lisp_Object outbuf
, shadow
;
2793 int nomenu
= NILP (menus
);
2794 register Lisp_Object start1
;
2795 struct gcpro gcpro1
;
2797 char *alternate_heading
2799 Keyboard translations:\n\n\
2800 You type Translation\n\
2801 -------- -----------\n";
2806 outbuf
= Fcurrent_buffer ();
2808 /* Report on alternates for keys. */
2809 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2812 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2813 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2815 for (c
= 0; c
< translate_len
; c
++)
2816 if (translate
[c
] != c
)
2818 char buf
[KEY_DESCRIPTION_SIZE
];
2821 if (alternate_heading
)
2823 insert_string (alternate_heading
);
2824 alternate_heading
= 0;
2827 bufend
= push_key_description (translate
[c
], buf
, 1);
2828 insert (buf
, bufend
- buf
);
2829 Findent_to (make_number (16), make_number (1));
2830 bufend
= push_key_description (c
, buf
, 1);
2831 insert (buf
, bufend
- buf
);
2839 if (!NILP (Vkey_translation_map
))
2840 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2841 "Key translations", nomenu
, 1, 0);
2844 /* Print the (major mode) local map. */
2846 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2847 start1
= current_kboard
->Voverriding_terminal_local_map
;
2848 else if (!NILP (Voverriding_local_map
))
2849 start1
= Voverriding_local_map
;
2853 describe_map_tree (start1
, 1, shadow
, prefix
,
2854 "\f\nOverriding Bindings", nomenu
, 0, 0);
2855 shadow
= Fcons (start1
, shadow
);
2859 /* Print the minor mode and major mode keymaps. */
2861 Lisp_Object
*modes
, *maps
;
2863 /* Temporarily switch to `buffer', so that we can get that buffer's
2864 minor modes correctly. */
2865 Fset_buffer (buffer
);
2867 nmaps
= current_minor_maps (&modes
, &maps
);
2868 Fset_buffer (outbuf
);
2870 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2871 XBUFFER (buffer
), Qkeymap
);
2874 describe_map_tree (start1
, 1, shadow
, prefix
,
2875 "\f\n`keymap' Property Bindings", nomenu
, 0, 0);
2876 shadow
= Fcons (start1
, shadow
);
2879 /* Print the minor mode maps. */
2880 for (i
= 0; i
< nmaps
; i
++)
2882 /* The title for a minor mode keymap
2883 is constructed at run time.
2884 We let describe_map_tree do the actual insertion
2885 because it takes care of other features when doing so. */
2888 if (!SYMBOLP (modes
[i
]))
2891 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
2895 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
2896 SCHARS (SYMBOL_NAME (modes
[i
])));
2897 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
2899 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2900 p
+= sizeof (" Minor Mode Bindings") - 1;
2903 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2904 shadow
= Fcons (maps
[i
], shadow
);
2907 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2908 XBUFFER (buffer
), Qlocal_map
);
2911 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
2912 describe_map_tree (start1
, 1, shadow
, prefix
,
2913 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2915 describe_map_tree (start1
, 1, shadow
, prefix
,
2916 "\f\n`local-map' Property Bindings",
2919 shadow
= Fcons (start1
, shadow
);
2923 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2924 "\f\nGlobal Bindings", nomenu
, 0, 1);
2926 /* Print the function-key-map translations under this prefix. */
2927 if (!NILP (Vfunction_key_map
))
2928 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2929 "\f\nFunction key map translations", nomenu
, 1, 0);
2935 /* Insert a description of the key bindings in STARTMAP,
2936 followed by those of all maps reachable through STARTMAP.
2937 If PARTIAL is nonzero, omit certain "uninteresting" commands
2938 (such as `undefined').
2939 If SHADOW is non-nil, it is a list of maps;
2940 don't mention keys which would be shadowed by any of them.
2941 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2942 TITLE, if not 0, is a string to insert at the beginning.
2943 TITLE should not end with a colon or a newline; we supply that.
2944 If NOMENU is not 0, then omit menu-bar commands.
2946 If TRANSL is nonzero, the definitions are actually key translations
2947 so print strings and vectors differently.
2949 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2953 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2955 Lisp_Object startmap
, shadow
, prefix
;
2962 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2963 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2970 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2973 GCPRO3 (maps
, seen
, sub_shadows
);
2979 /* Delete from MAPS each element that is for the menu bar. */
2980 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2982 Lisp_Object elt
, prefix
, tem
;
2985 prefix
= Fcar (elt
);
2986 if (XVECTOR (prefix
)->size
>= 1)
2988 tem
= Faref (prefix
, make_number (0));
2989 if (EQ (tem
, Qmenu_bar
))
2990 maps
= Fdelq (elt
, maps
);
2995 if (!NILP (maps
) || always_title
)
2999 insert_string (title
);
3002 insert_string (" Starting With ");
3003 insert1 (Fkey_description (prefix
, Qnil
));
3005 insert_string (":\n");
3007 insert_string (key_heading
);
3011 for (; !NILP (maps
); maps
= Fcdr (maps
))
3013 register Lisp_Object elt
, prefix
, tail
;
3016 prefix
= Fcar (elt
);
3020 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3024 shmap
= XCAR (tail
);
3026 /* If the sequence by which we reach this keymap is zero-length,
3027 then the shadow map for this keymap is just SHADOW. */
3028 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3029 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3031 /* If the sequence by which we reach this keymap actually has
3032 some elements, then the sequence's definition in SHADOW is
3033 what we should use. */
3036 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3037 if (INTEGERP (shmap
))
3041 /* If shmap is not nil and not a keymap,
3042 it completely shadows this map, so don't
3043 describe this map at all. */
3044 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3048 sub_shadows
= Fcons (shmap
, sub_shadows
);
3051 /* Maps we have already listed in this loop shadow this map. */
3052 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3055 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3057 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3060 describe_map (Fcdr (elt
), prefix
,
3061 transl
? describe_translation
: describe_command
,
3062 partial
, sub_shadows
, &seen
, nomenu
);
3068 insert_string ("\n");
3073 static int previous_description_column
;
3076 describe_command (definition
, args
)
3077 Lisp_Object definition
, args
;
3079 register Lisp_Object tem1
;
3080 int column
= (int) current_column (); /* iftc */
3081 int description_column
;
3083 /* If column 16 is no good, go to col 32;
3084 but don't push beyond that--go to next line instead. */
3088 description_column
= 32;
3090 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3091 description_column
= 32;
3093 description_column
= 16;
3095 Findent_to (make_number (description_column
), make_number (1));
3096 previous_description_column
= description_column
;
3098 if (SYMBOLP (definition
))
3100 tem1
= SYMBOL_NAME (definition
);
3102 insert_string ("\n");
3104 else if (STRINGP (definition
) || VECTORP (definition
))
3105 insert_string ("Keyboard Macro\n");
3106 else if (KEYMAPP (definition
))
3107 insert_string ("Prefix Command\n");
3109 insert_string ("??\n");
3113 describe_translation (definition
, args
)
3114 Lisp_Object definition
, args
;
3116 register Lisp_Object tem1
;
3118 Findent_to (make_number (16), make_number (1));
3120 if (SYMBOLP (definition
))
3122 tem1
= SYMBOL_NAME (definition
);
3124 insert_string ("\n");
3126 else if (STRINGP (definition
) || VECTORP (definition
))
3128 insert1 (Fkey_description (definition
, Qnil
));
3129 insert_string ("\n");
3131 else if (KEYMAPP (definition
))
3132 insert_string ("Prefix Command\n");
3134 insert_string ("??\n");
3137 /* Describe the contents of map MAP, assuming that this map itself is
3138 reached by the sequence of prefix keys PREFIX (a string or vector).
3139 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3142 describe_map (map
, prefix
, elt_describer
, partial
, shadow
, seen
, nomenu
)
3143 register Lisp_Object map
;
3145 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3151 Lisp_Object tail
, definition
, event
;
3153 Lisp_Object suppress
;
3156 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3161 suppress
= intern ("suppress-keymap");
3163 /* This vector gets used to present single keys to Flookup_key. Since
3164 that is done once per keymap element, we don't want to cons up a
3165 fresh vector every time. */
3166 kludge
= Fmake_vector (make_number (1), Qnil
);
3169 GCPRO3 (prefix
, definition
, kludge
);
3171 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3175 if (VECTORP (XCAR (tail
))
3176 || CHAR_TABLE_P (XCAR (tail
)))
3177 describe_vector (XCAR (tail
),
3178 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3180 else if (CONSP (XCAR (tail
)))
3182 event
= XCAR (XCAR (tail
));
3184 /* Ignore bindings whose "prefix" are not really valid events.
3185 (We get these in the frames and buffers menu.) */
3186 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3189 if (nomenu
&& EQ (event
, Qmenu_bar
))
3192 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3194 /* Don't show undefined commands or suppressed commands. */
3195 if (NILP (definition
)) continue;
3196 if (SYMBOLP (definition
) && partial
)
3198 tem
= Fget (definition
, suppress
);
3203 /* Don't show a command that isn't really visible
3204 because a local definition of the same key shadows it. */
3206 ASET (kludge
, 0, event
);
3209 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3210 if (!NILP (tem
)) continue;
3213 tem
= Flookup_key (map
, kludge
, Qt
);
3214 if (!EQ (tem
, definition
)) continue;
3218 previous_description_column
= 0;
3223 /* THIS gets the string to describe the character EVENT. */
3224 insert1 (Fkey_description (kludge
, prefix
));
3226 /* Print a description of the definition of this character.
3227 elt_describer will take care of spacing out far enough
3228 for alignment purposes. */
3229 (*elt_describer
) (definition
, Qnil
);
3231 else if (EQ (XCAR (tail
), Qkeymap
))
3233 /* The same keymap might be in the structure twice, if we're
3234 using an inherited keymap. So skip anything we've already
3236 tem
= Fassq (tail
, *seen
);
3237 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3239 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3247 describe_vector_princ (elt
, fun
)
3248 Lisp_Object elt
, fun
;
3250 Findent_to (make_number (16), make_number (1));
3255 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3256 doc
: /* Insert a description of contents of VECTOR.
3257 This is text showing the elements of vector matched against indices.
3258 DESCRIBER is the output function used; nil means use `princ'. */)
3260 Lisp_Object vector
, describer
;
3262 int count
= SPECPDL_INDEX ();
3263 if (NILP (describer
))
3264 describer
= intern ("princ");
3265 specbind (Qstandard_output
, Fcurrent_buffer ());
3266 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3267 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3268 Qnil
, Qnil
, (int *)0, 0, 0);
3270 return unbind_to (count
, Qnil
);
3273 /* Insert in the current buffer a description of the contents of VECTOR.
3274 We call ELT_DESCRIBER to insert the description of one value found
3277 ELT_PREFIX describes what "comes before" the keys or indices defined
3278 by this vector. This is a human-readable string whose size
3279 is not necessarily related to the situation.
3281 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3282 leads to this keymap.
3284 If the vector is a chartable, ELT_PREFIX is the vector
3285 of bytes that lead to the character set or portion of a character
3286 set described by this chartable.
3288 If PARTIAL is nonzero, it means do not mention suppressed commands
3289 (that assumes the vector is in a keymap).
3291 SHADOW is a list of keymaps that shadow this map.
3292 If it is non-nil, then we look up the key in those maps
3293 and we don't mention it now if it is defined by any of them.
3295 ENTIRE_MAP is the keymap in which this vector appears.
3296 If the definition in effect in the whole map does not match
3297 the one in this vector, we ignore this one.
3299 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3301 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3304 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3306 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3309 describe_vector (vector
, prefix
, args
, elt_describer
,
3310 partial
, shadow
, entire_map
,
3311 indices
, char_table_depth
, keymap_p
)
3312 register Lisp_Object vector
;
3313 Lisp_Object prefix
, args
;
3314 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3317 Lisp_Object entire_map
;
3319 int char_table_depth
;
3322 Lisp_Object definition
;
3324 Lisp_Object elt_prefix
= Qnil
;
3326 Lisp_Object suppress
;
3329 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3330 /* Range of elements to be handled. */
3332 Lisp_Object character
;
3341 /* Call Fkey_description first, to avoid GC bug for the other string. */
3342 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3345 tem
= Fkey_description (prefix
, Qnil
);
3346 elt_prefix
= concat2 (tem
, build_string (" "));
3351 /* This vector gets used to present single keys to Flookup_key. Since
3352 that is done once per vector element, we don't want to cons up a
3353 fresh vector every time. */
3354 kludge
= Fmake_vector (make_number (1), Qnil
);
3355 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3358 suppress
= intern ("suppress-keymap");
3361 to
= CHAR_TABLE_P (vector
) ? MAX_CHAR
+ 1 : XVECTOR (vector
)->size
;
3363 for (i
= from
; i
< to
; i
++)
3365 int range_beg
, range_end
;
3372 if (CHAR_TABLE_P (vector
))
3373 val
= char_table_ref_and_range (vector
, i
, &range_beg
, &i
);
3375 val
= AREF (vector
, i
);
3376 definition
= get_keyelt (val
, 0);
3378 if (NILP (definition
)) continue;
3380 /* Don't mention suppressed commands. */
3381 if (SYMBOLP (definition
) && partial
)
3385 tem
= Fget (definition
, suppress
);
3387 if (!NILP (tem
)) continue;
3390 character
= make_number (starting_i
);
3391 ASET (kludge
, 0, character
);
3393 /* If this binding is shadowed by some other map, ignore it. */
3398 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3400 if (!NILP (tem
)) continue;
3403 /* Ignore this definition if it is shadowed by an earlier
3404 one in the same keymap. */
3405 if (!NILP (entire_map
))
3409 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3411 if (!EQ (tem
, definition
))
3421 /* Output the prefix that applies to every entry in this map. */
3422 if (!NILP (elt_prefix
))
3423 insert1 (elt_prefix
);
3425 insert1 (Fkey_description (kludge
, prefix
));
3427 /* Find all consecutive characters or rows that have the same
3428 definition. But, for elements of a top level char table, if
3429 they are for charsets, we had better describe one by one even
3430 if they have the same definition. */
3431 if (CHAR_TABLE_P (vector
))
3433 && (val
= char_table_ref_and_range (vector
, i
+ 1,
3434 &range_beg
, &range_end
),
3435 tem2
= get_keyelt (val
, 0),
3437 && !NILP (Fequal (tem2
, definition
)))
3441 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3443 && !NILP (Fequal (tem2
, definition
)))
3446 /* If we have a range of more than one character,
3447 print where the range reaches to. */
3449 if (i
!= starting_i
)
3453 ASET (kludge
, 0, make_number (i
));
3455 if (!NILP (elt_prefix
))
3456 insert1 (elt_prefix
);
3458 insert1 (Fkey_description (kludge
, prefix
));
3461 /* Print a description of the definition of this character.
3462 elt_describer will take care of spacing out far enough
3463 for alignment purposes. */
3464 (*elt_describer
) (definition
, args
);
3467 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3469 if (!NILP (elt_prefix
))
3470 insert1 (elt_prefix
);
3471 insert ("default", 7);
3472 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3478 /* Apropos - finding all symbols whose names match a regexp. */
3479 static Lisp_Object apropos_predicate
;
3480 static Lisp_Object apropos_accumulate
;
3483 apropos_accum (symbol
, string
)
3484 Lisp_Object symbol
, string
;
3486 register Lisp_Object tem
;
3488 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3489 if (!NILP (tem
) && !NILP (apropos_predicate
))
3490 tem
= call1 (apropos_predicate
, symbol
);
3492 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3495 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3496 doc
: /* Show all symbols whose names contain match for REGEXP.
3497 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3498 for each symbol and a symbol is mentioned only if that returns non-nil.
3499 Return list of symbols found. */)
3501 Lisp_Object regexp
, predicate
;
3504 CHECK_STRING (regexp
);
3505 apropos_predicate
= predicate
;
3506 apropos_accumulate
= Qnil
;
3507 map_obarray (Vobarray
, apropos_accum
, regexp
);
3508 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3509 apropos_accumulate
= Qnil
;
3510 apropos_predicate
= Qnil
;
3517 Qkeymap
= intern ("keymap");
3518 staticpro (&Qkeymap
);
3519 staticpro (&apropos_predicate
);
3520 staticpro (&apropos_accumulate
);
3521 apropos_predicate
= Qnil
;
3522 apropos_accumulate
= Qnil
;
3524 /* Now we are ready to set up this property, so we can
3525 create char tables. */
3526 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3528 /* Initialize the keymaps standardly used.
3529 Each one is the value of a Lisp variable, and is also
3530 pointed to by a C variable */
3532 global_map
= Fmake_keymap (Qnil
);
3533 Fset (intern ("global-map"), global_map
);
3535 current_global_map
= global_map
;
3536 staticpro (&global_map
);
3537 staticpro (¤t_global_map
);
3539 meta_map
= Fmake_keymap (Qnil
);
3540 Fset (intern ("esc-map"), meta_map
);
3541 Ffset (intern ("ESC-prefix"), meta_map
);
3543 control_x_map
= Fmake_keymap (Qnil
);
3544 Fset (intern ("ctl-x-map"), control_x_map
);
3545 Ffset (intern ("Control-X-prefix"), control_x_map
);
3548 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3549 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3550 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3551 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3552 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3554 staticpro (&exclude_keys
);
3556 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3557 doc
: /* List of commands given new key bindings recently.
3558 This is used for internal purposes during Emacs startup;
3559 don't alter it yourself. */);
3560 Vdefine_key_rebound_commands
= Qt
;
3562 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3563 doc
: /* Default keymap to use when reading from the minibuffer. */);
3564 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3566 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3567 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3568 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3569 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3571 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3572 doc
: /* Local keymap for minibuffer input with completion. */);
3573 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3574 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3576 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3577 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3578 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3579 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3580 Vminibuffer_local_completion_map
);
3582 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3583 doc
: /* Alist of keymaps to use for minor modes.
3584 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3585 key sequences and look up bindings iff VARIABLE's value is non-nil.
3586 If two active keymaps bind the same key, the keymap appearing earlier
3587 in the list takes precedence. */);
3588 Vminor_mode_map_alist
= Qnil
;
3590 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3591 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3592 This variable is an alist just like `minor-mode-map-alist', and it is
3593 used the same way (and before `minor-mode-map-alist'); however,
3594 it is provided for major modes to bind locally. */);
3595 Vminor_mode_overriding_map_alist
= Qnil
;
3597 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3598 doc
: /* List of keymap alists to use for emulations modes.
3599 It is intended for modes or packages using multiple minor-mode keymaps.
3600 Each element is a keymap alist just like `minor-mode-map-alist', or a
3601 symbol with a variable binding which is a keymap alist, and it is used
3602 the same way. The "active" keymaps in each alist are used before
3603 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3604 Vemulation_mode_map_alists
= Qnil
;
3607 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3608 doc
: /* Keymap mapping ASCII function key sequences onto their preferred forms.
3609 This allows Emacs to recognize function keys sent from ASCII
3610 terminals at any point in a key sequence.
3612 The `read-key-sequence' function replaces any subsequence bound by
3613 `function-key-map' with its binding. More precisely, when the active
3614 keymaps have no binding for the current key sequence but
3615 `function-key-map' binds a suffix of the sequence to a vector or string,
3616 `read-key-sequence' replaces the matching suffix with its binding, and
3617 continues with the new sequence.
3619 The events that come from bindings in `function-key-map' are not
3620 themselves looked up in `function-key-map'.
3622 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3623 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3624 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3625 key, typing `ESC O P x' would return [f1 x]. */);
3626 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3628 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3629 doc
: /* Keymap of key translations that can override keymaps.
3630 This keymap works like `function-key-map', but comes after that,
3631 and its non-prefix bindings override ordinary bindings. */);
3632 Vkey_translation_map
= Qnil
;
3634 staticpro (&Vmouse_events
);
3635 Vmouse_events
= Fcons (intern ("menu-bar"),
3636 Fcons (intern ("tool-bar"),
3637 Fcons (intern ("header-line"),
3638 Fcons (intern ("mode-line"),
3639 Fcons (intern ("mouse-1"),
3640 Fcons (intern ("mouse-2"),
3641 Fcons (intern ("mouse-3"),
3642 Fcons (intern ("mouse-4"),
3643 Fcons (intern ("mouse-5"),
3647 Qsingle_key_description
= intern ("single-key-description");
3648 staticpro (&Qsingle_key_description
);
3650 Qkey_description
= intern ("key-description");
3651 staticpro (&Qkey_description
);
3653 Qkeymapp
= intern ("keymapp");
3654 staticpro (&Qkeymapp
);
3656 Qnon_ascii
= intern ("non-ascii");
3657 staticpro (&Qnon_ascii
);
3659 Qmenu_item
= intern ("menu-item");
3660 staticpro (&Qmenu_item
);
3662 Qremap
= intern ("remap");
3663 staticpro (&Qremap
);
3665 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3666 staticpro (&command_remapping_vector
);
3668 where_is_cache_keymaps
= Qt
;
3669 where_is_cache
= Qnil
;
3670 staticpro (&where_is_cache
);
3671 staticpro (&where_is_cache_keymaps
);
3673 defsubr (&Skeymapp
);
3674 defsubr (&Skeymap_parent
);
3675 defsubr (&Skeymap_prompt
);
3676 defsubr (&Sset_keymap_parent
);
3677 defsubr (&Smake_keymap
);
3678 defsubr (&Smake_sparse_keymap
);
3679 defsubr (&Smap_keymap
);
3680 defsubr (&Scopy_keymap
);
3681 defsubr (&Scommand_remapping
);
3682 defsubr (&Skey_binding
);
3683 defsubr (&Slocal_key_binding
);
3684 defsubr (&Sglobal_key_binding
);
3685 defsubr (&Sminor_mode_key_binding
);
3686 defsubr (&Sdefine_key
);
3687 defsubr (&Slookup_key
);
3688 defsubr (&Sdefine_prefix_command
);
3689 defsubr (&Suse_global_map
);
3690 defsubr (&Suse_local_map
);
3691 defsubr (&Scurrent_local_map
);
3692 defsubr (&Scurrent_global_map
);
3693 defsubr (&Scurrent_minor_mode_maps
);
3694 defsubr (&Scurrent_active_maps
);
3695 defsubr (&Saccessible_keymaps
);
3696 defsubr (&Skey_description
);
3697 defsubr (&Sdescribe_vector
);
3698 defsubr (&Ssingle_key_description
);
3699 defsubr (&Stext_char_description
);
3700 defsubr (&Swhere_is_internal
);
3701 defsubr (&Sdescribe_buffer_bindings
);
3702 defsubr (&Sapropos_internal
);
3708 initial_define_key (global_map
, 033, "ESC-prefix");
3709 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
3712 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
3713 (do not change this comment) */