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 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 2, or (at your option)
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; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
34 #include "termhooks.h"
35 #include "blockinput.h"
37 #include "intervals.h"
41 /* The number of elements in keymap vectors. */
42 #define DENSE_TABLE_SIZE (0200)
44 /* Actually allocate storage for these variables */
46 Lisp_Object current_global_map
; /* Current global keymap */
48 Lisp_Object global_map
; /* default global key bindings */
50 Lisp_Object meta_map
; /* The keymap used for globally bound
51 ESC-prefixed default commands */
53 Lisp_Object control_x_map
; /* The keymap used for globally bound
54 C-x-prefixed default commands */
56 /* was MinibufLocalMap */
57 Lisp_Object Vminibuffer_local_map
;
58 /* The keymap used by the minibuf for local
59 bindings when spaces are allowed in the
62 /* was MinibufLocalNSMap */
63 Lisp_Object Vminibuffer_local_ns_map
;
64 /* The keymap used by the minibuf for local
65 bindings when spaces are not encouraged
68 /* keymap used for minibuffers when doing completion */
69 /* was MinibufLocalCompletionMap */
70 Lisp_Object Vminibuffer_local_completion_map
;
72 /* keymap used for minibuffers when doing completion in filenames */
73 Lisp_Object Vminibuffer_local_filename_completion_map
;
75 /* keymap used for minibuffers when doing completion in filenames
77 Lisp_Object Vminibuffer_local_must_match_filename_map
;
79 /* keymap used for minibuffers when doing completion and require a match */
80 /* was MinibufLocalMustMatchMap */
81 Lisp_Object Vminibuffer_local_must_match_map
;
83 /* Alist of minor mode variables and keymaps. */
84 Lisp_Object Vminor_mode_map_alist
;
86 /* Alist of major-mode-specific overrides for
87 minor mode variables and keymaps. */
88 Lisp_Object Vminor_mode_overriding_map_alist
;
90 /* List of emulation mode keymap alists. */
91 Lisp_Object Vemulation_mode_map_alists
;
93 /* Keymap mapping ASCII function key sequences onto their preferred forms.
94 Initialized by the terminal-specific lisp files. See DEFVAR for more
96 Lisp_Object Vfunction_key_map
;
98 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
99 Lisp_Object Vkey_translation_map
;
101 /* A list of all commands given new bindings since a certain time
102 when nil was stored here.
103 This is used to speed up recomputation of menu key equivalents
104 when Emacs starts up. t means don't record anything here. */
105 Lisp_Object Vdefine_key_rebound_commands
;
107 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
109 /* Alist of elements like (DEL . "\d"). */
110 static Lisp_Object exclude_keys
;
112 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
113 static Lisp_Object command_remapping_vector
;
115 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
116 in a string key sequence is equivalent to prefixing with this
118 extern Lisp_Object meta_prefix_char
;
120 extern Lisp_Object Voverriding_local_map
;
122 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
123 static Lisp_Object where_is_cache
;
124 /* Which keymaps are reverse-stored in the cache. */
125 static Lisp_Object where_is_cache_keymaps
;
127 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
128 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
130 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
131 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
132 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
133 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
134 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
135 int, Lisp_Object
, Lisp_Object
*, int, int));
136 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
137 void (*) (Lisp_Object
, Lisp_Object
), int,
138 Lisp_Object
, Lisp_Object
, int *,
140 static void silly_event_symbol_error
P_ ((Lisp_Object
));
142 /* Keymap object support - constructors and predicates. */
144 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
145 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
146 CHARTABLE is a char-table that holds the bindings for all characters
147 without modifiers. All entries in it are initially nil, meaning
148 "command undefined". ALIST is an assoc-list which holds bindings for
149 function keys, mouse events, and any other things that appear in the
150 input stream. Initially, ALIST is nil.
152 The optional arg STRING supplies a menu name for the keymap
153 in case you use it as a menu with `x-popup-menu'. */)
159 tail
= Fcons (string
, Qnil
);
162 return Fcons (Qkeymap
,
163 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
166 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
167 doc
: /* Construct and return a new sparse keymap.
168 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
169 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
170 which binds the function key or mouse event SYMBOL to DEFINITION.
171 Initially the alist is nil.
173 The optional arg STRING supplies a menu name for the keymap
174 in case you use it as a menu with `x-popup-menu'. */)
179 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
180 return Fcons (Qkeymap
, Qnil
);
183 /* This function is used for installing the standard key bindings
184 at initialization time.
188 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
191 initial_define_key (keymap
, key
, defname
)
196 store_in_keymap (keymap
, make_number (key
), intern (defname
));
200 initial_define_lispy_key (keymap
, keyname
, defname
)
205 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
208 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
209 doc
: /* Return t if OBJECT is a keymap.
211 A keymap is a list (keymap . ALIST),
212 or a symbol whose function definition is itself a keymap.
213 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
214 a vector of densely packed bindings for small character codes
215 is also allowed as an element. */)
219 return (KEYMAPP (object
) ? Qt
: Qnil
);
222 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
223 doc
: /* Return the prompt-string of a keymap MAP.
224 If non-nil, the prompt is shown in the echo-area
225 when reading a key-sequence to be looked-up in this keymap. */)
229 map
= get_keymap (map
, 0, 0);
232 Lisp_Object tem
= XCAR (map
);
240 /* Check that OBJECT is a keymap (after dereferencing through any
241 symbols). If it is, return it.
243 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
244 is an autoload form, do the autoload and try again.
245 If AUTOLOAD is nonzero, callers must assume GC is possible.
247 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
248 is zero as well), return Qt.
250 ERROR controls how we respond if OBJECT isn't a keymap.
251 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
253 Note that most of the time, we don't want to pursue autoloads.
254 Functions like Faccessible_keymaps which scan entire keymap trees
255 shouldn't load every autoloaded keymap. I'm not sure about this,
256 but it seems to me that only read_key_sequence, Flookup_key, and
257 Fdefine_key should cause keymaps to be autoloaded.
259 This function can GC when AUTOLOAD is non-zero, because it calls
260 do_autoload which can GC. */
263 get_keymap (object
, error
, autoload
)
272 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
275 tem
= indirect_function (object
);
278 if (EQ (XCAR (tem
), Qkeymap
))
281 /* Should we do an autoload? Autoload forms for keymaps have
282 Qkeymap as their fifth element. */
283 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
288 tail
= Fnth (make_number (4), tem
);
289 if (EQ (tail
, Qkeymap
))
293 struct gcpro gcpro1
, gcpro2
;
295 GCPRO2 (tem
, object
);
296 do_autoload (tem
, object
);
309 wrong_type_argument (Qkeymapp
, object
);
313 /* Return the parent map of KEYMAP, or nil if it has none.
314 We assume that KEYMAP is a valid keymap. */
317 keymap_parent (keymap
, autoload
)
323 keymap
= get_keymap (keymap
, 1, autoload
);
325 /* Skip past the initial element `keymap'. */
326 list
= XCDR (keymap
);
327 for (; CONSP (list
); list
= XCDR (list
))
329 /* See if there is another `keymap'. */
334 return get_keymap (list
, 0, autoload
);
337 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
338 doc
: /* Return the parent keymap of KEYMAP. */)
342 return keymap_parent (keymap
, 1);
345 /* Check whether MAP is one of MAPS parents. */
347 keymap_memberp (map
, maps
)
348 Lisp_Object map
, maps
;
350 if (NILP (map
)) return 0;
351 while (KEYMAPP (maps
) && !EQ (map
, maps
))
352 maps
= keymap_parent (maps
, 0);
353 return (EQ (map
, maps
));
356 /* Set the parent keymap of MAP to PARENT. */
358 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
359 doc
: /* Modify KEYMAP to set its parent map to PARENT.
360 Return PARENT. PARENT should be nil or another keymap. */)
362 Lisp_Object keymap
, parent
;
364 Lisp_Object list
, prev
;
365 struct gcpro gcpro1
, gcpro2
;
368 /* Force a keymap flush for the next call to where-is.
369 Since this can be called from within where-is, we don't set where_is_cache
370 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
371 be changed during where-is, while where_is_cache_keymaps is only used at
372 the very beginning of where-is and can thus be changed here without any
374 This is a very minor correctness (rather than safety) issue. */
375 where_is_cache_keymaps
= Qt
;
377 GCPRO2 (keymap
, parent
);
378 keymap
= get_keymap (keymap
, 1, 1);
382 parent
= get_keymap (parent
, 1, 1);
384 /* Check for cycles. */
385 if (keymap_memberp (keymap
, parent
))
386 error ("Cyclic keymap inheritance");
389 /* Skip past the initial element `keymap'. */
394 /* If there is a parent keymap here, replace it.
395 If we came to the end, add the parent in PREV. */
396 if (!CONSP (list
) || KEYMAPP (list
))
398 /* If we already have the right parent, return now
399 so that we avoid the loops below. */
400 if (EQ (XCDR (prev
), parent
))
401 RETURN_UNGCPRO (parent
);
404 XSETCDR (prev
, parent
);
410 /* Scan through for submaps, and set their parents too. */
412 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
414 /* Stop the scan when we come to the parent. */
415 if (EQ (XCAR (list
), Qkeymap
))
418 /* If this element holds a prefix map, deal with it. */
419 if (CONSP (XCAR (list
))
420 && CONSP (XCDR (XCAR (list
))))
421 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
424 if (VECTORP (XCAR (list
)))
425 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
426 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
427 fix_submap_inheritance (keymap
, make_number (i
),
428 XVECTOR (XCAR (list
))->contents
[i
]);
430 if (CHAR_TABLE_P (XCAR (list
)))
432 Lisp_Object indices
[3];
434 map_char_table (fix_submap_inheritance
, Qnil
,
435 XCAR (list
), XCAR (list
),
440 RETURN_UNGCPRO (parent
);
443 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
444 if EVENT is also a prefix in MAP's parent,
445 make sure that SUBMAP inherits that definition as its own parent. */
448 fix_submap_inheritance (map
, event
, submap
)
449 Lisp_Object map
, event
, submap
;
451 Lisp_Object map_parent
, parent_entry
;
453 /* SUBMAP is a cons that we found as a key binding.
454 Discard the other things found in a menu key binding. */
456 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
458 /* If it isn't a keymap now, there's no work to do. */
462 map_parent
= keymap_parent (map
, 0);
463 if (!NILP (map_parent
))
465 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
469 /* If MAP's parent has something other than a keymap,
470 our own submap shadows it completely. */
471 if (!CONSP (parent_entry
))
474 if (! EQ (parent_entry
, submap
))
476 Lisp_Object submap_parent
;
477 submap_parent
= submap
;
482 tem
= keymap_parent (submap_parent
, 0);
486 if (keymap_memberp (tem
, parent_entry
))
487 /* Fset_keymap_parent could create a cycle. */
494 Fset_keymap_parent (submap_parent
, parent_entry
);
498 /* Look up IDX in MAP. IDX may be any sort of event.
499 Note that this does only one level of lookup; IDX must be a single
500 event, not a sequence.
502 If T_OK is non-zero, bindings for Qt are treated as default
503 bindings; any key left unmentioned by other tables and bindings is
504 given the binding of Qt.
506 If T_OK is zero, bindings for Qt are not treated specially.
508 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
511 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
520 /* Qunbound in VAL means we have found no binding yet. */
523 /* If idx is a list (some sort of mouse click, perhaps?),
524 the index we want to use is the car of the list, which
525 ought to be a symbol. */
526 idx
= EVENT_HEAD (idx
);
528 /* If idx is a symbol, it might have modifiers, which need to
529 be put in the canonical order. */
531 idx
= reorder_modifiers (idx
);
532 else if (INTEGERP (idx
))
533 /* Clobber the high bits that can be present on a machine
534 with more than 24 bits of integer. */
535 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
537 /* Handle the special meta -> esc mapping. */
538 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
540 /* See if there is a meta-map. If there's none, there is
541 no binding for IDX, unless a default binding exists in MAP. */
543 Lisp_Object meta_map
;
545 /* A strange value in which Meta is set would cause
546 infinite recursion. Protect against that. */
547 if (XINT (meta_prefix_char
) & CHAR_META
)
548 meta_prefix_char
= make_number (27);
549 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
550 t_ok
, noinherit
, autoload
),
553 if (CONSP (meta_map
))
556 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
559 /* Set IDX to t, so that we only find a default binding. */
562 /* We know there is no binding. */
566 /* t_binding is where we put a default binding that applies,
567 to use in case we do not find a binding specifically
568 for this key sequence. */
571 Lisp_Object t_binding
= Qnil
;
572 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
574 GCPRO4 (map
, tail
, idx
, t_binding
);
576 /* If `t_ok' is 2, both `t' and generic-char bindings are accepted.
577 If it is 1, only generic-char bindings are accepted.
578 Otherwise, neither are. */
581 for (tail
= XCDR (map
);
583 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
588 binding
= XCAR (tail
);
589 if (SYMBOLP (binding
))
591 /* If NOINHERIT, stop finding prefix definitions
592 after we pass a second occurrence of the `keymap' symbol. */
593 if (noinherit
&& EQ (binding
, Qkeymap
))
594 RETURN_UNGCPRO (Qnil
);
596 else if (CONSP (binding
))
598 Lisp_Object key
= XCAR (binding
);
601 val
= XCDR (binding
);
604 && (XINT (idx
) & CHAR_MODIFIER_MASK
) == 0
606 && (XINT (key
) & CHAR_MODIFIER_MASK
) == 0
607 && !SINGLE_BYTE_CHAR_P (XINT (idx
))
608 && !SINGLE_BYTE_CHAR_P (XINT (key
))
609 && CHAR_VALID_P (XINT (key
), 1)
610 && !CHAR_VALID_P (XINT (key
), 0)
611 && (CHAR_CHARSET (XINT (key
))
612 == CHAR_CHARSET (XINT (idx
))))
614 /* KEY is the generic character of the charset of IDX.
615 Use KEY's binding if there isn't a binding for IDX
617 t_binding
= XCDR (binding
);
620 else if (t_ok
> 1 && EQ (key
, Qt
))
622 t_binding
= XCDR (binding
);
626 else if (VECTORP (binding
))
628 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
629 val
= AREF (binding
, XFASTINT (idx
));
631 else if (CHAR_TABLE_P (binding
))
633 /* Character codes with modifiers
634 are not included in a char-table.
635 All character codes without modifiers are included. */
636 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
638 val
= Faref (binding
, idx
);
639 /* `nil' has a special meaning for char-tables, so
640 we use something else to record an explicitly
647 /* If we found a binding, clean it up and return it. */
648 if (!EQ (val
, Qunbound
))
651 /* A Qt binding is just like an explicit nil binding
652 (i.e. it shadows any parent binding but not bindings in
653 keymaps of lower precedence). */
655 val
= get_keyelt (val
, autoload
);
657 fix_submap_inheritance (map
, idx
, val
);
658 RETURN_UNGCPRO (val
);
663 return get_keyelt (t_binding
, autoload
);
668 map_keymap_item (fun
, args
, key
, val
, data
)
669 map_keymap_function_t fun
;
670 Lisp_Object args
, key
, val
;
673 /* We should maybe try to detect bindings shadowed by previous
674 ones and things like that. */
677 (*fun
) (key
, val
, args
, data
);
681 map_keymap_char_table_item (args
, key
, val
)
682 Lisp_Object args
, key
, val
;
686 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
688 map_keymap_item (fun
, XCDR (args
), key
, val
,
689 XSAVE_VALUE (XCAR (args
))->pointer
);
693 /* Call FUN for every binding in MAP.
694 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA).
695 AUTOLOAD if non-zero means that we can autoload keymaps if necessary. */
697 map_keymap (map
, fun
, args
, data
, autoload
)
698 map_keymap_function_t fun
;
699 Lisp_Object map
, args
;
703 struct gcpro gcpro1
, gcpro2
, gcpro3
;
707 GCPRO3 (map
, args
, tail
);
708 map
= get_keymap (map
, 1, autoload
);
709 for (tail
= (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
710 CONSP (tail
) || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
));
713 Lisp_Object binding
= XCAR (tail
);
716 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
717 else if (VECTORP (binding
))
719 /* Loop over the char values represented in the vector. */
720 int len
= ASIZE (binding
);
722 for (c
= 0; c
< len
; c
++)
724 Lisp_Object character
;
725 XSETFASTINT (character
, c
);
726 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
729 else if (CHAR_TABLE_P (binding
))
731 Lisp_Object indices
[3];
732 map_char_table (map_keymap_char_table_item
, Qnil
, binding
, binding
,
733 Fcons (make_save_value (fun
, 0),
734 Fcons (make_save_value (data
, 0),
743 map_keymap_call (key
, val
, fun
, dummy
)
744 Lisp_Object key
, val
, fun
;
747 call2 (fun
, key
, val
);
750 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
751 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
752 FUNCTION is called with two arguments: the event that is bound, and
753 the definition it is bound to. If the event is an integer, it may be
754 a generic character (see Info node `(elisp)Splitting Characters'), and
755 that means that all actual character events belonging to that generic
756 character are bound to the definition.
758 If KEYMAP has a parent, the parent's bindings are included as well.
759 This works recursively: if the parent has itself a parent, then the
760 grandparent's bindings are also included and so on.
761 usage: (map-keymap FUNCTION KEYMAP) */)
762 (function
, keymap
, sort_first
)
763 Lisp_Object function
, keymap
, sort_first
;
765 if (INTEGERP (function
))
766 /* We have to stop integers early since map_keymap gives them special
768 xsignal1 (Qinvalid_function
, function
);
769 if (! NILP (sort_first
))
770 return call3 (intern ("map-keymap-internal"), function
, keymap
, Qt
);
772 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
776 /* Given OBJECT which was found in a slot in a keymap,
777 trace indirect definitions to get the actual definition of that slot.
778 An indirect definition is a list of the form
779 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
780 and INDEX is the object to look up in KEYMAP to yield the definition.
782 Also if OBJECT has a menu string as the first element,
783 remove that. Also remove a menu help string as second element.
785 If AUTOLOAD is nonzero, load autoloadable keymaps
786 that are referred to with indirection.
788 This can GC because menu_item_eval_property calls Feval. */
791 get_keyelt (object
, autoload
)
797 if (!(CONSP (object
)))
798 /* This is really the value. */
801 /* If the keymap contents looks like (keymap ...) or (lambda ...)
803 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
806 /* If the keymap contents looks like (menu-item name . DEFN)
807 or (menu-item name DEFN ...) then use DEFN.
808 This is a new format menu item. */
809 else if (EQ (XCAR (object
), Qmenu_item
))
811 if (CONSP (XCDR (object
)))
815 object
= XCDR (XCDR (object
));
818 object
= XCAR (object
);
820 /* If there's a `:filter FILTER', apply FILTER to the
821 menu-item's definition to get the real definition to
823 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
824 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
827 filter
= XCAR (XCDR (tem
));
828 filter
= list2 (filter
, list2 (Qquote
, object
));
829 object
= menu_item_eval_property (filter
);
834 /* Invalid keymap. */
838 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
839 Keymap alist elements like (CHAR MENUSTRING . DEFN)
840 will be used by HierarKey menus. */
841 else if (STRINGP (XCAR (object
)))
843 object
= XCDR (object
);
844 /* Also remove a menu help string, if any,
845 following the menu item name. */
846 if (CONSP (object
) && STRINGP (XCAR (object
)))
847 object
= XCDR (object
);
848 /* Also remove the sublist that caches key equivalences, if any. */
849 if (CONSP (object
) && CONSP (XCAR (object
)))
852 carcar
= XCAR (XCAR (object
));
853 if (NILP (carcar
) || VECTORP (carcar
))
854 object
= XCDR (object
);
858 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
864 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
866 return (!CONSP (map
) ? object
/* Invalid keymap */
867 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
873 store_in_keymap (keymap
, idx
, def
)
875 register Lisp_Object idx
;
878 /* Flush any reverse-map cache. */
879 where_is_cache
= Qnil
;
880 where_is_cache_keymaps
= Qt
;
882 /* If we are preparing to dump, and DEF is a menu element
883 with a menu item indicator, copy it to ensure it is not pure. */
884 if (CONSP (def
) && PURE_P (def
)
885 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
886 def
= Fcons (XCAR (def
), XCDR (def
));
888 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
889 error ("attempt to define a key in a non-keymap");
891 /* If idx is a list (some sort of mouse click, perhaps?),
892 the index we want to use is the car of the list, which
893 ought to be a symbol. */
894 idx
= EVENT_HEAD (idx
);
896 /* If idx is a symbol, it might have modifiers, which need to
897 be put in the canonical order. */
899 idx
= reorder_modifiers (idx
);
900 else if (INTEGERP (idx
))
901 /* Clobber the high bits that can be present on a machine
902 with more than 24 bits of integer. */
903 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
905 /* Scan the keymap for a binding of idx. */
909 /* The cons after which we should insert new bindings. If the
910 keymap has a table element, we record its position here, so new
911 bindings will go after it; this way, the table will stay
912 towards the front of the alist and character lookups in dense
913 keymaps will remain fast. Otherwise, this just points at the
914 front of the keymap. */
915 Lisp_Object insertion_point
;
917 insertion_point
= keymap
;
918 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
925 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
928 ASET (elt
, XFASTINT (idx
), def
);
931 insertion_point
= tail
;
933 else if (CHAR_TABLE_P (elt
))
935 /* Character codes with modifiers
936 are not included in a char-table.
937 All character codes without modifiers are included. */
938 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
941 /* `nil' has a special meaning for char-tables, so
942 we use something else to record an explicitly
944 NILP (def
) ? Qt
: def
);
947 insertion_point
= tail
;
949 else if (CONSP (elt
))
951 if (EQ (idx
, XCAR (elt
)))
958 else if (EQ (elt
, Qkeymap
))
959 /* If we find a 'keymap' symbol in the spine of KEYMAP,
960 then we must have found the start of a second keymap
961 being used as the tail of KEYMAP, and a binding for IDX
962 should be inserted before it. */
969 /* We have scanned the entire keymap, and not found a binding for
970 IDX. Let's add one. */
971 CHECK_IMPURE (insertion_point
);
972 XSETCDR (insertion_point
,
973 Fcons (Fcons (idx
, def
), XCDR (insertion_point
)));
979 EXFUN (Fcopy_keymap
, 1);
982 copy_keymap_item (elt
)
985 Lisp_Object res
, tem
;
992 /* Is this a new format menu item. */
993 if (EQ (XCAR (tem
), Qmenu_item
))
995 /* Copy cell with menu-item marker. */
996 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1000 /* Copy cell with menu-item name. */
1001 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1007 /* Copy cell with binding and if the binding is a keymap,
1009 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1012 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1013 XSETCAR (elt
, Fcopy_keymap (tem
));
1015 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1016 /* Delete cache for key equivalences. */
1017 XSETCDR (elt
, XCDR (tem
));
1022 /* It may be an old fomat menu item.
1023 Skip the optional menu string. */
1024 if (STRINGP (XCAR (tem
)))
1026 /* Copy the cell, since copy-alist didn't go this deep. */
1027 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1029 /* Also skip the optional menu help string. */
1030 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1032 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1036 /* There may also be a list that caches key equivalences.
1037 Just delete it for the new keymap. */
1039 && CONSP (XCAR (tem
))
1040 && (NILP (XCAR (XCAR (tem
)))
1041 || VECTORP (XCAR (XCAR (tem
)))))
1043 XSETCDR (elt
, XCDR (tem
));
1046 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1047 XSETCDR (elt
, Fcopy_keymap (tem
));
1049 else if (EQ (XCAR (tem
), Qkeymap
))
1050 res
= Fcopy_keymap (elt
);
1056 copy_keymap_1 (chartable
, idx
, elt
)
1057 Lisp_Object chartable
, idx
, elt
;
1059 Faset (chartable
, idx
, copy_keymap_item (elt
));
1062 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1063 doc
: /* Return a copy of the keymap KEYMAP.
1064 The copy starts out with the same definitions of KEYMAP,
1065 but changing either the copy or KEYMAP does not affect the other.
1066 Any key definitions that are subkeymaps are recursively copied.
1067 However, a key definition which is a symbol whose definition is a keymap
1072 register Lisp_Object copy
, tail
;
1073 keymap
= get_keymap (keymap
, 1, 0);
1074 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1075 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1077 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1079 Lisp_Object elt
= XCAR (keymap
);
1080 if (CHAR_TABLE_P (elt
))
1082 Lisp_Object indices
[3];
1083 elt
= Fcopy_sequence (elt
);
1084 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, elt
, 0, indices
);
1086 else if (VECTORP (elt
))
1089 elt
= Fcopy_sequence (elt
);
1090 for (i
= 0; i
< ASIZE (elt
); i
++)
1091 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1093 else if (CONSP (elt
))
1094 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1095 XSETCDR (tail
, Fcons (elt
, Qnil
));
1097 keymap
= XCDR (keymap
);
1099 XSETCDR (tail
, keymap
);
1103 /* Simple Keymap mutators and accessors. */
1105 /* GC is possible in this function if it autoloads a keymap. */
1107 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1108 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1111 KEY is a string or a vector of symbols and characters meaning a
1112 sequence of keystrokes and events. Non-ASCII characters with codes
1113 above 127 (such as ISO Latin-1) can be included if you use a vector.
1114 Using [t] for KEY creates a default definition, which applies to any
1115 event type that has no other definition in this keymap.
1117 DEF is anything that can be a key's definition:
1118 nil (means key is undefined in this keymap),
1119 a command (a Lisp function suitable for interactive calling),
1120 a string (treated as a keyboard macro),
1121 a keymap (to define a prefix key),
1122 a symbol (when the key is looked up, the symbol will stand for its
1123 function definition, which should at that time be one of the above,
1124 or another symbol whose function definition is used, etc.),
1125 a cons (STRING . DEFN), meaning that DEFN is the definition
1126 (DEFN should be a valid definition in its own right),
1127 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP.
1129 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1130 binding is altered. If there is no binding for KEY, the new pair
1131 binding KEY to DEF is added at the front of KEYMAP. */)
1138 register Lisp_Object c
;
1139 register Lisp_Object cmd
;
1143 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1145 GCPRO3 (keymap
, key
, def
);
1146 keymap
= get_keymap (keymap
, 1, 1);
1148 CHECK_VECTOR_OR_STRING (key
);
1150 length
= XFASTINT (Flength (key
));
1152 RETURN_UNGCPRO (Qnil
);
1154 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1155 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1157 meta_bit
= VECTORP (key
) ? meta_modifier
: 0x80;
1159 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, 0)))
1160 { /* DEF is apparently an XEmacs-style keyboard macro. */
1161 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1162 int i
= ASIZE (def
);
1165 Lisp_Object c
= AREF (def
, i
);
1166 if (CONSP (c
) && lucid_event_type_list_p (c
))
1167 c
= Fevent_convert_list (c
);
1176 c
= Faref (key
, make_number (idx
));
1178 if (CONSP (c
) && lucid_event_type_list_p (c
))
1179 c
= Fevent_convert_list (c
);
1182 silly_event_symbol_error (c
);
1185 && (XINT (c
) & meta_bit
)
1188 c
= meta_prefix_char
;
1194 XSETINT (c
, XINT (c
) & ~meta_bit
);
1200 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1201 error ("Key sequence contains invalid event");
1204 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1206 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1208 /* If this key is undefined, make it a prefix. */
1210 cmd
= define_as_prefix (keymap
, c
);
1212 keymap
= get_keymap (cmd
, 0, 1);
1213 if (!CONSP (keymap
))
1214 /* We must use Fkey_description rather than just passing key to
1215 error; key might be a vector, not a string. */
1216 error ("Key sequence %s starts with non-prefix key %s",
1217 SDATA (Fkey_description (key
, Qnil
)),
1218 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1224 /* This function may GC (it calls Fkey_binding). */
1226 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 2, 0,
1227 doc
: /* Return the remapping for command COMMAND in current keymaps.
1228 Returns nil if COMMAND is not remapped (or not a symbol).
1230 If the optional argument POSITION is non-nil, it specifies a mouse
1231 position as returned by `event-start' and `event-end', and the
1232 remapping occurs in the keymaps associated with it. It can also be a
1233 number or marker, in which case the keymap properties at the specified
1234 buffer position instead of point are used. */)
1236 Lisp_Object command
, position
;
1238 if (!SYMBOLP (command
))
1241 ASET (command_remapping_vector
, 1, command
);
1242 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
, position
);
1245 /* Value is number if KEY is too long; nil if valid but has no definition. */
1246 /* GC is possible in this function if it autoloads a keymap. */
1248 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1249 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1250 nil means undefined. See doc of `define-key' for kinds of definitions.
1252 A number as value means KEY is "too long";
1253 that is, characters or symbols in it except for the last one
1254 fail to be a valid sequence of prefix characters in KEYMAP.
1255 The number is how many characters at the front of KEY
1256 it takes to reach a non-prefix key.
1258 Normally, `lookup-key' ignores bindings for t, which act as default
1259 bindings, used when nothing else in the keymap applies; this makes it
1260 usable as a general function for probing keymaps. However, if the
1261 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1262 recognize the default bindings, just as `read-key-sequence' does. */)
1263 (keymap
, key
, accept_default
)
1266 Lisp_Object accept_default
;
1269 register Lisp_Object cmd
;
1270 register Lisp_Object c
;
1272 int t_ok
= !NILP (accept_default
);
1273 struct gcpro gcpro1
, gcpro2
;
1275 GCPRO2 (keymap
, key
);
1276 keymap
= get_keymap (keymap
, 1, 1);
1278 CHECK_VECTOR_OR_STRING (key
);
1280 length
= XFASTINT (Flength (key
));
1282 RETURN_UNGCPRO (keymap
);
1287 c
= Faref (key
, make_number (idx
++));
1289 if (CONSP (c
) && lucid_event_type_list_p (c
))
1290 c
= Fevent_convert_list (c
);
1292 /* Turn the 8th bit of string chars into a meta modifier. */
1293 if (INTEGERP (c
) && XINT (c
) & 0x80 && STRINGP (key
))
1294 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1296 /* Allow string since binding for `menu-bar-select-buffer'
1297 includes the buffer name in the key sequence. */
1298 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1299 error ("Key sequence contains invalid event");
1301 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1303 RETURN_UNGCPRO (cmd
);
1305 keymap
= get_keymap (cmd
, 0, 1);
1306 if (!CONSP (keymap
))
1307 RETURN_UNGCPRO (make_number (idx
));
1313 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1314 Assume that currently it does not define C at all.
1315 Return the keymap. */
1318 define_as_prefix (keymap
, c
)
1319 Lisp_Object keymap
, c
;
1323 cmd
= Fmake_sparse_keymap (Qnil
);
1324 /* If this key is defined as a prefix in an inherited keymap,
1325 make it a prefix in this map, and make its definition
1326 inherit the other prefix definition. */
1327 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1328 store_in_keymap (keymap
, c
, cmd
);
1333 /* Append a key to the end of a key sequence. We always make a vector. */
1336 append_key (key_sequence
, key
)
1337 Lisp_Object key_sequence
, key
;
1339 Lisp_Object args
[2];
1341 args
[0] = key_sequence
;
1343 args
[1] = Fcons (key
, Qnil
);
1344 return Fvconcat (2, args
);
1347 /* Given a event type C which is a symbol,
1348 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1351 silly_event_symbol_error (c
)
1354 Lisp_Object parsed
, base
, name
, assoc
;
1357 parsed
= parse_modifiers (c
);
1358 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1359 base
= XCAR (parsed
);
1360 name
= Fsymbol_name (base
);
1361 /* This alist includes elements such as ("RET" . "\\r"). */
1362 assoc
= Fassoc (name
, exclude_keys
);
1366 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1368 Lisp_Object keystring
;
1369 if (modifiers
& alt_modifier
)
1370 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1371 if (modifiers
& ctrl_modifier
)
1372 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1373 if (modifiers
& hyper_modifier
)
1374 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1375 if (modifiers
& meta_modifier
)
1376 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1377 if (modifiers
& shift_modifier
)
1378 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1379 if (modifiers
& super_modifier
)
1380 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1383 c
= reorder_modifiers (c
);
1384 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1386 error ((modifiers
& ~meta_modifier
1387 ? "To bind the key %s, use [?%s], not [%s]"
1388 : "To bind the key %s, use \"%s\", not [%s]"),
1389 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1390 SDATA (SYMBOL_NAME (c
)));
1394 /* Global, local, and minor mode keymap stuff. */
1396 /* We can't put these variables inside current_minor_maps, since under
1397 some systems, static gets macro-defined to be the empty string.
1399 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1400 static int cmm_size
= 0;
1402 /* Store a pointer to an array of the keymaps of the currently active
1403 minor modes in *buf, and return the number of maps it contains.
1405 This function always returns a pointer to the same buffer, and may
1406 free or reallocate it, so if you want to keep it for a long time or
1407 hand it out to lisp code, copy it. This procedure will be called
1408 for every key sequence read, so the nice lispy approach (return a
1409 new assoclist, list, what have you) for each invocation would
1410 result in a lot of consing over time.
1412 If we used xrealloc/xmalloc and ran out of memory, they would throw
1413 back to the command loop, which would try to read a key sequence,
1414 which would call this function again, resulting in an infinite
1415 loop. Instead, we'll use realloc/malloc and silently truncate the
1416 list, let the key sequence be read, and hope some other piece of
1417 code signals the error. */
1419 current_minor_maps (modeptr
, mapptr
)
1420 Lisp_Object
**modeptr
, **mapptr
;
1423 int list_number
= 0;
1424 Lisp_Object alist
, assoc
, var
, val
;
1425 Lisp_Object emulation_alists
;
1426 Lisp_Object lists
[2];
1428 emulation_alists
= Vemulation_mode_map_alists
;
1429 lists
[0] = Vminor_mode_overriding_map_alist
;
1430 lists
[1] = Vminor_mode_map_alist
;
1432 for (list_number
= 0; list_number
< 2; list_number
++)
1434 if (CONSP (emulation_alists
))
1436 alist
= XCAR (emulation_alists
);
1437 emulation_alists
= XCDR (emulation_alists
);
1438 if (SYMBOLP (alist
))
1439 alist
= find_symbol_value (alist
);
1443 alist
= lists
[list_number
];
1445 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1446 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1447 && (var
= XCAR (assoc
), SYMBOLP (var
))
1448 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1453 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1454 and also an entry in Vminor_mode_map_alist,
1455 ignore the latter. */
1456 if (list_number
== 1)
1458 val
= assq_no_quit (var
, lists
[0]);
1465 int newsize
, allocsize
;
1466 Lisp_Object
*newmodes
, *newmaps
;
1468 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1469 allocsize
= newsize
* sizeof *newmodes
;
1471 /* Use malloc here. See the comment above this function.
1472 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1474 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1479 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1482 cmm_modes
= newmodes
;
1485 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1490 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1497 if (newmodes
== NULL
|| newmaps
== NULL
)
1502 /* Get the keymap definition--or nil if it is not defined. */
1503 temp
= Findirect_function (XCDR (assoc
), Qt
);
1507 cmm_maps
[i
] = temp
;
1513 if (modeptr
) *modeptr
= cmm_modes
;
1514 if (mapptr
) *mapptr
= cmm_maps
;
1518 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1520 doc
: /* Return a list of the currently active keymaps.
1521 OLP if non-nil indicates that we should obey `overriding-local-map' and
1522 `overriding-terminal-local-map'. */)
1526 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1530 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1531 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1532 /* The doc said that overriding-terminal-local-map should
1533 override overriding-local-map. The code used them both,
1534 but it seems clearer to use just one. rms, jan 2005. */
1535 else if (!NILP (Voverriding_local_map
))
1536 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1538 if (NILP (XCDR (keymaps
)))
1544 /* This usually returns the buffer's local map,
1545 but that can be overridden by a `local-map' property. */
1546 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1548 keymaps
= Fcons (local
, keymaps
);
1550 /* Now put all the minor mode keymaps on the list. */
1551 nmaps
= current_minor_maps (0, &maps
);
1553 for (i
= --nmaps
; i
>= 0; i
--)
1554 if (!NILP (maps
[i
]))
1555 keymaps
= Fcons (maps
[i
], keymaps
);
1557 /* This returns nil unless there is a `keymap' property. */
1558 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1560 keymaps
= Fcons (local
, keymaps
);
1566 /* GC is possible in this function if it autoloads a keymap. */
1568 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 4, 0,
1569 doc
: /* Return the binding for command KEY in current keymaps.
1570 KEY is a string or vector, a sequence of keystrokes.
1571 The binding is probably a symbol with a function definition.
1573 Normally, `key-binding' ignores bindings for t, which act as default
1574 bindings, used when nothing else in the keymap applies; this makes it
1575 usable as a general function for probing keymaps. However, if the
1576 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1577 recognize the default bindings, just as `read-key-sequence' does.
1579 Like the normal command loop, `key-binding' will remap the command
1580 resulting from looking up KEY by looking up the command in the
1581 current keymaps. However, if the optional third argument NO-REMAP
1582 is non-nil, `key-binding' returns the unmapped command.
1584 If KEY is a key sequence initiated with the mouse, the used keymaps
1585 will depend on the clicked mouse position with regard to the buffer
1586 and possible local keymaps on strings.
1588 If the optional argument POSITION is non-nil, it specifies a mouse
1589 position as returned by `event-start' and `event-end', and the lookup
1590 occurs in the keymaps associated with it instead of KEY. It can also
1591 be a number or marker, in which case the keymap properties at the
1592 specified buffer position instead of point are used.
1594 (key
, accept_default
, no_remap
, position
)
1595 Lisp_Object key
, accept_default
, no_remap
, position
;
1597 Lisp_Object
*maps
, value
;
1599 struct gcpro gcpro1
, gcpro2
;
1600 int count
= SPECPDL_INDEX ();
1602 GCPRO2 (key
, position
);
1604 if (NILP (position
) && VECTORP (key
))
1607 /* mouse events may have a symbolic prefix indicating the
1608 scrollbar or mode line */
1609 = AREF (key
, SYMBOLP (AREF (key
, 0)) && ASIZE (key
) > 1 ? 1 : 0);
1611 /* We are not interested in locations without event data */
1613 if (EVENT_HAS_PARAMETERS (event
))
1615 Lisp_Object kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1616 if (CONSP (XCDR (event
)) && EQ (kind
, Qmouse_click
))
1617 position
= EVENT_START (event
);
1621 /* Key sequences beginning with mouse clicks
1622 are read using the keymaps of the buffer clicked on, not
1623 the current buffer. So we may have to switch the buffer
1626 if (CONSP (position
))
1630 window
= POSN_WINDOW (position
);
1632 if (WINDOWP (window
)
1633 && BUFFERP (XWINDOW (window
)->buffer
)
1634 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1636 /* Arrange to go back to the original buffer once we're done
1637 processing the key sequence. We don't use
1638 save_excursion_{save,restore} here, in analogy to
1639 `read-key-sequence' to avoid saving point. Maybe this
1640 would not be a problem here, but it is easier to keep
1644 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1646 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1650 if (! NILP (current_kboard
->Voverriding_terminal_local_map
))
1652 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1653 key
, accept_default
);
1654 if (! NILP (value
) && !INTEGERP (value
))
1657 else if (! NILP (Voverriding_local_map
))
1659 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1660 if (! NILP (value
) && !INTEGERP (value
))
1665 Lisp_Object keymap
, local_map
;
1668 pt
= INTEGERP (position
) ? XINT (position
)
1669 : MARKERP (position
) ? marker_position (position
)
1672 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1673 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1675 if (CONSP (position
))
1679 /* For a mouse click, get the local text-property keymap
1680 of the place clicked on, rather than point. */
1682 if (POSN_INBUFFER_P (position
))
1686 pos
= POSN_BUFFER_POSN (position
);
1688 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1690 local_map
= get_local_map (XINT (pos
),
1691 current_buffer
, Qlocal_map
);
1693 keymap
= get_local_map (XINT (pos
),
1694 current_buffer
, Qkeymap
);
1698 /* If on a mode line string with a local keymap,
1699 or for a click on a string, i.e. overlay string or a
1700 string displayed via the `display' property,
1701 consider `local-map' and `keymap' properties of
1704 if (string
= POSN_STRING (position
),
1705 (CONSP (string
) && STRINGP (XCAR (string
))))
1707 Lisp_Object pos
, map
;
1709 pos
= XCDR (string
);
1710 string
= XCAR (string
);
1713 && XINT (pos
) < SCHARS (string
))
1715 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1719 map
= Fget_text_property (pos
, Qkeymap
, string
);
1727 if (! NILP (keymap
))
1729 value
= Flookup_key (keymap
, key
, accept_default
);
1730 if (! NILP (value
) && !INTEGERP (value
))
1734 nmaps
= current_minor_maps (0, &maps
);
1735 /* Note that all these maps are GCPRO'd
1736 in the places where we found them. */
1738 for (i
= 0; i
< nmaps
; i
++)
1739 if (! NILP (maps
[i
]))
1741 value
= Flookup_key (maps
[i
], key
, accept_default
);
1742 if (! NILP (value
) && !INTEGERP (value
))
1746 if (! NILP (local_map
))
1748 value
= Flookup_key (local_map
, key
, accept_default
);
1749 if (! NILP (value
) && !INTEGERP (value
))
1754 value
= Flookup_key (current_global_map
, key
, accept_default
);
1757 unbind_to (count
, Qnil
);
1760 if (NILP (value
) || INTEGERP (value
))
1763 /* If the result of the ordinary keymap lookup is an interactive
1764 command, look for a key binding (ie. remapping) for that command. */
1766 if (NILP (no_remap
) && SYMBOLP (value
))
1769 if (value1
= Fcommand_remapping (value
, position
), !NILP (value1
))
1776 /* GC is possible in this function if it autoloads a keymap. */
1778 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1779 doc
: /* Return the binding for command KEYS in current local keymap only.
1780 KEYS is a string or vector, a sequence of keystrokes.
1781 The binding is probably a symbol with a function definition.
1783 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1784 bindings; see the description of `lookup-key' for more details about this. */)
1785 (keys
, accept_default
)
1786 Lisp_Object keys
, accept_default
;
1788 register Lisp_Object map
;
1789 map
= current_buffer
->keymap
;
1792 return Flookup_key (map
, keys
, accept_default
);
1795 /* GC is possible in this function if it autoloads a keymap. */
1797 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1798 doc
: /* Return the binding for command KEYS in current global keymap only.
1799 KEYS is a string or vector, a sequence of keystrokes.
1800 The binding is probably a symbol with a function definition.
1801 This function's return values are the same as those of `lookup-key'
1804 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1805 bindings; see the description of `lookup-key' for more details about this. */)
1806 (keys
, accept_default
)
1807 Lisp_Object keys
, accept_default
;
1809 return Flookup_key (current_global_map
, keys
, accept_default
);
1812 /* GC is possible in this function if it autoloads a keymap. */
1814 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1815 doc
: /* Find the visible minor mode bindings of KEY.
1816 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1817 the symbol which names the minor mode binding KEY, and BINDING is
1818 KEY's definition in that mode. In particular, if KEY has no
1819 minor-mode bindings, return nil. If the first binding is a
1820 non-prefix, all subsequent bindings will be omitted, since they would
1821 be ignored. Similarly, the list doesn't include non-prefix bindings
1822 that come after prefix bindings.
1824 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1825 bindings; see the description of `lookup-key' for more details about this. */)
1826 (key
, accept_default
)
1827 Lisp_Object key
, accept_default
;
1829 Lisp_Object
*modes
, *maps
;
1831 Lisp_Object binding
;
1833 struct gcpro gcpro1
, gcpro2
;
1835 nmaps
= current_minor_maps (&modes
, &maps
);
1836 /* Note that all these maps are GCPRO'd
1837 in the places where we found them. */
1840 GCPRO2 (key
, binding
);
1842 for (i
= j
= 0; i
< nmaps
; i
++)
1844 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1845 && !INTEGERP (binding
))
1847 if (KEYMAPP (binding
))
1848 maps
[j
++] = Fcons (modes
[i
], binding
);
1850 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1854 return Flist (j
, maps
);
1857 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1858 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1859 A new sparse keymap is stored as COMMAND's function definition and its value.
1860 If a second optional argument MAPVAR is given, the map is stored as
1861 its value instead of as COMMAND's value; but COMMAND is still defined
1863 The third optional argument NAME, if given, supplies a menu name
1864 string for the map. This is required to use the keymap as a menu.
1865 This function returns COMMAND. */)
1866 (command
, mapvar
, name
)
1867 Lisp_Object command
, mapvar
, name
;
1870 map
= Fmake_sparse_keymap (name
);
1871 Ffset (command
, map
);
1875 Fset (command
, map
);
1879 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1880 doc
: /* Select KEYMAP as the global keymap. */)
1884 keymap
= get_keymap (keymap
, 1, 1);
1885 current_global_map
= keymap
;
1890 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1891 doc
: /* Select KEYMAP as the local keymap.
1892 If KEYMAP is nil, that means no local keymap. */)
1897 keymap
= get_keymap (keymap
, 1, 1);
1899 current_buffer
->keymap
= keymap
;
1904 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1905 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1908 return current_buffer
->keymap
;
1911 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1912 doc
: /* Return the current global keymap. */)
1915 return current_global_map
;
1918 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1919 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1923 int nmaps
= current_minor_maps (0, &maps
);
1925 return Flist (nmaps
, maps
);
1928 /* Help functions for describing and documenting keymaps. */
1932 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1933 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1934 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1938 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
1942 /* Look for and break cycles. */
1943 while (!NILP (tem
= Frassq (cmd
, maps
)))
1945 Lisp_Object prefix
= XCAR (tem
);
1946 int lim
= XINT (Flength (XCAR (tem
)));
1947 if (lim
<= XINT (Flength (thisseq
)))
1948 { /* This keymap was already seen with a smaller prefix. */
1950 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
1951 Faref (thisseq
, make_number (i
))))
1954 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1957 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1958 but maybe `cmd' occurs again further down in `maps', so keep
1960 maps
= XCDR (Fmemq (tem
, maps
));
1963 /* If the last key in thisseq is meta-prefix-char,
1964 turn it into a meta-ized keystroke. We know
1965 that the event we're about to append is an
1966 ascii keystroke since we're processing a
1970 int meta_bit
= meta_modifier
;
1971 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1972 tem
= Fcopy_sequence (thisseq
);
1974 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1976 /* This new sequence is the same length as
1977 thisseq, so stick it in the list right
1980 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1984 tem
= append_key (thisseq
, key
);
1985 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1990 accessible_keymaps_char_table (args
, index
, cmd
)
1991 Lisp_Object args
, index
, cmd
;
1993 accessible_keymaps_1 (index
, cmd
,
1997 XINT (XCDR (XCAR (args
))));
2000 /* This function cannot GC. */
2002 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
2004 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
2005 Returns a list of elements of the form (KEYS . MAP), where the sequence
2006 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
2007 so that the KEYS increase in length. The first element is ([] . KEYMAP).
2008 An optional argument PREFIX, if non-nil, should be a key sequence;
2009 then the value includes only maps for prefixes that start with PREFIX. */)
2011 Lisp_Object keymap
, prefix
;
2013 Lisp_Object maps
, tail
;
2016 /* no need for gcpro because we don't autoload any keymaps. */
2019 prefixlen
= XINT (Flength (prefix
));
2023 /* If a prefix was specified, start with the keymap (if any) for
2024 that prefix, so we don't waste time considering other prefixes. */
2026 tem
= Flookup_key (keymap
, prefix
, Qt
);
2027 /* Flookup_key may give us nil, or a number,
2028 if the prefix is not defined in this particular map.
2029 It might even give us a list that isn't a keymap. */
2030 tem
= get_keymap (tem
, 0, 0);
2033 /* Convert PREFIX to a vector now, so that later on
2034 we don't have to deal with the possibility of a string. */
2035 if (STRINGP (prefix
))
2040 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
2041 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
2045 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
2046 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2047 c
^= 0200 | meta_modifier
;
2048 ASET (copy
, i_before
, make_number (c
));
2052 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
2058 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
2059 get_keymap (keymap
, 1, 0)),
2062 /* For each map in the list maps,
2063 look at any other maps it points to,
2064 and stick them at the end if they are not already in the list.
2066 This is a breadth-first traversal, where tail is the queue of
2067 nodes, and maps accumulates a list of all nodes visited. */
2069 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2071 register Lisp_Object thisseq
, thismap
;
2073 /* Does the current sequence end in the meta-prefix-char? */
2076 thisseq
= Fcar (Fcar (tail
));
2077 thismap
= Fcdr (Fcar (tail
));
2078 last
= make_number (XINT (Flength (thisseq
)) - 1);
2079 is_metized
= (XINT (last
) >= 0
2080 /* Don't metize the last char of PREFIX. */
2081 && XINT (last
) >= prefixlen
2082 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
2084 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
2088 elt
= XCAR (thismap
);
2092 if (CHAR_TABLE_P (elt
))
2094 Lisp_Object indices
[3];
2096 map_char_table (accessible_keymaps_char_table
, Qnil
, elt
,
2097 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
2098 Fcons (tail
, thisseq
)),
2101 else if (VECTORP (elt
))
2105 /* Vector keymap. Scan all the elements. */
2106 for (i
= 0; i
< ASIZE (elt
); i
++)
2107 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
2108 maps
, tail
, thisseq
, is_metized
);
2111 else if (CONSP (elt
))
2112 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
2113 maps
, tail
, thisseq
,
2114 is_metized
&& INTEGERP (XCAR (elt
)));
2122 Lisp_Object Qsingle_key_description
, Qkey_description
;
2124 /* This function cannot GC. */
2126 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2127 doc
: /* Return a pretty description of key-sequence KEYS.
2128 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2129 Control characters turn into "C-foo" sequences, meta into "M-foo",
2130 spaces are put between sequence elements, etc. */)
2132 Lisp_Object keys
, prefix
;
2137 int size
= XINT (Flength (keys
));
2139 Lisp_Object sep
= build_string (" ");
2144 size
+= XINT (Flength (prefix
));
2146 /* This has one extra element at the end that we don't pass to Fconcat. */
2147 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2149 /* In effect, this computes
2150 (mapconcat 'single-key-description keys " ")
2151 but we shouldn't use mapconcat because it can do GC. */
2155 list
= prefix
, prefix
= Qnil
;
2156 else if (!NILP (keys
))
2157 list
= keys
, keys
= Qnil
;
2162 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2166 return empty_string
;
2167 return Fconcat (len
- 1, args
);
2171 size
= SCHARS (list
);
2172 else if (VECTORP (list
))
2173 size
= XVECTOR (list
)->size
;
2174 else if (CONSP (list
))
2175 size
= XINT (Flength (list
));
2177 wrong_type_argument (Qarrayp
, list
);
2186 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2187 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2188 c
^= 0200 | meta_modifier
;
2189 XSETFASTINT (key
, c
);
2191 else if (VECTORP (list
))
2193 key
= AREF (list
, i
++);
2205 || EQ (key
, meta_prefix_char
)
2206 || (XINT (key
) & meta_modifier
))
2208 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2210 if (EQ (key
, meta_prefix_char
))
2214 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2217 else if (EQ (key
, meta_prefix_char
))
2222 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2230 push_key_description (c
, p
, force_multibyte
)
2231 register unsigned int c
;
2233 int force_multibyte
;
2238 /* Clear all the meaningless bits above the meta bit. */
2239 c
&= meta_modifier
| ~ - meta_modifier
;
2240 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2241 | meta_modifier
| shift_modifier
| super_modifier
);
2243 valid_p
= SINGLE_BYTE_CHAR_P (c2
) || char_valid_p (c2
, 0);
2246 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2247 p
+= sprintf (p
, "[%d]", c
);
2251 if (c
& alt_modifier
)
2257 if ((c
& ctrl_modifier
) != 0
2258 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2262 c
&= ~ctrl_modifier
;
2264 if (c
& hyper_modifier
)
2268 c
-= hyper_modifier
;
2270 if (c
& meta_modifier
)
2276 if (c
& shift_modifier
)
2280 c
-= shift_modifier
;
2282 if (c
& super_modifier
)
2286 c
-= super_modifier
;
2302 else if (c
== Ctl ('M'))
2310 /* `C-' already added above. */
2311 if (c
> 0 && c
<= Ctl ('Z'))
2330 || (NILP (current_buffer
->enable_multibyte_characters
)
2331 && SINGLE_BYTE_CHAR_P (c
)
2332 && !force_multibyte
))
2338 if (force_multibyte
)
2340 if (SINGLE_BYTE_CHAR_P (c
))
2341 c
= unibyte_char_to_multibyte (c
);
2342 p
+= CHAR_STRING (c
, p
);
2344 else if (NILP (current_buffer
->enable_multibyte_characters
))
2348 /* The biggest character code uses 19 bits. */
2349 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
2351 if (c
>= (1 << bit_offset
))
2352 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
2356 p
+= CHAR_STRING (c
, p
);
2362 /* This function cannot GC. */
2364 DEFUN ("single-key-description", Fsingle_key_description
,
2365 Ssingle_key_description
, 1, 2, 0,
2366 doc
: /* Return a pretty description of command character KEY.
2367 Control characters turn into C-whatever, etc.
2368 Optional argument NO-ANGLES non-nil means don't put angle brackets
2369 around function keys and event symbols. */)
2371 Lisp_Object key
, no_angles
;
2373 if (CONSP (key
) && lucid_event_type_list_p (key
))
2374 key
= Fevent_convert_list (key
);
2376 key
= EVENT_HEAD (key
);
2378 if (INTEGERP (key
)) /* Normal character */
2380 unsigned int charset
, c1
, c2
;
2381 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
2383 if (SINGLE_BYTE_CHAR_P (without_bits
))
2386 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
2388 if (! CHAR_VALID_P (without_bits
, 1))
2392 sprintf (buf
, "Invalid char code %d", XINT (key
));
2393 return build_string (buf
);
2396 && ((c1
== 0 && c2
== -1) || c2
== 0))
2398 /* Handle a generic character. */
2402 name
= CHARSET_TABLE_INFO (charset
, CHARSET_SHORT_NAME_IDX
);
2403 CHECK_STRING (name
);
2405 /* Only a charset is specified. */
2406 sprintf (buf
, "Generic char %d: all of ", without_bits
);
2408 /* 1st code-point of 2-dimensional charset is specified. */
2409 sprintf (buf
, "Generic char %d: row %d of ", without_bits
, c1
);
2410 return concat2 (build_string (buf
), name
);
2414 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
2418 end
= push_key_description (XUINT (key
), tem
, 1);
2420 nchars
= multibyte_chars_in_text (tem
, nbytes
);
2421 if (nchars
== nbytes
)
2424 string
= build_string (tem
);
2427 string
= make_multibyte_string (tem
, nchars
, nbytes
);
2431 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2433 if (NILP (no_angles
))
2436 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2437 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2438 return build_string (buffer
);
2441 return Fsymbol_name (key
);
2443 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2444 return Fcopy_sequence (key
);
2446 error ("KEY must be an integer, cons, symbol, or string");
2451 push_text_char_description (c
, p
)
2452 register unsigned int c
;
2464 *p
++ = c
+ 64; /* 'A' - 1 */
2476 /* This function cannot GC. */
2478 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2479 doc
: /* Return a pretty description of file-character CHARACTER.
2480 Control characters turn into "^char", etc. This differs from
2481 `single-key-description' which turns them into "C-char".
2482 Also, this function recognizes the 2**7 bit as the Meta character,
2483 whereas `single-key-description' uses the 2**27 bit for Meta.
2484 See Info node `(elisp)Describing Characters' for examples. */)
2486 Lisp_Object character
;
2488 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2489 unsigned char str
[6];
2492 CHECK_NUMBER (character
);
2494 c
= XINT (character
);
2495 if (!SINGLE_BYTE_CHAR_P (c
))
2497 int len
= CHAR_STRING (c
, str
);
2499 return make_multibyte_string (str
, 1, len
);
2502 *push_text_char_description (c
& 0377, str
) = 0;
2504 return build_string (str
);
2507 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2510 ascii_sequence_p (seq
)
2514 int len
= XINT (Flength (seq
));
2516 for (i
= 0; i
< len
; i
++)
2518 Lisp_Object ii
, elt
;
2520 XSETFASTINT (ii
, i
);
2521 elt
= Faref (seq
, ii
);
2524 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2532 /* where-is - finding a command in a set of keymaps. */
2534 static Lisp_Object
where_is_internal ();
2535 static Lisp_Object
where_is_internal_1 ();
2536 static void where_is_internal_2 ();
2538 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2539 Returns the first non-nil binding found in any of those maps. */
2542 shadow_lookup (shadow
, key
, flag
)
2543 Lisp_Object shadow
, key
, flag
;
2545 Lisp_Object tail
, value
;
2547 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2549 value
= Flookup_key (XCAR (tail
), key
, flag
);
2550 if (NATNUMP (value
))
2552 value
= Flookup_key (XCAR (tail
),
2553 Fsubstring (key
, make_number (0), value
), flag
);
2557 else if (!NILP (value
))
2563 static Lisp_Object Vmouse_events
;
2565 /* This function can GC if Flookup_key autoloads any keymaps. */
2568 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2569 Lisp_Object definition
, keymaps
;
2570 Lisp_Object firstonly
, noindirect
, no_remap
;
2572 Lisp_Object maps
= Qnil
;
2573 Lisp_Object found
, sequences
;
2574 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2575 /* 1 means ignore all menu bindings entirely. */
2576 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2578 /* If this command is remapped, then it has no key bindings
2580 if (NILP (no_remap
) && SYMBOLP (definition
))
2583 if (tem
= Fcommand_remapping (definition
, Qnil
), !NILP (tem
))
2588 while (CONSP (found
))
2592 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2593 found
= XCDR (found
);
2596 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2600 for (; !NILP (maps
); maps
= Fcdr (maps
))
2602 /* Key sequence to reach map, and the map that it reaches */
2603 register Lisp_Object
this, map
, tem
;
2605 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2606 [M-CHAR] sequences, check if last character of the sequence
2607 is the meta-prefix char. */
2611 this = Fcar (Fcar (maps
));
2612 map
= Fcdr (Fcar (maps
));
2613 last
= make_number (XINT (Flength (this)) - 1);
2614 last_is_meta
= (XINT (last
) >= 0
2615 && EQ (Faref (this, last
), meta_prefix_char
));
2617 /* if (nomenus && !ascii_sequence_p (this)) */
2618 if (nomenus
&& XINT (last
) >= 0
2619 && SYMBOLP (tem
= Faref (this, make_number (0)))
2620 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2621 /* If no menu entries should be returned, skip over the
2622 keymaps bound to `menu-bar' and `tool-bar' and other
2623 non-ascii prefixes like `C-down-mouse-2'. */
2630 /* Because the code we want to run on each binding is rather
2631 large, we don't want to have two separate loop bodies for
2632 sparse keymap bindings and tables; we want to iterate one
2633 loop body over both keymap and vector bindings.
2635 For this reason, if Fcar (map) is a vector, we don't
2636 advance map to the next element until i indicates that we
2637 have finished off the vector. */
2638 Lisp_Object elt
, key
, binding
;
2646 /* Set key and binding to the current key and binding, and
2647 advance map and i to the next binding. */
2650 Lisp_Object sequence
;
2652 /* In a vector, look at each element. */
2653 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2655 binding
= AREF (elt
, i
);
2656 XSETFASTINT (key
, i
);
2657 sequence
= where_is_internal_1 (binding
, key
, definition
,
2659 last
, nomenus
, last_is_meta
);
2660 if (!NILP (sequence
))
2661 sequences
= Fcons (sequence
, sequences
);
2664 else if (CHAR_TABLE_P (elt
))
2666 Lisp_Object indices
[3];
2669 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2670 Qnil
), /* Result accumulator. */
2671 Fcons (Fcons (this, last
),
2672 Fcons (make_number (nomenus
),
2673 make_number (last_is_meta
))));
2674 map_char_table (where_is_internal_2
, Qnil
, elt
, elt
, args
,
2676 sequences
= XCDR (XCAR (args
));
2678 else if (CONSP (elt
))
2680 Lisp_Object sequence
;
2683 binding
= XCDR (elt
);
2685 sequence
= where_is_internal_1 (binding
, key
, definition
,
2687 last
, nomenus
, last_is_meta
);
2688 if (!NILP (sequence
))
2689 sequences
= Fcons (sequence
, sequences
);
2693 while (!NILP (sequences
))
2695 Lisp_Object sequence
, remapped
, function
;
2697 sequence
= XCAR (sequences
);
2698 sequences
= XCDR (sequences
);
2700 /* If the current sequence is a command remapping with
2701 format [remap COMMAND], find the key sequences
2702 which run COMMAND, and use those sequences instead. */
2705 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2706 && EQ (AREF (sequence
, 0), Qremap
)
2707 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2709 Lisp_Object remapped1
;
2711 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2712 if (CONSP (remapped1
))
2714 /* Verify that this key binding actually maps to the
2715 remapped command (see below). */
2716 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2718 sequence
= XCAR (remapped1
);
2719 remapped
= XCDR (remapped1
);
2720 goto record_sequence
;
2724 /* Verify that this key binding is not shadowed by another
2725 binding for the same key, before we say it exists.
2727 Mechanism: look for local definition of this key and if
2728 it is defined and does not match what we found then
2731 Either nil or number as value from Flookup_key
2733 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2737 /* Don't annoy user with strings from a menu such as
2738 Select Paste. Change them all to "(any string)",
2739 so that there seems to be only one menu item
2741 if (! NILP (sequence
))
2744 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2746 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2747 build_string ("(any string)"));
2750 /* It is a true unshadowed match. Record it, unless it's already
2751 been seen (as could happen when inheriting keymaps). */
2752 if (NILP (Fmember (sequence
, found
)))
2753 found
= Fcons (sequence
, found
);
2755 /* If firstonly is Qnon_ascii, then we can return the first
2756 binding we find. If firstonly is not Qnon_ascii but not
2757 nil, then we should return the first ascii-only binding
2759 if (EQ (firstonly
, Qnon_ascii
))
2760 RETURN_UNGCPRO (sequence
);
2761 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2762 RETURN_UNGCPRO (sequence
);
2764 if (CONSP (remapped
))
2766 sequence
= XCAR (remapped
);
2767 remapped
= XCDR (remapped
);
2768 goto record_sequence
;
2776 found
= Fnreverse (found
);
2778 /* firstonly may have been t, but we may have gone all the way through
2779 the keymaps without finding an all-ASCII key sequence. So just
2780 return the best we could find. */
2781 if (!NILP (firstonly
))
2782 return Fcar (found
);
2787 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2788 doc
: /* Return list of keys that invoke DEFINITION.
2789 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2790 If KEYMAP is nil, search all the currently active keymaps.
2791 If KEYMAP is a list of keymaps, search only those keymaps.
2793 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2794 rather than a list of all possible key sequences.
2795 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2796 no matter what it is.
2797 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2798 \(or their meta variants) and entirely reject menu bindings.
2800 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2801 to other keymaps or slots. This makes it possible to search for an
2802 indirect definition itself.
2804 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2805 that invoke a command which is remapped to DEFINITION, but include the
2806 remapped command in the returned list. */)
2807 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2808 Lisp_Object definition
, keymap
;
2809 Lisp_Object firstonly
, noindirect
, no_remap
;
2811 Lisp_Object sequences
, keymaps
;
2812 /* 1 means ignore all menu bindings entirely. */
2813 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2816 /* Find the relevant keymaps. */
2817 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2819 else if (!NILP (keymap
))
2820 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2822 keymaps
= Fcurrent_active_maps (Qnil
);
2824 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2825 We don't really need to check `keymap'. */
2826 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2830 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2832 /* Check heuristic-consistency of the cache. */
2833 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2834 where_is_cache
= Qnil
;
2836 if (NILP (where_is_cache
))
2838 /* We need to create the cache. */
2839 Lisp_Object args
[2];
2840 where_is_cache
= Fmake_hash_table (0, args
);
2841 where_is_cache_keymaps
= Qt
;
2843 /* Fill in the cache. */
2844 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2845 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2848 where_is_cache_keymaps
= keymaps
;
2851 /* We want to process definitions from the last to the first.
2852 Instead of consing, copy definitions to a vector and step
2853 over that vector. */
2854 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2855 n
= XINT (Flength (sequences
));
2856 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2857 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2858 defns
[i
++] = XCAR (sequences
);
2860 /* Verify that the key bindings are not shadowed. Note that
2861 the following can GC. */
2862 GCPRO2 (definition
, keymaps
);
2865 for (i
= n
- 1; i
>= 0; --i
)
2866 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2868 if (ascii_sequence_p (defns
[i
]))
2874 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2879 /* Kill the cache so that where_is_internal_1 doesn't think
2880 we're filling it up. */
2881 where_is_cache
= Qnil
;
2882 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2888 /* This is the function that Fwhere_is_internal calls using map_char_table.
2890 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2892 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2893 Since map_char_table doesn't really use the return value from this function,
2894 we the result append to RESULT, the slot in ARGS.
2896 This function can GC because it calls where_is_internal_1 which can
2900 where_is_internal_2 (args
, key
, binding
)
2901 Lisp_Object args
, key
, binding
;
2903 Lisp_Object definition
, noindirect
, this, last
;
2904 Lisp_Object result
, sequence
;
2905 int nomenus
, last_is_meta
;
2906 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2908 GCPRO3 (args
, key
, binding
);
2909 result
= XCDR (XCAR (args
));
2910 definition
= XCAR (XCAR (XCAR (args
)));
2911 noindirect
= XCDR (XCAR (XCAR (args
)));
2912 this = XCAR (XCAR (XCDR (args
)));
2913 last
= XCDR (XCAR (XCDR (args
)));
2914 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2915 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2917 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2918 this, last
, nomenus
, last_is_meta
);
2920 if (!NILP (sequence
))
2921 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2927 /* This function can GC because get_keyelt can. */
2930 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2931 nomenus
, last_is_meta
)
2932 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2933 int nomenus
, last_is_meta
;
2935 Lisp_Object sequence
;
2937 /* Search through indirections unless that's not wanted. */
2938 if (NILP (noindirect
))
2939 binding
= get_keyelt (binding
, 0);
2941 /* End this iteration if this element does not match
2944 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2945 || EQ (binding
, definition
)
2946 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2947 /* Doesn't match. */
2950 /* We have found a match. Construct the key sequence where we found it. */
2951 if (INTEGERP (key
) && last_is_meta
)
2953 sequence
= Fcopy_sequence (this);
2954 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2957 sequence
= append_key (this, key
);
2959 if (!NILP (where_is_cache
))
2961 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2962 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2969 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2971 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2972 doc
: /* Insert the list of all defined keys and their definitions.
2973 The list is inserted in the current buffer, while the bindings are
2974 looked up in BUFFER.
2975 The optional argument PREFIX, if non-nil, should be a key sequence;
2976 then we display only bindings that start with that prefix.
2977 The optional argument MENUS, if non-nil, says to mention menu bindings.
2978 \(Ordinarily these are omitted from the output.) */)
2979 (buffer
, prefix
, menus
)
2980 Lisp_Object buffer
, prefix
, menus
;
2982 Lisp_Object outbuf
, shadow
;
2983 int nomenu
= NILP (menus
);
2984 register Lisp_Object start1
;
2985 struct gcpro gcpro1
;
2987 char *alternate_heading
2989 Keyboard translations:\n\n\
2990 You type Translation\n\
2991 -------- -----------\n";
2996 outbuf
= Fcurrent_buffer ();
2998 /* Report on alternates for keys. */
2999 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
3002 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
3003 int translate_len
= SCHARS (Vkeyboard_translate_table
);
3005 for (c
= 0; c
< translate_len
; c
++)
3006 if (translate
[c
] != c
)
3008 char buf
[KEY_DESCRIPTION_SIZE
];
3011 if (alternate_heading
)
3013 insert_string (alternate_heading
);
3014 alternate_heading
= 0;
3017 bufend
= push_key_description (translate
[c
], buf
, 1);
3018 insert (buf
, bufend
- buf
);
3019 Findent_to (make_number (16), make_number (1));
3020 bufend
= push_key_description (c
, buf
, 1);
3021 insert (buf
, bufend
- buf
);
3025 /* Insert calls signal_after_change which may GC. */
3026 translate
= SDATA (Vkeyboard_translate_table
);
3032 if (!NILP (Vkey_translation_map
))
3033 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
3034 "Key translations", nomenu
, 1, 0, 0);
3037 /* Print the (major mode) local map. */
3039 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
3040 start1
= current_kboard
->Voverriding_terminal_local_map
;
3041 else if (!NILP (Voverriding_local_map
))
3042 start1
= Voverriding_local_map
;
3046 describe_map_tree (start1
, 1, shadow
, prefix
,
3047 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
3048 shadow
= Fcons (start1
, shadow
);
3052 /* Print the minor mode and major mode keymaps. */
3054 Lisp_Object
*modes
, *maps
;
3056 /* Temporarily switch to `buffer', so that we can get that buffer's
3057 minor modes correctly. */
3058 Fset_buffer (buffer
);
3060 nmaps
= current_minor_maps (&modes
, &maps
);
3061 Fset_buffer (outbuf
);
3063 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3064 XBUFFER (buffer
), Qkeymap
);
3067 describe_map_tree (start1
, 1, shadow
, prefix
,
3068 "\f\n`keymap' Property Bindings", nomenu
,
3070 shadow
= Fcons (start1
, shadow
);
3073 /* Print the minor mode maps. */
3074 for (i
= 0; i
< nmaps
; i
++)
3076 /* The title for a minor mode keymap
3077 is constructed at run time.
3078 We let describe_map_tree do the actual insertion
3079 because it takes care of other features when doing so. */
3082 if (!SYMBOLP (modes
[i
]))
3085 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3089 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
3090 SCHARS (SYMBOL_NAME (modes
[i
])));
3091 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3093 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
3094 p
+= sizeof (" Minor Mode Bindings") - 1;
3097 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3098 title
, nomenu
, 0, 0, 0);
3099 shadow
= Fcons (maps
[i
], shadow
);
3102 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3103 XBUFFER (buffer
), Qlocal_map
);
3106 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3107 describe_map_tree (start1
, 1, shadow
, prefix
,
3108 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3110 describe_map_tree (start1
, 1, shadow
, prefix
,
3111 "\f\n`local-map' Property Bindings",
3114 shadow
= Fcons (start1
, shadow
);
3118 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3119 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3121 /* Print the function-key-map translations under this prefix. */
3122 if (!NILP (Vfunction_key_map
))
3123 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
3124 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3130 /* Insert a description of the key bindings in STARTMAP,
3131 followed by those of all maps reachable through STARTMAP.
3132 If PARTIAL is nonzero, omit certain "uninteresting" commands
3133 (such as `undefined').
3134 If SHADOW is non-nil, it is a list of maps;
3135 don't mention keys which would be shadowed by any of them.
3136 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3137 TITLE, if not 0, is a string to insert at the beginning.
3138 TITLE should not end with a colon or a newline; we supply that.
3139 If NOMENU is not 0, then omit menu-bar commands.
3141 If TRANSL is nonzero, the definitions are actually key translations
3142 so print strings and vectors differently.
3144 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3147 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3148 don't omit it; instead, mention it but say it is shadowed. */
3151 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3152 always_title
, mention_shadow
)
3153 Lisp_Object startmap
, shadow
, prefix
;
3161 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3162 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3169 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3172 GCPRO3 (maps
, seen
, sub_shadows
);
3178 /* Delete from MAPS each element that is for the menu bar. */
3179 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3181 Lisp_Object elt
, prefix
, tem
;
3184 prefix
= Fcar (elt
);
3185 if (XVECTOR (prefix
)->size
>= 1)
3187 tem
= Faref (prefix
, make_number (0));
3188 if (EQ (tem
, Qmenu_bar
))
3189 maps
= Fdelq (elt
, maps
);
3194 if (!NILP (maps
) || always_title
)
3198 insert_string (title
);
3201 insert_string (" Starting With ");
3202 insert1 (Fkey_description (prefix
, Qnil
));
3204 insert_string (":\n");
3206 insert_string (key_heading
);
3210 for (; !NILP (maps
); maps
= Fcdr (maps
))
3212 register Lisp_Object elt
, prefix
, tail
;
3215 prefix
= Fcar (elt
);
3219 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3223 shmap
= XCAR (tail
);
3225 /* If the sequence by which we reach this keymap is zero-length,
3226 then the shadow map for this keymap is just SHADOW. */
3227 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3228 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3230 /* If the sequence by which we reach this keymap actually has
3231 some elements, then the sequence's definition in SHADOW is
3232 what we should use. */
3235 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3236 if (INTEGERP (shmap
))
3240 /* If shmap is not nil and not a keymap,
3241 it completely shadows this map, so don't
3242 describe this map at all. */
3243 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3247 sub_shadows
= Fcons (shmap
, sub_shadows
);
3250 /* Maps we have already listed in this loop shadow this map. */
3251 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3254 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3256 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3259 describe_map (Fcdr (elt
), prefix
,
3260 transl
? describe_translation
: describe_command
,
3261 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3267 insert_string ("\n");
3272 static int previous_description_column
;
3275 describe_command (definition
, args
)
3276 Lisp_Object definition
, args
;
3278 register Lisp_Object tem1
;
3279 int column
= (int) current_column (); /* iftc */
3280 int description_column
;
3282 /* If column 16 is no good, go to col 32;
3283 but don't push beyond that--go to next line instead. */
3287 description_column
= 32;
3289 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3290 description_column
= 32;
3292 description_column
= 16;
3294 Findent_to (make_number (description_column
), make_number (1));
3295 previous_description_column
= description_column
;
3297 if (SYMBOLP (definition
))
3299 tem1
= SYMBOL_NAME (definition
);
3301 insert_string ("\n");
3303 else if (STRINGP (definition
) || VECTORP (definition
))
3304 insert_string ("Keyboard Macro\n");
3305 else if (KEYMAPP (definition
))
3306 insert_string ("Prefix Command\n");
3308 insert_string ("??\n");
3312 describe_translation (definition
, args
)
3313 Lisp_Object definition
, args
;
3315 register Lisp_Object tem1
;
3317 Findent_to (make_number (16), make_number (1));
3319 if (SYMBOLP (definition
))
3321 tem1
= SYMBOL_NAME (definition
);
3323 insert_string ("\n");
3325 else if (STRINGP (definition
) || VECTORP (definition
))
3327 insert1 (Fkey_description (definition
, Qnil
));
3328 insert_string ("\n");
3330 else if (KEYMAPP (definition
))
3331 insert_string ("Prefix Command\n");
3333 insert_string ("??\n");
3336 /* describe_map puts all the usable elements of a sparse keymap
3337 into an array of `struct describe_map_elt',
3338 then sorts them by the events. */
3340 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3342 /* qsort comparison function for sorting `struct describe_map_elt' by
3346 describe_map_compare (aa
, bb
)
3347 const void *aa
, *bb
;
3349 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3350 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3351 return ((XINT (a
->event
) > XINT (b
->event
))
3352 - (XINT (a
->event
) < XINT (b
->event
)));
3353 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3355 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3357 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3358 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3359 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3364 /* Describe the contents of map MAP, assuming that this map itself is
3365 reached by the sequence of prefix keys PREFIX (a string or vector).
3366 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3369 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3370 seen
, nomenu
, mention_shadow
)
3371 register Lisp_Object map
;
3373 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3380 Lisp_Object tail
, definition
, event
;
3382 Lisp_Object suppress
;
3385 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3387 /* These accumulate the values from sparse keymap bindings,
3388 so we can sort them and handle them in order. */
3389 int length_needed
= 0;
3390 struct describe_map_elt
*vect
;
3397 suppress
= intern ("suppress-keymap");
3399 /* This vector gets used to present single keys to Flookup_key. Since
3400 that is done once per keymap element, we don't want to cons up a
3401 fresh vector every time. */
3402 kludge
= Fmake_vector (make_number (1), Qnil
);
3405 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3408 vect
= ((struct describe_map_elt
*)
3409 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3411 GCPRO3 (prefix
, definition
, kludge
);
3413 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3417 if (VECTORP (XCAR (tail
))
3418 || CHAR_TABLE_P (XCAR (tail
)))
3419 describe_vector (XCAR (tail
),
3420 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3421 (int *)0, 0, 1, mention_shadow
);
3422 else if (CONSP (XCAR (tail
)))
3424 int this_shadowed
= 0;
3426 event
= XCAR (XCAR (tail
));
3428 /* Ignore bindings whose "prefix" are not really valid events.
3429 (We get these in the frames and buffers menu.) */
3430 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3433 if (nomenu
&& EQ (event
, Qmenu_bar
))
3436 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3438 /* Don't show undefined commands or suppressed commands. */
3439 if (NILP (definition
)) continue;
3440 if (SYMBOLP (definition
) && partial
)
3442 tem
= Fget (definition
, suppress
);
3447 /* Don't show a command that isn't really visible
3448 because a local definition of the same key shadows it. */
3450 ASET (kludge
, 0, event
);
3453 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3456 /* Avoid generating duplicate entries if the
3457 shadowed binding has the same definition. */
3458 if (mention_shadow
&& !EQ (tem
, definition
))
3465 tem
= Flookup_key (map
, kludge
, Qt
);
3466 if (!EQ (tem
, definition
)) continue;
3468 vect
[slots_used
].event
= event
;
3469 vect
[slots_used
].definition
= definition
;
3470 vect
[slots_used
].shadowed
= this_shadowed
;
3473 else if (EQ (XCAR (tail
), Qkeymap
))
3475 /* The same keymap might be in the structure twice, if we're
3476 using an inherited keymap. So skip anything we've already
3478 tem
= Fassq (tail
, *seen
);
3479 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3481 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3485 /* If we found some sparse map events, sort them. */
3487 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3488 describe_map_compare
);
3490 /* Now output them in sorted order. */
3492 for (i
= 0; i
< slots_used
; i
++)
3494 Lisp_Object start
, end
;
3498 previous_description_column
= 0;
3503 ASET (kludge
, 0, vect
[i
].event
);
3504 start
= vect
[i
].event
;
3507 definition
= vect
[i
].definition
;
3509 /* Find consecutive chars that are identically defined. */
3510 if (INTEGERP (vect
[i
].event
))
3512 while (i
+ 1 < slots_used
3513 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3514 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3515 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3517 end
= vect
[i
].event
;
3520 /* Now START .. END is the range to describe next. */
3522 /* Insert the string to describe the event START. */
3523 insert1 (Fkey_description (kludge
, prefix
));
3525 if (!EQ (start
, end
))
3529 ASET (kludge
, 0, end
);
3530 /* Insert the string to describe the character END. */
3531 insert1 (Fkey_description (kludge
, prefix
));
3534 /* Print a description of the definition of this character.
3535 elt_describer will take care of spacing out far enough
3536 for alignment purposes. */
3537 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3539 if (vect
[i
].shadowed
)
3542 insert_string ("\n (that binding is currently shadowed by another mode)");
3551 describe_vector_princ (elt
, fun
)
3552 Lisp_Object elt
, fun
;
3554 Findent_to (make_number (16), make_number (1));
3559 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3560 doc
: /* Insert a description of contents of VECTOR.
3561 This is text showing the elements of vector matched against indices.
3562 DESCRIBER is the output function used; nil means use `princ'. */)
3564 Lisp_Object vector
, describer
;
3566 int count
= SPECPDL_INDEX ();
3567 if (NILP (describer
))
3568 describer
= intern ("princ");
3569 specbind (Qstandard_output
, Fcurrent_buffer ());
3570 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3571 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3572 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3574 return unbind_to (count
, Qnil
);
3577 /* Insert in the current buffer a description of the contents of VECTOR.
3578 We call ELT_DESCRIBER to insert the description of one value found
3581 ELT_PREFIX describes what "comes before" the keys or indices defined
3582 by this vector. This is a human-readable string whose size
3583 is not necessarily related to the situation.
3585 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3586 leads to this keymap.
3588 If the vector is a chartable, ELT_PREFIX is the vector
3589 of bytes that lead to the character set or portion of a character
3590 set described by this chartable.
3592 If PARTIAL is nonzero, it means do not mention suppressed commands
3593 (that assumes the vector is in a keymap).
3595 SHADOW is a list of keymaps that shadow this map.
3596 If it is non-nil, then we look up the key in those maps
3597 and we don't mention it now if it is defined by any of them.
3599 ENTIRE_MAP is the keymap in which this vector appears.
3600 If the definition in effect in the whole map does not match
3601 the one in this vector, we ignore this one.
3603 When describing a sub-char-table, INDICES is a list of
3604 indices at higher levels in this char-table,
3605 and CHAR_TABLE_DEPTH says how many levels down we have gone.
3607 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3609 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3612 describe_vector (vector
, prefix
, args
, elt_describer
,
3613 partial
, shadow
, entire_map
,
3614 indices
, char_table_depth
, keymap_p
,
3616 register Lisp_Object vector
;
3617 Lisp_Object prefix
, args
;
3618 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3621 Lisp_Object entire_map
;
3623 int char_table_depth
;
3627 Lisp_Object definition
;
3629 Lisp_Object elt_prefix
= Qnil
;
3631 Lisp_Object suppress
;
3634 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3635 /* Range of elements to be handled. */
3637 /* A flag to tell if a leaf in this level of char-table is not a
3638 generic character (i.e. a complete multibyte character). */
3646 indices
= (int *) alloca (3 * sizeof (int));
3652 /* Call Fkey_description first, to avoid GC bug for the other string. */
3653 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3656 tem
= Fkey_description (prefix
, Qnil
);
3657 elt_prefix
= concat2 (tem
, build_string (" "));
3662 /* This vector gets used to present single keys to Flookup_key. Since
3663 that is done once per vector element, we don't want to cons up a
3664 fresh vector every time. */
3665 kludge
= Fmake_vector (make_number (1), Qnil
);
3666 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3669 suppress
= intern ("suppress-keymap");
3671 if (CHAR_TABLE_P (vector
))
3673 if (char_table_depth
== 0)
3675 /* VECTOR is a top level char-table. */
3678 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3682 /* VECTOR is a sub char-table. */
3683 if (char_table_depth
>= 3)
3684 /* A char-table is never that deep. */
3685 error ("Too deep char table");
3688 = (CHARSET_VALID_P (indices
[0])
3689 && ((CHARSET_DIMENSION (indices
[0]) == 1
3690 && char_table_depth
== 1)
3691 || char_table_depth
== 2));
3693 /* Meaningful elements are from 32th to 127th. */
3695 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3700 /* This does the right thing for ordinary vectors. */
3704 to
= XVECTOR (vector
)->size
;
3707 for (i
= from
; i
< to
; i
++)
3709 int this_shadowed
= 0;
3712 if (CHAR_TABLE_P (vector
))
3714 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3717 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3718 && !CHARSET_DEFINED_P (i
- 128))
3722 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3725 definition
= get_keyelt (AREF (vector
, i
), 0);
3727 if (NILP (definition
)) continue;
3729 /* Don't mention suppressed commands. */
3730 if (SYMBOLP (definition
) && partial
)
3734 tem
= Fget (definition
, suppress
);
3736 if (!NILP (tem
)) continue;
3739 /* Set CHARACTER to the character this entry describes, if any.
3740 Also update *INDICES. */
3741 if (CHAR_TABLE_P (vector
))
3743 indices
[char_table_depth
] = i
;
3745 if (char_table_depth
== 0)
3748 indices
[0] = i
- 128;
3750 else if (complete_char
)
3752 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3760 ASET (kludge
, 0, make_number (character
));
3762 /* If this binding is shadowed by some other map, ignore it. */
3763 if (!NILP (shadow
) && complete_char
)
3767 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3778 /* Ignore this definition if it is shadowed by an earlier
3779 one in the same keymap. */
3780 if (!NILP (entire_map
) && complete_char
)
3784 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3786 if (!EQ (tem
, definition
))
3792 if (char_table_depth
== 0)
3797 /* For a sub char-table, show the depth by indentation.
3798 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3799 if (char_table_depth
> 0)
3800 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3802 /* Output the prefix that applies to every entry in this map. */
3803 if (!NILP (elt_prefix
))
3804 insert1 (elt_prefix
);
3806 /* Insert or describe the character this slot is for,
3807 or a description of what it is for. */
3808 if (SUB_CHAR_TABLE_P (vector
))
3811 insert_char (character
);
3814 /* We need an octal representation for this block of
3817 sprintf (work
, "(row %d)", i
);
3818 insert (work
, strlen (work
));
3821 else if (CHAR_TABLE_P (vector
))
3824 insert1 (Fkey_description (kludge
, prefix
));
3827 /* Print the information for this character set. */
3828 insert_string ("<");
3829 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3831 insert_from_string (tem2
, 0, 0, SCHARS (tem2
),
3840 insert1 (Fkey_description (kludge
, prefix
));
3843 /* If we find a sub char-table within a char-table,
3844 scan it recursively; it defines the details for
3845 a character set or a portion of a character set. */
3846 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3849 describe_vector (definition
, prefix
, args
, elt_describer
,
3850 partial
, shadow
, entire_map
,
3851 indices
, char_table_depth
+ 1, keymap_p
,
3858 /* Find all consecutive characters or rows that have the same
3859 definition. But, for elements of a top level char table, if
3860 they are for charsets, we had better describe one by one even
3861 if they have the same definition. */
3862 if (CHAR_TABLE_P (vector
))
3866 if (char_table_depth
== 0)
3867 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3869 while (i
+ 1 < limit
3870 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3872 && !NILP (Fequal (tem2
, definition
)))
3877 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3879 && !NILP (Fequal (tem2
, definition
)))
3883 /* If we have a range of more than one character,
3884 print where the range reaches to. */
3886 if (i
!= starting_i
)
3890 ASET (kludge
, 0, make_number (i
));
3892 if (!NILP (elt_prefix
))
3893 insert1 (elt_prefix
);
3895 if (CHAR_TABLE_P (vector
))
3897 if (char_table_depth
== 0)
3899 insert1 (Fkey_description (kludge
, prefix
));
3901 else if (complete_char
)
3903 indices
[char_table_depth
] = i
;
3904 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3905 insert_char (character
);
3909 /* We need an octal representation for this block of
3912 sprintf (work
, "(row %d)", i
);
3913 insert (work
, strlen (work
));
3918 insert1 (Fkey_description (kludge
, prefix
));
3922 /* Print a description of the definition of this character.
3923 elt_describer will take care of spacing out far enough
3924 for alignment purposes. */
3925 (*elt_describer
) (definition
, args
);
3930 insert_string (" (binding currently shadowed)");
3935 /* For (sub) char-table, print `defalt' slot at last. */
3936 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3938 insert (" ", char_table_depth
* 2);
3939 insert_string ("<<default>>");
3940 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3946 /* Apropos - finding all symbols whose names match a regexp. */
3947 static Lisp_Object apropos_predicate
;
3948 static Lisp_Object apropos_accumulate
;
3951 apropos_accum (symbol
, string
)
3952 Lisp_Object symbol
, string
;
3954 register Lisp_Object tem
;
3956 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3957 if (!NILP (tem
) && !NILP (apropos_predicate
))
3958 tem
= call1 (apropos_predicate
, symbol
);
3960 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3963 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3964 doc
: /* Show all symbols whose names contain match for REGEXP.
3965 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3966 for each symbol and a symbol is mentioned only if that returns non-nil.
3967 Return list of symbols found. */)
3969 Lisp_Object regexp
, predicate
;
3972 CHECK_STRING (regexp
);
3973 apropos_predicate
= predicate
;
3974 apropos_accumulate
= Qnil
;
3975 map_obarray (Vobarray
, apropos_accum
, regexp
);
3976 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3977 apropos_accumulate
= Qnil
;
3978 apropos_predicate
= Qnil
;
3985 Qkeymap
= intern ("keymap");
3986 staticpro (&Qkeymap
);
3987 staticpro (&apropos_predicate
);
3988 staticpro (&apropos_accumulate
);
3989 apropos_predicate
= Qnil
;
3990 apropos_accumulate
= Qnil
;
3992 /* Now we are ready to set up this property, so we can
3993 create char tables. */
3994 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3996 /* Initialize the keymaps standardly used.
3997 Each one is the value of a Lisp variable, and is also
3998 pointed to by a C variable */
4000 global_map
= Fmake_keymap (Qnil
);
4001 Fset (intern ("global-map"), global_map
);
4003 current_global_map
= global_map
;
4004 staticpro (&global_map
);
4005 staticpro (¤t_global_map
);
4007 meta_map
= Fmake_keymap (Qnil
);
4008 Fset (intern ("esc-map"), meta_map
);
4009 Ffset (intern ("ESC-prefix"), meta_map
);
4011 control_x_map
= Fmake_keymap (Qnil
);
4012 Fset (intern ("ctl-x-map"), control_x_map
);
4013 Ffset (intern ("Control-X-prefix"), control_x_map
);
4016 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
4017 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
4018 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
4019 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
4020 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
4022 staticpro (&exclude_keys
);
4024 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
4025 doc
: /* List of commands given new key bindings recently.
4026 This is used for internal purposes during Emacs startup;
4027 don't alter it yourself. */);
4028 Vdefine_key_rebound_commands
= Qt
;
4030 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
4031 doc
: /* Default keymap to use when reading from the minibuffer. */);
4032 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
4034 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
4035 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
4036 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
4037 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
4039 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
4040 doc
: /* Local keymap for minibuffer input with completion. */);
4041 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
4042 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
4044 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
4045 &Vminibuffer_local_filename_completion_map
,
4046 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
4047 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
4048 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
4049 Vminibuffer_local_completion_map
);
4052 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
4053 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
4054 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
4055 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
4056 Vminibuffer_local_completion_map
);
4058 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
4059 &Vminibuffer_local_must_match_filename_map
,
4060 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
4061 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
4062 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
4063 Vminibuffer_local_must_match_map
);
4065 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
4066 doc
: /* Alist of keymaps to use for minor modes.
4067 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
4068 key sequences and look up bindings iff VARIABLE's value is non-nil.
4069 If two active keymaps bind the same key, the keymap appearing earlier
4070 in the list takes precedence. */);
4071 Vminor_mode_map_alist
= Qnil
;
4073 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
4074 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
4075 This variable is an alist just like `minor-mode-map-alist', and it is
4076 used the same way (and before `minor-mode-map-alist'); however,
4077 it is provided for major modes to bind locally. */);
4078 Vminor_mode_overriding_map_alist
= Qnil
;
4080 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
4081 doc
: /* List of keymap alists to use for emulations modes.
4082 It is intended for modes or packages using multiple minor-mode keymaps.
4083 Each element is a keymap alist just like `minor-mode-map-alist', or a
4084 symbol with a variable binding which is a keymap alist, and it is used
4085 the same way. The "active" keymaps in each alist are used before
4086 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
4087 Vemulation_mode_map_alists
= Qnil
;
4090 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
4091 doc
: /* Keymap that translates key sequences to key sequences during input.
4092 This is used mainly for mapping ASCII function key sequences into
4093 real Emacs function key events (symbols).
4095 The `read-key-sequence' function replaces any subsequence bound by
4096 `function-key-map' with its binding. More precisely, when the active
4097 keymaps have no binding for the current key sequence but
4098 `function-key-map' binds a suffix of the sequence to a vector or string,
4099 `read-key-sequence' replaces the matching suffix with its binding, and
4100 continues with the new sequence.
4102 If the binding is a function, it is called with one argument (the prompt)
4103 and its return value (a key sequence) is used.
4105 The events that come from bindings in `function-key-map' are not
4106 themselves looked up in `function-key-map'.
4108 For example, suppose `function-key-map' binds `ESC O P' to [f1].
4109 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
4110 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
4111 key, typing `ESC O P x' would return [f1 x]. */);
4112 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
4114 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
4115 doc
: /* Keymap of key translations that can override keymaps.
4116 This keymap works like `function-key-map', but comes after that,
4117 and its non-prefix bindings override ordinary bindings. */);
4118 Vkey_translation_map
= Qnil
;
4120 staticpro (&Vmouse_events
);
4121 Vmouse_events
= Fcons (intern ("menu-bar"),
4122 Fcons (intern ("tool-bar"),
4123 Fcons (intern ("header-line"),
4124 Fcons (intern ("mode-line"),
4125 Fcons (intern ("mouse-1"),
4126 Fcons (intern ("mouse-2"),
4127 Fcons (intern ("mouse-3"),
4128 Fcons (intern ("mouse-4"),
4129 Fcons (intern ("mouse-5"),
4133 Qsingle_key_description
= intern ("single-key-description");
4134 staticpro (&Qsingle_key_description
);
4136 Qkey_description
= intern ("key-description");
4137 staticpro (&Qkey_description
);
4139 Qkeymapp
= intern ("keymapp");
4140 staticpro (&Qkeymapp
);
4142 Qnon_ascii
= intern ("non-ascii");
4143 staticpro (&Qnon_ascii
);
4145 Qmenu_item
= intern ("menu-item");
4146 staticpro (&Qmenu_item
);
4148 Qremap
= intern ("remap");
4149 staticpro (&Qremap
);
4151 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
4152 staticpro (&command_remapping_vector
);
4154 where_is_cache_keymaps
= Qt
;
4155 where_is_cache
= Qnil
;
4156 staticpro (&where_is_cache
);
4157 staticpro (&where_is_cache_keymaps
);
4159 defsubr (&Skeymapp
);
4160 defsubr (&Skeymap_parent
);
4161 defsubr (&Skeymap_prompt
);
4162 defsubr (&Sset_keymap_parent
);
4163 defsubr (&Smake_keymap
);
4164 defsubr (&Smake_sparse_keymap
);
4165 defsubr (&Smap_keymap
);
4166 defsubr (&Scopy_keymap
);
4167 defsubr (&Scommand_remapping
);
4168 defsubr (&Skey_binding
);
4169 defsubr (&Slocal_key_binding
);
4170 defsubr (&Sglobal_key_binding
);
4171 defsubr (&Sminor_mode_key_binding
);
4172 defsubr (&Sdefine_key
);
4173 defsubr (&Slookup_key
);
4174 defsubr (&Sdefine_prefix_command
);
4175 defsubr (&Suse_global_map
);
4176 defsubr (&Suse_local_map
);
4177 defsubr (&Scurrent_local_map
);
4178 defsubr (&Scurrent_global_map
);
4179 defsubr (&Scurrent_minor_mode_maps
);
4180 defsubr (&Scurrent_active_maps
);
4181 defsubr (&Saccessible_keymaps
);
4182 defsubr (&Skey_description
);
4183 defsubr (&Sdescribe_vector
);
4184 defsubr (&Ssingle_key_description
);
4185 defsubr (&Stext_char_description
);
4186 defsubr (&Swhere_is_internal
);
4187 defsubr (&Sdescribe_buffer_bindings
);
4188 defsubr (&Sapropos_internal
);
4194 initial_define_key (global_map
, 033, "ESC-prefix");
4195 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
4198 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4199 (do not change this comment) */