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 && CHAR_VALID_P (charset
, 1)
2390 && ((c1
== 0 && c2
== -1) || c2
== 0))
2392 /* Handle a generic character. */
2396 name
= CHARSET_TABLE_INFO (charset
, CHARSET_SHORT_NAME_IDX
);
2397 CHECK_STRING (name
);
2399 /* Only a charset is specified. */
2400 sprintf (buf
, "Generic char %d: all of ", without_bits
);
2402 /* 1st code-point of 2-dimensional charset is specified. */
2403 sprintf (buf
, "Generic char %d: row %d of ", without_bits
, c1
);
2404 return concat2 (build_string (buf
), name
);
2408 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
2412 end
= push_key_description (XUINT (key
), tem
, 1);
2414 nchars
= multibyte_chars_in_text (tem
, nbytes
);
2415 if (nchars
== nbytes
)
2418 string
= build_string (tem
);
2421 string
= make_multibyte_string (tem
, nchars
, nbytes
);
2425 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2427 if (NILP (no_angles
))
2430 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2431 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2432 return build_string (buffer
);
2435 return Fsymbol_name (key
);
2437 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2438 return Fcopy_sequence (key
);
2440 error ("KEY must be an integer, cons, symbol, or string");
2445 push_text_char_description (c
, p
)
2446 register unsigned int c
;
2458 *p
++ = c
+ 64; /* 'A' - 1 */
2470 /* This function cannot GC. */
2472 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2473 doc
: /* Return a pretty description of file-character CHARACTER.
2474 Control characters turn into "^char", etc. This differs from
2475 `single-key-description' which turns them into "C-char".
2476 Also, this function recognizes the 2**7 bit as the Meta character,
2477 whereas `single-key-description' uses the 2**27 bit for Meta.
2478 See Info node `(elisp)Describing Characters' for examples. */)
2480 Lisp_Object character
;
2482 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2483 unsigned char str
[6];
2486 CHECK_NUMBER (character
);
2488 c
= XINT (character
);
2489 if (!SINGLE_BYTE_CHAR_P (c
))
2491 int len
= CHAR_STRING (c
, str
);
2493 return make_multibyte_string (str
, 1, len
);
2496 *push_text_char_description (c
& 0377, str
) = 0;
2498 return build_string (str
);
2501 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2504 ascii_sequence_p (seq
)
2508 int len
= XINT (Flength (seq
));
2510 for (i
= 0; i
< len
; i
++)
2512 Lisp_Object ii
, elt
;
2514 XSETFASTINT (ii
, i
);
2515 elt
= Faref (seq
, ii
);
2518 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2526 /* where-is - finding a command in a set of keymaps. */
2528 static Lisp_Object
where_is_internal ();
2529 static Lisp_Object
where_is_internal_1 ();
2530 static void where_is_internal_2 ();
2532 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2533 Returns the first non-nil binding found in any of those maps. */
2536 shadow_lookup (shadow
, key
, flag
)
2537 Lisp_Object shadow
, key
, flag
;
2539 Lisp_Object tail
, value
;
2541 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2543 value
= Flookup_key (XCAR (tail
), key
, flag
);
2544 if (NATNUMP (value
))
2546 value
= Flookup_key (XCAR (tail
),
2547 Fsubstring (key
, make_number (0), value
), flag
);
2551 else if (!NILP (value
))
2557 static Lisp_Object Vmouse_events
;
2559 /* This function can GC if Flookup_key autoloads any keymaps. */
2562 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2563 Lisp_Object definition
, keymaps
;
2564 Lisp_Object firstonly
, noindirect
, no_remap
;
2566 Lisp_Object maps
= Qnil
;
2567 Lisp_Object found
, sequences
;
2568 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2569 /* 1 means ignore all menu bindings entirely. */
2570 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2572 /* If this command is remapped, then it has no key bindings
2574 if (NILP (no_remap
) && SYMBOLP (definition
))
2577 if (tem
= Fcommand_remapping (definition
, Qnil
), !NILP (tem
))
2582 while (CONSP (found
))
2586 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2587 found
= XCDR (found
);
2590 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2594 for (; !NILP (maps
); maps
= Fcdr (maps
))
2596 /* Key sequence to reach map, and the map that it reaches */
2597 register Lisp_Object
this, map
, tem
;
2599 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2600 [M-CHAR] sequences, check if last character of the sequence
2601 is the meta-prefix char. */
2605 this = Fcar (Fcar (maps
));
2606 map
= Fcdr (Fcar (maps
));
2607 last
= make_number (XINT (Flength (this)) - 1);
2608 last_is_meta
= (XINT (last
) >= 0
2609 && EQ (Faref (this, last
), meta_prefix_char
));
2611 /* if (nomenus && !ascii_sequence_p (this)) */
2612 if (nomenus
&& XINT (last
) >= 0
2613 && SYMBOLP (tem
= Faref (this, make_number (0)))
2614 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2615 /* If no menu entries should be returned, skip over the
2616 keymaps bound to `menu-bar' and `tool-bar' and other
2617 non-ascii prefixes like `C-down-mouse-2'. */
2624 /* Because the code we want to run on each binding is rather
2625 large, we don't want to have two separate loop bodies for
2626 sparse keymap bindings and tables; we want to iterate one
2627 loop body over both keymap and vector bindings.
2629 For this reason, if Fcar (map) is a vector, we don't
2630 advance map to the next element until i indicates that we
2631 have finished off the vector. */
2632 Lisp_Object elt
, key
, binding
;
2640 /* Set key and binding to the current key and binding, and
2641 advance map and i to the next binding. */
2644 Lisp_Object sequence
;
2646 /* In a vector, look at each element. */
2647 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2649 binding
= AREF (elt
, i
);
2650 XSETFASTINT (key
, i
);
2651 sequence
= where_is_internal_1 (binding
, key
, definition
,
2653 last
, nomenus
, last_is_meta
);
2654 if (!NILP (sequence
))
2655 sequences
= Fcons (sequence
, sequences
);
2658 else if (CHAR_TABLE_P (elt
))
2660 Lisp_Object indices
[3];
2663 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2664 Qnil
), /* Result accumulator. */
2665 Fcons (Fcons (this, last
),
2666 Fcons (make_number (nomenus
),
2667 make_number (last_is_meta
))));
2668 map_char_table (where_is_internal_2
, Qnil
, elt
, elt
, args
,
2670 sequences
= XCDR (XCAR (args
));
2672 else if (CONSP (elt
))
2674 Lisp_Object sequence
;
2677 binding
= XCDR (elt
);
2679 sequence
= where_is_internal_1 (binding
, key
, definition
,
2681 last
, nomenus
, last_is_meta
);
2682 if (!NILP (sequence
))
2683 sequences
= Fcons (sequence
, sequences
);
2687 while (!NILP (sequences
))
2689 Lisp_Object sequence
, remapped
, function
;
2691 sequence
= XCAR (sequences
);
2692 sequences
= XCDR (sequences
);
2694 /* If the current sequence is a command remapping with
2695 format [remap COMMAND], find the key sequences
2696 which run COMMAND, and use those sequences instead. */
2699 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2700 && EQ (AREF (sequence
, 0), Qremap
)
2701 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2703 Lisp_Object remapped1
;
2705 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2706 if (CONSP (remapped1
))
2708 /* Verify that this key binding actually maps to the
2709 remapped command (see below). */
2710 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2712 sequence
= XCAR (remapped1
);
2713 remapped
= XCDR (remapped1
);
2714 goto record_sequence
;
2718 /* Verify that this key binding is not shadowed by another
2719 binding for the same key, before we say it exists.
2721 Mechanism: look for local definition of this key and if
2722 it is defined and does not match what we found then
2725 Either nil or number as value from Flookup_key
2727 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2731 /* Don't annoy user with strings from a menu such as
2732 Select Paste. Change them all to "(any string)",
2733 so that there seems to be only one menu item
2735 if (! NILP (sequence
))
2738 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2740 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2741 build_string ("(any string)"));
2744 /* It is a true unshadowed match. Record it, unless it's already
2745 been seen (as could happen when inheriting keymaps). */
2746 if (NILP (Fmember (sequence
, found
)))
2747 found
= Fcons (sequence
, found
);
2749 /* If firstonly is Qnon_ascii, then we can return the first
2750 binding we find. If firstonly is not Qnon_ascii but not
2751 nil, then we should return the first ascii-only binding
2753 if (EQ (firstonly
, Qnon_ascii
))
2754 RETURN_UNGCPRO (sequence
);
2755 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2756 RETURN_UNGCPRO (sequence
);
2758 if (CONSP (remapped
))
2760 sequence
= XCAR (remapped
);
2761 remapped
= XCDR (remapped
);
2762 goto record_sequence
;
2770 found
= Fnreverse (found
);
2772 /* firstonly may have been t, but we may have gone all the way through
2773 the keymaps without finding an all-ASCII key sequence. So just
2774 return the best we could find. */
2775 if (!NILP (firstonly
))
2776 return Fcar (found
);
2781 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2782 doc
: /* Return list of keys that invoke DEFINITION.
2783 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2784 If KEYMAP is nil, search all the currently active keymaps.
2785 If KEYMAP is a list of keymaps, search only those keymaps.
2787 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2788 rather than a list of all possible key sequences.
2789 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2790 no matter what it is.
2791 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2792 \(or their meta variants) and entirely reject menu bindings.
2794 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2795 to other keymaps or slots. This makes it possible to search for an
2796 indirect definition itself.
2798 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2799 that invoke a command which is remapped to DEFINITION, but include the
2800 remapped command in the returned list. */)
2801 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2802 Lisp_Object definition
, keymap
;
2803 Lisp_Object firstonly
, noindirect
, no_remap
;
2805 Lisp_Object sequences
, keymaps
;
2806 /* 1 means ignore all menu bindings entirely. */
2807 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2810 /* Find the relevant keymaps. */
2811 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2813 else if (!NILP (keymap
))
2814 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2816 keymaps
= Fcurrent_active_maps (Qnil
);
2818 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2819 We don't really need to check `keymap'. */
2820 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2824 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2826 /* Check heuristic-consistency of the cache. */
2827 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2828 where_is_cache
= Qnil
;
2830 if (NILP (where_is_cache
))
2832 /* We need to create the cache. */
2833 Lisp_Object args
[2];
2834 where_is_cache
= Fmake_hash_table (0, args
);
2835 where_is_cache_keymaps
= Qt
;
2837 /* Fill in the cache. */
2838 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2839 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2842 where_is_cache_keymaps
= keymaps
;
2845 /* We want to process definitions from the last to the first.
2846 Instead of consing, copy definitions to a vector and step
2847 over that vector. */
2848 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2849 n
= XINT (Flength (sequences
));
2850 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2851 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2852 defns
[i
++] = XCAR (sequences
);
2854 /* Verify that the key bindings are not shadowed. Note that
2855 the following can GC. */
2856 GCPRO2 (definition
, keymaps
);
2859 for (i
= n
- 1; i
>= 0; --i
)
2860 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2862 if (ascii_sequence_p (defns
[i
]))
2868 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2873 /* Kill the cache so that where_is_internal_1 doesn't think
2874 we're filling it up. */
2875 where_is_cache
= Qnil
;
2876 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2882 /* This is the function that Fwhere_is_internal calls using map_char_table.
2884 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2886 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2887 Since map_char_table doesn't really use the return value from this function,
2888 we the result append to RESULT, the slot in ARGS.
2890 This function can GC because it calls where_is_internal_1 which can
2894 where_is_internal_2 (args
, key
, binding
)
2895 Lisp_Object args
, key
, binding
;
2897 Lisp_Object definition
, noindirect
, this, last
;
2898 Lisp_Object result
, sequence
;
2899 int nomenus
, last_is_meta
;
2900 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2902 GCPRO3 (args
, key
, binding
);
2903 result
= XCDR (XCAR (args
));
2904 definition
= XCAR (XCAR (XCAR (args
)));
2905 noindirect
= XCDR (XCAR (XCAR (args
)));
2906 this = XCAR (XCAR (XCDR (args
)));
2907 last
= XCDR (XCAR (XCDR (args
)));
2908 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2909 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2911 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2912 this, last
, nomenus
, last_is_meta
);
2914 if (!NILP (sequence
))
2915 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2921 /* This function can GC because get_keyelt can. */
2924 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2925 nomenus
, last_is_meta
)
2926 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2927 int nomenus
, last_is_meta
;
2929 Lisp_Object sequence
;
2931 /* Search through indirections unless that's not wanted. */
2932 if (NILP (noindirect
))
2933 binding
= get_keyelt (binding
, 0);
2935 /* End this iteration if this element does not match
2938 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2939 || EQ (binding
, definition
)
2940 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2941 /* Doesn't match. */
2944 /* We have found a match. Construct the key sequence where we found it. */
2945 if (INTEGERP (key
) && last_is_meta
)
2947 sequence
= Fcopy_sequence (this);
2948 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2951 sequence
= append_key (this, key
);
2953 if (!NILP (where_is_cache
))
2955 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2956 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2963 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2965 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2966 doc
: /* Insert the list of all defined keys and their definitions.
2967 The list is inserted in the current buffer, while the bindings are
2968 looked up in BUFFER.
2969 The optional argument PREFIX, if non-nil, should be a key sequence;
2970 then we display only bindings that start with that prefix.
2971 The optional argument MENUS, if non-nil, says to mention menu bindings.
2972 \(Ordinarily these are omitted from the output.) */)
2973 (buffer
, prefix
, menus
)
2974 Lisp_Object buffer
, prefix
, menus
;
2976 Lisp_Object outbuf
, shadow
;
2977 int nomenu
= NILP (menus
);
2978 register Lisp_Object start1
;
2979 struct gcpro gcpro1
;
2981 char *alternate_heading
2983 Keyboard translations:\n\n\
2984 You type Translation\n\
2985 -------- -----------\n";
2990 outbuf
= Fcurrent_buffer ();
2992 /* Report on alternates for keys. */
2993 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2996 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2997 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2999 for (c
= 0; c
< translate_len
; c
++)
3000 if (translate
[c
] != c
)
3002 char buf
[KEY_DESCRIPTION_SIZE
];
3005 if (alternate_heading
)
3007 insert_string (alternate_heading
);
3008 alternate_heading
= 0;
3011 bufend
= push_key_description (translate
[c
], buf
, 1);
3012 insert (buf
, bufend
- buf
);
3013 Findent_to (make_number (16), make_number (1));
3014 bufend
= push_key_description (c
, buf
, 1);
3015 insert (buf
, bufend
- buf
);
3019 /* Insert calls signal_after_change which may GC. */
3020 translate
= SDATA (Vkeyboard_translate_table
);
3026 if (!NILP (Vkey_translation_map
))
3027 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
3028 "Key translations", nomenu
, 1, 0, 0);
3031 /* Print the (major mode) local map. */
3033 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
3034 start1
= current_kboard
->Voverriding_terminal_local_map
;
3035 else if (!NILP (Voverriding_local_map
))
3036 start1
= Voverriding_local_map
;
3040 describe_map_tree (start1
, 1, shadow
, prefix
,
3041 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
3042 shadow
= Fcons (start1
, shadow
);
3046 /* Print the minor mode and major mode keymaps. */
3048 Lisp_Object
*modes
, *maps
;
3050 /* Temporarily switch to `buffer', so that we can get that buffer's
3051 minor modes correctly. */
3052 Fset_buffer (buffer
);
3054 nmaps
= current_minor_maps (&modes
, &maps
);
3055 Fset_buffer (outbuf
);
3057 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3058 XBUFFER (buffer
), Qkeymap
);
3061 describe_map_tree (start1
, 1, shadow
, prefix
,
3062 "\f\n`keymap' Property Bindings", nomenu
,
3064 shadow
= Fcons (start1
, shadow
);
3067 /* Print the minor mode maps. */
3068 for (i
= 0; i
< nmaps
; i
++)
3070 /* The title for a minor mode keymap
3071 is constructed at run time.
3072 We let describe_map_tree do the actual insertion
3073 because it takes care of other features when doing so. */
3076 if (!SYMBOLP (modes
[i
]))
3079 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3083 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
3084 SCHARS (SYMBOL_NAME (modes
[i
])));
3085 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3087 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
3088 p
+= sizeof (" Minor Mode Bindings") - 1;
3091 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3092 title
, nomenu
, 0, 0, 0);
3093 shadow
= Fcons (maps
[i
], shadow
);
3096 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3097 XBUFFER (buffer
), Qlocal_map
);
3100 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3101 describe_map_tree (start1
, 1, shadow
, prefix
,
3102 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3104 describe_map_tree (start1
, 1, shadow
, prefix
,
3105 "\f\n`local-map' Property Bindings",
3108 shadow
= Fcons (start1
, shadow
);
3112 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3113 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3115 /* Print the function-key-map translations under this prefix. */
3116 if (!NILP (Vfunction_key_map
))
3117 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
3118 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3124 /* Insert a description of the key bindings in STARTMAP,
3125 followed by those of all maps reachable through STARTMAP.
3126 If PARTIAL is nonzero, omit certain "uninteresting" commands
3127 (such as `undefined').
3128 If SHADOW is non-nil, it is a list of maps;
3129 don't mention keys which would be shadowed by any of them.
3130 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3131 TITLE, if not 0, is a string to insert at the beginning.
3132 TITLE should not end with a colon or a newline; we supply that.
3133 If NOMENU is not 0, then omit menu-bar commands.
3135 If TRANSL is nonzero, the definitions are actually key translations
3136 so print strings and vectors differently.
3138 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3141 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3142 don't omit it; instead, mention it but say it is shadowed. */
3145 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3146 always_title
, mention_shadow
)
3147 Lisp_Object startmap
, shadow
, prefix
;
3155 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3156 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3163 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3166 GCPRO3 (maps
, seen
, sub_shadows
);
3172 /* Delete from MAPS each element that is for the menu bar. */
3173 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3175 Lisp_Object elt
, prefix
, tem
;
3178 prefix
= Fcar (elt
);
3179 if (XVECTOR (prefix
)->size
>= 1)
3181 tem
= Faref (prefix
, make_number (0));
3182 if (EQ (tem
, Qmenu_bar
))
3183 maps
= Fdelq (elt
, maps
);
3188 if (!NILP (maps
) || always_title
)
3192 insert_string (title
);
3195 insert_string (" Starting With ");
3196 insert1 (Fkey_description (prefix
, Qnil
));
3198 insert_string (":\n");
3200 insert_string (key_heading
);
3204 for (; !NILP (maps
); maps
= Fcdr (maps
))
3206 register Lisp_Object elt
, prefix
, tail
;
3209 prefix
= Fcar (elt
);
3213 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3217 shmap
= XCAR (tail
);
3219 /* If the sequence by which we reach this keymap is zero-length,
3220 then the shadow map for this keymap is just SHADOW. */
3221 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3222 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3224 /* If the sequence by which we reach this keymap actually has
3225 some elements, then the sequence's definition in SHADOW is
3226 what we should use. */
3229 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3230 if (INTEGERP (shmap
))
3234 /* If shmap is not nil and not a keymap,
3235 it completely shadows this map, so don't
3236 describe this map at all. */
3237 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3241 sub_shadows
= Fcons (shmap
, sub_shadows
);
3244 /* Maps we have already listed in this loop shadow this map. */
3245 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3248 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3250 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3253 describe_map (Fcdr (elt
), prefix
,
3254 transl
? describe_translation
: describe_command
,
3255 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3261 insert_string ("\n");
3266 static int previous_description_column
;
3269 describe_command (definition
, args
)
3270 Lisp_Object definition
, args
;
3272 register Lisp_Object tem1
;
3273 int column
= (int) current_column (); /* iftc */
3274 int description_column
;
3276 /* If column 16 is no good, go to col 32;
3277 but don't push beyond that--go to next line instead. */
3281 description_column
= 32;
3283 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3284 description_column
= 32;
3286 description_column
= 16;
3288 Findent_to (make_number (description_column
), make_number (1));
3289 previous_description_column
= description_column
;
3291 if (SYMBOLP (definition
))
3293 tem1
= SYMBOL_NAME (definition
);
3295 insert_string ("\n");
3297 else if (STRINGP (definition
) || VECTORP (definition
))
3298 insert_string ("Keyboard Macro\n");
3299 else if (KEYMAPP (definition
))
3300 insert_string ("Prefix Command\n");
3302 insert_string ("??\n");
3306 describe_translation (definition
, args
)
3307 Lisp_Object definition
, args
;
3309 register Lisp_Object tem1
;
3311 Findent_to (make_number (16), make_number (1));
3313 if (SYMBOLP (definition
))
3315 tem1
= SYMBOL_NAME (definition
);
3317 insert_string ("\n");
3319 else if (STRINGP (definition
) || VECTORP (definition
))
3321 insert1 (Fkey_description (definition
, Qnil
));
3322 insert_string ("\n");
3324 else if (KEYMAPP (definition
))
3325 insert_string ("Prefix Command\n");
3327 insert_string ("??\n");
3330 /* describe_map puts all the usable elements of a sparse keymap
3331 into an array of `struct describe_map_elt',
3332 then sorts them by the events. */
3334 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3336 /* qsort comparison function for sorting `struct describe_map_elt' by
3340 describe_map_compare (aa
, bb
)
3341 const void *aa
, *bb
;
3343 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3344 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3345 return ((XINT (a
->event
) > XINT (b
->event
))
3346 - (XINT (a
->event
) < XINT (b
->event
)));
3347 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3349 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3351 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3352 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3353 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3358 /* Describe the contents of map MAP, assuming that this map itself is
3359 reached by the sequence of prefix keys PREFIX (a string or vector).
3360 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3363 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3364 seen
, nomenu
, mention_shadow
)
3365 register Lisp_Object map
;
3367 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3374 Lisp_Object tail
, definition
, event
;
3376 Lisp_Object suppress
;
3379 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3381 /* These accumulate the values from sparse keymap bindings,
3382 so we can sort them and handle them in order. */
3383 int length_needed
= 0;
3384 struct describe_map_elt
*vect
;
3391 suppress
= intern ("suppress-keymap");
3393 /* This vector gets used to present single keys to Flookup_key. Since
3394 that is done once per keymap element, we don't want to cons up a
3395 fresh vector every time. */
3396 kludge
= Fmake_vector (make_number (1), Qnil
);
3399 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3402 vect
= ((struct describe_map_elt
*)
3403 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3405 GCPRO3 (prefix
, definition
, kludge
);
3407 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3411 if (VECTORP (XCAR (tail
))
3412 || CHAR_TABLE_P (XCAR (tail
)))
3413 describe_vector (XCAR (tail
),
3414 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3415 (int *)0, 0, 1, mention_shadow
);
3416 else if (CONSP (XCAR (tail
)))
3418 int this_shadowed
= 0;
3420 event
= XCAR (XCAR (tail
));
3422 /* Ignore bindings whose "prefix" are not really valid events.
3423 (We get these in the frames and buffers menu.) */
3424 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3427 if (nomenu
&& EQ (event
, Qmenu_bar
))
3430 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3432 /* Don't show undefined commands or suppressed commands. */
3433 if (NILP (definition
)) continue;
3434 if (SYMBOLP (definition
) && partial
)
3436 tem
= Fget (definition
, suppress
);
3441 /* Don't show a command that isn't really visible
3442 because a local definition of the same key shadows it. */
3444 ASET (kludge
, 0, event
);
3447 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3450 /* Avoid generating duplicate entries if the
3451 shadowed binding has the same definition. */
3452 if (mention_shadow
&& !EQ (tem
, definition
))
3459 tem
= Flookup_key (map
, kludge
, Qt
);
3460 if (!EQ (tem
, definition
)) continue;
3462 vect
[slots_used
].event
= event
;
3463 vect
[slots_used
].definition
= definition
;
3464 vect
[slots_used
].shadowed
= this_shadowed
;
3467 else if (EQ (XCAR (tail
), Qkeymap
))
3469 /* The same keymap might be in the structure twice, if we're
3470 using an inherited keymap. So skip anything we've already
3472 tem
= Fassq (tail
, *seen
);
3473 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3475 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3479 /* If we found some sparse map events, sort them. */
3481 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3482 describe_map_compare
);
3484 /* Now output them in sorted order. */
3486 for (i
= 0; i
< slots_used
; i
++)
3488 Lisp_Object start
, end
;
3492 previous_description_column
= 0;
3497 ASET (kludge
, 0, vect
[i
].event
);
3498 start
= vect
[i
].event
;
3501 definition
= vect
[i
].definition
;
3503 /* Find consecutive chars that are identically defined. */
3504 if (INTEGERP (vect
[i
].event
))
3506 while (i
+ 1 < slots_used
3507 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3508 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3509 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3511 end
= vect
[i
].event
;
3514 /* Now START .. END is the range to describe next. */
3516 /* Insert the string to describe the event START. */
3517 insert1 (Fkey_description (kludge
, prefix
));
3519 if (!EQ (start
, end
))
3523 ASET (kludge
, 0, end
);
3524 /* Insert the string to describe the character END. */
3525 insert1 (Fkey_description (kludge
, prefix
));
3528 /* Print a description of the definition of this character.
3529 elt_describer will take care of spacing out far enough
3530 for alignment purposes. */
3531 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3533 if (vect
[i
].shadowed
)
3536 insert_string ("\n (that binding is currently shadowed by another mode)");
3545 describe_vector_princ (elt
, fun
)
3546 Lisp_Object elt
, fun
;
3548 Findent_to (make_number (16), make_number (1));
3553 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3554 doc
: /* Insert a description of contents of VECTOR.
3555 This is text showing the elements of vector matched against indices.
3556 DESCRIBER is the output function used; nil means use `princ'. */)
3558 Lisp_Object vector
, describer
;
3560 int count
= SPECPDL_INDEX ();
3561 if (NILP (describer
))
3562 describer
= intern ("princ");
3563 specbind (Qstandard_output
, Fcurrent_buffer ());
3564 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3565 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3566 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3568 return unbind_to (count
, Qnil
);
3571 /* Insert in the current buffer a description of the contents of VECTOR.
3572 We call ELT_DESCRIBER to insert the description of one value found
3575 ELT_PREFIX describes what "comes before" the keys or indices defined
3576 by this vector. This is a human-readable string whose size
3577 is not necessarily related to the situation.
3579 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3580 leads to this keymap.
3582 If the vector is a chartable, ELT_PREFIX is the vector
3583 of bytes that lead to the character set or portion of a character
3584 set described by this chartable.
3586 If PARTIAL is nonzero, it means do not mention suppressed commands
3587 (that assumes the vector is in a keymap).
3589 SHADOW is a list of keymaps that shadow this map.
3590 If it is non-nil, then we look up the key in those maps
3591 and we don't mention it now if it is defined by any of them.
3593 ENTIRE_MAP is the keymap in which this vector appears.
3594 If the definition in effect in the whole map does not match
3595 the one in this vector, we ignore this one.
3597 When describing a sub-char-table, INDICES is a list of
3598 indices at higher levels in this char-table,
3599 and CHAR_TABLE_DEPTH says how many levels down we have gone.
3601 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3603 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3606 describe_vector (vector
, prefix
, args
, elt_describer
,
3607 partial
, shadow
, entire_map
,
3608 indices
, char_table_depth
, keymap_p
,
3610 register Lisp_Object vector
;
3611 Lisp_Object prefix
, args
;
3612 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3615 Lisp_Object entire_map
;
3617 int char_table_depth
;
3621 Lisp_Object definition
;
3623 Lisp_Object elt_prefix
= Qnil
;
3625 Lisp_Object suppress
;
3628 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3629 /* Range of elements to be handled. */
3631 /* A flag to tell if a leaf in this level of char-table is not a
3632 generic character (i.e. a complete multibyte character). */
3640 indices
= (int *) alloca (3 * sizeof (int));
3646 /* Call Fkey_description first, to avoid GC bug for the other string. */
3647 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3650 tem
= Fkey_description (prefix
, Qnil
);
3651 elt_prefix
= concat2 (tem
, build_string (" "));
3656 /* This vector gets used to present single keys to Flookup_key. Since
3657 that is done once per vector element, we don't want to cons up a
3658 fresh vector every time. */
3659 kludge
= Fmake_vector (make_number (1), Qnil
);
3660 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3663 suppress
= intern ("suppress-keymap");
3665 if (CHAR_TABLE_P (vector
))
3667 if (char_table_depth
== 0)
3669 /* VECTOR is a top level char-table. */
3672 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3676 /* VECTOR is a sub char-table. */
3677 if (char_table_depth
>= 3)
3678 /* A char-table is never that deep. */
3679 error ("Too deep char table");
3682 = (CHARSET_VALID_P (indices
[0])
3683 && ((CHARSET_DIMENSION (indices
[0]) == 1
3684 && char_table_depth
== 1)
3685 || char_table_depth
== 2));
3687 /* Meaningful elements are from 32th to 127th. */
3689 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3694 /* This does the right thing for ordinary vectors. */
3698 to
= XVECTOR (vector
)->size
;
3701 for (i
= from
; i
< to
; i
++)
3703 int this_shadowed
= 0;
3706 if (CHAR_TABLE_P (vector
))
3708 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3711 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3712 && !CHARSET_DEFINED_P (i
- 128))
3716 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3719 definition
= get_keyelt (AREF (vector
, i
), 0);
3721 if (NILP (definition
)) continue;
3723 /* Don't mention suppressed commands. */
3724 if (SYMBOLP (definition
) && partial
)
3728 tem
= Fget (definition
, suppress
);
3730 if (!NILP (tem
)) continue;
3733 /* Set CHARACTER to the character this entry describes, if any.
3734 Also update *INDICES. */
3735 if (CHAR_TABLE_P (vector
))
3737 indices
[char_table_depth
] = i
;
3739 if (char_table_depth
== 0)
3742 indices
[0] = i
- 128;
3744 else if (complete_char
)
3746 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3754 ASET (kludge
, 0, make_number (character
));
3756 /* If this binding is shadowed by some other map, ignore it. */
3757 if (!NILP (shadow
) && complete_char
)
3761 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3772 /* Ignore this definition if it is shadowed by an earlier
3773 one in the same keymap. */
3774 if (!NILP (entire_map
) && complete_char
)
3778 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3780 if (!EQ (tem
, definition
))
3786 if (char_table_depth
== 0)
3791 /* For a sub char-table, show the depth by indentation.
3792 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3793 if (char_table_depth
> 0)
3794 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3796 /* Output the prefix that applies to every entry in this map. */
3797 if (!NILP (elt_prefix
))
3798 insert1 (elt_prefix
);
3800 /* Insert or describe the character this slot is for,
3801 or a description of what it is for. */
3802 if (SUB_CHAR_TABLE_P (vector
))
3805 insert_char (character
);
3808 /* We need an octal representation for this block of
3811 sprintf (work
, "(row %d)", i
);
3812 insert (work
, strlen (work
));
3815 else if (CHAR_TABLE_P (vector
))
3818 insert1 (Fkey_description (kludge
, prefix
));
3821 /* Print the information for this character set. */
3822 insert_string ("<");
3823 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3825 insert_from_string (tem2
, 0, 0, SCHARS (tem2
),
3834 insert1 (Fkey_description (kludge
, prefix
));
3837 /* If we find a sub char-table within a char-table,
3838 scan it recursively; it defines the details for
3839 a character set or a portion of a character set. */
3840 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3843 describe_vector (definition
, prefix
, args
, elt_describer
,
3844 partial
, shadow
, entire_map
,
3845 indices
, char_table_depth
+ 1, keymap_p
,
3852 /* Find all consecutive characters or rows that have the same
3853 definition. But, for elements of a top level char table, if
3854 they are for charsets, we had better describe one by one even
3855 if they have the same definition. */
3856 if (CHAR_TABLE_P (vector
))
3860 if (char_table_depth
== 0)
3861 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3863 while (i
+ 1 < limit
3864 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3866 && !NILP (Fequal (tem2
, definition
)))
3871 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3873 && !NILP (Fequal (tem2
, definition
)))
3877 /* If we have a range of more than one character,
3878 print where the range reaches to. */
3880 if (i
!= starting_i
)
3884 ASET (kludge
, 0, make_number (i
));
3886 if (!NILP (elt_prefix
))
3887 insert1 (elt_prefix
);
3889 if (CHAR_TABLE_P (vector
))
3891 if (char_table_depth
== 0)
3893 insert1 (Fkey_description (kludge
, prefix
));
3895 else if (complete_char
)
3897 indices
[char_table_depth
] = i
;
3898 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3899 insert_char (character
);
3903 /* We need an octal representation for this block of
3906 sprintf (work
, "(row %d)", i
);
3907 insert (work
, strlen (work
));
3912 insert1 (Fkey_description (kludge
, prefix
));
3916 /* Print a description of the definition of this character.
3917 elt_describer will take care of spacing out far enough
3918 for alignment purposes. */
3919 (*elt_describer
) (definition
, args
);
3924 insert_string (" (binding currently shadowed)");
3929 /* For (sub) char-table, print `defalt' slot at last. */
3930 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3932 insert (" ", char_table_depth
* 2);
3933 insert_string ("<<default>>");
3934 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3940 /* Apropos - finding all symbols whose names match a regexp. */
3941 static Lisp_Object apropos_predicate
;
3942 static Lisp_Object apropos_accumulate
;
3945 apropos_accum (symbol
, string
)
3946 Lisp_Object symbol
, string
;
3948 register Lisp_Object tem
;
3950 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3951 if (!NILP (tem
) && !NILP (apropos_predicate
))
3952 tem
= call1 (apropos_predicate
, symbol
);
3954 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3957 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3958 doc
: /* Show all symbols whose names contain match for REGEXP.
3959 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3960 for each symbol and a symbol is mentioned only if that returns non-nil.
3961 Return list of symbols found. */)
3963 Lisp_Object regexp
, predicate
;
3966 CHECK_STRING (regexp
);
3967 apropos_predicate
= predicate
;
3968 apropos_accumulate
= Qnil
;
3969 map_obarray (Vobarray
, apropos_accum
, regexp
);
3970 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3971 apropos_accumulate
= Qnil
;
3972 apropos_predicate
= Qnil
;
3979 Qkeymap
= intern ("keymap");
3980 staticpro (&Qkeymap
);
3981 staticpro (&apropos_predicate
);
3982 staticpro (&apropos_accumulate
);
3983 apropos_predicate
= Qnil
;
3984 apropos_accumulate
= Qnil
;
3986 /* Now we are ready to set up this property, so we can
3987 create char tables. */
3988 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3990 /* Initialize the keymaps standardly used.
3991 Each one is the value of a Lisp variable, and is also
3992 pointed to by a C variable */
3994 global_map
= Fmake_keymap (Qnil
);
3995 Fset (intern ("global-map"), global_map
);
3997 current_global_map
= global_map
;
3998 staticpro (&global_map
);
3999 staticpro (¤t_global_map
);
4001 meta_map
= Fmake_keymap (Qnil
);
4002 Fset (intern ("esc-map"), meta_map
);
4003 Ffset (intern ("ESC-prefix"), meta_map
);
4005 control_x_map
= Fmake_keymap (Qnil
);
4006 Fset (intern ("ctl-x-map"), control_x_map
);
4007 Ffset (intern ("Control-X-prefix"), control_x_map
);
4010 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
4011 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
4012 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
4013 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
4014 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
4016 staticpro (&exclude_keys
);
4018 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
4019 doc
: /* List of commands given new key bindings recently.
4020 This is used for internal purposes during Emacs startup;
4021 don't alter it yourself. */);
4022 Vdefine_key_rebound_commands
= Qt
;
4024 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
4025 doc
: /* Default keymap to use when reading from the minibuffer. */);
4026 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
4028 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
4029 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
4030 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
4031 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
4033 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
4034 doc
: /* Local keymap for minibuffer input with completion. */);
4035 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
4036 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
4038 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
4039 &Vminibuffer_local_filename_completion_map
,
4040 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
4041 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
4042 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
4043 Vminibuffer_local_completion_map
);
4046 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
4047 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
4048 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
4049 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
4050 Vminibuffer_local_completion_map
);
4052 DEFVAR_LISP ("minibuffer-local-must-match-filename-map",
4053 &Vminibuffer_local_must_match_filename_map
,
4054 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
4055 Vminibuffer_local_must_match_filename_map
= Fmake_sparse_keymap (Qnil
);
4056 Fset_keymap_parent (Vminibuffer_local_must_match_filename_map
,
4057 Vminibuffer_local_must_match_map
);
4059 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
4060 doc
: /* Alist of keymaps to use for minor modes.
4061 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
4062 key sequences and look up bindings iff VARIABLE's value is non-nil.
4063 If two active keymaps bind the same key, the keymap appearing earlier
4064 in the list takes precedence. */);
4065 Vminor_mode_map_alist
= Qnil
;
4067 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
4068 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
4069 This variable is an alist just like `minor-mode-map-alist', and it is
4070 used the same way (and before `minor-mode-map-alist'); however,
4071 it is provided for major modes to bind locally. */);
4072 Vminor_mode_overriding_map_alist
= Qnil
;
4074 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
4075 doc
: /* List of keymap alists to use for emulations modes.
4076 It is intended for modes or packages using multiple minor-mode keymaps.
4077 Each element is a keymap alist just like `minor-mode-map-alist', or a
4078 symbol with a variable binding which is a keymap alist, and it is used
4079 the same way. The "active" keymaps in each alist are used before
4080 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
4081 Vemulation_mode_map_alists
= Qnil
;
4084 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
4085 doc
: /* Keymap that translates key sequences to key sequences during input.
4086 This is used mainly for mapping ASCII function key sequences into
4087 real Emacs function key events (symbols).
4089 The `read-key-sequence' function replaces any subsequence bound by
4090 `function-key-map' with its binding. More precisely, when the active
4091 keymaps have no binding for the current key sequence but
4092 `function-key-map' binds a suffix of the sequence to a vector or string,
4093 `read-key-sequence' replaces the matching suffix with its binding, and
4094 continues with the new sequence.
4096 If the binding is a function, it is called with one argument (the prompt)
4097 and its return value (a key sequence) is used.
4099 The events that come from bindings in `function-key-map' are not
4100 themselves looked up in `function-key-map'.
4102 For example, suppose `function-key-map' binds `ESC O P' to [f1].
4103 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
4104 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
4105 key, typing `ESC O P x' would return [f1 x]. */);
4106 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
4108 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
4109 doc
: /* Keymap of key translations that can override keymaps.
4110 This keymap works like `function-key-map', but comes after that,
4111 and its non-prefix bindings override ordinary bindings. */);
4112 Vkey_translation_map
= Qnil
;
4114 staticpro (&Vmouse_events
);
4115 Vmouse_events
= Fcons (intern ("menu-bar"),
4116 Fcons (intern ("tool-bar"),
4117 Fcons (intern ("header-line"),
4118 Fcons (intern ("mode-line"),
4119 Fcons (intern ("mouse-1"),
4120 Fcons (intern ("mouse-2"),
4121 Fcons (intern ("mouse-3"),
4122 Fcons (intern ("mouse-4"),
4123 Fcons (intern ("mouse-5"),
4127 Qsingle_key_description
= intern ("single-key-description");
4128 staticpro (&Qsingle_key_description
);
4130 Qkey_description
= intern ("key-description");
4131 staticpro (&Qkey_description
);
4133 Qkeymapp
= intern ("keymapp");
4134 staticpro (&Qkeymapp
);
4136 Qnon_ascii
= intern ("non-ascii");
4137 staticpro (&Qnon_ascii
);
4139 Qmenu_item
= intern ("menu-item");
4140 staticpro (&Qmenu_item
);
4142 Qremap
= intern ("remap");
4143 staticpro (&Qremap
);
4145 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
4146 staticpro (&command_remapping_vector
);
4148 where_is_cache_keymaps
= Qt
;
4149 where_is_cache
= Qnil
;
4150 staticpro (&where_is_cache
);
4151 staticpro (&where_is_cache_keymaps
);
4153 defsubr (&Skeymapp
);
4154 defsubr (&Skeymap_parent
);
4155 defsubr (&Skeymap_prompt
);
4156 defsubr (&Sset_keymap_parent
);
4157 defsubr (&Smake_keymap
);
4158 defsubr (&Smake_sparse_keymap
);
4159 defsubr (&Smap_keymap
);
4160 defsubr (&Scopy_keymap
);
4161 defsubr (&Scommand_remapping
);
4162 defsubr (&Skey_binding
);
4163 defsubr (&Slocal_key_binding
);
4164 defsubr (&Sglobal_key_binding
);
4165 defsubr (&Sminor_mode_key_binding
);
4166 defsubr (&Sdefine_key
);
4167 defsubr (&Slookup_key
);
4168 defsubr (&Sdefine_prefix_command
);
4169 defsubr (&Suse_global_map
);
4170 defsubr (&Suse_local_map
);
4171 defsubr (&Scurrent_local_map
);
4172 defsubr (&Scurrent_global_map
);
4173 defsubr (&Scurrent_minor_mode_maps
);
4174 defsubr (&Scurrent_active_maps
);
4175 defsubr (&Saccessible_keymaps
);
4176 defsubr (&Skey_description
);
4177 defsubr (&Sdescribe_vector
);
4178 defsubr (&Ssingle_key_description
);
4179 defsubr (&Stext_char_description
);
4180 defsubr (&Swhere_is_internal
);
4181 defsubr (&Sdescribe_buffer_bindings
);
4182 defsubr (&Sapropos_internal
);
4188 initial_define_key (global_map
, 033, "ESC-prefix");
4189 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
4192 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4193 (do not change this comment) */