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
, make_number (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
)) {
1616 kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1617 if (EQ (kind
, Qmouse_click
))
1618 position
= EVENT_START (event
);
1622 /* Key sequences beginning with mouse clicks
1623 are read using the keymaps of the buffer clicked on, not
1624 the current buffer. So we may have to switch the buffer
1627 if (CONSP (position
))
1631 window
= POSN_WINDOW (position
);
1633 if (WINDOWP (window
)
1634 && BUFFERP (XWINDOW (window
)->buffer
)
1635 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1637 /* Arrange to go back to the original buffer once we're done
1638 processing the key sequence. We don't use
1639 save_excursion_{save,restore} here, in analogy to
1640 `read-key-sequence' to avoid saving point. Maybe this
1641 would not be a problem here, but it is easier to keep
1645 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1647 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1651 if (! NILP (current_kboard
->Voverriding_terminal_local_map
))
1653 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1654 key
, accept_default
);
1655 if (! NILP (value
) && !INTEGERP (value
))
1658 else if (! NILP (Voverriding_local_map
))
1660 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1661 if (! NILP (value
) && !INTEGERP (value
))
1666 Lisp_Object keymap
, local_map
;
1669 pt
= INTEGERP (position
) ? XINT (position
)
1670 : MARKERP (position
) ? marker_position (position
)
1673 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1674 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1676 if (CONSP (position
))
1680 /* For a mouse click, get the local text-property keymap
1681 of the place clicked on, rather than point. */
1683 if (POSN_INBUFFER_P (position
))
1687 pos
= POSN_BUFFER_POSN (position
);
1689 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1691 local_map
= get_local_map (XINT (pos
),
1692 current_buffer
, Qlocal_map
);
1694 keymap
= get_local_map (XINT (pos
),
1695 current_buffer
, Qkeymap
);
1699 /* If on a mode line string with a local keymap,
1700 or for a click on a string, i.e. overlay string or a
1701 string displayed via the `display' property,
1702 consider `local-map' and `keymap' properties of
1705 if (string
= POSN_STRING (position
),
1706 (CONSP (string
) && STRINGP (XCAR (string
))))
1708 Lisp_Object pos
, map
;
1710 pos
= XCDR (string
);
1711 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
);
2389 && CHARSET_DEFINED_P (charset
)
2390 && ((c1
>= 0 && c1
< 32)
2391 || (c2
>= 0 && c2
< 32)))
2393 /* Handle a generic character. */
2395 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
2396 CHECK_STRING (name
);
2397 return concat2 (build_string ("Character set "), name
);
2401 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
2405 end
= push_key_description (XUINT (key
), tem
, 1);
2407 nchars
= multibyte_chars_in_text (tem
, nbytes
);
2408 if (nchars
== nbytes
)
2411 string
= build_string (tem
);
2414 string
= make_multibyte_string (tem
, nchars
, nbytes
);
2418 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2420 if (NILP (no_angles
))
2423 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2424 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2425 return build_string (buffer
);
2428 return Fsymbol_name (key
);
2430 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2431 return Fcopy_sequence (key
);
2433 error ("KEY must be an integer, cons, symbol, or string");
2438 push_text_char_description (c
, p
)
2439 register unsigned int c
;
2451 *p
++ = c
+ 64; /* 'A' - 1 */
2463 /* This function cannot GC. */
2465 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2466 doc
: /* Return a pretty description of file-character CHARACTER.
2467 Control characters turn into "^char", etc. This differs from
2468 `single-key-description' which turns them into "C-char".
2469 Also, this function recognizes the 2**7 bit as the Meta character,
2470 whereas `single-key-description' uses the 2**27 bit for Meta.
2471 See Info node `(elisp)Describing Characters' for examples. */)
2473 Lisp_Object character
;
2475 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2476 unsigned char str
[6];
2479 CHECK_NUMBER (character
);
2481 c
= XINT (character
);
2482 if (!SINGLE_BYTE_CHAR_P (c
))
2484 int len
= CHAR_STRING (c
, str
);
2486 return make_multibyte_string (str
, 1, len
);
2489 *push_text_char_description (c
& 0377, str
) = 0;
2491 return build_string (str
);
2494 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2497 ascii_sequence_p (seq
)
2501 int len
= XINT (Flength (seq
));
2503 for (i
= 0; i
< len
; i
++)
2505 Lisp_Object ii
, elt
;
2507 XSETFASTINT (ii
, i
);
2508 elt
= Faref (seq
, ii
);
2511 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2519 /* where-is - finding a command in a set of keymaps. */
2521 static Lisp_Object
where_is_internal ();
2522 static Lisp_Object
where_is_internal_1 ();
2523 static void where_is_internal_2 ();
2525 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2526 Returns the first non-nil binding found in any of those maps. */
2529 shadow_lookup (shadow
, key
, flag
)
2530 Lisp_Object shadow
, key
, flag
;
2532 Lisp_Object tail
, value
;
2534 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2536 value
= Flookup_key (XCAR (tail
), key
, flag
);
2537 if (NATNUMP (value
))
2539 value
= Flookup_key (XCAR (tail
),
2540 Fsubstring (key
, make_number (0), value
), flag
);
2544 else if (!NILP (value
))
2550 static Lisp_Object Vmouse_events
;
2552 /* This function can GC if Flookup_key autoloads any keymaps. */
2555 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2556 Lisp_Object definition
, keymaps
;
2557 Lisp_Object firstonly
, noindirect
, no_remap
;
2559 Lisp_Object maps
= Qnil
;
2560 Lisp_Object found
, sequences
;
2561 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2562 /* 1 means ignore all menu bindings entirely. */
2563 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2565 /* If this command is remapped, then it has no key bindings
2567 if (NILP (no_remap
) && SYMBOLP (definition
))
2570 if (tem
= Fcommand_remapping (definition
, Qnil
), !NILP (tem
))
2575 while (CONSP (found
))
2579 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2580 found
= XCDR (found
);
2583 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2587 for (; !NILP (maps
); maps
= Fcdr (maps
))
2589 /* Key sequence to reach map, and the map that it reaches */
2590 register Lisp_Object
this, map
, tem
;
2592 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2593 [M-CHAR] sequences, check if last character of the sequence
2594 is the meta-prefix char. */
2598 this = Fcar (Fcar (maps
));
2599 map
= Fcdr (Fcar (maps
));
2600 last
= make_number (XINT (Flength (this)) - 1);
2601 last_is_meta
= (XINT (last
) >= 0
2602 && EQ (Faref (this, last
), meta_prefix_char
));
2604 /* if (nomenus && !ascii_sequence_p (this)) */
2605 if (nomenus
&& XINT (last
) >= 0
2606 && SYMBOLP (tem
= Faref (this, make_number (0)))
2607 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2608 /* If no menu entries should be returned, skip over the
2609 keymaps bound to `menu-bar' and `tool-bar' and other
2610 non-ascii prefixes like `C-down-mouse-2'. */
2617 /* Because the code we want to run on each binding is rather
2618 large, we don't want to have two separate loop bodies for
2619 sparse keymap bindings and tables; we want to iterate one
2620 loop body over both keymap and vector bindings.
2622 For this reason, if Fcar (map) is a vector, we don't
2623 advance map to the next element until i indicates that we
2624 have finished off the vector. */
2625 Lisp_Object elt
, key
, binding
;
2633 /* Set key and binding to the current key and binding, and
2634 advance map and i to the next binding. */
2637 Lisp_Object sequence
;
2639 /* In a vector, look at each element. */
2640 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2642 binding
= AREF (elt
, i
);
2643 XSETFASTINT (key
, i
);
2644 sequence
= where_is_internal_1 (binding
, key
, definition
,
2646 last
, nomenus
, last_is_meta
);
2647 if (!NILP (sequence
))
2648 sequences
= Fcons (sequence
, sequences
);
2651 else if (CHAR_TABLE_P (elt
))
2653 Lisp_Object indices
[3];
2656 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2657 Qnil
), /* Result accumulator. */
2658 Fcons (Fcons (this, last
),
2659 Fcons (make_number (nomenus
),
2660 make_number (last_is_meta
))));
2661 map_char_table (where_is_internal_2
, Qnil
, elt
, elt
, args
,
2663 sequences
= XCDR (XCAR (args
));
2665 else if (CONSP (elt
))
2667 Lisp_Object sequence
;
2670 binding
= XCDR (elt
);
2672 sequence
= where_is_internal_1 (binding
, key
, definition
,
2674 last
, nomenus
, last_is_meta
);
2675 if (!NILP (sequence
))
2676 sequences
= Fcons (sequence
, sequences
);
2680 while (!NILP (sequences
))
2682 Lisp_Object sequence
, remapped
, function
;
2684 sequence
= XCAR (sequences
);
2685 sequences
= XCDR (sequences
);
2687 /* If the current sequence is a command remapping with
2688 format [remap COMMAND], find the key sequences
2689 which run COMMAND, and use those sequences instead. */
2692 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2693 && EQ (AREF (sequence
, 0), Qremap
)
2694 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2696 Lisp_Object remapped1
;
2698 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2699 if (CONSP (remapped1
))
2701 /* Verify that this key binding actually maps to the
2702 remapped command (see below). */
2703 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2705 sequence
= XCAR (remapped1
);
2706 remapped
= XCDR (remapped1
);
2707 goto record_sequence
;
2711 /* Verify that this key binding is not shadowed by another
2712 binding for the same key, before we say it exists.
2714 Mechanism: look for local definition of this key and if
2715 it is defined and does not match what we found then
2718 Either nil or number as value from Flookup_key
2720 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2724 /* Don't annoy user with strings from a menu such as
2725 Select Paste. Change them all to "(any string)",
2726 so that there seems to be only one menu item
2728 if (! NILP (sequence
))
2731 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2733 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2734 build_string ("(any string)"));
2737 /* It is a true unshadowed match. Record it, unless it's already
2738 been seen (as could happen when inheriting keymaps). */
2739 if (NILP (Fmember (sequence
, found
)))
2740 found
= Fcons (sequence
, found
);
2742 /* If firstonly is Qnon_ascii, then we can return the first
2743 binding we find. If firstonly is not Qnon_ascii but not
2744 nil, then we should return the first ascii-only binding
2746 if (EQ (firstonly
, Qnon_ascii
))
2747 RETURN_UNGCPRO (sequence
);
2748 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2749 RETURN_UNGCPRO (sequence
);
2751 if (CONSP (remapped
))
2753 sequence
= XCAR (remapped
);
2754 remapped
= XCDR (remapped
);
2755 goto record_sequence
;
2763 found
= Fnreverse (found
);
2765 /* firstonly may have been t, but we may have gone all the way through
2766 the keymaps without finding an all-ASCII key sequence. So just
2767 return the best we could find. */
2768 if (!NILP (firstonly
))
2769 return Fcar (found
);
2774 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2775 doc
: /* Return list of keys that invoke DEFINITION.
2776 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2777 If KEYMAP is nil, search all the currently active keymaps.
2778 If KEYMAP is a list of keymaps, search only those keymaps.
2780 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2781 rather than a list of all possible key sequences.
2782 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2783 no matter what it is.
2784 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2785 \(or their meta variants) and entirely reject menu bindings.
2787 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2788 to other keymaps or slots. This makes it possible to search for an
2789 indirect definition itself.
2791 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2792 that invoke a command which is remapped to DEFINITION, but include the
2793 remapped command in the returned list. */)
2794 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2795 Lisp_Object definition
, keymap
;
2796 Lisp_Object firstonly
, noindirect
, no_remap
;
2798 Lisp_Object sequences
, keymaps
;
2799 /* 1 means ignore all menu bindings entirely. */
2800 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2803 /* Find the relevant keymaps. */
2804 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2806 else if (!NILP (keymap
))
2807 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2809 keymaps
= Fcurrent_active_maps (Qnil
);
2811 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2812 We don't really need to check `keymap'. */
2813 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2817 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2819 /* Check heuristic-consistency of the cache. */
2820 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2821 where_is_cache
= Qnil
;
2823 if (NILP (where_is_cache
))
2825 /* We need to create the cache. */
2826 Lisp_Object args
[2];
2827 where_is_cache
= Fmake_hash_table (0, args
);
2828 where_is_cache_keymaps
= Qt
;
2830 /* Fill in the cache. */
2831 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2832 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2835 where_is_cache_keymaps
= keymaps
;
2838 /* We want to process definitions from the last to the first.
2839 Instead of consing, copy definitions to a vector and step
2840 over that vector. */
2841 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2842 n
= XINT (Flength (sequences
));
2843 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2844 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2845 defns
[i
++] = XCAR (sequences
);
2847 /* Verify that the key bindings are not shadowed. Note that
2848 the following can GC. */
2849 GCPRO2 (definition
, keymaps
);
2852 for (i
= n
- 1; i
>= 0; --i
)
2853 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2855 if (ascii_sequence_p (defns
[i
]))
2861 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2866 /* Kill the cache so that where_is_internal_1 doesn't think
2867 we're filling it up. */
2868 where_is_cache
= Qnil
;
2869 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2875 /* This is the function that Fwhere_is_internal calls using map_char_table.
2877 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2879 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2880 Since map_char_table doesn't really use the return value from this function,
2881 we the result append to RESULT, the slot in ARGS.
2883 This function can GC because it calls where_is_internal_1 which can
2887 where_is_internal_2 (args
, key
, binding
)
2888 Lisp_Object args
, key
, binding
;
2890 Lisp_Object definition
, noindirect
, this, last
;
2891 Lisp_Object result
, sequence
;
2892 int nomenus
, last_is_meta
;
2893 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2895 GCPRO3 (args
, key
, binding
);
2896 result
= XCDR (XCAR (args
));
2897 definition
= XCAR (XCAR (XCAR (args
)));
2898 noindirect
= XCDR (XCAR (XCAR (args
)));
2899 this = XCAR (XCAR (XCDR (args
)));
2900 last
= XCDR (XCAR (XCDR (args
)));
2901 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2902 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2904 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2905 this, last
, nomenus
, last_is_meta
);
2907 if (!NILP (sequence
))
2908 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2914 /* This function can GC because get_keyelt can. */
2917 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2918 nomenus
, last_is_meta
)
2919 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2920 int nomenus
, last_is_meta
;
2922 Lisp_Object sequence
;
2924 /* Search through indirections unless that's not wanted. */
2925 if (NILP (noindirect
))
2926 binding
= get_keyelt (binding
, 0);
2928 /* End this iteration if this element does not match
2931 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2932 || EQ (binding
, definition
)
2933 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2934 /* Doesn't match. */
2937 /* We have found a match. Construct the key sequence where we found it. */
2938 if (INTEGERP (key
) && last_is_meta
)
2940 sequence
= Fcopy_sequence (this);
2941 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2944 sequence
= append_key (this, key
);
2946 if (!NILP (where_is_cache
))
2948 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2949 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2956 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2958 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2959 doc
: /* Insert the list of all defined keys and their definitions.
2960 The list is inserted in the current buffer, while the bindings are
2961 looked up in BUFFER.
2962 The optional argument PREFIX, if non-nil, should be a key sequence;
2963 then we display only bindings that start with that prefix.
2964 The optional argument MENUS, if non-nil, says to mention menu bindings.
2965 \(Ordinarily these are omitted from the output.) */)
2966 (buffer
, prefix
, menus
)
2967 Lisp_Object buffer
, prefix
, menus
;
2969 Lisp_Object outbuf
, shadow
;
2970 int nomenu
= NILP (menus
);
2971 register Lisp_Object start1
;
2972 struct gcpro gcpro1
;
2974 char *alternate_heading
2976 Keyboard translations:\n\n\
2977 You type Translation\n\
2978 -------- -----------\n";
2983 outbuf
= Fcurrent_buffer ();
2985 /* Report on alternates for keys. */
2986 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2989 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2990 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2992 for (c
= 0; c
< translate_len
; c
++)
2993 if (translate
[c
] != c
)
2995 char buf
[KEY_DESCRIPTION_SIZE
];
2998 if (alternate_heading
)
3000 insert_string (alternate_heading
);
3001 alternate_heading
= 0;
3004 bufend
= push_key_description (translate
[c
], buf
, 1);
3005 insert (buf
, bufend
- buf
);
3006 Findent_to (make_number (16), make_number (1));
3007 bufend
= push_key_description (c
, buf
, 1);
3008 insert (buf
, bufend
- buf
);
3012 /* Insert calls signal_after_change which may GC. */
3013 translate
= SDATA (Vkeyboard_translate_table
);
3019 if (!NILP (Vkey_translation_map
))
3020 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
3021 "Key translations", nomenu
, 1, 0, 0);
3024 /* Print the (major mode) local map. */
3026 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
3027 start1
= current_kboard
->Voverriding_terminal_local_map
;
3028 else if (!NILP (Voverriding_local_map
))
3029 start1
= Voverriding_local_map
;
3033 describe_map_tree (start1
, 1, shadow
, prefix
,
3034 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
3035 shadow
= Fcons (start1
, shadow
);
3039 /* Print the minor mode and major mode keymaps. */
3041 Lisp_Object
*modes
, *maps
;
3043 /* Temporarily switch to `buffer', so that we can get that buffer's
3044 minor modes correctly. */
3045 Fset_buffer (buffer
);
3047 nmaps
= current_minor_maps (&modes
, &maps
);
3048 Fset_buffer (outbuf
);
3050 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3051 XBUFFER (buffer
), Qkeymap
);
3054 describe_map_tree (start1
, 1, shadow
, prefix
,
3055 "\f\n`keymap' Property Bindings", nomenu
,
3057 shadow
= Fcons (start1
, shadow
);
3060 /* Print the minor mode maps. */
3061 for (i
= 0; i
< nmaps
; i
++)
3063 /* The title for a minor mode keymap
3064 is constructed at run time.
3065 We let describe_map_tree do the actual insertion
3066 because it takes care of other features when doing so. */
3069 if (!SYMBOLP (modes
[i
]))
3072 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3076 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
3077 SCHARS (SYMBOL_NAME (modes
[i
])));
3078 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3080 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
3081 p
+= sizeof (" Minor Mode Bindings") - 1;
3084 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3085 title
, nomenu
, 0, 0, 0);
3086 shadow
= Fcons (maps
[i
], shadow
);
3089 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3090 XBUFFER (buffer
), Qlocal_map
);
3093 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3094 describe_map_tree (start1
, 1, shadow
, prefix
,
3095 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3097 describe_map_tree (start1
, 1, shadow
, prefix
,
3098 "\f\n`local-map' Property Bindings",
3101 shadow
= Fcons (start1
, shadow
);
3105 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3106 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3108 /* Print the function-key-map translations under this prefix. */
3109 if (!NILP (Vfunction_key_map
))
3110 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
3111 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3117 /* Insert a description of the key bindings in STARTMAP,
3118 followed by those of all maps reachable through STARTMAP.
3119 If PARTIAL is nonzero, omit certain "uninteresting" commands
3120 (such as `undefined').
3121 If SHADOW is non-nil, it is a list of maps;
3122 don't mention keys which would be shadowed by any of them.
3123 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3124 TITLE, if not 0, is a string to insert at the beginning.
3125 TITLE should not end with a colon or a newline; we supply that.
3126 If NOMENU is not 0, then omit menu-bar commands.
3128 If TRANSL is nonzero, the definitions are actually key translations
3129 so print strings and vectors differently.
3131 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3134 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3135 don't omit it; instead, mention it but say it is shadowed. */
3138 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3139 always_title
, mention_shadow
)
3140 Lisp_Object startmap
, shadow
, prefix
;
3148 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3149 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3156 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3159 GCPRO3 (maps
, seen
, sub_shadows
);
3165 /* Delete from MAPS each element that is for the menu bar. */
3166 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3168 Lisp_Object elt
, prefix
, tem
;
3171 prefix
= Fcar (elt
);
3172 if (XVECTOR (prefix
)->size
>= 1)
3174 tem
= Faref (prefix
, make_number (0));
3175 if (EQ (tem
, Qmenu_bar
))
3176 maps
= Fdelq (elt
, maps
);
3181 if (!NILP (maps
) || always_title
)
3185 insert_string (title
);
3188 insert_string (" Starting With ");
3189 insert1 (Fkey_description (prefix
, Qnil
));
3191 insert_string (":\n");
3193 insert_string (key_heading
);
3197 for (; !NILP (maps
); maps
= Fcdr (maps
))
3199 register Lisp_Object elt
, prefix
, tail
;
3202 prefix
= Fcar (elt
);
3206 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3210 shmap
= XCAR (tail
);
3212 /* If the sequence by which we reach this keymap is zero-length,
3213 then the shadow map for this keymap is just SHADOW. */
3214 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3215 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3217 /* If the sequence by which we reach this keymap actually has
3218 some elements, then the sequence's definition in SHADOW is
3219 what we should use. */
3222 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3223 if (INTEGERP (shmap
))
3227 /* If shmap is not nil and not a keymap,
3228 it completely shadows this map, so don't
3229 describe this map at all. */
3230 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3234 sub_shadows
= Fcons (shmap
, sub_shadows
);
3237 /* Maps we have already listed in this loop shadow this map. */
3238 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3241 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3243 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3246 describe_map (Fcdr (elt
), prefix
,
3247 transl
? describe_translation
: describe_command
,
3248 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3254 insert_string ("\n");
3259 static int previous_description_column
;
3262 describe_command (definition
, args
)
3263 Lisp_Object definition
, args
;
3265 register Lisp_Object tem1
;
3266 int column
= (int) current_column (); /* iftc */
3267 int description_column
;
3269 /* If column 16 is no good, go to col 32;
3270 but don't push beyond that--go to next line instead. */
3274 description_column
= 32;
3276 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3277 description_column
= 32;
3279 description_column
= 16;
3281 Findent_to (make_number (description_column
), make_number (1));
3282 previous_description_column
= description_column
;
3284 if (SYMBOLP (definition
))
3286 tem1
= SYMBOL_NAME (definition
);
3288 insert_string ("\n");
3290 else if (STRINGP (definition
) || VECTORP (definition
))
3291 insert_string ("Keyboard Macro\n");
3292 else if (KEYMAPP (definition
))
3293 insert_string ("Prefix Command\n");
3295 insert_string ("??\n");
3299 describe_translation (definition
, args
)
3300 Lisp_Object definition
, args
;
3302 register Lisp_Object tem1
;
3304 Findent_to (make_number (16), make_number (1));
3306 if (SYMBOLP (definition
))
3308 tem1
= SYMBOL_NAME (definition
);
3310 insert_string ("\n");
3312 else if (STRINGP (definition
) || VECTORP (definition
))
3314 insert1 (Fkey_description (definition
, Qnil
));
3315 insert_string ("\n");
3317 else if (KEYMAPP (definition
))
3318 insert_string ("Prefix Command\n");
3320 insert_string ("??\n");
3323 /* describe_map puts all the usable elements of a sparse keymap
3324 into an array of `struct describe_map_elt',
3325 then sorts them by the events. */
3327 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3329 /* qsort comparison function for sorting `struct describe_map_elt' by
3333 describe_map_compare (aa
, bb
)
3334 const void *aa
, *bb
;
3336 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3337 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3338 return ((XINT (a
->event
) > XINT (b
->event
))
3339 - (XINT (a
->event
) < XINT (b
->event
)));
3340 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3342 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3344 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3345 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3346 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3351 /* Describe the contents of map MAP, assuming that this map itself is
3352 reached by the sequence of prefix keys PREFIX (a string or vector).
3353 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3356 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3357 seen
, nomenu
, mention_shadow
)
3358 register Lisp_Object map
;
3360 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3367 Lisp_Object tail
, definition
, event
;
3369 Lisp_Object suppress
;
3372 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3374 /* These accumulate the values from sparse keymap bindings,
3375 so we can sort them and handle them in order. */
3376 int length_needed
= 0;
3377 struct describe_map_elt
*vect
;
3384 suppress
= intern ("suppress-keymap");
3386 /* This vector gets used to present single keys to Flookup_key. Since
3387 that is done once per keymap element, we don't want to cons up a
3388 fresh vector every time. */
3389 kludge
= Fmake_vector (make_number (1), Qnil
);
3392 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3395 vect
= ((struct describe_map_elt
*)
3396 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3398 GCPRO3 (prefix
, definition
, kludge
);
3400 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3404 if (VECTORP (XCAR (tail
))
3405 || CHAR_TABLE_P (XCAR (tail
)))
3406 describe_vector (XCAR (tail
),
3407 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3408 (int *)0, 0, 1, mention_shadow
);
3409 else if (CONSP (XCAR (tail
)))
3411 int this_shadowed
= 0;
3413 event
= XCAR (XCAR (tail
));
3415 /* Ignore bindings whose "prefix" are not really valid events.
3416 (We get these in the frames and buffers menu.) */
3417 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3420 if (nomenu
&& EQ (event
, Qmenu_bar
))
3423 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3425 /* Don't show undefined commands or suppressed commands. */
3426 if (NILP (definition
)) continue;
3427 if (SYMBOLP (definition
) && partial
)
3429 tem
= Fget (definition
, suppress
);
3434 /* Don't show a command that isn't really visible
3435 because a local definition of the same key shadows it. */
3437 ASET (kludge
, 0, event
);
3440 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3443 /* Avoid generating duplicate entries if the
3444 shadowed binding has the same definition. */
3445 if (mention_shadow
&& !EQ (tem
, definition
))
3452 tem
= Flookup_key (map
, kludge
, Qt
);
3453 if (!EQ (tem
, definition
)) continue;
3455 vect
[slots_used
].event
= event
;
3456 vect
[slots_used
].definition
= definition
;
3457 vect
[slots_used
].shadowed
= this_shadowed
;
3460 else if (EQ (XCAR (tail
), Qkeymap
))
3462 /* The same keymap might be in the structure twice, if we're
3463 using an inherited keymap. So skip anything we've already
3465 tem
= Fassq (tail
, *seen
);
3466 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3468 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3472 /* If we found some sparse map events, sort them. */
3474 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3475 describe_map_compare
);
3477 /* Now output them in sorted order. */
3479 for (i
= 0; i
< slots_used
; i
++)
3481 Lisp_Object start
, end
;
3485 previous_description_column
= 0;
3490 ASET (kludge
, 0, vect
[i
].event
);
3491 start
= vect
[i
].event
;
3494 definition
= vect
[i
].definition
;
3496 /* Find consecutive chars that are identically defined. */
3497 if (INTEGERP (vect
[i
].event
))
3499 while (i
+ 1 < slots_used
3500 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3501 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3502 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3504 end
= vect
[i
].event
;
3507 /* Now START .. END is the range to describe next. */
3509 /* Insert the string to describe the event START. */
3510 insert1 (Fkey_description (kludge
, prefix
));
3512 if (!EQ (start
, end
))
3516 ASET (kludge
, 0, end
);
3517 /* Insert the string to describe the character END. */
3518 insert1 (Fkey_description (kludge
, prefix
));
3521 /* Print a description of the definition of this character.
3522 elt_describer will take care of spacing out far enough
3523 for alignment purposes. */
3524 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3526 if (vect
[i
].shadowed
)
3529 insert_string ("\n (that binding is currently shadowed by another mode)");
3538 describe_vector_princ (elt
, fun
)
3539 Lisp_Object elt
, fun
;
3541 Findent_to (make_number (16), make_number (1));
3546 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3547 doc
: /* Insert a description of contents of VECTOR.
3548 This is text showing the elements of vector matched against indices.
3549 DESCRIBER is the output function used; nil means use `princ'. */)
3551 Lisp_Object vector
, describer
;
3553 int count
= SPECPDL_INDEX ();
3554 if (NILP (describer
))
3555 describer
= intern ("princ");
3556 specbind (Qstandard_output
, Fcurrent_buffer ());
3557 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3558 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3559 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3561 return unbind_to (count
, Qnil
);
3564 /* Insert in the current buffer a description of the contents of VECTOR.
3565 We call ELT_DESCRIBER to insert the description of one value found
3568 ELT_PREFIX describes what "comes before" the keys or indices defined
3569 by this vector. This is a human-readable string whose size
3570 is not necessarily related to the situation.
3572 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3573 leads to this keymap.
3575 If the vector is a chartable, ELT_PREFIX is the vector
3576 of bytes that lead to the character set or portion of a character
3577 set described by this chartable.
3579 If PARTIAL is nonzero, it means do not mention suppressed commands
3580 (that assumes the vector is in a keymap).
3582 SHADOW is a list of keymaps that shadow this map.
3583 If it is non-nil, then we look up the key in those maps
3584 and we don't mention it now if it is defined by any of them.
3586 ENTIRE_MAP is the keymap in which this vector appears.
3587 If the definition in effect in the whole map does not match
3588 the one in this vector, we ignore this one.
3590 When describing a sub-char-table, INDICES is a list of
3591 indices at higher levels in this char-table,
3592 and CHAR_TABLE_DEPTH says how many levels down we have gone.
3594 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3596 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3599 describe_vector (vector
, prefix
, args
, elt_describer
,
3600 partial
, shadow
, entire_map
,
3601 indices
, char_table_depth
, keymap_p
,
3603 register Lisp_Object vector
;
3604 Lisp_Object prefix
, args
;
3605 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3608 Lisp_Object entire_map
;
3610 int char_table_depth
;
3614 Lisp_Object definition
;
3616 Lisp_Object elt_prefix
= Qnil
;
3618 Lisp_Object suppress
;
3621 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3622 /* Range of elements to be handled. */
3624 /* A flag to tell if a leaf in this level of char-table is not a
3625 generic character (i.e. a complete multibyte character). */
3633 indices
= (int *) alloca (3 * sizeof (int));
3639 /* Call Fkey_description first, to avoid GC bug for the other string. */
3640 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3643 tem
= Fkey_description (prefix
, Qnil
);
3644 elt_prefix
= concat2 (tem
, build_string (" "));
3649 /* This vector gets used to present single keys to Flookup_key. Since
3650 that is done once per vector element, we don't want to cons up a
3651 fresh vector every time. */
3652 kludge
= Fmake_vector (make_number (1), Qnil
);
3653 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3656 suppress
= intern ("suppress-keymap");
3658 if (CHAR_TABLE_P (vector
))
3660 if (char_table_depth
== 0)
3662 /* VECTOR is a top level char-table. */
3665 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3669 /* VECTOR is a sub char-table. */
3670 if (char_table_depth
>= 3)
3671 /* A char-table is never that deep. */
3672 error ("Too deep char table");
3675 = (CHARSET_VALID_P (indices
[0])
3676 && ((CHARSET_DIMENSION (indices
[0]) == 1
3677 && char_table_depth
== 1)
3678 || char_table_depth
== 2));
3680 /* Meaningful elements are from 32th to 127th. */
3682 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3687 /* This does the right thing for ordinary vectors. */
3691 to
= XVECTOR (vector
)->size
;
3694 for (i
= from
; i
< to
; i
++)
3696 int this_shadowed
= 0;
3699 if (CHAR_TABLE_P (vector
))
3701 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3704 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3705 && !CHARSET_DEFINED_P (i
- 128))
3709 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3712 definition
= get_keyelt (AREF (vector
, i
), 0);
3714 if (NILP (definition
)) continue;
3716 /* Don't mention suppressed commands. */
3717 if (SYMBOLP (definition
) && partial
)
3721 tem
= Fget (definition
, suppress
);
3723 if (!NILP (tem
)) continue;
3726 /* Set CHARACTER to the character this entry describes, if any.
3727 Also update *INDICES. */
3728 if (CHAR_TABLE_P (vector
))
3730 indices
[char_table_depth
] = i
;
3732 if (char_table_depth
== 0)
3735 indices
[0] = i
- 128;
3737 else if (complete_char
)
3739 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3747 ASET (kludge
, 0, make_number (character
));
3749 /* If this binding is shadowed by some other map, ignore it. */
3750 if (!NILP (shadow
) && complete_char
)
3754 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3765 /* Ignore this definition if it is shadowed by an earlier
3766 one in the same keymap. */
3767 if (!NILP (entire_map
) && complete_char
)
3771 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3773 if (!EQ (tem
, definition
))
3779 if (char_table_depth
== 0)
3784 /* For a sub char-table, show the depth by indentation.
3785 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3786 if (char_table_depth
> 0)
3787 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3789 /* Output the prefix that applies to every entry in this map. */
3790 if (!NILP (elt_prefix
))
3791 insert1 (elt_prefix
);
3793 /* Insert or describe the character this slot is for,
3794 or a description of what it is for. */
3795 if (SUB_CHAR_TABLE_P (vector
))
3798 insert_char (character
);
3801 /* We need an octal representation for this block of
3804 sprintf (work
, "(row %d)", i
);
3805 insert (work
, strlen (work
));
3808 else if (CHAR_TABLE_P (vector
))
3811 insert1 (Fkey_description (kludge
, prefix
));
3814 /* Print the information for this character set. */
3815 insert_string ("<");
3816 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3818 insert_from_string (tem2
, 0, 0, SCHARS (tem2
),
3827 insert1 (Fkey_description (kludge
, prefix
));
3830 /* If we find a sub char-table within a char-table,
3831 scan it recursively; it defines the details for
3832 a character set or a portion of a character set. */
3833 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3836 describe_vector (definition
, prefix
, args
, elt_describer
,
3837 partial
, shadow
, entire_map
,
3838 indices
, char_table_depth
+ 1, keymap_p
,
3845 /* Find all consecutive characters or rows that have the same
3846 definition. But, for elements of a top level char table, if
3847 they are for charsets, we had better describe one by one even
3848 if they have the same definition. */
3849 if (CHAR_TABLE_P (vector
))
3853 if (char_table_depth
== 0)
3854 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3856 while (i
+ 1 < limit
3857 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3859 && !NILP (Fequal (tem2
, definition
)))
3864 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3866 && !NILP (Fequal (tem2
, definition
)))
3870 /* If we have a range of more than one character,
3871 print where the range reaches to. */
3873 if (i
!= starting_i
)
3877 ASET (kludge
, 0, make_number (i
));
3879 if (!NILP (elt_prefix
))
3880 insert1 (elt_prefix
);
3882 if (CHAR_TABLE_P (vector
))
3884 if (char_table_depth
== 0)
3886 insert1 (Fkey_description (kludge
, prefix
));
3888 else if (complete_char
)
3890 indices
[char_table_depth
] = i
;
3891 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3892 insert_char (character
);
3896 /* We need an octal representation for this block of
3899 sprintf (work
, "(row %d)", i
);
3900 insert (work
, strlen (work
));
3905 insert1 (Fkey_description (kludge
, prefix
));
3909 /* Print a description of the definition of this character.
3910 elt_describer will take care of spacing out far enough
3911 for alignment purposes. */
3912 (*elt_describer
) (definition
, args
);
3917 insert_string (" (binding currently shadowed)");
3922 /* For (sub) char-table, print `defalt' slot at last. */
3923 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3925 insert (" ", char_table_depth
* 2);
3926 insert_string ("<<default>>");
3927 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3933 /* Apropos - finding all symbols whose names match a regexp. */
3934 static Lisp_Object apropos_predicate
;
3935 static Lisp_Object apropos_accumulate
;
3938 apropos_accum (symbol
, string
)
3939 Lisp_Object symbol
, string
;
3941 register Lisp_Object tem
;
3943 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3944 if (!NILP (tem
) && !NILP (apropos_predicate
))
3945 tem
= call1 (apropos_predicate
, symbol
);
3947 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3950 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3951 doc
: /* Show all symbols whose names contain match for REGEXP.
3952 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3953 for each symbol and a symbol is mentioned only if that returns non-nil.
3954 Return list of symbols found. */)
3956 Lisp_Object regexp
, predicate
;
3959 CHECK_STRING (regexp
);
3960 apropos_predicate
= predicate
;
3961 apropos_accumulate
= Qnil
;
3962 map_obarray (Vobarray
, apropos_accum
, regexp
);
3963 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3964 apropos_accumulate
= Qnil
;
3965 apropos_predicate
= Qnil
;
3972 Qkeymap
= intern ("keymap");
3973 staticpro (&Qkeymap
);
3974 staticpro (&apropos_predicate
);
3975 staticpro (&apropos_accumulate
);
3976 apropos_predicate
= Qnil
;
3977 apropos_accumulate
= Qnil
;
3979 /* Now we are ready to set up this property, so we can
3980 create char tables. */
3981 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3983 /* Initialize the keymaps standardly used.
3984 Each one is the value of a Lisp variable, and is also
3985 pointed to by a C variable */
3987 global_map
= Fmake_keymap (Qnil
);
3988 Fset (intern ("global-map"), global_map
);
3990 current_global_map
= global_map
;
3991 staticpro (&global_map
);
3992 staticpro (¤t_global_map
);
3994 meta_map
= Fmake_keymap (Qnil
);
3995 Fset (intern ("esc-map"), meta_map
);
3996 Ffset (intern ("ESC-prefix"), meta_map
);
3998 control_x_map
= Fmake_keymap (Qnil
);
3999 Fset (intern ("ctl-x-map"), control_x_map
);
4000 Ffset (intern ("Control-X-prefix"), control_x_map
);
4003 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
4004 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
4005 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
4006 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
4007 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
4009 staticpro (&exclude_keys
);
4011 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
4012 doc
: /* List of commands given new key bindings recently.
4013 This is used for internal purposes during Emacs startup;
4014 don't alter it yourself. */);
4015 Vdefine_key_rebound_commands
= Qt
;
4017 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
4018 doc
: /* Default keymap to use when reading from the minibuffer. */);
4019 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
4021 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
4022 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
4023 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
4024 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
4026 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
4027 doc
: /* Local keymap for minibuffer input with completion. */);
4028 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
4029 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
4031 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
4032 &Vminibuffer_local_filename_completion_map
,
4033 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
4034 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
4035 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
4036 Vminibuffer_local_completion_map
);
4039 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
4040 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
4041 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
4042 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
4043 Vminibuffer_local_completion_map
);
4045 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
4046 &Vminibuffer_local_must_match_filename_map
,
4047 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
4048 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
4049 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
4050 Vminibuffer_local_must_match_map
);
4052 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
4053 doc
: /* Alist of keymaps to use for minor modes.
4054 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
4055 key sequences and look up bindings iff VARIABLE's value is non-nil.
4056 If two active keymaps bind the same key, the keymap appearing earlier
4057 in the list takes precedence. */);
4058 Vminor_mode_map_alist
= Qnil
;
4060 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
4061 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
4062 This variable is an alist just like `minor-mode-map-alist', and it is
4063 used the same way (and before `minor-mode-map-alist'); however,
4064 it is provided for major modes to bind locally. */);
4065 Vminor_mode_overriding_map_alist
= Qnil
;
4067 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
4068 doc
: /* List of keymap alists to use for emulations modes.
4069 It is intended for modes or packages using multiple minor-mode keymaps.
4070 Each element is a keymap alist just like `minor-mode-map-alist', or a
4071 symbol with a variable binding which is a keymap alist, and it is used
4072 the same way. The "active" keymaps in each alist are used before
4073 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
4074 Vemulation_mode_map_alists
= Qnil
;
4077 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
4078 doc
: /* Keymap that translates key sequences to key sequences during input.
4079 This is used mainly for mapping ASCII function key sequences into
4080 real Emacs function key events (symbols).
4082 The `read-key-sequence' function replaces any subsequence bound by
4083 `function-key-map' with its binding. More precisely, when the active
4084 keymaps have no binding for the current key sequence but
4085 `function-key-map' binds a suffix of the sequence to a vector or string,
4086 `read-key-sequence' replaces the matching suffix with its binding, and
4087 continues with the new sequence.
4089 If the binding is a function, it is called with one argument (the prompt)
4090 and its return value (a key sequence) is used.
4092 The events that come from bindings in `function-key-map' are not
4093 themselves looked up in `function-key-map'.
4095 For example, suppose `function-key-map' binds `ESC O P' to [f1].
4096 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
4097 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
4098 key, typing `ESC O P x' would return [f1 x]. */);
4099 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
4101 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
4102 doc
: /* Keymap of key translations that can override keymaps.
4103 This keymap works like `function-key-map', but comes after that,
4104 and its non-prefix bindings override ordinary bindings. */);
4105 Vkey_translation_map
= Qnil
;
4107 staticpro (&Vmouse_events
);
4108 Vmouse_events
= Fcons (intern ("menu-bar"),
4109 Fcons (intern ("tool-bar"),
4110 Fcons (intern ("header-line"),
4111 Fcons (intern ("mode-line"),
4112 Fcons (intern ("mouse-1"),
4113 Fcons (intern ("mouse-2"),
4114 Fcons (intern ("mouse-3"),
4115 Fcons (intern ("mouse-4"),
4116 Fcons (intern ("mouse-5"),
4120 Qsingle_key_description
= intern ("single-key-description");
4121 staticpro (&Qsingle_key_description
);
4123 Qkey_description
= intern ("key-description");
4124 staticpro (&Qkey_description
);
4126 Qkeymapp
= intern ("keymapp");
4127 staticpro (&Qkeymapp
);
4129 Qnon_ascii
= intern ("non-ascii");
4130 staticpro (&Qnon_ascii
);
4132 Qmenu_item
= intern ("menu-item");
4133 staticpro (&Qmenu_item
);
4135 Qremap
= intern ("remap");
4136 staticpro (&Qremap
);
4138 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
4139 staticpro (&command_remapping_vector
);
4141 where_is_cache_keymaps
= Qt
;
4142 where_is_cache
= Qnil
;
4143 staticpro (&where_is_cache
);
4144 staticpro (&where_is_cache_keymaps
);
4146 defsubr (&Skeymapp
);
4147 defsubr (&Skeymap_parent
);
4148 defsubr (&Skeymap_prompt
);
4149 defsubr (&Sset_keymap_parent
);
4150 defsubr (&Smake_keymap
);
4151 defsubr (&Smake_sparse_keymap
);
4152 defsubr (&Smap_keymap
);
4153 defsubr (&Scopy_keymap
);
4154 defsubr (&Scommand_remapping
);
4155 defsubr (&Skey_binding
);
4156 defsubr (&Slocal_key_binding
);
4157 defsubr (&Sglobal_key_binding
);
4158 defsubr (&Sminor_mode_key_binding
);
4159 defsubr (&Sdefine_key
);
4160 defsubr (&Slookup_key
);
4161 defsubr (&Sdefine_prefix_command
);
4162 defsubr (&Suse_global_map
);
4163 defsubr (&Suse_local_map
);
4164 defsubr (&Scurrent_local_map
);
4165 defsubr (&Scurrent_global_map
);
4166 defsubr (&Scurrent_minor_mode_maps
);
4167 defsubr (&Scurrent_active_maps
);
4168 defsubr (&Saccessible_keymaps
);
4169 defsubr (&Skey_description
);
4170 defsubr (&Sdescribe_vector
);
4171 defsubr (&Ssingle_key_description
);
4172 defsubr (&Stext_char_description
);
4173 defsubr (&Swhere_is_internal
);
4174 defsubr (&Sdescribe_buffer_bindings
);
4175 defsubr (&Sapropos_internal
);
4181 initial_define_key (global_map
, 033, "ESC-prefix");
4182 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
4185 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4186 (do not change this comment) */