1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "character.h"
32 #include "termhooks.h"
33 #include "blockinput.h"
35 #include "intervals.h"
39 /* The number of elements in keymap vectors. */
40 #define DENSE_TABLE_SIZE (0200)
42 /* Actually allocate storage for these variables */
44 Lisp_Object current_global_map
; /* Current global keymap */
46 Lisp_Object global_map
; /* default global key bindings */
48 Lisp_Object meta_map
; /* The keymap used for globally bound
49 ESC-prefixed default commands */
51 Lisp_Object control_x_map
; /* The keymap used for globally bound
52 C-x-prefixed default commands */
54 /* The keymap used by the minibuf for local
55 bindings when spaces are allowed in the
58 /* The keymap used by the minibuf for local
59 bindings when spaces are not encouraged
62 /* keymap used for minibuffers when doing completion */
63 /* keymap used for minibuffers when doing completion and require a match */
64 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
65 Lisp_Object QCadvertised_binding
;
67 /* Alist of elements like (DEL . "\d"). */
68 static Lisp_Object exclude_keys
;
70 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
71 static Lisp_Object command_remapping_vector
;
73 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
74 static Lisp_Object where_is_cache
;
75 /* Which keymaps are reverse-stored in the cache. */
76 static Lisp_Object where_is_cache_keymaps
;
78 static Lisp_Object
store_in_keymap (Lisp_Object
, Lisp_Object
, Lisp_Object
);
79 static void fix_submap_inheritance (Lisp_Object
, Lisp_Object
, Lisp_Object
);
81 static Lisp_Object
define_as_prefix (Lisp_Object
, Lisp_Object
);
82 static void describe_command (Lisp_Object
, Lisp_Object
);
83 static void describe_translation (Lisp_Object
, Lisp_Object
);
84 static void describe_map (Lisp_Object
, Lisp_Object
,
85 void (*) (Lisp_Object
, Lisp_Object
),
86 int, Lisp_Object
, Lisp_Object
*, int, int);
87 static void describe_vector (Lisp_Object
, Lisp_Object
, Lisp_Object
,
88 void (*) (Lisp_Object
, Lisp_Object
), int,
89 Lisp_Object
, Lisp_Object
, int *,
91 static void silly_event_symbol_error (Lisp_Object
);
92 static Lisp_Object
get_keyelt (Lisp_Object
, int);
94 /* Keymap object support - constructors and predicates. */
96 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
97 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
98 CHARTABLE is a char-table that holds the bindings for all characters
99 without modifiers. All entries in it are initially nil, meaning
100 "command undefined". ALIST is an assoc-list which holds bindings for
101 function keys, mouse events, and any other things that appear in the
102 input stream. Initially, ALIST is nil.
104 The optional arg STRING supplies a menu name for the keymap
105 in case you use it as a menu with `x-popup-menu'. */)
110 tail
= Fcons (string
, Qnil
);
113 return Fcons (Qkeymap
,
114 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
117 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
118 doc
: /* Construct and return a new sparse keymap.
119 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
120 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
121 which binds the function key or mouse event SYMBOL to DEFINITION.
122 Initially the alist is nil.
124 The optional arg STRING supplies a menu name for the keymap
125 in case you use it as a menu with `x-popup-menu'. */)
130 if (!NILP (Vpurify_flag
))
131 string
= Fpurecopy (string
);
132 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
134 return Fcons (Qkeymap
, Qnil
);
137 /* This function is used for installing the standard key bindings
138 at initialization time.
142 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
145 initial_define_key (Lisp_Object keymap
, int key
, const char *defname
)
147 store_in_keymap (keymap
, make_number (key
), intern_c_string (defname
));
151 initial_define_lispy_key (Lisp_Object keymap
, const char *keyname
, const char *defname
)
153 store_in_keymap (keymap
, intern_c_string (keyname
), intern_c_string (defname
));
156 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
157 doc
: /* Return t if OBJECT is a keymap.
159 A keymap is a list (keymap . ALIST),
160 or a symbol whose function definition is itself a keymap.
161 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
162 a vector of densely packed bindings for small character codes
163 is also allowed as an element. */)
166 return (KEYMAPP (object
) ? Qt
: Qnil
);
169 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
170 doc
: /* Return the prompt-string of a keymap MAP.
171 If non-nil, the prompt is shown in the echo-area
172 when reading a key-sequence to be looked-up in this keymap. */)
175 map
= get_keymap (map
, 0, 0);
178 Lisp_Object tem
= XCAR (map
);
186 /* Check that OBJECT is a keymap (after dereferencing through any
187 symbols). If it is, return it.
189 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
190 is an autoload form, do the autoload and try again.
191 If AUTOLOAD is nonzero, callers must assume GC is possible.
193 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
194 is zero as well), return Qt.
196 ERROR controls how we respond if OBJECT isn't a keymap.
197 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
199 Note that most of the time, we don't want to pursue autoloads.
200 Functions like Faccessible_keymaps which scan entire keymap trees
201 shouldn't load every autoloaded keymap. I'm not sure about this,
202 but it seems to me that only read_key_sequence, Flookup_key, and
203 Fdefine_key should cause keymaps to be autoloaded.
205 This function can GC when AUTOLOAD is non-zero, because it calls
206 do_autoload which can GC. */
209 get_keymap (Lisp_Object object
, int error
, int autoload
)
216 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
219 tem
= indirect_function (object
);
222 if (EQ (XCAR (tem
), Qkeymap
))
225 /* Should we do an autoload? Autoload forms for keymaps have
226 Qkeymap as their fifth element. */
227 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
232 tail
= Fnth (make_number (4), tem
);
233 if (EQ (tail
, Qkeymap
))
237 struct gcpro gcpro1
, gcpro2
;
239 GCPRO2 (tem
, object
);
240 do_autoload (tem
, object
);
253 wrong_type_argument (Qkeymapp
, object
);
257 /* Return the parent map of KEYMAP, or nil if it has none.
258 We assume that KEYMAP is a valid keymap. */
261 keymap_parent (Lisp_Object keymap
, int autoload
)
265 keymap
= get_keymap (keymap
, 1, autoload
);
267 /* Skip past the initial element `keymap'. */
268 list
= XCDR (keymap
);
269 for (; CONSP (list
); list
= XCDR (list
))
271 /* See if there is another `keymap'. */
276 return get_keymap (list
, 0, autoload
);
279 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
280 doc
: /* Return the parent keymap of KEYMAP.
281 If KEYMAP has no parent, return nil. */)
284 return keymap_parent (keymap
, 1);
287 /* Check whether MAP is one of MAPS parents. */
289 keymap_memberp (Lisp_Object map
, Lisp_Object maps
)
291 if (NILP (map
)) return 0;
292 while (KEYMAPP (maps
) && !EQ (map
, maps
))
293 maps
= keymap_parent (maps
, 0);
294 return (EQ (map
, maps
));
297 /* Set the parent keymap of MAP to PARENT. */
299 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
300 doc
: /* Modify KEYMAP to set its parent map to PARENT.
301 Return PARENT. PARENT should be nil or another keymap. */)
302 (Lisp_Object keymap
, Lisp_Object parent
)
304 Lisp_Object list
, prev
;
305 struct gcpro gcpro1
, gcpro2
;
308 /* Force a keymap flush for the next call to where-is.
309 Since this can be called from within where-is, we don't set where_is_cache
310 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
311 be changed during where-is, while where_is_cache_keymaps is only used at
312 the very beginning of where-is and can thus be changed here without any
314 This is a very minor correctness (rather than safety) issue. */
315 where_is_cache_keymaps
= Qt
;
317 GCPRO2 (keymap
, parent
);
318 keymap
= get_keymap (keymap
, 1, 1);
322 parent
= get_keymap (parent
, 1, 1);
324 /* Check for cycles. */
325 if (keymap_memberp (keymap
, parent
))
326 error ("Cyclic keymap inheritance");
329 /* Skip past the initial element `keymap'. */
334 /* If there is a parent keymap here, replace it.
335 If we came to the end, add the parent in PREV. */
336 if (!CONSP (list
) || KEYMAPP (list
))
338 /* If we already have the right parent, return now
339 so that we avoid the loops below. */
340 if (EQ (XCDR (prev
), parent
))
341 RETURN_UNGCPRO (parent
);
344 XSETCDR (prev
, parent
);
350 /* Scan through for submaps, and set their parents too. */
352 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
354 /* Stop the scan when we come to the parent. */
355 if (EQ (XCAR (list
), Qkeymap
))
358 /* If this element holds a prefix map, deal with it. */
359 if (CONSP (XCAR (list
))
360 && CONSP (XCDR (XCAR (list
))))
361 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
364 if (VECTORP (XCAR (list
)))
365 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
366 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
367 fix_submap_inheritance (keymap
, make_number (i
),
368 XVECTOR (XCAR (list
))->contents
[i
]);
370 if (CHAR_TABLE_P (XCAR (list
)))
372 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
376 RETURN_UNGCPRO (parent
);
379 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
380 if EVENT is also a prefix in MAP's parent,
381 make sure that SUBMAP inherits that definition as its own parent. */
384 fix_submap_inheritance (Lisp_Object map
, Lisp_Object event
, Lisp_Object submap
)
386 Lisp_Object map_parent
, parent_entry
;
388 /* SUBMAP is a cons that we found as a key binding.
389 Discard the other things found in a menu key binding. */
391 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
393 /* If it isn't a keymap now, there's no work to do. */
397 map_parent
= keymap_parent (map
, 0);
398 if (!NILP (map_parent
))
400 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
404 /* If MAP's parent has something other than a keymap,
405 our own submap shadows it completely. */
406 if (!CONSP (parent_entry
))
409 if (! EQ (parent_entry
, submap
))
411 Lisp_Object submap_parent
;
412 submap_parent
= submap
;
417 tem
= keymap_parent (submap_parent
, 0);
421 if (keymap_memberp (tem
, parent_entry
))
422 /* Fset_keymap_parent could create a cycle. */
429 Fset_keymap_parent (submap_parent
, parent_entry
);
433 /* Look up IDX in MAP. IDX may be any sort of event.
434 Note that this does only one level of lookup; IDX must be a single
435 event, not a sequence.
437 If T_OK is non-zero, bindings for Qt are treated as default
438 bindings; any key left unmentioned by other tables and bindings is
439 given the binding of Qt.
441 If T_OK is zero, bindings for Qt are not treated specially.
443 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
446 access_keymap (Lisp_Object map
, Lisp_Object idx
, int t_ok
, int noinherit
, int autoload
)
450 /* Qunbound in VAL means we have found no binding yet. */
453 /* If idx is a list (some sort of mouse click, perhaps?),
454 the index we want to use is the car of the list, which
455 ought to be a symbol. */
456 idx
= EVENT_HEAD (idx
);
458 /* If idx is a symbol, it might have modifiers, which need to
459 be put in the canonical order. */
461 idx
= reorder_modifiers (idx
);
462 else if (INTEGERP (idx
))
463 /* Clobber the high bits that can be present on a machine
464 with more than 24 bits of integer. */
465 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
467 /* Handle the special meta -> esc mapping. */
468 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
470 /* See if there is a meta-map. If there's none, there is
471 no binding for IDX, unless a default binding exists in MAP. */
473 Lisp_Object meta_map
;
475 /* A strange value in which Meta is set would cause
476 infinite recursion. Protect against that. */
477 if (XINT (meta_prefix_char
) & CHAR_META
)
478 meta_prefix_char
= make_number (27);
479 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
480 t_ok
, noinherit
, autoload
),
483 if (CONSP (meta_map
))
486 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
489 /* Set IDX to t, so that we only find a default binding. */
492 /* We know there is no binding. */
496 /* t_binding is where we put a default binding that applies,
497 to use in case we do not find a binding specifically
498 for this key sequence. */
501 Lisp_Object t_binding
= Qnil
;
502 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
504 GCPRO4 (map
, tail
, idx
, t_binding
);
506 for (tail
= XCDR (map
);
508 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
513 binding
= XCAR (tail
);
514 if (SYMBOLP (binding
))
516 /* If NOINHERIT, stop finding prefix definitions
517 after we pass a second occurrence of the `keymap' symbol. */
518 if (noinherit
&& EQ (binding
, Qkeymap
))
519 RETURN_UNGCPRO (Qnil
);
521 else if (CONSP (binding
))
523 Lisp_Object key
= XCAR (binding
);
526 val
= XCDR (binding
);
527 else if (t_ok
&& EQ (key
, Qt
))
529 t_binding
= XCDR (binding
);
533 else if (VECTORP (binding
))
535 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
536 val
= AREF (binding
, XFASTINT (idx
));
538 else if (CHAR_TABLE_P (binding
))
540 /* Character codes with modifiers
541 are not included in a char-table.
542 All character codes without modifiers are included. */
543 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
545 val
= Faref (binding
, idx
);
546 /* `nil' has a special meaning for char-tables, so
547 we use something else to record an explicitly
554 /* If we found a binding, clean it up and return it. */
555 if (!EQ (val
, Qunbound
))
558 /* A Qt binding is just like an explicit nil binding
559 (i.e. it shadows any parent binding but not bindings in
560 keymaps of lower precedence). */
562 val
= get_keyelt (val
, autoload
);
564 fix_submap_inheritance (map
, idx
, val
);
565 RETURN_UNGCPRO (val
);
570 return get_keyelt (t_binding
, autoload
);
575 map_keymap_item (map_keymap_function_t fun
, Lisp_Object args
, Lisp_Object key
, Lisp_Object val
, void *data
)
577 /* We should maybe try to detect bindings shadowed by previous
578 ones and things like that. */
581 (*fun
) (key
, val
, args
, data
);
585 map_keymap_char_table_item (Lisp_Object args
, Lisp_Object key
, Lisp_Object val
)
589 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
591 /* If the key is a range, make a copy since map_char_table modifies
594 key
= Fcons (XCAR (key
), XCDR (key
));
595 map_keymap_item (fun
, XCDR (args
), key
, val
,
596 XSAVE_VALUE (XCAR (args
))->pointer
);
600 /* Call FUN for every binding in MAP and stop at (and return) the parent.
601 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA). */
603 map_keymap_internal (Lisp_Object map
,
604 map_keymap_function_t fun
,
608 struct gcpro gcpro1
, gcpro2
, gcpro3
;
610 = (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
612 GCPRO3 (map
, args
, tail
);
613 for (; CONSP (tail
) && !EQ (Qkeymap
, XCAR (tail
)); tail
= XCDR (tail
))
615 Lisp_Object binding
= XCAR (tail
);
618 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
619 else if (VECTORP (binding
))
621 /* Loop over the char values represented in the vector. */
622 int len
= ASIZE (binding
);
624 for (c
= 0; c
< len
; c
++)
626 Lisp_Object character
;
627 XSETFASTINT (character
, c
);
628 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
631 else if (CHAR_TABLE_P (binding
))
633 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
634 Fcons (make_save_value (fun
, 0),
635 Fcons (make_save_value (data
, 0),
644 map_keymap_call (Lisp_Object key
, Lisp_Object val
, Lisp_Object fun
, void *dummy
)
646 call2 (fun
, key
, val
);
649 /* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
650 A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
652 map_keymap (Lisp_Object map
, map_keymap_function_t fun
, Lisp_Object args
, void *data
, int autoload
)
656 map
= get_keymap (map
, 1, autoload
);
659 map
= map_keymap_internal (map
, fun
, args
, data
);
660 map
= get_keymap (map
, 0, autoload
);
665 Lisp_Object Qkeymap_canonicalize
;
667 /* Same as map_keymap, but does it right, properly eliminating duplicate
668 bindings due to inheritance. */
670 map_keymap_canonical (Lisp_Object map
, map_keymap_function_t fun
, Lisp_Object args
, void *data
)
674 /* map_keymap_canonical may be used from redisplay (e.g. when building menus)
675 so be careful to ignore errors and to inhibit redisplay. */
676 map
= safe_call1 (Qkeymap_canonicalize
, map
);
677 /* No need to use `map_keymap' here because canonical map has no parent. */
678 map_keymap_internal (map
, fun
, args
, data
);
682 DEFUN ("map-keymap-internal", Fmap_keymap_internal
, Smap_keymap_internal
, 2, 2, 0,
683 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
684 FUNCTION is called with two arguments: the event that is bound, and
685 the definition it is bound to. The event may be a character range.
686 If KEYMAP has a parent, this function returns it without processing it. */)
687 (Lisp_Object function
, Lisp_Object keymap
)
691 keymap
= get_keymap (keymap
, 1, 1);
692 keymap
= map_keymap_internal (keymap
, map_keymap_call
, function
, NULL
);
697 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
698 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
699 FUNCTION is called with two arguments: the event that is bound, and
700 the definition it is bound to. The event may be a character range.
702 If KEYMAP has a parent, the parent's bindings are included as well.
703 This works recursively: if the parent has itself a parent, then the
704 grandparent's bindings are also included and so on.
705 usage: (map-keymap FUNCTION KEYMAP) */)
706 (Lisp_Object function
, Lisp_Object keymap
, Lisp_Object sort_first
)
708 if (! NILP (sort_first
))
709 return call2 (intern ("map-keymap-sorted"), function
, keymap
);
711 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
715 /* Given OBJECT which was found in a slot in a keymap,
716 trace indirect definitions to get the actual definition of that slot.
717 An indirect definition is a list of the form
718 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
719 and INDEX is the object to look up in KEYMAP to yield the definition.
721 Also if OBJECT has a menu string as the first element,
722 remove that. Also remove a menu help string as second element.
724 If AUTOLOAD is nonzero, load autoloadable keymaps
725 that are referred to with indirection.
727 This can GC because menu_item_eval_property calls Feval. */
730 get_keyelt (Lisp_Object object
, int autoload
)
734 if (!(CONSP (object
)))
735 /* This is really the value. */
738 /* If the keymap contents looks like (keymap ...) or (lambda ...)
740 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
743 /* If the keymap contents looks like (menu-item name . DEFN)
744 or (menu-item name DEFN ...) then use DEFN.
745 This is a new format menu item. */
746 else if (EQ (XCAR (object
), Qmenu_item
))
748 if (CONSP (XCDR (object
)))
752 object
= XCDR (XCDR (object
));
755 object
= XCAR (object
);
757 /* If there's a `:filter FILTER', apply FILTER to the
758 menu-item's definition to get the real definition to
760 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
761 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
764 filter
= XCAR (XCDR (tem
));
765 filter
= list2 (filter
, list2 (Qquote
, object
));
766 object
= menu_item_eval_property (filter
);
771 /* Invalid keymap. */
775 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
776 Keymap alist elements like (CHAR MENUSTRING . DEFN)
777 will be used by HierarKey menus. */
778 else if (STRINGP (XCAR (object
)))
780 object
= XCDR (object
);
781 /* Also remove a menu help string, if any,
782 following the menu item name. */
783 if (CONSP (object
) && STRINGP (XCAR (object
)))
784 object
= XCDR (object
);
785 /* Also remove the sublist that caches key equivalences, if any. */
786 if (CONSP (object
) && CONSP (XCAR (object
)))
789 carcar
= XCAR (XCAR (object
));
790 if (NILP (carcar
) || VECTORP (carcar
))
791 object
= XCDR (object
);
795 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
801 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
803 return (!CONSP (map
) ? object
/* Invalid keymap */
804 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
810 store_in_keymap (Lisp_Object keymap
, register Lisp_Object idx
, Lisp_Object def
)
812 /* Flush any reverse-map cache. */
813 where_is_cache
= Qnil
;
814 where_is_cache_keymaps
= Qt
;
816 /* If we are preparing to dump, and DEF is a menu element
817 with a menu item indicator, copy it to ensure it is not pure. */
818 if (CONSP (def
) && PURE_P (def
)
819 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
820 def
= Fcons (XCAR (def
), XCDR (def
));
822 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
823 error ("attempt to define a key in a non-keymap");
825 /* If idx is a cons, and the car part is a character, idx must be of
826 the form (FROM-CHAR . TO-CHAR). */
827 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
828 CHECK_CHARACTER_CDR (idx
);
830 /* If idx is a list (some sort of mouse click, perhaps?),
831 the index we want to use is the car of the list, which
832 ought to be a symbol. */
833 idx
= EVENT_HEAD (idx
);
835 /* If idx is a symbol, it might have modifiers, which need to
836 be put in the canonical order. */
838 idx
= reorder_modifiers (idx
);
839 else if (INTEGERP (idx
))
840 /* Clobber the high bits that can be present on a machine
841 with more than 24 bits of integer. */
842 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
844 /* Scan the keymap for a binding of idx. */
848 /* The cons after which we should insert new bindings. If the
849 keymap has a table element, we record its position here, so new
850 bindings will go after it; this way, the table will stay
851 towards the front of the alist and character lookups in dense
852 keymaps will remain fast. Otherwise, this just points at the
853 front of the keymap. */
854 Lisp_Object insertion_point
;
856 insertion_point
= keymap
;
857 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
864 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
867 ASET (elt
, XFASTINT (idx
), def
);
870 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
872 int from
= XFASTINT (XCAR (idx
));
873 int to
= XFASTINT (XCDR (idx
));
875 if (to
>= ASIZE (elt
))
876 to
= ASIZE (elt
) - 1;
877 for (; from
<= to
; from
++)
878 ASET (elt
, from
, def
);
879 if (to
== XFASTINT (XCDR (idx
)))
880 /* We have defined all keys in IDX. */
883 insertion_point
= tail
;
885 else if (CHAR_TABLE_P (elt
))
887 /* Character codes with modifiers
888 are not included in a char-table.
889 All character codes without modifiers are included. */
890 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
893 /* `nil' has a special meaning for char-tables, so
894 we use something else to record an explicitly
896 NILP (def
) ? Qt
: def
);
899 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
901 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
904 insertion_point
= tail
;
906 else if (CONSP (elt
))
908 if (EQ (idx
, XCAR (elt
)))
914 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
916 int from
= XFASTINT (XCAR (idx
));
917 int to
= XFASTINT (XCDR (idx
));
919 if (from
<= XFASTINT (XCAR (elt
))
920 && to
>= XFASTINT (XCAR (elt
)))
928 else if (EQ (elt
, Qkeymap
))
929 /* If we find a 'keymap' symbol in the spine of KEYMAP,
930 then we must have found the start of a second keymap
931 being used as the tail of KEYMAP, and a binding for IDX
932 should be inserted before it. */
939 /* We have scanned the entire keymap, and not found a binding for
940 IDX. Let's add one. */
944 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
946 /* IDX specifies a range of characters, and not all of them
947 were handled yet, which means this keymap doesn't have a
948 char-table. So, we insert a char-table now. */
949 elt
= Fmake_char_table (Qkeymap
, Qnil
);
950 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
953 elt
= Fcons (idx
, def
);
954 CHECK_IMPURE (insertion_point
);
955 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
962 EXFUN (Fcopy_keymap
, 1);
965 copy_keymap_item (Lisp_Object elt
)
967 Lisp_Object res
, tem
;
974 /* Is this a new format menu item. */
975 if (EQ (XCAR (tem
), Qmenu_item
))
977 /* Copy cell with menu-item marker. */
978 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
982 /* Copy cell with menu-item name. */
983 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
989 /* Copy cell with binding and if the binding is a keymap,
991 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
994 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
995 XSETCAR (elt
, Fcopy_keymap (tem
));
997 if (CONSP (tem
) && CONSP (XCAR (tem
)))
998 /* Delete cache for key equivalences. */
999 XSETCDR (elt
, XCDR (tem
));
1004 /* It may be an old fomat menu item.
1005 Skip the optional menu string. */
1006 if (STRINGP (XCAR (tem
)))
1008 /* Copy the cell, since copy-alist didn't go this deep. */
1009 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1011 /* Also skip the optional menu help string. */
1012 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1014 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1018 /* There may also be a list that caches key equivalences.
1019 Just delete it for the new keymap. */
1021 && CONSP (XCAR (tem
))
1022 && (NILP (XCAR (XCAR (tem
)))
1023 || VECTORP (XCAR (XCAR (tem
)))))
1025 XSETCDR (elt
, XCDR (tem
));
1028 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1029 XSETCDR (elt
, Fcopy_keymap (tem
));
1031 else if (EQ (XCAR (tem
), Qkeymap
))
1032 res
= Fcopy_keymap (elt
);
1038 copy_keymap_1 (Lisp_Object chartable
, Lisp_Object idx
, Lisp_Object elt
)
1040 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1043 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1044 doc
: /* Return a copy of the keymap KEYMAP.
1045 The copy starts out with the same definitions of KEYMAP,
1046 but changing either the copy or KEYMAP does not affect the other.
1047 Any key definitions that are subkeymaps are recursively copied.
1048 However, a key definition which is a symbol whose definition is a keymap
1050 (Lisp_Object keymap
)
1052 register Lisp_Object copy
, tail
;
1053 keymap
= get_keymap (keymap
, 1, 0);
1054 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1055 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1057 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1059 Lisp_Object elt
= XCAR (keymap
);
1060 if (CHAR_TABLE_P (elt
))
1062 elt
= Fcopy_sequence (elt
);
1063 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1065 else if (VECTORP (elt
))
1068 elt
= Fcopy_sequence (elt
);
1069 for (i
= 0; i
< ASIZE (elt
); i
++)
1070 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1072 else if (CONSP (elt
))
1073 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1074 XSETCDR (tail
, Fcons (elt
, Qnil
));
1076 keymap
= XCDR (keymap
);
1078 XSETCDR (tail
, keymap
);
1082 /* Simple Keymap mutators and accessors. */
1084 /* GC is possible in this function if it autoloads a keymap. */
1086 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1087 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1090 KEY is a string or a vector of symbols and characters, representing a
1091 sequence of keystrokes and events. Non-ASCII characters with codes
1092 above 127 (such as ISO Latin-1) can be represented by vectors.
1093 Two types of vector have special meanings:
1094 [remap COMMAND] remaps any key binding for COMMAND.
1095 [t] creates a default definition, which applies to any event with no
1096 other definition in KEYMAP.
1098 DEF is anything that can be a key's definition:
1099 nil (means key is undefined in this keymap),
1100 a command (a Lisp function suitable for interactive calling),
1101 a string (treated as a keyboard macro),
1102 a keymap (to define a prefix key),
1103 a symbol (when the key is looked up, the symbol will stand for its
1104 function definition, which should at that time be one of the above,
1105 or another symbol whose function definition is used, etc.),
1106 a cons (STRING . DEFN), meaning that DEFN is the definition
1107 (DEFN should be a valid definition in its own right),
1108 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
1109 or an extended menu item definition.
1110 (See info node `(elisp)Extended Menu Items'.)
1112 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1113 binding is altered. If there is no binding for KEY, the new pair
1114 binding KEY to DEF is added at the front of KEYMAP. */)
1115 (Lisp_Object keymap
, Lisp_Object key
, Lisp_Object def
)
1118 register Lisp_Object c
;
1119 register Lisp_Object cmd
;
1123 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1125 GCPRO3 (keymap
, key
, def
);
1126 keymap
= get_keymap (keymap
, 1, 1);
1128 CHECK_VECTOR_OR_STRING (key
);
1130 length
= XFASTINT (Flength (key
));
1132 RETURN_UNGCPRO (Qnil
);
1134 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1135 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1137 meta_bit
= (VECTORP (key
) || (STRINGP (key
) && STRING_MULTIBYTE (key
))
1138 ? meta_modifier
: 0x80);
1140 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, 0)))
1141 { /* DEF is apparently an XEmacs-style keyboard macro. */
1142 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1143 int i
= ASIZE (def
);
1146 Lisp_Object c
= AREF (def
, i
);
1147 if (CONSP (c
) && lucid_event_type_list_p (c
))
1148 c
= Fevent_convert_list (c
);
1157 c
= Faref (key
, make_number (idx
));
1161 /* C may be a Lucid style event type list or a cons (FROM .
1162 TO) specifying a range of characters. */
1163 if (lucid_event_type_list_p (c
))
1164 c
= Fevent_convert_list (c
);
1165 else if (CHARACTERP (XCAR (c
)))
1166 CHECK_CHARACTER_CDR (c
);
1170 silly_event_symbol_error (c
);
1173 && (XINT (c
) & meta_bit
)
1176 c
= meta_prefix_char
;
1182 XSETINT (c
, XINT (c
) & ~meta_bit
);
1188 if (!INTEGERP (c
) && !SYMBOLP (c
)
1190 /* If C is a range, it must be a leaf. */
1191 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1192 message_with_string ("Key sequence contains invalid event %s", c
, 1);
1195 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1197 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1199 /* If this key is undefined, make it a prefix. */
1201 cmd
= define_as_prefix (keymap
, c
);
1203 keymap
= get_keymap (cmd
, 0, 1);
1204 if (!CONSP (keymap
))
1205 /* We must use Fkey_description rather than just passing key to
1206 error; key might be a vector, not a string. */
1207 error ("Key sequence %s starts with non-prefix key %s",
1208 SDATA (Fkey_description (key
, Qnil
)),
1209 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1215 /* This function may GC (it calls Fkey_binding). */
1217 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 3, 0,
1218 doc
: /* Return the remapping for command COMMAND.
1219 Returns nil if COMMAND is not remapped (or not a symbol).
1221 If the optional argument POSITION is non-nil, it specifies a mouse
1222 position as returned by `event-start' and `event-end', and the
1223 remapping occurs in the keymaps associated with it. It can also be a
1224 number or marker, in which case the keymap properties at the specified
1225 buffer position instead of point are used. The KEYMAPS argument is
1226 ignored if POSITION is non-nil.
1228 If the optional argument KEYMAPS is non-nil, it should be a list of
1229 keymaps to search for command remapping. Otherwise, search for the
1230 remapping in all currently active keymaps. */)
1231 (Lisp_Object command
, Lisp_Object position
, Lisp_Object keymaps
)
1233 if (!SYMBOLP (command
))
1236 ASET (command_remapping_vector
, 1, command
);
1239 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
, position
);
1242 Lisp_Object maps
, binding
;
1244 for (maps
= keymaps
; CONSP (maps
); maps
= XCDR (maps
))
1246 binding
= Flookup_key (XCAR (maps
), command_remapping_vector
, Qnil
);
1247 if (!NILP (binding
) && !INTEGERP (binding
))
1254 /* Value is number if KEY is too long; nil if valid but has no definition. */
1255 /* GC is possible in this function if it autoloads a keymap. */
1257 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1258 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1259 A value of nil means undefined. See doc of `define-key'
1260 for kinds of definitions.
1262 A number as value means KEY is "too long";
1263 that is, characters or symbols in it except for the last one
1264 fail to be a valid sequence of prefix characters in KEYMAP.
1265 The number is how many characters at the front of KEY
1266 it takes to reach a non-prefix key.
1268 Normally, `lookup-key' ignores bindings for t, which act as default
1269 bindings, used when nothing else in the keymap applies; this makes it
1270 usable as a general function for probing keymaps. However, if the
1271 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1272 recognize the default bindings, just as `read-key-sequence' does. */)
1273 (Lisp_Object keymap
, Lisp_Object key
, Lisp_Object accept_default
)
1276 register Lisp_Object cmd
;
1277 register Lisp_Object c
;
1279 int t_ok
= !NILP (accept_default
);
1280 struct gcpro gcpro1
, gcpro2
;
1282 GCPRO2 (keymap
, key
);
1283 keymap
= get_keymap (keymap
, 1, 1);
1285 CHECK_VECTOR_OR_STRING (key
);
1287 length
= XFASTINT (Flength (key
));
1289 RETURN_UNGCPRO (keymap
);
1294 c
= Faref (key
, make_number (idx
++));
1296 if (CONSP (c
) && lucid_event_type_list_p (c
))
1297 c
= Fevent_convert_list (c
);
1299 /* Turn the 8th bit of string chars into a meta modifier. */
1300 if (STRINGP (key
) && XINT (c
) & 0x80 && !STRING_MULTIBYTE (key
))
1301 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1303 /* Allow string since binding for `menu-bar-select-buffer'
1304 includes the buffer name in the key sequence. */
1305 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1306 message_with_string ("Key sequence contains invalid event %s", c
, 1);
1308 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1310 RETURN_UNGCPRO (cmd
);
1312 keymap
= get_keymap (cmd
, 0, 1);
1313 if (!CONSP (keymap
))
1314 RETURN_UNGCPRO (make_number (idx
));
1320 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1321 Assume that currently it does not define C at all.
1322 Return the keymap. */
1325 define_as_prefix (Lisp_Object keymap
, Lisp_Object c
)
1329 cmd
= Fmake_sparse_keymap (Qnil
);
1330 /* If this key is defined as a prefix in an inherited keymap,
1331 make it a prefix in this map, and make its definition
1332 inherit the other prefix definition. */
1333 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1334 store_in_keymap (keymap
, c
, cmd
);
1339 /* Append a key to the end of a key sequence. We always make a vector. */
1342 append_key (Lisp_Object key_sequence
, Lisp_Object key
)
1344 Lisp_Object args
[2];
1346 args
[0] = key_sequence
;
1348 args
[1] = Fcons (key
, Qnil
);
1349 return Fvconcat (2, args
);
1352 /* Given a event type C which is a symbol,
1353 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1356 silly_event_symbol_error (Lisp_Object c
)
1358 Lisp_Object parsed
, base
, name
, assoc
;
1361 parsed
= parse_modifiers (c
);
1362 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1363 base
= XCAR (parsed
);
1364 name
= Fsymbol_name (base
);
1365 /* This alist includes elements such as ("RET" . "\\r"). */
1366 assoc
= Fassoc (name
, exclude_keys
);
1370 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1372 Lisp_Object keystring
;
1373 if (modifiers
& alt_modifier
)
1374 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1375 if (modifiers
& ctrl_modifier
)
1376 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1377 if (modifiers
& hyper_modifier
)
1378 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1379 if (modifiers
& meta_modifier
)
1380 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1381 if (modifiers
& shift_modifier
)
1382 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1383 if (modifiers
& super_modifier
)
1384 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1387 c
= reorder_modifiers (c
);
1388 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1390 error ((modifiers
& ~meta_modifier
1391 ? "To bind the key %s, use [?%s], not [%s]"
1392 : "To bind the key %s, use \"%s\", not [%s]"),
1393 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1394 SDATA (SYMBOL_NAME (c
)));
1398 /* Global, local, and minor mode keymap stuff. */
1400 /* We can't put these variables inside current_minor_maps, since under
1401 some systems, static gets macro-defined to be the empty string.
1403 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1404 static int cmm_size
= 0;
1406 /* Store a pointer to an array of the currently active minor modes in
1407 *modeptr, a pointer to an array of the keymaps of the currently
1408 active minor modes in *mapptr, and return the number of maps
1411 This function always returns a pointer to the same buffer, and may
1412 free or reallocate it, so if you want to keep it for a long time or
1413 hand it out to lisp code, copy it. This procedure will be called
1414 for every key sequence read, so the nice lispy approach (return a
1415 new assoclist, list, what have you) for each invocation would
1416 result in a lot of consing over time.
1418 If we used xrealloc/xmalloc and ran out of memory, they would throw
1419 back to the command loop, which would try to read a key sequence,
1420 which would call this function again, resulting in an infinite
1421 loop. Instead, we'll use realloc/malloc and silently truncate the
1422 list, let the key sequence be read, and hope some other piece of
1423 code signals the error. */
1425 current_minor_maps (Lisp_Object
**modeptr
, Lisp_Object
**mapptr
)
1428 int list_number
= 0;
1429 Lisp_Object alist
, assoc
, var
, val
;
1430 Lisp_Object emulation_alists
;
1431 Lisp_Object lists
[2];
1433 emulation_alists
= Vemulation_mode_map_alists
;
1434 lists
[0] = Vminor_mode_overriding_map_alist
;
1435 lists
[1] = Vminor_mode_map_alist
;
1437 for (list_number
= 0; list_number
< 2; list_number
++)
1439 if (CONSP (emulation_alists
))
1441 alist
= XCAR (emulation_alists
);
1442 emulation_alists
= XCDR (emulation_alists
);
1443 if (SYMBOLP (alist
))
1444 alist
= find_symbol_value (alist
);
1448 alist
= lists
[list_number
];
1450 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1451 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1452 && (var
= XCAR (assoc
), SYMBOLP (var
))
1453 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1458 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1459 and also an entry in Vminor_mode_map_alist,
1460 ignore the latter. */
1461 if (list_number
== 1)
1463 val
= assq_no_quit (var
, lists
[0]);
1470 int newsize
, allocsize
;
1471 Lisp_Object
*newmodes
, *newmaps
;
1473 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1474 allocsize
= newsize
* sizeof *newmodes
;
1476 /* Use malloc here. See the comment above this function.
1477 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1479 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1484 memcpy (newmodes
, cmm_modes
,
1485 cmm_size
* sizeof cmm_modes
[0]);
1488 cmm_modes
= newmodes
;
1491 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1496 memcpy (newmaps
, cmm_maps
,
1497 cmm_size
* sizeof cmm_maps
[0]);
1504 if (newmodes
== NULL
|| newmaps
== NULL
)
1509 /* Get the keymap definition--or nil if it is not defined. */
1510 temp
= Findirect_function (XCDR (assoc
), Qt
);
1514 cmm_maps
[i
] = temp
;
1520 if (modeptr
) *modeptr
= cmm_modes
;
1521 if (mapptr
) *mapptr
= cmm_maps
;
1525 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1527 doc
: /* Return a list of the currently active keymaps.
1528 OLP if non-nil indicates that we should obey `overriding-local-map' and
1529 `overriding-terminal-local-map'. POSITION can specify a click position
1530 like in the respective argument of `key-binding'. */)
1531 (Lisp_Object olp
, Lisp_Object position
)
1533 int count
= SPECPDL_INDEX ();
1535 Lisp_Object keymaps
;
1537 /* If a mouse click position is given, our variables are based on
1538 the buffer clicked on, not the current buffer. So we may have to
1539 switch the buffer here. */
1541 if (CONSP (position
))
1545 window
= POSN_WINDOW (position
);
1547 if (WINDOWP (window
)
1548 && BUFFERP (XWINDOW (window
)->buffer
)
1549 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1551 /* Arrange to go back to the original buffer once we're done
1552 processing the key sequence. We don't use
1553 save_excursion_{save,restore} here, in analogy to
1554 `read-key-sequence' to avoid saving point. Maybe this
1555 would not be a problem here, but it is easier to keep
1559 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1561 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1565 keymaps
= Fcons (current_global_map
, Qnil
);
1569 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1570 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1571 /* The doc said that overriding-terminal-local-map should
1572 override overriding-local-map. The code used them both,
1573 but it seems clearer to use just one. rms, jan 2005. */
1574 else if (!NILP (Voverriding_local_map
))
1575 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1577 if (NILP (XCDR (keymaps
)))
1582 Lisp_Object keymap
, local_map
;
1585 pt
= INTEGERP (position
) ? XINT (position
)
1586 : MARKERP (position
) ? marker_position (position
)
1589 /* Get the buffer local maps, possibly overriden by text or
1590 overlay properties */
1592 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1593 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1595 if (CONSP (position
))
1599 /* For a mouse click, get the local text-property keymap
1600 of the place clicked on, rather than point. */
1602 if (POSN_INBUFFER_P (position
))
1606 pos
= POSN_BUFFER_POSN (position
);
1608 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1610 local_map
= get_local_map (XINT (pos
),
1611 current_buffer
, Qlocal_map
);
1613 keymap
= get_local_map (XINT (pos
),
1614 current_buffer
, Qkeymap
);
1618 /* If on a mode line string with a local keymap,
1619 or for a click on a string, i.e. overlay string or a
1620 string displayed via the `display' property,
1621 consider `local-map' and `keymap' properties of
1624 if (string
= POSN_STRING (position
),
1625 (CONSP (string
) && STRINGP (XCAR (string
))))
1627 Lisp_Object pos
, map
;
1629 pos
= XCDR (string
);
1630 string
= XCAR (string
);
1633 && XINT (pos
) < SCHARS (string
))
1635 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1639 map
= Fget_text_property (pos
, Qkeymap
, string
);
1647 if (!NILP (local_map
))
1648 keymaps
= Fcons (local_map
, keymaps
);
1650 /* Now put all the minor mode keymaps on the list. */
1651 nmaps
= current_minor_maps (0, &maps
);
1653 for (i
= --nmaps
; i
>= 0; i
--)
1654 if (!NILP (maps
[i
]))
1655 keymaps
= Fcons (maps
[i
], keymaps
);
1658 keymaps
= Fcons (keymap
, keymaps
);
1661 unbind_to (count
, Qnil
);
1666 /* GC is possible in this function if it autoloads a keymap. */
1668 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 4, 0,
1669 doc
: /* Return the binding for command KEY in current keymaps.
1670 KEY is a string or vector, a sequence of keystrokes.
1671 The binding is probably a symbol with a function definition.
1673 Normally, `key-binding' ignores bindings for t, which act as default
1674 bindings, used when nothing else in the keymap applies; this makes it
1675 usable as a general function for probing keymaps. However, if the
1676 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1677 recognize the default bindings, just as `read-key-sequence' does.
1679 Like the normal command loop, `key-binding' will remap the command
1680 resulting from looking up KEY by looking up the command in the
1681 current keymaps. However, if the optional third argument NO-REMAP
1682 is non-nil, `key-binding' returns the unmapped command.
1684 If KEY is a key sequence initiated with the mouse, the used keymaps
1685 will depend on the clicked mouse position with regard to the buffer
1686 and possible local keymaps on strings.
1688 If the optional argument POSITION is non-nil, it specifies a mouse
1689 position as returned by `event-start' and `event-end', and the lookup
1690 occurs in the keymaps associated with it instead of KEY. It can also
1691 be a number or marker, in which case the keymap properties at the
1692 specified buffer position instead of point are used.
1694 (Lisp_Object key
, Lisp_Object accept_default
, Lisp_Object no_remap
, Lisp_Object position
)
1696 Lisp_Object
*maps
, value
;
1698 struct gcpro gcpro1
, gcpro2
;
1699 int count
= SPECPDL_INDEX ();
1701 GCPRO2 (key
, position
);
1703 if (NILP (position
) && VECTORP (key
))
1706 /* mouse events may have a symbolic prefix indicating the
1707 scrollbar or mode line */
1708 = AREF (key
, SYMBOLP (AREF (key
, 0)) && ASIZE (key
) > 1 ? 1 : 0);
1710 /* We are not interested in locations without event data */
1712 if (EVENT_HAS_PARAMETERS (event
) && CONSP (XCDR (event
)))
1714 Lisp_Object kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1715 if (EQ (kind
, Qmouse_click
))
1716 position
= EVENT_START (event
);
1720 /* Key sequences beginning with mouse clicks
1721 are read using the keymaps of the buffer clicked on, not
1722 the current buffer. So we may have to switch the buffer
1725 if (CONSP (position
))
1729 window
= POSN_WINDOW (position
);
1731 if (WINDOWP (window
)
1732 && BUFFERP (XWINDOW (window
)->buffer
)
1733 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1735 /* Arrange to go back to the original buffer once we're done
1736 processing the key sequence. We don't use
1737 save_excursion_{save,restore} here, in analogy to
1738 `read-key-sequence' to avoid saving point. Maybe this
1739 would not be a problem here, but it is easier to keep
1743 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1745 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1749 if (! NILP (current_kboard
->Voverriding_terminal_local_map
))
1751 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1752 key
, accept_default
);
1753 if (! NILP (value
) && !INTEGERP (value
))
1756 else if (! NILP (Voverriding_local_map
))
1758 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1759 if (! NILP (value
) && !INTEGERP (value
))
1764 Lisp_Object keymap
, local_map
;
1767 pt
= INTEGERP (position
) ? XINT (position
)
1768 : MARKERP (position
) ? marker_position (position
)
1771 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1772 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1774 if (CONSP (position
))
1778 /* For a mouse click, get the local text-property keymap
1779 of the place clicked on, rather than point. */
1781 if (POSN_INBUFFER_P (position
))
1785 pos
= POSN_BUFFER_POSN (position
);
1787 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1789 local_map
= get_local_map (XINT (pos
),
1790 current_buffer
, Qlocal_map
);
1792 keymap
= get_local_map (XINT (pos
),
1793 current_buffer
, Qkeymap
);
1797 /* If on a mode line string with a local keymap,
1798 or for a click on a string, i.e. overlay string or a
1799 string displayed via the `display' property,
1800 consider `local-map' and `keymap' properties of
1803 if (string
= POSN_STRING (position
),
1804 (CONSP (string
) && STRINGP (XCAR (string
))))
1806 Lisp_Object pos
, map
;
1808 pos
= XCDR (string
);
1809 string
= XCAR (string
);
1812 && XINT (pos
) < SCHARS (string
))
1814 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1818 map
= Fget_text_property (pos
, Qkeymap
, string
);
1826 if (! NILP (keymap
))
1828 value
= Flookup_key (keymap
, key
, accept_default
);
1829 if (! NILP (value
) && !INTEGERP (value
))
1833 nmaps
= current_minor_maps (0, &maps
);
1834 /* Note that all these maps are GCPRO'd
1835 in the places where we found them. */
1837 for (i
= 0; i
< nmaps
; i
++)
1838 if (! NILP (maps
[i
]))
1840 value
= Flookup_key (maps
[i
], key
, accept_default
);
1841 if (! NILP (value
) && !INTEGERP (value
))
1845 if (! NILP (local_map
))
1847 value
= Flookup_key (local_map
, key
, accept_default
);
1848 if (! NILP (value
) && !INTEGERP (value
))
1853 value
= Flookup_key (current_global_map
, key
, accept_default
);
1856 unbind_to (count
, Qnil
);
1859 if (NILP (value
) || INTEGERP (value
))
1862 /* If the result of the ordinary keymap lookup is an interactive
1863 command, look for a key binding (ie. remapping) for that command. */
1865 if (NILP (no_remap
) && SYMBOLP (value
))
1868 if (value1
= Fcommand_remapping (value
, position
, Qnil
), !NILP (value1
))
1875 /* GC is possible in this function if it autoloads a keymap. */
1877 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1878 doc
: /* Return the binding for command KEYS in current local keymap only.
1879 KEYS is a string or vector, a sequence of keystrokes.
1880 The binding is probably a symbol with a function definition.
1882 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1883 bindings; see the description of `lookup-key' for more details about this. */)
1884 (Lisp_Object keys
, Lisp_Object accept_default
)
1886 register Lisp_Object map
;
1887 map
= current_buffer
->keymap
;
1890 return Flookup_key (map
, keys
, accept_default
);
1893 /* GC is possible in this function if it autoloads a keymap. */
1895 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1896 doc
: /* Return the binding for command KEYS in current global keymap only.
1897 KEYS is a string or vector, a sequence of keystrokes.
1898 The binding is probably a symbol with a function definition.
1899 This function's return values are the same as those of `lookup-key'
1902 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1903 bindings; see the description of `lookup-key' for more details about this. */)
1904 (Lisp_Object keys
, Lisp_Object accept_default
)
1906 return Flookup_key (current_global_map
, keys
, accept_default
);
1909 /* GC is possible in this function if it autoloads a keymap. */
1911 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1912 doc
: /* Find the visible minor mode bindings of KEY.
1913 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1914 the symbol which names the minor mode binding KEY, and BINDING is
1915 KEY's definition in that mode. In particular, if KEY has no
1916 minor-mode bindings, return nil. If the first binding is a
1917 non-prefix, all subsequent bindings will be omitted, since they would
1918 be ignored. Similarly, the list doesn't include non-prefix bindings
1919 that come after prefix bindings.
1921 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1922 bindings; see the description of `lookup-key' for more details about this. */)
1923 (Lisp_Object key
, Lisp_Object accept_default
)
1925 Lisp_Object
*modes
, *maps
;
1927 Lisp_Object binding
;
1929 struct gcpro gcpro1
, gcpro2
;
1931 nmaps
= current_minor_maps (&modes
, &maps
);
1932 /* Note that all these maps are GCPRO'd
1933 in the places where we found them. */
1936 GCPRO2 (key
, binding
);
1938 for (i
= j
= 0; i
< nmaps
; i
++)
1940 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1941 && !INTEGERP (binding
))
1943 if (KEYMAPP (binding
))
1944 maps
[j
++] = Fcons (modes
[i
], binding
);
1946 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1950 return Flist (j
, maps
);
1953 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1954 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1955 A new sparse keymap is stored as COMMAND's function definition and its value.
1956 If a second optional argument MAPVAR is given, the map is stored as
1957 its value instead of as COMMAND's value; but COMMAND is still defined
1959 The third optional argument NAME, if given, supplies a menu name
1960 string for the map. This is required to use the keymap as a menu.
1961 This function returns COMMAND. */)
1962 (Lisp_Object command
, Lisp_Object mapvar
, Lisp_Object name
)
1965 map
= Fmake_sparse_keymap (name
);
1966 Ffset (command
, map
);
1970 Fset (command
, map
);
1974 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1975 doc
: /* Select KEYMAP as the global keymap. */)
1976 (Lisp_Object keymap
)
1978 keymap
= get_keymap (keymap
, 1, 1);
1979 current_global_map
= keymap
;
1984 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1985 doc
: /* Select KEYMAP as the local keymap.
1986 If KEYMAP is nil, that means no local keymap. */)
1987 (Lisp_Object keymap
)
1990 keymap
= get_keymap (keymap
, 1, 1);
1992 current_buffer
->keymap
= keymap
;
1997 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1998 doc
: /* Return current buffer's local keymap, or nil if it has none.
1999 Normally the local keymap is set by the major mode with `use-local-map'. */)
2002 return current_buffer
->keymap
;
2005 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
2006 doc
: /* Return the current global keymap. */)
2009 return current_global_map
;
2012 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
2013 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
2017 int nmaps
= current_minor_maps (0, &maps
);
2019 return Flist (nmaps
, maps
);
2022 /* Help functions for describing and documenting keymaps. */
2024 struct accessible_keymaps_data
{
2025 Lisp_Object maps
, tail
, thisseq
;
2026 /* Does the current sequence end in the meta-prefix-char? */
2031 accessible_keymaps_1 (Lisp_Object key
, Lisp_Object cmd
, Lisp_Object args
, void *data
)
2032 /* Use void* data to be compatible with map_keymap_function_t. */
2034 struct accessible_keymaps_data
*d
= data
; /* Cast! */
2035 Lisp_Object maps
= d
->maps
;
2036 Lisp_Object tail
= d
->tail
;
2037 Lisp_Object thisseq
= d
->thisseq
;
2038 int is_metized
= d
->is_metized
&& INTEGERP (key
);
2041 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
2045 /* Look for and break cycles. */
2046 while (!NILP (tem
= Frassq (cmd
, maps
)))
2048 Lisp_Object prefix
= XCAR (tem
);
2049 int lim
= XINT (Flength (XCAR (tem
)));
2050 if (lim
<= XINT (Flength (thisseq
)))
2051 { /* This keymap was already seen with a smaller prefix. */
2053 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
2054 Faref (thisseq
, make_number (i
))))
2057 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
2060 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
2061 but maybe `cmd' occurs again further down in `maps', so keep
2063 maps
= XCDR (Fmemq (tem
, maps
));
2066 /* If the last key in thisseq is meta-prefix-char,
2067 turn it into a meta-ized keystroke. We know
2068 that the event we're about to append is an
2069 ascii keystroke since we're processing a
2073 int meta_bit
= meta_modifier
;
2074 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
2075 tem
= Fcopy_sequence (thisseq
);
2077 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
2079 /* This new sequence is the same length as
2080 thisseq, so stick it in the list right
2083 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
2087 tem
= append_key (thisseq
, key
);
2088 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
2092 /* This function cannot GC. */
2094 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
2096 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
2097 Returns a list of elements of the form (KEYS . MAP), where the sequence
2098 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
2099 so that the KEYS increase in length. The first element is ([] . KEYMAP).
2100 An optional argument PREFIX, if non-nil, should be a key sequence;
2101 then the value includes only maps for prefixes that start with PREFIX. */)
2102 (Lisp_Object keymap
, Lisp_Object prefix
)
2104 Lisp_Object maps
, tail
;
2105 int prefixlen
= XINT (Flength (prefix
));
2107 /* no need for gcpro because we don't autoload any keymaps. */
2111 /* If a prefix was specified, start with the keymap (if any) for
2112 that prefix, so we don't waste time considering other prefixes. */
2114 tem
= Flookup_key (keymap
, prefix
, Qt
);
2115 /* Flookup_key may give us nil, or a number,
2116 if the prefix is not defined in this particular map.
2117 It might even give us a list that isn't a keymap. */
2118 tem
= get_keymap (tem
, 0, 0);
2119 /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
2120 want to return it. */
2123 /* Convert PREFIX to a vector now, so that later on
2124 we don't have to deal with the possibility of a string. */
2125 if (STRINGP (prefix
))
2130 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
2131 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
2135 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
2136 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2137 c
^= 0200 | meta_modifier
;
2138 ASET (copy
, i_before
, make_number (c
));
2142 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
2148 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
2149 get_keymap (keymap
, 1, 0)),
2152 /* For each map in the list maps,
2153 look at any other maps it points to,
2154 and stick them at the end if they are not already in the list.
2156 This is a breadth-first traversal, where tail is the queue of
2157 nodes, and maps accumulates a list of all nodes visited. */
2159 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2161 struct accessible_keymaps_data data
;
2162 register Lisp_Object thismap
= Fcdr (XCAR (tail
));
2165 data
.thisseq
= Fcar (XCAR (tail
));
2168 last
= make_number (XINT (Flength (data
.thisseq
)) - 1);
2169 /* Does the current sequence end in the meta-prefix-char? */
2170 data
.is_metized
= (XINT (last
) >= 0
2171 /* Don't metize the last char of PREFIX. */
2172 && XINT (last
) >= prefixlen
2173 && EQ (Faref (data
.thisseq
, last
), meta_prefix_char
));
2175 /* Since we can't run lisp code, we can't scan autoloaded maps. */
2176 if (CONSP (thismap
))
2177 map_keymap (thismap
, accessible_keymaps_1
, Qnil
, &data
, 0);
2181 Lisp_Object Qsingle_key_description
, Qkey_description
;
2183 /* This function cannot GC. */
2185 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2186 doc
: /* Return a pretty description of key-sequence KEYS.
2187 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2188 Control characters turn into "C-foo" sequences, meta into "M-foo",
2189 spaces are put between sequence elements, etc. */)
2190 (Lisp_Object keys
, Lisp_Object prefix
)
2195 int size
= XINT (Flength (keys
));
2197 Lisp_Object sep
= build_string (" ");
2202 size
+= XINT (Flength (prefix
));
2204 /* This has one extra element at the end that we don't pass to Fconcat. */
2205 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2207 /* In effect, this computes
2208 (mapconcat 'single-key-description keys " ")
2209 but we shouldn't use mapconcat because it can do GC. */
2213 list
= prefix
, prefix
= Qnil
;
2214 else if (!NILP (keys
))
2215 list
= keys
, keys
= Qnil
;
2220 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2224 return empty_unibyte_string
;
2225 return Fconcat (len
- 1, args
);
2229 size
= SCHARS (list
);
2230 else if (VECTORP (list
))
2231 size
= XVECTOR (list
)->size
;
2232 else if (CONSP (list
))
2233 size
= XINT (Flength (list
));
2235 wrong_type_argument (Qarrayp
, list
);
2244 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2245 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2246 c
^= 0200 | meta_modifier
;
2247 XSETFASTINT (key
, c
);
2249 else if (VECTORP (list
))
2251 key
= AREF (list
, i
); i
++;
2263 || EQ (key
, meta_prefix_char
)
2264 || (XINT (key
) & meta_modifier
))
2266 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2268 if (EQ (key
, meta_prefix_char
))
2272 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2275 else if (EQ (key
, meta_prefix_char
))
2280 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2288 push_key_description (register unsigned int c
, register char *p
, int force_multibyte
)
2292 /* Clear all the meaningless bits above the meta bit. */
2293 c
&= meta_modifier
| ~ - meta_modifier
;
2294 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2295 | meta_modifier
| shift_modifier
| super_modifier
);
2297 if (! CHARACTERP (make_number (c2
)))
2299 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2300 p
+= sprintf (p
, "[%d]", c
);
2304 if (c
& alt_modifier
)
2310 if ((c
& ctrl_modifier
) != 0
2311 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2315 c
&= ~ctrl_modifier
;
2317 if (c
& hyper_modifier
)
2321 c
-= hyper_modifier
;
2323 if (c
& meta_modifier
)
2329 if (c
& shift_modifier
)
2333 c
-= shift_modifier
;
2335 if (c
& super_modifier
)
2339 c
-= super_modifier
;
2355 else if (c
== Ctl ('M'))
2363 /* `C-' already added above. */
2364 if (c
> 0 && c
<= Ctl ('Z'))
2383 || (NILP (current_buffer
->enable_multibyte_characters
)
2384 && SINGLE_BYTE_CHAR_P (c
)
2385 && !force_multibyte
))
2391 /* Now we are sure that C is a valid character code. */
2392 if (NILP (current_buffer
->enable_multibyte_characters
)
2393 && ! force_multibyte
)
2394 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2396 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2402 /* This function cannot GC. */
2404 DEFUN ("single-key-description", Fsingle_key_description
,
2405 Ssingle_key_description
, 1, 2, 0,
2406 doc
: /* Return a pretty description of command character KEY.
2407 Control characters turn into C-whatever, etc.
2408 Optional argument NO-ANGLES non-nil means don't put angle brackets
2409 around function keys and event symbols. */)
2410 (Lisp_Object key
, Lisp_Object no_angles
)
2412 if (CONSP (key
) && lucid_event_type_list_p (key
))
2413 key
= Fevent_convert_list (key
);
2415 key
= EVENT_HEAD (key
);
2417 if (INTEGERP (key
)) /* Normal character */
2419 char tem
[KEY_DESCRIPTION_SIZE
];
2421 *push_key_description (XUINT (key
), tem
, 1) = 0;
2422 return build_string (tem
);
2424 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2426 if (NILP (no_angles
))
2429 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2430 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2431 return build_string (buffer
);
2434 return Fsymbol_name (key
);
2436 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2437 return Fcopy_sequence (key
);
2439 error ("KEY must be an integer, cons, symbol, or string");
2444 push_text_char_description (register unsigned int c
, register char *p
)
2455 *p
++ = c
+ 64; /* 'A' - 1 */
2467 /* This function cannot GC. */
2469 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2470 doc
: /* Return a pretty description of file-character CHARACTER.
2471 Control characters turn into "^char", etc. This differs from
2472 `single-key-description' which turns them into "C-char".
2473 Also, this function recognizes the 2**7 bit as the Meta character,
2474 whereas `single-key-description' uses the 2**27 bit for Meta.
2475 See Info node `(elisp)Describing Characters' for examples. */)
2476 (Lisp_Object character
)
2478 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2479 unsigned char str
[6];
2482 CHECK_NUMBER (character
);
2484 c
= XINT (character
);
2485 if (!ASCII_CHAR_P (c
))
2487 int len
= CHAR_STRING (c
, str
);
2489 return make_multibyte_string (str
, 1, len
);
2492 *push_text_char_description (c
& 0377, str
) = 0;
2494 return build_string (str
);
2497 static int where_is_preferred_modifier
;
2499 /* Return 0 if SEQ uses non-preferred modifiers or non-char events.
2500 Else, return 2 if SEQ uses the where_is_preferred_modifier,
2503 preferred_sequence_p (Lisp_Object seq
)
2506 int len
= XINT (Flength (seq
));
2509 for (i
= 0; i
< len
; i
++)
2511 Lisp_Object ii
, elt
;
2513 XSETFASTINT (ii
, i
);
2514 elt
= Faref (seq
, ii
);
2516 if (!INTEGERP (elt
))
2520 int modifiers
= XUINT (elt
) & (CHAR_MODIFIER_MASK
& ~CHAR_META
);
2521 if (modifiers
== where_is_preferred_modifier
)
2532 /* where-is - finding a command in a set of keymaps. */
2534 static void where_is_internal_1 (Lisp_Object key
, Lisp_Object binding
,
2535 Lisp_Object args
, void *data
);
2537 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2538 Returns the first non-nil binding found in any of those maps.
2539 If REMAP is true, pass the result of the lookup through command
2540 remapping before returning it. */
2543 shadow_lookup (Lisp_Object shadow
, Lisp_Object key
, Lisp_Object flag
,
2546 Lisp_Object tail
, value
;
2548 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2550 value
= Flookup_key (XCAR (tail
), key
, flag
);
2551 if (NATNUMP (value
))
2553 value
= Flookup_key (XCAR (tail
),
2554 Fsubstring (key
, make_number (0), value
), flag
);
2558 else if (!NILP (value
))
2560 Lisp_Object remapping
;
2561 if (remap
&& SYMBOLP (value
)
2562 && (remapping
= Fcommand_remapping (value
, Qnil
, shadow
),
2572 static Lisp_Object Vmouse_events
;
2574 struct where_is_internal_data
{
2575 Lisp_Object definition
, this, last
;
2576 int last_is_meta
, noindirect
;
2577 Lisp_Object sequences
;
2580 /* This function can't GC, AFAIK. */
2581 /* Return the list of bindings found. This list is ordered "longest
2582 to shortest". It may include bindings that are actually shadowed
2583 by others, as well as duplicate bindings and remapping bindings.
2584 The list returned is potentially shared with where_is_cache, so
2585 be careful not to modify it via side-effects. */
2588 where_is_internal (Lisp_Object definition
, Lisp_Object keymaps
,
2589 int noindirect
, int nomenus
)
2591 Lisp_Object maps
= Qnil
;
2593 struct where_is_internal_data data
;
2595 /* Only important use of caching is for the menubar
2596 (i.e. where-is-internal called with (def nil t nil nil)). */
2597 if (nomenus
&& !noindirect
)
2599 /* Check heuristic-consistency of the cache. */
2600 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2601 where_is_cache
= Qnil
;
2603 if (NILP (where_is_cache
))
2605 /* We need to create the cache. */
2606 Lisp_Object args
[2];
2607 where_is_cache
= Fmake_hash_table (0, args
);
2608 where_is_cache_keymaps
= Qt
;
2611 /* We can reuse the cache. */
2612 return Fgethash (definition
, where_is_cache
, Qnil
);
2615 /* Kill the cache so that where_is_internal_1 doesn't think
2616 we're filling it up. */
2617 where_is_cache
= Qnil
;
2620 while (CONSP (found
))
2624 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2625 found
= XCDR (found
);
2628 data
.sequences
= Qnil
;
2629 for (; CONSP (maps
); maps
= XCDR (maps
))
2631 /* Key sequence to reach map, and the map that it reaches */
2632 register Lisp_Object
this, map
, tem
;
2634 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2635 [M-CHAR] sequences, check if last character of the sequence
2636 is the meta-prefix char. */
2640 this = Fcar (XCAR (maps
));
2641 map
= Fcdr (XCAR (maps
));
2642 last
= make_number (XINT (Flength (this)) - 1);
2643 last_is_meta
= (XINT (last
) >= 0
2644 && EQ (Faref (this, last
), meta_prefix_char
));
2646 /* if (nomenus && !preferred_sequence_p (this)) */
2647 if (nomenus
&& XINT (last
) >= 0
2648 && SYMBOLP (tem
= Faref (this, make_number (0)))
2649 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2650 /* If no menu entries should be returned, skip over the
2651 keymaps bound to `menu-bar' and `tool-bar' and other
2652 non-ascii prefixes like `C-down-mouse-2'. */
2657 data
.definition
= definition
;
2658 data
.noindirect
= noindirect
;
2661 data
.last_is_meta
= last_is_meta
;
2664 map_keymap (map
, where_is_internal_1
, Qnil
, &data
, 0);
2667 if (nomenus
&& !noindirect
)
2668 { /* Remember for which keymaps this cache was built.
2669 We do it here (late) because we want to keep where_is_cache_keymaps
2670 set to t while the cache isn't fully filled. */
2671 where_is_cache_keymaps
= keymaps
;
2672 /* During cache-filling, data.sequences is not filled by
2673 where_is_internal_1. */
2674 return Fgethash (definition
, where_is_cache
, Qnil
);
2677 return data
.sequences
;
2680 /* This function can GC if Flookup_key autoloads any keymaps. */
2682 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2683 doc
: /* Return list of keys that invoke DEFINITION.
2684 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2685 If KEYMAP is nil, search all the currently active keymaps.
2686 If KEYMAP is a list of keymaps, search only those keymaps.
2688 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2689 rather than a list of all possible key sequences.
2690 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2691 no matter what it is.
2692 If FIRSTONLY has another non-nil value, prefer bindings
2693 that use the modifier key specified in `where-is-preferred-modifier'
2694 \(or their meta variants) and entirely reject menu bindings.
2696 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2697 to other keymaps or slots. This makes it possible to search for an
2698 indirect definition itself.
2700 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2701 that invoke a command which is remapped to DEFINITION, but include the
2702 remapped command in the returned list. */)
2703 (Lisp_Object definition
, Lisp_Object keymap
, Lisp_Object firstonly
, Lisp_Object noindirect
, Lisp_Object no_remap
)
2705 /* The keymaps in which to search. */
2706 Lisp_Object keymaps
;
2707 /* Potentially relevant bindings in "shortest to longest" order. */
2708 Lisp_Object sequences
= Qnil
;
2709 /* Actually relevant bindings. */
2710 Lisp_Object found
= Qnil
;
2711 /* 1 means ignore all menu bindings entirely. */
2712 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2713 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
2714 /* List of sequences found via remapping. Keep them in a separate
2715 variable, so as to push them later, since we prefer
2716 non-remapped binding. */
2717 Lisp_Object remapped_sequences
= Qnil
;
2718 /* Whether or not we're handling remapped sequences. This is needed
2719 because remapping is not done recursively by Fcommand_remapping: you
2720 can't remap a remapped command. */
2722 Lisp_Object tem
= Qnil
;
2724 /* Refresh the C version of the modifier preference. */
2725 where_is_preferred_modifier
2726 = parse_solitary_modifier (Vwhere_is_preferred_modifier
);
2728 /* Find the relevant keymaps. */
2729 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2731 else if (!NILP (keymap
))
2732 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2734 keymaps
= Fcurrent_active_maps (Qnil
, Qnil
);
2736 GCPRO6 (definition
, keymaps
, found
, sequences
, remapped_sequences
, tem
);
2738 tem
= Fcommand_remapping (definition
, Qnil
, keymaps
);
2739 /* If `definition' is remapped to tem', then OT1H no key will run
2740 that command (since they will run `tem' instead), so we should
2741 return nil; but OTOH all keys bound to `definition' (or to `tem')
2742 will run the same command.
2743 So for menu-shortcut purposes, we want to find all the keys bound (maybe
2744 via remapping) to `tem'. But for the purpose of finding the keys that
2745 run `definition', then we'd want to just return nil.
2746 We choose to make it work right for menu-shortcuts, since it's the most
2748 Known bugs: if you remap switch-to-buffer to toto, C-h f switch-to-buffer
2749 will tell you that switch-to-buffer is bound to C-x b even though C-x b
2750 will run toto instead. And if `toto' is itself remapped to forward-char,
2751 then C-h f toto will tell you that it's bound to C-f even though C-f does
2752 not run toto and it won't tell you that C-x b does run toto. */
2753 if (NILP (no_remap
) && !NILP (tem
))
2756 if (SYMBOLP (definition
)
2757 && !NILP (firstonly
)
2758 && !NILP (tem
= Fget (definition
, QCadvertised_binding
)))
2760 /* We have a list of advertized bindings. */
2762 if (EQ (shadow_lookup (keymaps
, XCAR (tem
), Qnil
, 0), definition
))
2766 if (EQ (shadow_lookup (keymaps
, tem
, Qnil
, 0), definition
))
2770 sequences
= Freverse (where_is_internal (definition
, keymaps
,
2771 !NILP (noindirect
), nomenus
));
2773 while (CONSP (sequences
)
2774 /* If we're at the end of the `sequences' list and we haven't
2775 considered remapped sequences yet, copy them over and
2777 || (!remapped
&& (sequences
= remapped_sequences
,
2781 Lisp_Object sequence
, function
;
2783 sequence
= XCAR (sequences
);
2784 sequences
= XCDR (sequences
);
2786 /* Verify that this key binding is not shadowed by another
2787 binding for the same key, before we say it exists.
2789 Mechanism: look for local definition of this key and if
2790 it is defined and does not match what we found then
2793 Either nil or number as value from Flookup_key
2795 if (NILP (Fequal (shadow_lookup (keymaps
, sequence
, Qnil
, remapped
),
2799 /* If the current sequence is a command remapping with
2800 format [remap COMMAND], find the key sequences
2801 which run COMMAND, and use those sequences instead. */
2802 if (NILP (no_remap
) && !remapped
2803 && VECTORP (sequence
) && ASIZE (sequence
) == 2
2804 && EQ (AREF (sequence
, 0), Qremap
)
2805 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2807 Lisp_Object seqs
= where_is_internal (function
, keymaps
,
2808 !NILP (noindirect
), nomenus
);
2809 remapped_sequences
= nconc2 (Freverse (seqs
), remapped_sequences
);
2813 /* Don't annoy user with strings from a menu such as the
2814 entries from the "Edit => Paste from Kill Menu".
2815 Change them all to "(any string)", so that there
2816 seems to be only one menu item to report. */
2817 if (! NILP (sequence
))
2820 tem
= Faref (sequence
, make_number (ASIZE (sequence
) - 1));
2822 Faset (sequence
, make_number (ASIZE (sequence
) - 1),
2823 build_string ("(any string)"));
2826 /* It is a true unshadowed match. Record it, unless it's already
2827 been seen (as could happen when inheriting keymaps). */
2828 if (NILP (Fmember (sequence
, found
)))
2829 found
= Fcons (sequence
, found
);
2831 /* If firstonly is Qnon_ascii, then we can return the first
2832 binding we find. If firstonly is not Qnon_ascii but not
2833 nil, then we should return the first ascii-only binding
2835 if (EQ (firstonly
, Qnon_ascii
))
2836 RETURN_UNGCPRO (sequence
);
2837 else if (!NILP (firstonly
)
2838 && 2 == preferred_sequence_p (sequence
))
2839 RETURN_UNGCPRO (sequence
);
2844 found
= Fnreverse (found
);
2846 /* firstonly may have been t, but we may have gone all the way through
2847 the keymaps without finding an all-ASCII key sequence. So just
2848 return the best we could find. */
2849 if (NILP (firstonly
))
2851 else if (where_is_preferred_modifier
== 0)
2852 return Fcar (found
);
2854 { /* Maybe we did not find a preferred_modifier binding, but we did find
2855 some ASCII binding. */
2856 Lisp_Object bindings
= found
;
2857 while (CONSP (bindings
))
2858 if (preferred_sequence_p (XCAR (bindings
)))
2859 return XCAR (bindings
);
2861 bindings
= XCDR (bindings
);
2862 return Fcar (found
);
2866 /* This function can GC because get_keyelt can. */
2869 where_is_internal_1 (Lisp_Object key
, Lisp_Object binding
, Lisp_Object args
, void *data
)
2871 struct where_is_internal_data
*d
= data
; /* Cast! */
2872 Lisp_Object definition
= d
->definition
;
2873 int noindirect
= d
->noindirect
;
2874 Lisp_Object
this = d
->this;
2875 Lisp_Object last
= d
->last
;
2876 int last_is_meta
= d
->last_is_meta
;
2877 Lisp_Object sequence
;
2879 /* Search through indirections unless that's not wanted. */
2881 binding
= get_keyelt (binding
, 0);
2883 /* End this iteration if this element does not match
2886 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2887 || EQ (binding
, definition
)
2888 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2889 /* Doesn't match. */
2892 /* We have found a match. Construct the key sequence where we found it. */
2893 if (INTEGERP (key
) && last_is_meta
)
2895 sequence
= Fcopy_sequence (this);
2896 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2901 key
= Fcons (XCAR (key
), XCDR (key
));
2902 sequence
= append_key (this, key
);
2905 if (!NILP (where_is_cache
))
2907 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2908 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2911 d
->sequences
= Fcons (sequence
, d
->sequences
);
2914 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2916 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2917 doc
: /* Insert the list of all defined keys and their definitions.
2918 The list is inserted in the current buffer, while the bindings are
2919 looked up in BUFFER.
2920 The optional argument PREFIX, if non-nil, should be a key sequence;
2921 then we display only bindings that start with that prefix.
2922 The optional argument MENUS, if non-nil, says to mention menu bindings.
2923 \(Ordinarily these are omitted from the output.) */)
2924 (Lisp_Object buffer
, Lisp_Object prefix
, Lisp_Object menus
)
2926 Lisp_Object outbuf
, shadow
;
2927 int nomenu
= NILP (menus
);
2928 register Lisp_Object start1
;
2929 struct gcpro gcpro1
;
2931 const char *alternate_heading
2933 Keyboard translations:\n\n\
2934 You type Translation\n\
2935 -------- -----------\n";
2937 CHECK_BUFFER (buffer
);
2942 outbuf
= Fcurrent_buffer ();
2944 /* Report on alternates for keys. */
2945 if (STRINGP (current_kboard
->Vkeyboard_translate_table
) && !NILP (prefix
))
2948 const unsigned char *translate
= SDATA (current_kboard
->Vkeyboard_translate_table
);
2949 int translate_len
= SCHARS (current_kboard
->Vkeyboard_translate_table
);
2951 for (c
= 0; c
< translate_len
; c
++)
2952 if (translate
[c
] != c
)
2954 char buf
[KEY_DESCRIPTION_SIZE
];
2957 if (alternate_heading
)
2959 insert_string (alternate_heading
);
2960 alternate_heading
= 0;
2963 bufend
= push_key_description (translate
[c
], buf
, 1);
2964 insert (buf
, bufend
- buf
);
2965 Findent_to (make_number (16), make_number (1));
2966 bufend
= push_key_description (c
, buf
, 1);
2967 insert (buf
, bufend
- buf
);
2971 /* Insert calls signal_after_change which may GC. */
2972 translate
= SDATA (current_kboard
->Vkeyboard_translate_table
);
2978 if (!NILP (Vkey_translation_map
))
2979 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2980 "Key translations", nomenu
, 1, 0, 0);
2983 /* Print the (major mode) local map. */
2985 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2986 start1
= current_kboard
->Voverriding_terminal_local_map
;
2987 else if (!NILP (Voverriding_local_map
))
2988 start1
= Voverriding_local_map
;
2992 describe_map_tree (start1
, 1, shadow
, prefix
,
2993 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
2994 shadow
= Fcons (start1
, shadow
);
2998 /* Print the minor mode and major mode keymaps. */
3000 Lisp_Object
*modes
, *maps
;
3002 /* Temporarily switch to `buffer', so that we can get that buffer's
3003 minor modes correctly. */
3004 Fset_buffer (buffer
);
3006 nmaps
= current_minor_maps (&modes
, &maps
);
3007 Fset_buffer (outbuf
);
3009 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3010 XBUFFER (buffer
), Qkeymap
);
3013 describe_map_tree (start1
, 1, shadow
, prefix
,
3014 "\f\n`keymap' Property Bindings", nomenu
,
3016 shadow
= Fcons (start1
, shadow
);
3019 /* Print the minor mode maps. */
3020 for (i
= 0; i
< nmaps
; i
++)
3022 /* The title for a minor mode keymap
3023 is constructed at run time.
3024 We let describe_map_tree do the actual insertion
3025 because it takes care of other features when doing so. */
3028 if (!SYMBOLP (modes
[i
]))
3031 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3035 memcpy (p
, SDATA (SYMBOL_NAME (modes
[i
])),
3036 SCHARS (SYMBOL_NAME (modes
[i
])));
3037 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3039 memcpy (p
, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
3040 p
+= strlen (" Minor Mode Bindings");
3043 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3044 title
, nomenu
, 0, 0, 0);
3045 shadow
= Fcons (maps
[i
], shadow
);
3048 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3049 XBUFFER (buffer
), Qlocal_map
);
3052 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3053 describe_map_tree (start1
, 1, shadow
, prefix
,
3054 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3056 describe_map_tree (start1
, 1, shadow
, prefix
,
3057 "\f\n`local-map' Property Bindings",
3060 shadow
= Fcons (start1
, shadow
);
3064 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3065 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3067 /* Print the function-key-map translations under this prefix. */
3068 if (!NILP (current_kboard
->Vlocal_function_key_map
))
3069 describe_map_tree (current_kboard
->Vlocal_function_key_map
, 0, Qnil
, prefix
,
3070 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3072 /* Print the input-decode-map translations under this prefix. */
3073 if (!NILP (current_kboard
->Vinput_decode_map
))
3074 describe_map_tree (current_kboard
->Vinput_decode_map
, 0, Qnil
, prefix
,
3075 "\f\nInput decoding map translations", nomenu
, 1, 0, 0);
3081 /* Insert a description of the key bindings in STARTMAP,
3082 followed by those of all maps reachable through STARTMAP.
3083 If PARTIAL is nonzero, omit certain "uninteresting" commands
3084 (such as `undefined').
3085 If SHADOW is non-nil, it is a list of maps;
3086 don't mention keys which would be shadowed by any of them.
3087 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3088 TITLE, if not 0, is a string to insert at the beginning.
3089 TITLE should not end with a colon or a newline; we supply that.
3090 If NOMENU is not 0, then omit menu-bar commands.
3092 If TRANSL is nonzero, the definitions are actually key translations
3093 so print strings and vectors differently.
3095 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3098 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3099 don't omit it; instead, mention it but say it is shadowed. */
3102 describe_map_tree (Lisp_Object startmap
, int partial
, Lisp_Object shadow
,
3103 Lisp_Object prefix
, const char *title
, int nomenu
, int transl
,
3104 int always_title
, int mention_shadow
)
3106 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3107 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3109 const char *key_heading
3114 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3117 GCPRO3 (maps
, seen
, sub_shadows
);
3123 /* Delete from MAPS each element that is for the menu bar. */
3124 for (list
= maps
; CONSP (list
); list
= XCDR (list
))
3126 Lisp_Object elt
, prefix
, tem
;
3129 prefix
= Fcar (elt
);
3130 if (XVECTOR (prefix
)->size
>= 1)
3132 tem
= Faref (prefix
, make_number (0));
3133 if (EQ (tem
, Qmenu_bar
))
3134 maps
= Fdelq (elt
, maps
);
3139 if (!NILP (maps
) || always_title
)
3143 insert_string (title
);
3146 insert_string (" Starting With ");
3147 insert1 (Fkey_description (prefix
, Qnil
));
3149 insert_string (":\n");
3151 insert_string (key_heading
);
3155 for (; CONSP (maps
); maps
= XCDR (maps
))
3157 register Lisp_Object elt
, prefix
, tail
;
3160 prefix
= Fcar (elt
);
3164 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3168 shmap
= XCAR (tail
);
3170 /* If the sequence by which we reach this keymap is zero-length,
3171 then the shadow map for this keymap is just SHADOW. */
3172 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3173 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3175 /* If the sequence by which we reach this keymap actually has
3176 some elements, then the sequence's definition in SHADOW is
3177 what we should use. */
3180 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3181 if (INTEGERP (shmap
))
3185 /* If shmap is not nil and not a keymap,
3186 it completely shadows this map, so don't
3187 describe this map at all. */
3188 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3192 sub_shadows
= Fcons (shmap
, sub_shadows
);
3195 /* Maps we have already listed in this loop shadow this map. */
3196 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3199 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3201 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3204 describe_map (Fcdr (elt
), prefix
,
3205 transl
? describe_translation
: describe_command
,
3206 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3212 insert_string ("\n");
3217 static int previous_description_column
;
3220 describe_command (Lisp_Object definition
, Lisp_Object args
)
3222 register Lisp_Object tem1
;
3223 int column
= (int) current_column (); /* iftc */
3224 int description_column
;
3226 /* If column 16 is no good, go to col 32;
3227 but don't push beyond that--go to next line instead. */
3231 description_column
= 32;
3233 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3234 description_column
= 32;
3236 description_column
= 16;
3238 Findent_to (make_number (description_column
), make_number (1));
3239 previous_description_column
= description_column
;
3241 if (SYMBOLP (definition
))
3243 tem1
= SYMBOL_NAME (definition
);
3245 insert_string ("\n");
3247 else if (STRINGP (definition
) || VECTORP (definition
))
3248 insert_string ("Keyboard Macro\n");
3249 else if (KEYMAPP (definition
))
3250 insert_string ("Prefix Command\n");
3252 insert_string ("??\n");
3256 describe_translation (Lisp_Object definition
, Lisp_Object args
)
3258 register Lisp_Object tem1
;
3260 Findent_to (make_number (16), make_number (1));
3262 if (SYMBOLP (definition
))
3264 tem1
= SYMBOL_NAME (definition
);
3266 insert_string ("\n");
3268 else if (STRINGP (definition
) || VECTORP (definition
))
3270 insert1 (Fkey_description (definition
, Qnil
));
3271 insert_string ("\n");
3273 else if (KEYMAPP (definition
))
3274 insert_string ("Prefix Command\n");
3276 insert_string ("??\n");
3279 /* describe_map puts all the usable elements of a sparse keymap
3280 into an array of `struct describe_map_elt',
3281 then sorts them by the events. */
3283 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3285 /* qsort comparison function for sorting `struct describe_map_elt' by
3289 describe_map_compare (const void *aa
, const void *bb
)
3291 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3292 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3293 return ((XINT (a
->event
) > XINT (b
->event
))
3294 - (XINT (a
->event
) < XINT (b
->event
)));
3295 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3297 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3299 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3300 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3301 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3306 /* Describe the contents of map MAP, assuming that this map itself is
3307 reached by the sequence of prefix keys PREFIX (a string or vector).
3308 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3311 describe_map (Lisp_Object map
, Lisp_Object prefix
,
3312 void (*elt_describer
) (Lisp_Object
, Lisp_Object
),
3313 int partial
, Lisp_Object shadow
,
3314 Lisp_Object
*seen
, int nomenu
, int mention_shadow
)
3316 Lisp_Object tail
, definition
, event
;
3318 Lisp_Object suppress
;
3321 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3323 /* These accumulate the values from sparse keymap bindings,
3324 so we can sort them and handle them in order. */
3325 int length_needed
= 0;
3326 struct describe_map_elt
*vect
;
3333 suppress
= intern ("suppress-keymap");
3335 /* This vector gets used to present single keys to Flookup_key. Since
3336 that is done once per keymap element, we don't want to cons up a
3337 fresh vector every time. */
3338 kludge
= Fmake_vector (make_number (1), Qnil
);
3341 GCPRO3 (prefix
, definition
, kludge
);
3343 map
= call1 (Qkeymap_canonicalize
, map
);
3345 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3348 vect
= ((struct describe_map_elt
*)
3349 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3351 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3355 if (VECTORP (XCAR (tail
))
3356 || CHAR_TABLE_P (XCAR (tail
)))
3357 describe_vector (XCAR (tail
),
3358 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3359 (int *)0, 0, 1, mention_shadow
);
3360 else if (CONSP (XCAR (tail
)))
3362 int this_shadowed
= 0;
3364 event
= XCAR (XCAR (tail
));
3366 /* Ignore bindings whose "prefix" are not really valid events.
3367 (We get these in the frames and buffers menu.) */
3368 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3371 if (nomenu
&& EQ (event
, Qmenu_bar
))
3374 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3376 /* Don't show undefined commands or suppressed commands. */
3377 if (NILP (definition
)) continue;
3378 if (SYMBOLP (definition
) && partial
)
3380 tem
= Fget (definition
, suppress
);
3385 /* Don't show a command that isn't really visible
3386 because a local definition of the same key shadows it. */
3388 ASET (kludge
, 0, event
);
3391 tem
= shadow_lookup (shadow
, kludge
, Qt
, 0);
3394 /* If both bindings are keymaps, this key is a prefix key,
3395 so don't say it is shadowed. */
3396 if (KEYMAPP (definition
) && KEYMAPP (tem
))
3398 /* Avoid generating duplicate entries if the
3399 shadowed binding has the same definition. */
3400 else if (mention_shadow
&& !EQ (tem
, definition
))
3407 tem
= Flookup_key (map
, kludge
, Qt
);
3408 if (!EQ (tem
, definition
)) continue;
3410 vect
[slots_used
].event
= event
;
3411 vect
[slots_used
].definition
= definition
;
3412 vect
[slots_used
].shadowed
= this_shadowed
;
3415 else if (EQ (XCAR (tail
), Qkeymap
))
3417 /* The same keymap might be in the structure twice, if we're
3418 using an inherited keymap. So skip anything we've already
3420 tem
= Fassq (tail
, *seen
);
3421 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3423 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3427 /* If we found some sparse map events, sort them. */
3429 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3430 describe_map_compare
);
3432 /* Now output them in sorted order. */
3434 for (i
= 0; i
< slots_used
; i
++)
3436 Lisp_Object start
, end
;
3440 previous_description_column
= 0;
3445 ASET (kludge
, 0, vect
[i
].event
);
3446 start
= vect
[i
].event
;
3449 definition
= vect
[i
].definition
;
3451 /* Find consecutive chars that are identically defined. */
3452 if (INTEGERP (vect
[i
].event
))
3454 while (i
+ 1 < slots_used
3455 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3456 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3457 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3459 end
= vect
[i
].event
;
3462 /* Now START .. END is the range to describe next. */
3464 /* Insert the string to describe the event START. */
3465 insert1 (Fkey_description (kludge
, prefix
));
3467 if (!EQ (start
, end
))
3471 ASET (kludge
, 0, end
);
3472 /* Insert the string to describe the character END. */
3473 insert1 (Fkey_description (kludge
, prefix
));
3476 /* Print a description of the definition of this character.
3477 elt_describer will take care of spacing out far enough
3478 for alignment purposes. */
3479 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3481 if (vect
[i
].shadowed
)
3484 insert_string ("\n (that binding is currently shadowed by another mode)");
3493 describe_vector_princ (Lisp_Object elt
, Lisp_Object fun
)
3495 Findent_to (make_number (16), make_number (1));
3500 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3501 doc
: /* Insert a description of contents of VECTOR.
3502 This is text showing the elements of vector matched against indices.
3503 DESCRIBER is the output function used; nil means use `princ'. */)
3504 (Lisp_Object vector
, Lisp_Object describer
)
3506 int count
= SPECPDL_INDEX ();
3507 if (NILP (describer
))
3508 describer
= intern ("princ");
3509 specbind (Qstandard_output
, Fcurrent_buffer ());
3510 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3511 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3512 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3514 return unbind_to (count
, Qnil
);
3517 /* Insert in the current buffer a description of the contents of VECTOR.
3518 We call ELT_DESCRIBER to insert the description of one value found
3521 ELT_PREFIX describes what "comes before" the keys or indices defined
3522 by this vector. This is a human-readable string whose size
3523 is not necessarily related to the situation.
3525 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3526 leads to this keymap.
3528 If the vector is a chartable, ELT_PREFIX is the vector
3529 of bytes that lead to the character set or portion of a character
3530 set described by this chartable.
3532 If PARTIAL is nonzero, it means do not mention suppressed commands
3533 (that assumes the vector is in a keymap).
3535 SHADOW is a list of keymaps that shadow this map.
3536 If it is non-nil, then we look up the key in those maps
3537 and we don't mention it now if it is defined by any of them.
3539 ENTIRE_MAP is the keymap in which this vector appears.
3540 If the definition in effect in the whole map does not match
3541 the one in this vector, we ignore this one.
3543 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3545 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3548 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3550 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3553 describe_vector (Lisp_Object vector
, Lisp_Object prefix
, Lisp_Object args
,
3554 void (*elt_describer
) (Lisp_Object
, Lisp_Object
),
3555 int partial
, Lisp_Object shadow
, Lisp_Object entire_map
,
3556 int *indices
, int char_table_depth
, int keymap_p
,
3559 Lisp_Object definition
;
3561 Lisp_Object elt_prefix
= Qnil
;
3563 Lisp_Object suppress
;
3566 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3567 /* Range of elements to be handled. */
3569 Lisp_Object character
;
3578 /* Call Fkey_description first, to avoid GC bug for the other string. */
3579 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3582 tem
= Fkey_description (prefix
, Qnil
);
3583 elt_prefix
= concat2 (tem
, build_string (" "));
3588 /* This vector gets used to present single keys to Flookup_key. Since
3589 that is done once per vector element, we don't want to cons up a
3590 fresh vector every time. */
3591 kludge
= Fmake_vector (make_number (1), Qnil
);
3592 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3595 suppress
= intern ("suppress-keymap");
3598 if (CHAR_TABLE_P (vector
))
3599 stop
= MAX_5_BYTE_CHAR
+ 1, to
= MAX_CHAR
+ 1;
3601 stop
= to
= XVECTOR (vector
)->size
;
3603 for (i
= from
; ; i
++)
3605 int this_shadowed
= 0;
3606 int range_beg
, range_end
;
3620 if (CHAR_TABLE_P (vector
))
3624 val
= char_table_ref_and_range (vector
, range_beg
, &range_beg
, &i
);
3627 val
= AREF (vector
, i
);
3628 definition
= get_keyelt (val
, 0);
3630 if (NILP (definition
)) continue;
3632 /* Don't mention suppressed commands. */
3633 if (SYMBOLP (definition
) && partial
)
3637 tem
= Fget (definition
, suppress
);
3639 if (!NILP (tem
)) continue;
3642 character
= make_number (starting_i
);
3643 ASET (kludge
, 0, character
);
3645 /* If this binding is shadowed by some other map, ignore it. */
3650 tem
= shadow_lookup (shadow
, kludge
, Qt
, 0);
3661 /* Ignore this definition if it is shadowed by an earlier
3662 one in the same keymap. */
3663 if (!NILP (entire_map
))
3667 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3669 if (!EQ (tem
, definition
))
3679 /* Output the prefix that applies to every entry in this map. */
3680 if (!NILP (elt_prefix
))
3681 insert1 (elt_prefix
);
3683 insert1 (Fkey_description (kludge
, prefix
));
3685 /* Find all consecutive characters or rows that have the same
3686 definition. But, VECTOR is a char-table, we had better put a
3687 boundary between normal characters (-#x3FFF7F) and 8-bit
3688 characters (#x3FFF80-). */
3689 if (CHAR_TABLE_P (vector
))
3692 && (range_beg
= i
+ 1, range_end
= stop
- 1,
3693 val
= char_table_ref_and_range (vector
, range_beg
,
3694 &range_beg
, &range_end
),
3695 tem2
= get_keyelt (val
, 0),
3697 && !NILP (Fequal (tem2
, definition
)))
3702 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3704 && !NILP (Fequal (tem2
, definition
)))
3707 /* If we have a range of more than one character,
3708 print where the range reaches to. */
3710 if (i
!= starting_i
)
3714 ASET (kludge
, 0, make_number (i
));
3716 if (!NILP (elt_prefix
))
3717 insert1 (elt_prefix
);
3719 insert1 (Fkey_description (kludge
, prefix
));
3722 /* Print a description of the definition of this character.
3723 elt_describer will take care of spacing out far enough
3724 for alignment purposes. */
3725 (*elt_describer
) (definition
, args
);
3730 insert_string (" (binding currently shadowed)");
3735 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3737 if (!NILP (elt_prefix
))
3738 insert1 (elt_prefix
);
3739 insert ("default", 7);
3740 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3746 /* Apropos - finding all symbols whose names match a regexp. */
3747 static Lisp_Object apropos_predicate
;
3748 static Lisp_Object apropos_accumulate
;
3751 apropos_accum (Lisp_Object symbol
, Lisp_Object string
)
3753 register Lisp_Object tem
;
3755 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3756 if (!NILP (tem
) && !NILP (apropos_predicate
))
3757 tem
= call1 (apropos_predicate
, symbol
);
3759 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3762 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3763 doc
: /* Show all symbols whose names contain match for REGEXP.
3764 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3765 for each symbol and a symbol is mentioned only if that returns non-nil.
3766 Return list of symbols found. */)
3767 (Lisp_Object regexp
, Lisp_Object predicate
)
3770 CHECK_STRING (regexp
);
3771 apropos_predicate
= predicate
;
3772 apropos_accumulate
= Qnil
;
3773 map_obarray (Vobarray
, apropos_accum
, regexp
);
3774 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3775 apropos_accumulate
= Qnil
;
3776 apropos_predicate
= Qnil
;
3781 syms_of_keymap (void)
3783 Qkeymap
= intern_c_string ("keymap");
3784 staticpro (&Qkeymap
);
3785 staticpro (&apropos_predicate
);
3786 staticpro (&apropos_accumulate
);
3787 apropos_predicate
= Qnil
;
3788 apropos_accumulate
= Qnil
;
3790 Qkeymap_canonicalize
= intern_c_string ("keymap-canonicalize");
3791 staticpro (&Qkeymap_canonicalize
);
3793 /* Now we are ready to set up this property, so we can
3794 create char tables. */
3795 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3797 /* Initialize the keymaps standardly used.
3798 Each one is the value of a Lisp variable, and is also
3799 pointed to by a C variable */
3801 global_map
= Fmake_keymap (Qnil
);
3802 Fset (intern_c_string ("global-map"), global_map
);
3804 current_global_map
= global_map
;
3805 staticpro (&global_map
);
3806 staticpro (¤t_global_map
);
3808 meta_map
= Fmake_keymap (Qnil
);
3809 Fset (intern_c_string ("esc-map"), meta_map
);
3810 Ffset (intern_c_string ("ESC-prefix"), meta_map
);
3812 control_x_map
= Fmake_keymap (Qnil
);
3813 Fset (intern_c_string ("ctl-x-map"), control_x_map
);
3814 Ffset (intern_c_string ("Control-X-prefix"), control_x_map
);
3817 = pure_cons (pure_cons (make_pure_c_string ("DEL"), make_pure_c_string ("\\d")),
3818 pure_cons (pure_cons (make_pure_c_string ("TAB"), make_pure_c_string ("\\t")),
3819 pure_cons (pure_cons (make_pure_c_string ("RET"), make_pure_c_string ("\\r")),
3820 pure_cons (pure_cons (make_pure_c_string ("ESC"), make_pure_c_string ("\\e")),
3821 pure_cons (pure_cons (make_pure_c_string ("SPC"), make_pure_c_string (" ")),
3823 staticpro (&exclude_keys
);
3825 DEFVAR_LISP ("define-key-rebound-commands", Vdefine_key_rebound_commands
,
3826 doc
: /* List of commands given new key bindings recently.
3827 This is used for internal purposes during Emacs startup;
3828 don't alter it yourself. */);
3829 Vdefine_key_rebound_commands
= Qt
;
3831 DEFVAR_LISP ("minibuffer-local-map", Vminibuffer_local_map
,
3832 doc
: /* Default keymap to use when reading from the minibuffer. */);
3833 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3835 DEFVAR_LISP ("minibuffer-local-ns-map", Vminibuffer_local_ns_map
,
3836 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3837 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3838 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3840 DEFVAR_LISP ("minibuffer-local-completion-map", Vminibuffer_local_completion_map
,
3841 doc
: /* Local keymap for minibuffer input with completion. */);
3842 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3843 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3845 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3846 Vminibuffer_local_filename_completion_map
,
3847 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3848 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3849 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3850 Vminibuffer_local_completion_map
);
3853 DEFVAR_LISP ("minibuffer-local-must-match-map", Vminibuffer_local_must_match_map
,
3854 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3855 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3856 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3857 Vminibuffer_local_completion_map
);
3859 DEFVAR_LISP ("minibuffer-local-filename-must-match-map",
3860 Vminibuffer_local_filename_must_match_map
,
3861 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3862 Vminibuffer_local_filename_must_match_map
= Fmake_sparse_keymap (Qnil
);
3863 Fset_keymap_parent (Vminibuffer_local_filename_must_match_map
,
3864 Vminibuffer_local_must_match_map
);
3866 DEFVAR_LISP ("minor-mode-map-alist", Vminor_mode_map_alist
,
3867 doc
: /* Alist of keymaps to use for minor modes.
3868 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3869 key sequences and look up bindings if VARIABLE's value is non-nil.
3870 If two active keymaps bind the same key, the keymap appearing earlier
3871 in the list takes precedence. */);
3872 Vminor_mode_map_alist
= Qnil
;
3874 DEFVAR_LISP ("minor-mode-overriding-map-alist", Vminor_mode_overriding_map_alist
,
3875 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3876 This variable is an alist just like `minor-mode-map-alist', and it is
3877 used the same way (and before `minor-mode-map-alist'); however,
3878 it is provided for major modes to bind locally. */);
3879 Vminor_mode_overriding_map_alist
= Qnil
;
3881 DEFVAR_LISP ("emulation-mode-map-alists", Vemulation_mode_map_alists
,
3882 doc
: /* List of keymap alists to use for emulations modes.
3883 It is intended for modes or packages using multiple minor-mode keymaps.
3884 Each element is a keymap alist just like `minor-mode-map-alist', or a
3885 symbol with a variable binding which is a keymap alist, and it is used
3886 the same way. The "active" keymaps in each alist are used before
3887 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3888 Vemulation_mode_map_alists
= Qnil
;
3890 DEFVAR_LISP ("where-is-preferred-modifier", Vwhere_is_preferred_modifier
,
3891 doc
: /* Preferred modifier to use for `where-is'.
3892 When a single binding is requested, `where-is' will return one that
3893 uses this modifier if possible. If nil, or if no such binding exists,
3894 bindings using keys without modifiers (or only with meta) will be
3896 Vwhere_is_preferred_modifier
= Qnil
;
3897 where_is_preferred_modifier
= 0;
3899 staticpro (&Vmouse_events
);
3900 Vmouse_events
= pure_cons (intern_c_string ("menu-bar"),
3901 pure_cons (intern_c_string ("tool-bar"),
3902 pure_cons (intern_c_string ("header-line"),
3903 pure_cons (intern_c_string ("mode-line"),
3904 pure_cons (intern_c_string ("mouse-1"),
3905 pure_cons (intern_c_string ("mouse-2"),
3906 pure_cons (intern_c_string ("mouse-3"),
3907 pure_cons (intern_c_string ("mouse-4"),
3908 pure_cons (intern_c_string ("mouse-5"),
3912 Qsingle_key_description
= intern_c_string ("single-key-description");
3913 staticpro (&Qsingle_key_description
);
3915 Qkey_description
= intern_c_string ("key-description");
3916 staticpro (&Qkey_description
);
3918 Qkeymapp
= intern_c_string ("keymapp");
3919 staticpro (&Qkeymapp
);
3921 Qnon_ascii
= intern_c_string ("non-ascii");
3922 staticpro (&Qnon_ascii
);
3924 Qmenu_item
= intern_c_string ("menu-item");
3925 staticpro (&Qmenu_item
);
3927 Qremap
= intern_c_string ("remap");
3928 staticpro (&Qremap
);
3930 QCadvertised_binding
= intern_c_string (":advertised-binding");
3931 staticpro (&QCadvertised_binding
);
3933 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3934 staticpro (&command_remapping_vector
);
3936 where_is_cache_keymaps
= Qt
;
3937 where_is_cache
= Qnil
;
3938 staticpro (&where_is_cache
);
3939 staticpro (&where_is_cache_keymaps
);
3941 defsubr (&Skeymapp
);
3942 defsubr (&Skeymap_parent
);
3943 defsubr (&Skeymap_prompt
);
3944 defsubr (&Sset_keymap_parent
);
3945 defsubr (&Smake_keymap
);
3946 defsubr (&Smake_sparse_keymap
);
3947 defsubr (&Smap_keymap_internal
);
3948 defsubr (&Smap_keymap
);
3949 defsubr (&Scopy_keymap
);
3950 defsubr (&Scommand_remapping
);
3951 defsubr (&Skey_binding
);
3952 defsubr (&Slocal_key_binding
);
3953 defsubr (&Sglobal_key_binding
);
3954 defsubr (&Sminor_mode_key_binding
);
3955 defsubr (&Sdefine_key
);
3956 defsubr (&Slookup_key
);
3957 defsubr (&Sdefine_prefix_command
);
3958 defsubr (&Suse_global_map
);
3959 defsubr (&Suse_local_map
);
3960 defsubr (&Scurrent_local_map
);
3961 defsubr (&Scurrent_global_map
);
3962 defsubr (&Scurrent_minor_mode_maps
);
3963 defsubr (&Scurrent_active_maps
);
3964 defsubr (&Saccessible_keymaps
);
3965 defsubr (&Skey_description
);
3966 defsubr (&Sdescribe_vector
);
3967 defsubr (&Ssingle_key_description
);
3968 defsubr (&Stext_char_description
);
3969 defsubr (&Swhere_is_internal
);
3970 defsubr (&Sdescribe_buffer_bindings
);
3971 defsubr (&Sapropos_internal
);
3975 keys_of_keymap (void)
3977 initial_define_key (global_map
, 033, "ESC-prefix");
3978 initial_define_key (global_map
, Ctl ('X'), "Control-X-prefix");