1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "character.h"
32 #include "termhooks.h"
33 #include "blockinput.h"
35 #include "intervals.h"
39 /* The number of elements in keymap vectors. */
40 #define DENSE_TABLE_SIZE (0200)
42 /* Actually allocate storage for these variables */
44 Lisp_Object current_global_map
; /* Current global keymap */
46 Lisp_Object global_map
; /* default global key bindings */
48 Lisp_Object meta_map
; /* The keymap used for globally bound
49 ESC-prefixed default commands */
51 Lisp_Object control_x_map
; /* The keymap used for globally bound
52 C-x-prefixed default commands */
54 /* was MinibufLocalMap */
55 Lisp_Object Vminibuffer_local_map
;
56 /* The keymap used by the minibuf for local
57 bindings when spaces are allowed in the
60 /* was MinibufLocalNSMap */
61 Lisp_Object Vminibuffer_local_ns_map
;
62 /* The keymap used by the minibuf for local
63 bindings when spaces are not encouraged
66 /* keymap used for minibuffers when doing completion */
67 /* was MinibufLocalCompletionMap */
68 Lisp_Object Vminibuffer_local_completion_map
;
70 /* keymap used for minibuffers when doing completion in filenames */
71 Lisp_Object Vminibuffer_local_filename_completion_map
;
73 /* keymap used for minibuffers when doing completion in filenames
75 Lisp_Object Vminibuffer_local_filename_must_match_map
;
77 /* keymap used for minibuffers when doing completion and require a match */
78 /* was MinibufLocalMustMatchMap */
79 Lisp_Object Vminibuffer_local_must_match_map
;
81 /* Alist of minor mode variables and keymaps. */
82 Lisp_Object Vminor_mode_map_alist
;
84 /* Alist of major-mode-specific overrides for
85 minor mode variables and keymaps. */
86 Lisp_Object Vminor_mode_overriding_map_alist
;
88 /* List of emulation mode keymap alists. */
89 Lisp_Object Vemulation_mode_map_alists
;
91 /* A list of all commands given new bindings since a certain time
92 when nil was stored here.
93 This is used to speed up recomputation of menu key equivalents
94 when Emacs starts up. t means don't record anything here. */
95 Lisp_Object Vdefine_key_rebound_commands
;
97 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
98 Lisp_Object QCadvertised_binding
;
100 /* Alist of elements like (DEL . "\d"). */
101 static Lisp_Object exclude_keys
;
103 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
104 static Lisp_Object command_remapping_vector
;
106 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
107 in a string key sequence is equivalent to prefixing with this
109 extern Lisp_Object meta_prefix_char
;
111 extern Lisp_Object Voverriding_local_map
;
113 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
114 static Lisp_Object where_is_cache
;
115 /* Which keymaps are reverse-stored in the cache. */
116 static Lisp_Object where_is_cache_keymaps
;
118 static Lisp_Object
store_in_keymap (Lisp_Object
, Lisp_Object
, Lisp_Object
);
119 static void fix_submap_inheritance (Lisp_Object
, Lisp_Object
, Lisp_Object
);
121 static Lisp_Object
define_as_prefix (Lisp_Object
, Lisp_Object
);
122 static void describe_command (Lisp_Object
, Lisp_Object
);
123 static void describe_translation (Lisp_Object
, Lisp_Object
);
124 static void describe_map (Lisp_Object
, Lisp_Object
,
125 void (*) (Lisp_Object
, Lisp_Object
),
126 int, Lisp_Object
, Lisp_Object
*, int, int);
127 static void describe_vector (Lisp_Object
, Lisp_Object
, Lisp_Object
,
128 void (*) (Lisp_Object
, Lisp_Object
), int,
129 Lisp_Object
, Lisp_Object
, int *,
131 static void silly_event_symbol_error (Lisp_Object
);
133 /* Keymap object support - constructors and predicates. */
135 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
136 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
137 CHARTABLE is a char-table that holds the bindings for all characters
138 without modifiers. All entries in it are initially nil, meaning
139 "command undefined". ALIST is an assoc-list which holds bindings for
140 function keys, mouse events, and any other things that appear in the
141 input stream. Initially, ALIST is nil.
143 The optional arg STRING supplies a menu name for the keymap
144 in case you use it as a menu with `x-popup-menu'. */)
150 tail
= Fcons (string
, Qnil
);
153 return Fcons (Qkeymap
,
154 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
157 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
158 doc
: /* Construct and return a new sparse keymap.
159 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
160 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
161 which binds the function key or mouse event SYMBOL to DEFINITION.
162 Initially the alist is nil.
164 The optional arg STRING supplies a menu name for the keymap
165 in case you use it as a menu with `x-popup-menu'. */)
171 if (!NILP (Vpurify_flag
))
172 string
= Fpurecopy (string
);
173 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
175 return Fcons (Qkeymap
, Qnil
);
178 /* This function is used for installing the standard key bindings
179 at initialization time.
183 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
186 initial_define_key (Lisp_Object keymap
, int key
, char *defname
)
188 store_in_keymap (keymap
, make_number (key
), intern_c_string (defname
));
192 initial_define_lispy_key (Lisp_Object keymap
, char *keyname
, char *defname
)
194 store_in_keymap (keymap
, intern_c_string (keyname
), intern_c_string (defname
));
197 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
198 doc
: /* Return t if OBJECT is a keymap.
200 A keymap is a list (keymap . ALIST),
201 or a symbol whose function definition is itself a keymap.
202 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);
203 a vector of densely packed bindings for small character codes
204 is also allowed as an element. */)
208 return (KEYMAPP (object
) ? Qt
: Qnil
);
211 DEFUN ("keymap-prompt", Fkeymap_prompt
, Skeymap_prompt
, 1, 1, 0,
212 doc
: /* Return the prompt-string of a keymap MAP.
213 If non-nil, the prompt is shown in the echo-area
214 when reading a key-sequence to be looked-up in this keymap. */)
218 map
= get_keymap (map
, 0, 0);
221 Lisp_Object tem
= XCAR (map
);
229 /* Check that OBJECT is a keymap (after dereferencing through any
230 symbols). If it is, return it.
232 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
233 is an autoload form, do the autoload and try again.
234 If AUTOLOAD is nonzero, callers must assume GC is possible.
236 If the map needs to be autoloaded, but AUTOLOAD is zero (and ERROR
237 is zero as well), return Qt.
239 ERROR controls how we respond if OBJECT isn't a keymap.
240 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
242 Note that most of the time, we don't want to pursue autoloads.
243 Functions like Faccessible_keymaps which scan entire keymap trees
244 shouldn't load every autoloaded keymap. I'm not sure about this,
245 but it seems to me that only read_key_sequence, Flookup_key, and
246 Fdefine_key should cause keymaps to be autoloaded.
248 This function can GC when AUTOLOAD is non-zero, because it calls
249 do_autoload which can GC. */
252 get_keymap (Lisp_Object object
, int error
, int autoload
)
259 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
262 tem
= indirect_function (object
);
265 if (EQ (XCAR (tem
), Qkeymap
))
268 /* Should we do an autoload? Autoload forms for keymaps have
269 Qkeymap as their fifth element. */
270 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
275 tail
= Fnth (make_number (4), tem
);
276 if (EQ (tail
, Qkeymap
))
280 struct gcpro gcpro1
, gcpro2
;
282 GCPRO2 (tem
, object
);
283 do_autoload (tem
, object
);
296 wrong_type_argument (Qkeymapp
, object
);
300 /* Return the parent map of KEYMAP, or nil if it has none.
301 We assume that KEYMAP is a valid keymap. */
304 keymap_parent (Lisp_Object keymap
, int autoload
)
308 keymap
= get_keymap (keymap
, 1, autoload
);
310 /* Skip past the initial element `keymap'. */
311 list
= XCDR (keymap
);
312 for (; CONSP (list
); list
= XCDR (list
))
314 /* See if there is another `keymap'. */
319 return get_keymap (list
, 0, autoload
);
322 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
323 doc
: /* Return the parent keymap of KEYMAP.
324 If KEYMAP has no parent, return nil. */)
328 return keymap_parent (keymap
, 1);
331 /* Check whether MAP is one of MAPS parents. */
333 keymap_memberp (Lisp_Object map
, Lisp_Object maps
)
335 if (NILP (map
)) return 0;
336 while (KEYMAPP (maps
) && !EQ (map
, maps
))
337 maps
= keymap_parent (maps
, 0);
338 return (EQ (map
, maps
));
341 /* Set the parent keymap of MAP to PARENT. */
343 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
344 doc
: /* Modify KEYMAP to set its parent map to PARENT.
345 Return PARENT. PARENT should be nil or another keymap. */)
347 Lisp_Object keymap
, parent
;
349 Lisp_Object list
, prev
;
350 struct gcpro gcpro1
, gcpro2
;
353 /* Force a keymap flush for the next call to where-is.
354 Since this can be called from within where-is, we don't set where_is_cache
355 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
356 be changed during where-is, while where_is_cache_keymaps is only used at
357 the very beginning of where-is and can thus be changed here without any
359 This is a very minor correctness (rather than safety) issue. */
360 where_is_cache_keymaps
= Qt
;
362 GCPRO2 (keymap
, parent
);
363 keymap
= get_keymap (keymap
, 1, 1);
367 parent
= get_keymap (parent
, 1, 1);
369 /* Check for cycles. */
370 if (keymap_memberp (keymap
, parent
))
371 error ("Cyclic keymap inheritance");
374 /* Skip past the initial element `keymap'. */
379 /* If there is a parent keymap here, replace it.
380 If we came to the end, add the parent in PREV. */
381 if (!CONSP (list
) || KEYMAPP (list
))
383 /* If we already have the right parent, return now
384 so that we avoid the loops below. */
385 if (EQ (XCDR (prev
), parent
))
386 RETURN_UNGCPRO (parent
);
389 XSETCDR (prev
, parent
);
395 /* Scan through for submaps, and set their parents too. */
397 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
399 /* Stop the scan when we come to the parent. */
400 if (EQ (XCAR (list
), Qkeymap
))
403 /* If this element holds a prefix map, deal with it. */
404 if (CONSP (XCAR (list
))
405 && CONSP (XCDR (XCAR (list
))))
406 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
409 if (VECTORP (XCAR (list
)))
410 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
411 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
412 fix_submap_inheritance (keymap
, make_number (i
),
413 XVECTOR (XCAR (list
))->contents
[i
]);
415 if (CHAR_TABLE_P (XCAR (list
)))
417 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
), keymap
);
421 RETURN_UNGCPRO (parent
);
424 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
425 if EVENT is also a prefix in MAP's parent,
426 make sure that SUBMAP inherits that definition as its own parent. */
429 fix_submap_inheritance (Lisp_Object map
, Lisp_Object event
, Lisp_Object submap
)
431 Lisp_Object map_parent
, parent_entry
;
433 /* SUBMAP is a cons that we found as a key binding.
434 Discard the other things found in a menu key binding. */
436 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
438 /* If it isn't a keymap now, there's no work to do. */
442 map_parent
= keymap_parent (map
, 0);
443 if (!NILP (map_parent
))
445 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
449 /* If MAP's parent has something other than a keymap,
450 our own submap shadows it completely. */
451 if (!CONSP (parent_entry
))
454 if (! EQ (parent_entry
, submap
))
456 Lisp_Object submap_parent
;
457 submap_parent
= submap
;
462 tem
= keymap_parent (submap_parent
, 0);
466 if (keymap_memberp (tem
, parent_entry
))
467 /* Fset_keymap_parent could create a cycle. */
474 Fset_keymap_parent (submap_parent
, parent_entry
);
478 /* Look up IDX in MAP. IDX may be any sort of event.
479 Note that this does only one level of lookup; IDX must be a single
480 event, not a sequence.
482 If T_OK is non-zero, bindings for Qt are treated as default
483 bindings; any key left unmentioned by other tables and bindings is
484 given the binding of Qt.
486 If T_OK is zero, bindings for Qt are not treated specially.
488 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
491 access_keymap (Lisp_Object map
, Lisp_Object idx
, int t_ok
, int noinherit
, int autoload
)
495 /* Qunbound in VAL means we have found no binding yet. */
498 /* If idx is a list (some sort of mouse click, perhaps?),
499 the index we want to use is the car of the list, which
500 ought to be a symbol. */
501 idx
= EVENT_HEAD (idx
);
503 /* If idx is a symbol, it might have modifiers, which need to
504 be put in the canonical order. */
506 idx
= reorder_modifiers (idx
);
507 else if (INTEGERP (idx
))
508 /* Clobber the high bits that can be present on a machine
509 with more than 24 bits of integer. */
510 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
512 /* Handle the special meta -> esc mapping. */
513 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
515 /* See if there is a meta-map. If there's none, there is
516 no binding for IDX, unless a default binding exists in MAP. */
518 Lisp_Object meta_map
;
520 /* A strange value in which Meta is set would cause
521 infinite recursion. Protect against that. */
522 if (XINT (meta_prefix_char
) & CHAR_META
)
523 meta_prefix_char
= make_number (27);
524 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
525 t_ok
, noinherit
, autoload
),
528 if (CONSP (meta_map
))
531 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
534 /* Set IDX to t, so that we only find a default binding. */
537 /* We know there is no binding. */
541 /* t_binding is where we put a default binding that applies,
542 to use in case we do not find a binding specifically
543 for this key sequence. */
546 Lisp_Object t_binding
= Qnil
;
547 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
549 GCPRO4 (map
, tail
, idx
, t_binding
);
551 for (tail
= XCDR (map
);
553 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
558 binding
= XCAR (tail
);
559 if (SYMBOLP (binding
))
561 /* If NOINHERIT, stop finding prefix definitions
562 after we pass a second occurrence of the `keymap' symbol. */
563 if (noinherit
&& EQ (binding
, Qkeymap
))
564 RETURN_UNGCPRO (Qnil
);
566 else if (CONSP (binding
))
568 Lisp_Object key
= XCAR (binding
);
571 val
= XCDR (binding
);
572 else if (t_ok
&& EQ (key
, Qt
))
574 t_binding
= XCDR (binding
);
578 else if (VECTORP (binding
))
580 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
581 val
= AREF (binding
, XFASTINT (idx
));
583 else if (CHAR_TABLE_P (binding
))
585 /* Character codes with modifiers
586 are not included in a char-table.
587 All character codes without modifiers are included. */
588 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
590 val
= Faref (binding
, idx
);
591 /* `nil' has a special meaning for char-tables, so
592 we use something else to record an explicitly
599 /* If we found a binding, clean it up and return it. */
600 if (!EQ (val
, Qunbound
))
603 /* A Qt binding is just like an explicit nil binding
604 (i.e. it shadows any parent binding but not bindings in
605 keymaps of lower precedence). */
607 val
= get_keyelt (val
, autoload
);
609 fix_submap_inheritance (map
, idx
, val
);
610 RETURN_UNGCPRO (val
);
615 return get_keyelt (t_binding
, autoload
);
620 map_keymap_item (map_keymap_function_t fun
, Lisp_Object args
, Lisp_Object key
, Lisp_Object val
, void *data
)
622 /* We should maybe try to detect bindings shadowed by previous
623 ones and things like that. */
626 (*fun
) (key
, val
, args
, data
);
630 map_keymap_char_table_item (Lisp_Object args
, Lisp_Object key
, Lisp_Object val
)
634 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
636 /* If the key is a range, make a copy since map_char_table modifies
639 key
= Fcons (XCAR (key
), XCDR (key
));
640 map_keymap_item (fun
, XCDR (args
), key
, val
,
641 XSAVE_VALUE (XCAR (args
))->pointer
);
645 /* Call FUN for every binding in MAP and stop at (and return) the parent.
646 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA). */
648 map_keymap_internal (Lisp_Object map
,
649 map_keymap_function_t fun
,
653 struct gcpro gcpro1
, gcpro2
, gcpro3
;
655 = (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
657 GCPRO3 (map
, args
, tail
);
658 for (; CONSP (tail
) && !EQ (Qkeymap
, XCAR (tail
)); tail
= XCDR (tail
))
660 Lisp_Object binding
= XCAR (tail
);
663 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
664 else if (VECTORP (binding
))
666 /* Loop over the char values represented in the vector. */
667 int len
= ASIZE (binding
);
669 for (c
= 0; c
< len
; c
++)
671 Lisp_Object character
;
672 XSETFASTINT (character
, c
);
673 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
676 else if (CHAR_TABLE_P (binding
))
678 map_char_table (map_keymap_char_table_item
, Qnil
, binding
,
679 Fcons (make_save_value (fun
, 0),
680 Fcons (make_save_value (data
, 0),
689 map_keymap_call (Lisp_Object key
, Lisp_Object val
, Lisp_Object fun
, void *dummy
)
691 call2 (fun
, key
, val
);
694 /* Same as map_keymap_internal, but doesn't traverses parent keymaps as well.
695 A non-zero AUTOLOAD indicates that autoloaded keymaps should be loaded. */
697 map_keymap (Lisp_Object map
, map_keymap_function_t fun
, Lisp_Object args
, void *data
, int autoload
)
701 map
= get_keymap (map
, 1, autoload
);
704 map
= map_keymap_internal (map
, fun
, args
, data
);
705 map
= get_keymap (map
, 0, autoload
);
710 Lisp_Object Qkeymap_canonicalize
;
712 /* Same as map_keymap, but does it right, properly eliminating duplicate
713 bindings due to inheritance. */
715 map_keymap_canonical (Lisp_Object map
, map_keymap_function_t fun
, Lisp_Object args
, void *data
)
719 /* map_keymap_canonical may be used from redisplay (e.g. when building menus)
720 so be careful to ignore errors and to inhibit redisplay. */
721 map
= safe_call1 (Qkeymap_canonicalize
, map
);
722 /* No need to use `map_keymap' here because canonical map has no parent. */
723 map_keymap_internal (map
, fun
, args
, data
);
727 DEFUN ("map-keymap-internal", Fmap_keymap_internal
, Smap_keymap_internal
, 2, 2, 0,
728 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
729 FUNCTION is called with two arguments: the event that is bound, and
730 the definition it is bound to. The event may be a character range.
731 If KEYMAP has a parent, this function returns it without processing it. */)
733 Lisp_Object function
, keymap
;
737 keymap
= get_keymap (keymap
, 1, 1);
738 keymap
= map_keymap_internal (keymap
, map_keymap_call
, function
, NULL
);
743 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
744 doc
: /* Call FUNCTION once for each event binding in KEYMAP.
745 FUNCTION is called with two arguments: the event that is bound, and
746 the definition it is bound to. The event may be a character range.
748 If KEYMAP has a parent, the parent's bindings are included as well.
749 This works recursively: if the parent has itself a parent, then the
750 grandparent's bindings are also included and so on.
751 usage: (map-keymap FUNCTION KEYMAP) */)
752 (function
, keymap
, sort_first
)
753 Lisp_Object function
, keymap
, sort_first
;
755 if (! NILP (sort_first
))
756 return call2 (intern ("map-keymap-sorted"), function
, keymap
);
758 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
762 /* Given OBJECT which was found in a slot in a keymap,
763 trace indirect definitions to get the actual definition of that slot.
764 An indirect definition is a list of the form
765 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
766 and INDEX is the object to look up in KEYMAP to yield the definition.
768 Also if OBJECT has a menu string as the first element,
769 remove that. Also remove a menu help string as second element.
771 If AUTOLOAD is nonzero, load autoloadable keymaps
772 that are referred to with indirection.
774 This can GC because menu_item_eval_property calls Feval. */
777 get_keyelt (Lisp_Object object
, int autoload
)
781 if (!(CONSP (object
)))
782 /* This is really the value. */
785 /* If the keymap contents looks like (keymap ...) or (lambda ...)
787 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
790 /* If the keymap contents looks like (menu-item name . DEFN)
791 or (menu-item name DEFN ...) then use DEFN.
792 This is a new format menu item. */
793 else if (EQ (XCAR (object
), Qmenu_item
))
795 if (CONSP (XCDR (object
)))
799 object
= XCDR (XCDR (object
));
802 object
= XCAR (object
);
804 /* If there's a `:filter FILTER', apply FILTER to the
805 menu-item's definition to get the real definition to
807 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
808 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
811 filter
= XCAR (XCDR (tem
));
812 filter
= list2 (filter
, list2 (Qquote
, object
));
813 object
= menu_item_eval_property (filter
);
818 /* Invalid keymap. */
822 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
823 Keymap alist elements like (CHAR MENUSTRING . DEFN)
824 will be used by HierarKey menus. */
825 else if (STRINGP (XCAR (object
)))
827 object
= XCDR (object
);
828 /* Also remove a menu help string, if any,
829 following the menu item name. */
830 if (CONSP (object
) && STRINGP (XCAR (object
)))
831 object
= XCDR (object
);
832 /* Also remove the sublist that caches key equivalences, if any. */
833 if (CONSP (object
) && CONSP (XCAR (object
)))
836 carcar
= XCAR (XCAR (object
));
837 if (NILP (carcar
) || VECTORP (carcar
))
838 object
= XCDR (object
);
842 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
848 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
850 return (!CONSP (map
) ? object
/* Invalid keymap */
851 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
857 store_in_keymap (Lisp_Object keymap
, register Lisp_Object idx
, Lisp_Object def
)
859 /* Flush any reverse-map cache. */
860 where_is_cache
= Qnil
;
861 where_is_cache_keymaps
= Qt
;
863 /* If we are preparing to dump, and DEF is a menu element
864 with a menu item indicator, copy it to ensure it is not pure. */
865 if (CONSP (def
) && PURE_P (def
)
866 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
867 def
= Fcons (XCAR (def
), XCDR (def
));
869 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
870 error ("attempt to define a key in a non-keymap");
872 /* If idx is a cons, and the car part is a character, idx must be of
873 the form (FROM-CHAR . TO-CHAR). */
874 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
875 CHECK_CHARACTER_CDR (idx
);
877 /* If idx is a list (some sort of mouse click, perhaps?),
878 the index we want to use is the car of the list, which
879 ought to be a symbol. */
880 idx
= EVENT_HEAD (idx
);
882 /* If idx is a symbol, it might have modifiers, which need to
883 be put in the canonical order. */
885 idx
= reorder_modifiers (idx
);
886 else if (INTEGERP (idx
))
887 /* Clobber the high bits that can be present on a machine
888 with more than 24 bits of integer. */
889 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
891 /* Scan the keymap for a binding of idx. */
895 /* The cons after which we should insert new bindings. If the
896 keymap has a table element, we record its position here, so new
897 bindings will go after it; this way, the table will stay
898 towards the front of the alist and character lookups in dense
899 keymaps will remain fast. Otherwise, this just points at the
900 front of the keymap. */
901 Lisp_Object insertion_point
;
903 insertion_point
= keymap
;
904 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
911 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
914 ASET (elt
, XFASTINT (idx
), def
);
917 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
919 int from
= XFASTINT (XCAR (idx
));
920 int to
= XFASTINT (XCDR (idx
));
922 if (to
>= ASIZE (elt
))
923 to
= ASIZE (elt
) - 1;
924 for (; from
<= to
; from
++)
925 ASET (elt
, from
, def
);
926 if (to
== XFASTINT (XCDR (idx
)))
927 /* We have defined all keys in IDX. */
930 insertion_point
= tail
;
932 else if (CHAR_TABLE_P (elt
))
934 /* Character codes with modifiers
935 are not included in a char-table.
936 All character codes without modifiers are included. */
937 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
940 /* `nil' has a special meaning for char-tables, so
941 we use something else to record an explicitly
943 NILP (def
) ? Qt
: def
);
946 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
948 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
951 insertion_point
= tail
;
953 else if (CONSP (elt
))
955 if (EQ (idx
, XCAR (elt
)))
961 else if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
963 int from
= XFASTINT (XCAR (idx
));
964 int to
= XFASTINT (XCDR (idx
));
966 if (from
<= XFASTINT (XCAR (elt
))
967 && to
>= XFASTINT (XCAR (elt
)))
975 else if (EQ (elt
, Qkeymap
))
976 /* If we find a 'keymap' symbol in the spine of KEYMAP,
977 then we must have found the start of a second keymap
978 being used as the tail of KEYMAP, and a binding for IDX
979 should be inserted before it. */
986 /* We have scanned the entire keymap, and not found a binding for
987 IDX. Let's add one. */
991 if (CONSP (idx
) && CHARACTERP (XCAR (idx
)))
993 /* IDX specifies a range of characters, and not all of them
994 were handled yet, which means this keymap doesn't have a
995 char-table. So, we insert a char-table now. */
996 elt
= Fmake_char_table (Qkeymap
, Qnil
);
997 Fset_char_table_range (elt
, idx
, NILP (def
) ? Qt
: def
);
1000 elt
= Fcons (idx
, def
);
1001 CHECK_IMPURE (insertion_point
);
1002 XSETCDR (insertion_point
, Fcons (elt
, XCDR (insertion_point
)));
1009 EXFUN (Fcopy_keymap
, 1);
1012 copy_keymap_item (Lisp_Object elt
)
1014 Lisp_Object res
, tem
;
1021 /* Is this a new format menu item. */
1022 if (EQ (XCAR (tem
), Qmenu_item
))
1024 /* Copy cell with menu-item marker. */
1025 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1029 /* Copy cell with menu-item name. */
1030 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1036 /* Copy cell with binding and if the binding is a keymap,
1038 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1041 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1042 XSETCAR (elt
, Fcopy_keymap (tem
));
1044 if (CONSP (tem
) && CONSP (XCAR (tem
)))
1045 /* Delete cache for key equivalences. */
1046 XSETCDR (elt
, XCDR (tem
));
1051 /* It may be an old fomat menu item.
1052 Skip the optional menu string. */
1053 if (STRINGP (XCAR (tem
)))
1055 /* Copy the cell, since copy-alist didn't go this deep. */
1056 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1058 /* Also skip the optional menu help string. */
1059 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1061 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1065 /* There may also be a list that caches key equivalences.
1066 Just delete it for the new keymap. */
1068 && CONSP (XCAR (tem
))
1069 && (NILP (XCAR (XCAR (tem
)))
1070 || VECTORP (XCAR (XCAR (tem
)))))
1072 XSETCDR (elt
, XCDR (tem
));
1075 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1076 XSETCDR (elt
, Fcopy_keymap (tem
));
1078 else if (EQ (XCAR (tem
), Qkeymap
))
1079 res
= Fcopy_keymap (elt
);
1085 copy_keymap_1 (Lisp_Object chartable
, Lisp_Object idx
, Lisp_Object elt
)
1087 Fset_char_table_range (chartable
, idx
, copy_keymap_item (elt
));
1090 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1091 doc
: /* Return a copy of the keymap KEYMAP.
1092 The copy starts out with the same definitions of KEYMAP,
1093 but changing either the copy or KEYMAP does not affect the other.
1094 Any key definitions that are subkeymaps are recursively copied.
1095 However, a key definition which is a symbol whose definition is a keymap
1100 register Lisp_Object copy
, tail
;
1101 keymap
= get_keymap (keymap
, 1, 0);
1102 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1103 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1105 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1107 Lisp_Object elt
= XCAR (keymap
);
1108 if (CHAR_TABLE_P (elt
))
1110 elt
= Fcopy_sequence (elt
);
1111 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
);
1113 else if (VECTORP (elt
))
1116 elt
= Fcopy_sequence (elt
);
1117 for (i
= 0; i
< ASIZE (elt
); i
++)
1118 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1120 else if (CONSP (elt
))
1121 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1122 XSETCDR (tail
, Fcons (elt
, Qnil
));
1124 keymap
= XCDR (keymap
);
1126 XSETCDR (tail
, keymap
);
1130 /* Simple Keymap mutators and accessors. */
1132 /* GC is possible in this function if it autoloads a keymap. */
1134 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1135 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1138 KEY is a string or a vector of symbols and characters meaning a
1139 sequence of keystrokes and events. Non-ASCII characters with codes
1140 above 127 (such as ISO Latin-1) can be included if you use a vector.
1141 Using [t] for KEY creates a default definition, which applies to any
1142 event type that has no other definition in this keymap.
1144 DEF is anything that can be a key's definition:
1145 nil (means key is undefined in this keymap),
1146 a command (a Lisp function suitable for interactive calling),
1147 a string (treated as a keyboard macro),
1148 a keymap (to define a prefix key),
1149 a symbol (when the key is looked up, the symbol will stand for its
1150 function definition, which should at that time be one of the above,
1151 or another symbol whose function definition is used, etc.),
1152 a cons (STRING . DEFN), meaning that DEFN is the definition
1153 (DEFN should be a valid definition in its own right),
1154 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
1155 or an extended menu item definition.
1156 (See info node `(elisp)Extended Menu Items'.)
1158 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1159 binding is altered. If there is no binding for KEY, the new pair
1160 binding KEY to DEF is added at the front of KEYMAP. */)
1167 register Lisp_Object c
;
1168 register Lisp_Object cmd
;
1172 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1174 GCPRO3 (keymap
, key
, def
);
1175 keymap
= get_keymap (keymap
, 1, 1);
1177 CHECK_VECTOR_OR_STRING (key
);
1179 length
= XFASTINT (Flength (key
));
1181 RETURN_UNGCPRO (Qnil
);
1183 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1184 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1186 meta_bit
= (VECTORP (key
) || (STRINGP (key
) && STRING_MULTIBYTE (key
))
1187 ? meta_modifier
: 0x80);
1189 if (VECTORP (def
) && ASIZE (def
) > 0 && CONSP (AREF (def
, 0)))
1190 { /* DEF is apparently an XEmacs-style keyboard macro. */
1191 Lisp_Object tmp
= Fmake_vector (make_number (ASIZE (def
)), Qnil
);
1192 int i
= ASIZE (def
);
1195 Lisp_Object c
= AREF (def
, i
);
1196 if (CONSP (c
) && lucid_event_type_list_p (c
))
1197 c
= Fevent_convert_list (c
);
1206 c
= Faref (key
, make_number (idx
));
1210 /* C may be a Lucid style event type list or a cons (FROM .
1211 TO) specifying a range of characters. */
1212 if (lucid_event_type_list_p (c
))
1213 c
= Fevent_convert_list (c
);
1214 else if (CHARACTERP (XCAR (c
)))
1215 CHECK_CHARACTER_CDR (c
);
1219 silly_event_symbol_error (c
);
1222 && (XINT (c
) & meta_bit
)
1225 c
= meta_prefix_char
;
1231 XSETINT (c
, XINT (c
) & ~meta_bit
);
1237 if (!INTEGERP (c
) && !SYMBOLP (c
)
1239 /* If C is a range, it must be a leaf. */
1240 || (INTEGERP (XCAR (c
)) && idx
!= length
)))
1241 error ("Key sequence contains invalid event");
1244 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1246 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1248 /* If this key is undefined, make it a prefix. */
1250 cmd
= define_as_prefix (keymap
, c
);
1252 keymap
= get_keymap (cmd
, 0, 1);
1253 if (!CONSP (keymap
))
1254 /* We must use Fkey_description rather than just passing key to
1255 error; key might be a vector, not a string. */
1256 error ("Key sequence %s starts with non-prefix key %s",
1257 SDATA (Fkey_description (key
, Qnil
)),
1258 SDATA (Fkey_description (Fsubstring (key
, make_number (0),
1264 /* This function may GC (it calls Fkey_binding). */
1266 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 3, 0,
1267 doc
: /* Return the remapping for command COMMAND.
1268 Returns nil if COMMAND is not remapped (or not a symbol).
1270 If the optional argument POSITION is non-nil, it specifies a mouse
1271 position as returned by `event-start' and `event-end', and the
1272 remapping occurs in the keymaps associated with it. It can also be a
1273 number or marker, in which case the keymap properties at the specified
1274 buffer position instead of point are used. The KEYMAPS argument is
1275 ignored if POSITION is non-nil.
1277 If the optional argument KEYMAPS is non-nil, it should be a list of
1278 keymaps to search for command remapping. Otherwise, search for the
1279 remapping in all currently active keymaps. */)
1280 (command
, position
, keymaps
)
1281 Lisp_Object command
, position
, keymaps
;
1283 if (!SYMBOLP (command
))
1286 ASET (command_remapping_vector
, 1, command
);
1289 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
, position
);
1292 Lisp_Object maps
, binding
;
1294 for (maps
= keymaps
; CONSP (maps
); maps
= XCDR (maps
))
1296 binding
= Flookup_key (XCAR (maps
), command_remapping_vector
, Qnil
);
1297 if (!NILP (binding
) && !INTEGERP (binding
))
1304 /* Value is number if KEY is too long; nil if valid but has no definition. */
1305 /* GC is possible in this function if it autoloads a keymap. */
1307 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1308 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1309 A value of nil means undefined. See doc of `define-key'
1310 for kinds of definitions.
1312 A number as value means KEY is "too long";
1313 that is, characters or symbols in it except for the last one
1314 fail to be a valid sequence of prefix characters in KEYMAP.
1315 The number is how many characters at the front of KEY
1316 it takes to reach a non-prefix key.
1318 Normally, `lookup-key' ignores bindings for t, which act as default
1319 bindings, used when nothing else in the keymap applies; this makes it
1320 usable as a general function for probing keymaps. However, if the
1321 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1322 recognize the default bindings, just as `read-key-sequence' does. */)
1323 (keymap
, key
, accept_default
)
1326 Lisp_Object accept_default
;
1329 register Lisp_Object cmd
;
1330 register Lisp_Object c
;
1332 int t_ok
= !NILP (accept_default
);
1333 struct gcpro gcpro1
, gcpro2
;
1335 GCPRO2 (keymap
, key
);
1336 keymap
= get_keymap (keymap
, 1, 1);
1338 CHECK_VECTOR_OR_STRING (key
);
1340 length
= XFASTINT (Flength (key
));
1342 RETURN_UNGCPRO (keymap
);
1347 c
= Faref (key
, make_number (idx
++));
1349 if (CONSP (c
) && lucid_event_type_list_p (c
))
1350 c
= Fevent_convert_list (c
);
1352 /* Turn the 8th bit of string chars into a meta modifier. */
1353 if (STRINGP (key
) && XINT (c
) & 0x80 && !STRING_MULTIBYTE (key
))
1354 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1356 /* Allow string since binding for `menu-bar-select-buffer'
1357 includes the buffer name in the key sequence. */
1358 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1359 error ("Key sequence contains invalid event");
1361 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1363 RETURN_UNGCPRO (cmd
);
1365 keymap
= get_keymap (cmd
, 0, 1);
1366 if (!CONSP (keymap
))
1367 RETURN_UNGCPRO (make_number (idx
));
1373 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1374 Assume that currently it does not define C at all.
1375 Return the keymap. */
1378 define_as_prefix (Lisp_Object keymap
, Lisp_Object c
)
1382 cmd
= Fmake_sparse_keymap (Qnil
);
1383 /* If this key is defined as a prefix in an inherited keymap,
1384 make it a prefix in this map, and make its definition
1385 inherit the other prefix definition. */
1386 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1387 store_in_keymap (keymap
, c
, cmd
);
1392 /* Append a key to the end of a key sequence. We always make a vector. */
1395 append_key (Lisp_Object key_sequence
, Lisp_Object key
)
1397 Lisp_Object args
[2];
1399 args
[0] = key_sequence
;
1401 args
[1] = Fcons (key
, Qnil
);
1402 return Fvconcat (2, args
);
1405 /* Given a event type C which is a symbol,
1406 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1409 silly_event_symbol_error (Lisp_Object c
)
1411 Lisp_Object parsed
, base
, name
, assoc
;
1414 parsed
= parse_modifiers (c
);
1415 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1416 base
= XCAR (parsed
);
1417 name
= Fsymbol_name (base
);
1418 /* This alist includes elements such as ("RET" . "\\r"). */
1419 assoc
= Fassoc (name
, exclude_keys
);
1423 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1425 Lisp_Object keystring
;
1426 if (modifiers
& alt_modifier
)
1427 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1428 if (modifiers
& ctrl_modifier
)
1429 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1430 if (modifiers
& hyper_modifier
)
1431 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1432 if (modifiers
& meta_modifier
)
1433 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1434 if (modifiers
& shift_modifier
)
1435 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1436 if (modifiers
& super_modifier
)
1437 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1440 c
= reorder_modifiers (c
);
1441 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1443 error ((modifiers
& ~meta_modifier
1444 ? "To bind the key %s, use [?%s], not [%s]"
1445 : "To bind the key %s, use \"%s\", not [%s]"),
1446 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1447 SDATA (SYMBOL_NAME (c
)));
1451 /* Global, local, and minor mode keymap stuff. */
1453 /* We can't put these variables inside current_minor_maps, since under
1454 some systems, static gets macro-defined to be the empty string.
1456 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1457 static int cmm_size
= 0;
1459 /* Store a pointer to an array of the currently active minor modes in
1460 *modeptr, a pointer to an array of the keymaps of the currently
1461 active minor modes in *mapptr, and return the number of maps
1464 This function always returns a pointer to the same buffer, and may
1465 free or reallocate it, so if you want to keep it for a long time or
1466 hand it out to lisp code, copy it. This procedure will be called
1467 for every key sequence read, so the nice lispy approach (return a
1468 new assoclist, list, what have you) for each invocation would
1469 result in a lot of consing over time.
1471 If we used xrealloc/xmalloc and ran out of memory, they would throw
1472 back to the command loop, which would try to read a key sequence,
1473 which would call this function again, resulting in an infinite
1474 loop. Instead, we'll use realloc/malloc and silently truncate the
1475 list, let the key sequence be read, and hope some other piece of
1476 code signals the error. */
1478 current_minor_maps (Lisp_Object
**modeptr
, Lisp_Object
**mapptr
)
1481 int list_number
= 0;
1482 Lisp_Object alist
, assoc
, var
, val
;
1483 Lisp_Object emulation_alists
;
1484 Lisp_Object lists
[2];
1486 emulation_alists
= Vemulation_mode_map_alists
;
1487 lists
[0] = Vminor_mode_overriding_map_alist
;
1488 lists
[1] = Vminor_mode_map_alist
;
1490 for (list_number
= 0; list_number
< 2; list_number
++)
1492 if (CONSP (emulation_alists
))
1494 alist
= XCAR (emulation_alists
);
1495 emulation_alists
= XCDR (emulation_alists
);
1496 if (SYMBOLP (alist
))
1497 alist
= find_symbol_value (alist
);
1501 alist
= lists
[list_number
];
1503 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1504 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1505 && (var
= XCAR (assoc
), SYMBOLP (var
))
1506 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1511 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1512 and also an entry in Vminor_mode_map_alist,
1513 ignore the latter. */
1514 if (list_number
== 1)
1516 val
= assq_no_quit (var
, lists
[0]);
1523 int newsize
, allocsize
;
1524 Lisp_Object
*newmodes
, *newmaps
;
1526 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1527 allocsize
= newsize
* sizeof *newmodes
;
1529 /* Use malloc here. See the comment above this function.
1530 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1532 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1537 memcpy (newmodes
, cmm_modes
,
1538 cmm_size
* sizeof cmm_modes
[0]);
1541 cmm_modes
= newmodes
;
1544 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1549 memcpy (newmaps
, cmm_maps
,
1550 cmm_size
* sizeof cmm_maps
[0]);
1557 if (newmodes
== NULL
|| newmaps
== NULL
)
1562 /* Get the keymap definition--or nil if it is not defined. */
1563 temp
= Findirect_function (XCDR (assoc
), Qt
);
1567 cmm_maps
[i
] = temp
;
1573 if (modeptr
) *modeptr
= cmm_modes
;
1574 if (mapptr
) *mapptr
= cmm_maps
;
1578 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1580 doc
: /* Return a list of the currently active keymaps.
1581 OLP if non-nil indicates that we should obey `overriding-local-map' and
1582 `overriding-terminal-local-map'. POSITION can specify a click position
1583 like in the respective argument of `key-binding'. */)
1585 Lisp_Object olp
, position
;
1587 int count
= SPECPDL_INDEX ();
1589 Lisp_Object keymaps
;
1591 /* If a mouse click position is given, our variables are based on
1592 the buffer clicked on, not the current buffer. So we may have to
1593 switch the buffer here. */
1595 if (CONSP (position
))
1599 window
= POSN_WINDOW (position
);
1601 if (WINDOWP (window
)
1602 && BUFFERP (XWINDOW (window
)->buffer
)
1603 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1605 /* Arrange to go back to the original buffer once we're done
1606 processing the key sequence. We don't use
1607 save_excursion_{save,restore} here, in analogy to
1608 `read-key-sequence' to avoid saving point. Maybe this
1609 would not be a problem here, but it is easier to keep
1613 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1615 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1619 keymaps
= Fcons (current_global_map
, Qnil
);
1623 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1624 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1625 /* The doc said that overriding-terminal-local-map should
1626 override overriding-local-map. The code used them both,
1627 but it seems clearer to use just one. rms, jan 2005. */
1628 else if (!NILP (Voverriding_local_map
))
1629 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1631 if (NILP (XCDR (keymaps
)))
1636 Lisp_Object keymap
, local_map
;
1639 pt
= INTEGERP (position
) ? XINT (position
)
1640 : MARKERP (position
) ? marker_position (position
)
1643 /* Get the buffer local maps, possibly overriden by text or
1644 overlay properties */
1646 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1647 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1649 if (CONSP (position
))
1653 /* For a mouse click, get the local text-property keymap
1654 of the place clicked on, rather than point. */
1656 if (POSN_INBUFFER_P (position
))
1660 pos
= POSN_BUFFER_POSN (position
);
1662 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1664 local_map
= get_local_map (XINT (pos
),
1665 current_buffer
, Qlocal_map
);
1667 keymap
= get_local_map (XINT (pos
),
1668 current_buffer
, Qkeymap
);
1672 /* If on a mode line string with a local keymap,
1673 or for a click on a string, i.e. overlay string or a
1674 string displayed via the `display' property,
1675 consider `local-map' and `keymap' properties of
1678 if (string
= POSN_STRING (position
),
1679 (CONSP (string
) && STRINGP (XCAR (string
))))
1681 Lisp_Object pos
, map
;
1683 pos
= XCDR (string
);
1684 string
= XCAR (string
);
1687 && XINT (pos
) < SCHARS (string
))
1689 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1693 map
= Fget_text_property (pos
, Qkeymap
, string
);
1701 if (!NILP (local_map
))
1702 keymaps
= Fcons (local_map
, keymaps
);
1704 /* Now put all the minor mode keymaps on the list. */
1705 nmaps
= current_minor_maps (0, &maps
);
1707 for (i
= --nmaps
; i
>= 0; i
--)
1708 if (!NILP (maps
[i
]))
1709 keymaps
= Fcons (maps
[i
], keymaps
);
1712 keymaps
= Fcons (keymap
, keymaps
);
1715 unbind_to (count
, Qnil
);
1720 /* GC is possible in this function if it autoloads a keymap. */
1722 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 4, 0,
1723 doc
: /* Return the binding for command KEY in current keymaps.
1724 KEY is a string or vector, a sequence of keystrokes.
1725 The binding is probably a symbol with a function definition.
1727 Normally, `key-binding' ignores bindings for t, which act as default
1728 bindings, used when nothing else in the keymap applies; this makes it
1729 usable as a general function for probing keymaps. However, if the
1730 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1731 recognize the default bindings, just as `read-key-sequence' does.
1733 Like the normal command loop, `key-binding' will remap the command
1734 resulting from looking up KEY by looking up the command in the
1735 current keymaps. However, if the optional third argument NO-REMAP
1736 is non-nil, `key-binding' returns the unmapped command.
1738 If KEY is a key sequence initiated with the mouse, the used keymaps
1739 will depend on the clicked mouse position with regard to the buffer
1740 and possible local keymaps on strings.
1742 If the optional argument POSITION is non-nil, it specifies a mouse
1743 position as returned by `event-start' and `event-end', and the lookup
1744 occurs in the keymaps associated with it instead of KEY. It can also
1745 be a number or marker, in which case the keymap properties at the
1746 specified buffer position instead of point are used.
1748 (key
, accept_default
, no_remap
, position
)
1749 Lisp_Object key
, accept_default
, no_remap
, position
;
1751 Lisp_Object
*maps
, value
;
1753 struct gcpro gcpro1
, gcpro2
;
1754 int count
= SPECPDL_INDEX ();
1756 GCPRO2 (key
, position
);
1758 if (NILP (position
) && VECTORP (key
))
1761 /* mouse events may have a symbolic prefix indicating the
1762 scrollbar or mode line */
1763 = AREF (key
, SYMBOLP (AREF (key
, 0)) && ASIZE (key
) > 1 ? 1 : 0);
1765 /* We are not interested in locations without event data */
1767 if (EVENT_HAS_PARAMETERS (event
) && CONSP (XCDR (event
)))
1769 Lisp_Object kind
= EVENT_HEAD_KIND (EVENT_HEAD (event
));
1770 if (EQ (kind
, Qmouse_click
))
1771 position
= EVENT_START (event
);
1775 /* Key sequences beginning with mouse clicks
1776 are read using the keymaps of the buffer clicked on, not
1777 the current buffer. So we may have to switch the buffer
1780 if (CONSP (position
))
1784 window
= POSN_WINDOW (position
);
1786 if (WINDOWP (window
)
1787 && BUFFERP (XWINDOW (window
)->buffer
)
1788 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
1790 /* Arrange to go back to the original buffer once we're done
1791 processing the key sequence. We don't use
1792 save_excursion_{save,restore} here, in analogy to
1793 `read-key-sequence' to avoid saving point. Maybe this
1794 would not be a problem here, but it is easier to keep
1798 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
1800 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
1804 if (! NILP (current_kboard
->Voverriding_terminal_local_map
))
1806 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1807 key
, accept_default
);
1808 if (! NILP (value
) && !INTEGERP (value
))
1811 else if (! NILP (Voverriding_local_map
))
1813 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1814 if (! NILP (value
) && !INTEGERP (value
))
1819 Lisp_Object keymap
, local_map
;
1822 pt
= INTEGERP (position
) ? XINT (position
)
1823 : MARKERP (position
) ? marker_position (position
)
1826 local_map
= get_local_map (pt
, current_buffer
, Qlocal_map
);
1827 keymap
= get_local_map (pt
, current_buffer
, Qkeymap
);
1829 if (CONSP (position
))
1833 /* For a mouse click, get the local text-property keymap
1834 of the place clicked on, rather than point. */
1836 if (POSN_INBUFFER_P (position
))
1840 pos
= POSN_BUFFER_POSN (position
);
1842 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
1844 local_map
= get_local_map (XINT (pos
),
1845 current_buffer
, Qlocal_map
);
1847 keymap
= get_local_map (XINT (pos
),
1848 current_buffer
, Qkeymap
);
1852 /* If on a mode line string with a local keymap,
1853 or for a click on a string, i.e. overlay string or a
1854 string displayed via the `display' property,
1855 consider `local-map' and `keymap' properties of
1858 if (string
= POSN_STRING (position
),
1859 (CONSP (string
) && STRINGP (XCAR (string
))))
1861 Lisp_Object pos
, map
;
1863 pos
= XCDR (string
);
1864 string
= XCAR (string
);
1867 && XINT (pos
) < SCHARS (string
))
1869 map
= Fget_text_property (pos
, Qlocal_map
, string
);
1873 map
= Fget_text_property (pos
, Qkeymap
, string
);
1881 if (! NILP (keymap
))
1883 value
= Flookup_key (keymap
, key
, accept_default
);
1884 if (! NILP (value
) && !INTEGERP (value
))
1888 nmaps
= current_minor_maps (0, &maps
);
1889 /* Note that all these maps are GCPRO'd
1890 in the places where we found them. */
1892 for (i
= 0; i
< nmaps
; i
++)
1893 if (! NILP (maps
[i
]))
1895 value
= Flookup_key (maps
[i
], key
, accept_default
);
1896 if (! NILP (value
) && !INTEGERP (value
))
1900 if (! NILP (local_map
))
1902 value
= Flookup_key (local_map
, key
, accept_default
);
1903 if (! NILP (value
) && !INTEGERP (value
))
1908 value
= Flookup_key (current_global_map
, key
, accept_default
);
1911 unbind_to (count
, Qnil
);
1914 if (NILP (value
) || INTEGERP (value
))
1917 /* If the result of the ordinary keymap lookup is an interactive
1918 command, look for a key binding (ie. remapping) for that command. */
1920 if (NILP (no_remap
) && SYMBOLP (value
))
1923 if (value1
= Fcommand_remapping (value
, position
, Qnil
), !NILP (value1
))
1930 /* GC is possible in this function if it autoloads a keymap. */
1932 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1933 doc
: /* Return the binding for command KEYS in current local keymap only.
1934 KEYS is a string or vector, a sequence of keystrokes.
1935 The binding is probably a symbol with a function definition.
1937 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1938 bindings; see the description of `lookup-key' for more details about this. */)
1939 (keys
, accept_default
)
1940 Lisp_Object keys
, accept_default
;
1942 register Lisp_Object map
;
1943 map
= current_buffer
->keymap
;
1946 return Flookup_key (map
, keys
, accept_default
);
1949 /* GC is possible in this function if it autoloads a keymap. */
1951 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1952 doc
: /* Return the binding for command KEYS in current global keymap only.
1953 KEYS is a string or vector, a sequence of keystrokes.
1954 The binding is probably a symbol with a function definition.
1955 This function's return values are the same as those of `lookup-key'
1958 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1959 bindings; see the description of `lookup-key' for more details about this. */)
1960 (keys
, accept_default
)
1961 Lisp_Object keys
, accept_default
;
1963 return Flookup_key (current_global_map
, keys
, accept_default
);
1966 /* GC is possible in this function if it autoloads a keymap. */
1968 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1969 doc
: /* Find the visible minor mode bindings of KEY.
1970 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1971 the symbol which names the minor mode binding KEY, and BINDING is
1972 KEY's definition in that mode. In particular, if KEY has no
1973 minor-mode bindings, return nil. If the first binding is a
1974 non-prefix, all subsequent bindings will be omitted, since they would
1975 be ignored. Similarly, the list doesn't include non-prefix bindings
1976 that come after prefix bindings.
1978 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1979 bindings; see the description of `lookup-key' for more details about this. */)
1980 (key
, accept_default
)
1981 Lisp_Object key
, accept_default
;
1983 Lisp_Object
*modes
, *maps
;
1985 Lisp_Object binding
;
1987 struct gcpro gcpro1
, gcpro2
;
1989 nmaps
= current_minor_maps (&modes
, &maps
);
1990 /* Note that all these maps are GCPRO'd
1991 in the places where we found them. */
1994 GCPRO2 (key
, binding
);
1996 for (i
= j
= 0; i
< nmaps
; i
++)
1998 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1999 && !INTEGERP (binding
))
2001 if (KEYMAPP (binding
))
2002 maps
[j
++] = Fcons (modes
[i
], binding
);
2004 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
2008 return Flist (j
, maps
);
2011 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
2012 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
2013 A new sparse keymap is stored as COMMAND's function definition and its value.
2014 If a second optional argument MAPVAR is given, the map is stored as
2015 its value instead of as COMMAND's value; but COMMAND is still defined
2017 The third optional argument NAME, if given, supplies a menu name
2018 string for the map. This is required to use the keymap as a menu.
2019 This function returns COMMAND. */)
2020 (command
, mapvar
, name
)
2021 Lisp_Object command
, mapvar
, name
;
2024 map
= Fmake_sparse_keymap (name
);
2025 Ffset (command
, map
);
2029 Fset (command
, map
);
2033 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
2034 doc
: /* Select KEYMAP as the global keymap. */)
2038 keymap
= get_keymap (keymap
, 1, 1);
2039 current_global_map
= keymap
;
2044 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
2045 doc
: /* Select KEYMAP as the local keymap.
2046 If KEYMAP is nil, that means no local keymap. */)
2051 keymap
= get_keymap (keymap
, 1, 1);
2053 current_buffer
->keymap
= keymap
;
2058 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
2059 doc
: /* Return current buffer's local keymap, or nil if it has none.
2060 Normally the local keymap is set by the major mode with `use-local-map'. */)
2063 return current_buffer
->keymap
;
2066 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
2067 doc
: /* Return the current global keymap. */)
2070 return current_global_map
;
2073 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
2074 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
2078 int nmaps
= current_minor_maps (0, &maps
);
2080 return Flist (nmaps
, maps
);
2083 /* Help functions for describing and documenting keymaps. */
2085 struct accessible_keymaps_data
{
2086 Lisp_Object maps
, tail
, thisseq
;
2087 /* Does the current sequence end in the meta-prefix-char? */
2092 accessible_keymaps_1 (Lisp_Object key
, Lisp_Object cmd
, Lisp_Object args
, void *data
)
2093 /* Use void* data to be compatible with map_keymap_function_t. */
2095 struct accessible_keymaps_data
*d
= data
; /* Cast! */
2096 Lisp_Object maps
= d
->maps
;
2097 Lisp_Object tail
= d
->tail
;
2098 Lisp_Object thisseq
= d
->thisseq
;
2099 int is_metized
= d
->is_metized
&& INTEGERP (key
);
2102 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
2106 /* Look for and break cycles. */
2107 while (!NILP (tem
= Frassq (cmd
, maps
)))
2109 Lisp_Object prefix
= XCAR (tem
);
2110 int lim
= XINT (Flength (XCAR (tem
)));
2111 if (lim
<= XINT (Flength (thisseq
)))
2112 { /* This keymap was already seen with a smaller prefix. */
2114 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
2115 Faref (thisseq
, make_number (i
))))
2118 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
2121 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
2122 but maybe `cmd' occurs again further down in `maps', so keep
2124 maps
= XCDR (Fmemq (tem
, maps
));
2127 /* If the last key in thisseq is meta-prefix-char,
2128 turn it into a meta-ized keystroke. We know
2129 that the event we're about to append is an
2130 ascii keystroke since we're processing a
2134 int meta_bit
= meta_modifier
;
2135 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
2136 tem
= Fcopy_sequence (thisseq
);
2138 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
2140 /* This new sequence is the same length as
2141 thisseq, so stick it in the list right
2144 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
2148 tem
= append_key (thisseq
, key
);
2149 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
2153 /* This function cannot GC. */
2155 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
2157 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
2158 Returns a list of elements of the form (KEYS . MAP), where the sequence
2159 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
2160 so that the KEYS increase in length. The first element is ([] . KEYMAP).
2161 An optional argument PREFIX, if non-nil, should be a key sequence;
2162 then the value includes only maps for prefixes that start with PREFIX. */)
2164 Lisp_Object keymap
, prefix
;
2166 Lisp_Object maps
, tail
;
2167 int prefixlen
= XINT (Flength (prefix
));
2169 /* no need for gcpro because we don't autoload any keymaps. */
2173 /* If a prefix was specified, start with the keymap (if any) for
2174 that prefix, so we don't waste time considering other prefixes. */
2176 tem
= Flookup_key (keymap
, prefix
, Qt
);
2177 /* Flookup_key may give us nil, or a number,
2178 if the prefix is not defined in this particular map.
2179 It might even give us a list that isn't a keymap. */
2180 tem
= get_keymap (tem
, 0, 0);
2181 /* If the keymap is autoloaded `tem' is not a cons-cell, but we still
2182 want to return it. */
2185 /* Convert PREFIX to a vector now, so that later on
2186 we don't have to deal with the possibility of a string. */
2187 if (STRINGP (prefix
))
2192 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
2193 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
2197 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
2198 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2199 c
^= 0200 | meta_modifier
;
2200 ASET (copy
, i_before
, make_number (c
));
2204 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
2210 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
2211 get_keymap (keymap
, 1, 0)),
2214 /* For each map in the list maps,
2215 look at any other maps it points to,
2216 and stick them at the end if they are not already in the list.
2218 This is a breadth-first traversal, where tail is the queue of
2219 nodes, and maps accumulates a list of all nodes visited. */
2221 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
2223 struct accessible_keymaps_data data
;
2224 register Lisp_Object thismap
= Fcdr (XCAR (tail
));
2227 data
.thisseq
= Fcar (XCAR (tail
));
2230 last
= make_number (XINT (Flength (data
.thisseq
)) - 1);
2231 /* Does the current sequence end in the meta-prefix-char? */
2232 data
.is_metized
= (XINT (last
) >= 0
2233 /* Don't metize the last char of PREFIX. */
2234 && XINT (last
) >= prefixlen
2235 && EQ (Faref (data
.thisseq
, last
), meta_prefix_char
));
2237 /* Since we can't run lisp code, we can't scan autoloaded maps. */
2238 if (CONSP (thismap
))
2239 map_keymap (thismap
, accessible_keymaps_1
, Qnil
, &data
, 0);
2243 Lisp_Object Qsingle_key_description
, Qkey_description
;
2245 /* This function cannot GC. */
2247 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
2248 doc
: /* Return a pretty description of key-sequence KEYS.
2249 Optional arg PREFIX is the sequence of keys leading up to KEYS.
2250 Control characters turn into "C-foo" sequences, meta into "M-foo",
2251 spaces are put between sequence elements, etc. */)
2253 Lisp_Object keys
, prefix
;
2258 int size
= XINT (Flength (keys
));
2260 Lisp_Object sep
= build_string (" ");
2265 size
+= XINT (Flength (prefix
));
2267 /* This has one extra element at the end that we don't pass to Fconcat. */
2268 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
2270 /* In effect, this computes
2271 (mapconcat 'single-key-description keys " ")
2272 but we shouldn't use mapconcat because it can do GC. */
2276 list
= prefix
, prefix
= Qnil
;
2277 else if (!NILP (keys
))
2278 list
= keys
, keys
= Qnil
;
2283 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2287 return empty_unibyte_string
;
2288 return Fconcat (len
- 1, args
);
2292 size
= SCHARS (list
);
2293 else if (VECTORP (list
))
2294 size
= XVECTOR (list
)->size
;
2295 else if (CONSP (list
))
2296 size
= XINT (Flength (list
));
2298 wrong_type_argument (Qarrayp
, list
);
2307 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2308 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2309 c
^= 0200 | meta_modifier
;
2310 XSETFASTINT (key
, c
);
2312 else if (VECTORP (list
))
2314 key
= AREF (list
, i
); i
++;
2326 || EQ (key
, meta_prefix_char
)
2327 || (XINT (key
) & meta_modifier
))
2329 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2331 if (EQ (key
, meta_prefix_char
))
2335 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2338 else if (EQ (key
, meta_prefix_char
))
2343 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2351 push_key_description (register unsigned int c
, register char *p
, int force_multibyte
)
2355 /* Clear all the meaningless bits above the meta bit. */
2356 c
&= meta_modifier
| ~ - meta_modifier
;
2357 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2358 | meta_modifier
| shift_modifier
| super_modifier
);
2360 if (! CHARACTERP (make_number (c2
)))
2362 /* KEY_DESCRIPTION_SIZE is large enough for this. */
2363 p
+= sprintf (p
, "[%d]", c
);
2367 if (c
& alt_modifier
)
2373 if ((c
& ctrl_modifier
) != 0
2374 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2378 c
&= ~ctrl_modifier
;
2380 if (c
& hyper_modifier
)
2384 c
-= hyper_modifier
;
2386 if (c
& meta_modifier
)
2392 if (c
& shift_modifier
)
2396 c
-= shift_modifier
;
2398 if (c
& super_modifier
)
2402 c
-= super_modifier
;
2418 else if (c
== Ctl ('M'))
2426 /* `C-' already added above. */
2427 if (c
> 0 && c
<= Ctl ('Z'))
2446 || (NILP (current_buffer
->enable_multibyte_characters
)
2447 && SINGLE_BYTE_CHAR_P (c
)
2448 && !force_multibyte
))
2454 /* Now we are sure that C is a valid character code. */
2455 if (NILP (current_buffer
->enable_multibyte_characters
)
2456 && ! force_multibyte
)
2457 *p
++ = multibyte_char_to_unibyte (c
, Qnil
);
2459 p
+= CHAR_STRING (c
, (unsigned char *) p
);
2465 /* This function cannot GC. */
2467 DEFUN ("single-key-description", Fsingle_key_description
,
2468 Ssingle_key_description
, 1, 2, 0,
2469 doc
: /* Return a pretty description of command character KEY.
2470 Control characters turn into C-whatever, etc.
2471 Optional argument NO-ANGLES non-nil means don't put angle brackets
2472 around function keys and event symbols. */)
2474 Lisp_Object key
, no_angles
;
2476 if (CONSP (key
) && lucid_event_type_list_p (key
))
2477 key
= Fevent_convert_list (key
);
2479 key
= EVENT_HEAD (key
);
2481 if (INTEGERP (key
)) /* Normal character */
2483 char tem
[KEY_DESCRIPTION_SIZE
];
2485 *push_key_description (XUINT (key
), tem
, 1) = 0;
2486 return build_string (tem
);
2488 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2490 if (NILP (no_angles
))
2493 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2494 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2495 return build_string (buffer
);
2498 return Fsymbol_name (key
);
2500 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2501 return Fcopy_sequence (key
);
2503 error ("KEY must be an integer, cons, symbol, or string");
2508 push_text_char_description (register unsigned int c
, register char *p
)
2519 *p
++ = c
+ 64; /* 'A' - 1 */
2531 /* This function cannot GC. */
2533 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2534 doc
: /* Return a pretty description of file-character CHARACTER.
2535 Control characters turn into "^char", etc. This differs from
2536 `single-key-description' which turns them into "C-char".
2537 Also, this function recognizes the 2**7 bit as the Meta character,
2538 whereas `single-key-description' uses the 2**27 bit for Meta.
2539 See Info node `(elisp)Describing Characters' for examples. */)
2541 Lisp_Object character
;
2543 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2544 unsigned char str
[6];
2547 CHECK_NUMBER (character
);
2549 c
= XINT (character
);
2550 if (!ASCII_CHAR_P (c
))
2552 int len
= CHAR_STRING (c
, str
);
2554 return make_multibyte_string (str
, 1, len
);
2557 *push_text_char_description (c
& 0377, str
) = 0;
2559 return build_string (str
);
2562 static int where_is_preferred_modifier
;
2564 /* Return 0 if SEQ uses non-preferred modifiers or non-char events.
2565 Else, return 2 if SEQ uses the where_is_preferred_modifier,
2568 preferred_sequence_p (Lisp_Object seq
)
2571 int len
= XINT (Flength (seq
));
2574 for (i
= 0; i
< len
; i
++)
2576 Lisp_Object ii
, elt
;
2578 XSETFASTINT (ii
, i
);
2579 elt
= Faref (seq
, ii
);
2581 if (!INTEGERP (elt
))
2585 int modifiers
= XUINT (elt
) & (CHAR_MODIFIER_MASK
& ~CHAR_META
);
2586 if (modifiers
== where_is_preferred_modifier
)
2597 /* where-is - finding a command in a set of keymaps. */
2599 static void where_is_internal_1 (Lisp_Object key
, Lisp_Object binding
,
2600 Lisp_Object args
, void *data
);
2602 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2603 Returns the first non-nil binding found in any of those maps.
2604 If REMAP is true, pass the result of the lookup through command
2605 remapping before returning it. */
2608 shadow_lookup (Lisp_Object shadow
, Lisp_Object key
, Lisp_Object flag
,
2611 Lisp_Object tail
, value
;
2613 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2615 value
= Flookup_key (XCAR (tail
), key
, flag
);
2616 if (NATNUMP (value
))
2618 value
= Flookup_key (XCAR (tail
),
2619 Fsubstring (key
, make_number (0), value
), flag
);
2623 else if (!NILP (value
))
2625 Lisp_Object remapping
;
2626 if (remap
&& SYMBOLP (value
)
2627 && (remapping
= Fcommand_remapping (value
, Qnil
, shadow
),
2637 static Lisp_Object Vmouse_events
;
2639 struct where_is_internal_data
{
2640 Lisp_Object definition
, this, last
;
2641 int last_is_meta
, noindirect
;
2642 Lisp_Object sequences
;
2645 /* This function can't GC, AFAIK. */
2646 /* Return the list of bindings found. This list is ordered "longest
2647 to shortest". It may include bindings that are actually shadowed
2648 by others, as well as duplicate bindings and remapping bindings.
2649 The list returned is potentially shared with where_is_cache, so
2650 be careful not to modify it via side-effects. */
2653 where_is_internal (Lisp_Object definition
, Lisp_Object keymaps
,
2654 int noindirect
, int nomenus
)
2656 Lisp_Object maps
= Qnil
;
2658 struct where_is_internal_data data
;
2660 /* Only important use of caching is for the menubar
2661 (i.e. where-is-internal called with (def nil t nil nil)). */
2662 if (nomenus
&& !noindirect
)
2664 /* Check heuristic-consistency of the cache. */
2665 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2666 where_is_cache
= Qnil
;
2668 if (NILP (where_is_cache
))
2670 /* We need to create the cache. */
2671 Lisp_Object args
[2];
2672 where_is_cache
= Fmake_hash_table (0, args
);
2673 where_is_cache_keymaps
= Qt
;
2676 /* We can reuse the cache. */
2677 return Fgethash (definition
, where_is_cache
, Qnil
);
2680 /* Kill the cache so that where_is_internal_1 doesn't think
2681 we're filling it up. */
2682 where_is_cache
= Qnil
;
2685 while (CONSP (found
))
2689 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2690 found
= XCDR (found
);
2693 data
.sequences
= Qnil
;
2694 for (; CONSP (maps
); maps
= XCDR (maps
))
2696 /* Key sequence to reach map, and the map that it reaches */
2697 register Lisp_Object
this, map
, tem
;
2699 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2700 [M-CHAR] sequences, check if last character of the sequence
2701 is the meta-prefix char. */
2705 this = Fcar (XCAR (maps
));
2706 map
= Fcdr (XCAR (maps
));
2707 last
= make_number (XINT (Flength (this)) - 1);
2708 last_is_meta
= (XINT (last
) >= 0
2709 && EQ (Faref (this, last
), meta_prefix_char
));
2711 /* if (nomenus && !preferred_sequence_p (this)) */
2712 if (nomenus
&& XINT (last
) >= 0
2713 && SYMBOLP (tem
= Faref (this, make_number (0)))
2714 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2715 /* If no menu entries should be returned, skip over the
2716 keymaps bound to `menu-bar' and `tool-bar' and other
2717 non-ascii prefixes like `C-down-mouse-2'. */
2722 data
.definition
= definition
;
2723 data
.noindirect
= noindirect
;
2726 data
.last_is_meta
= last_is_meta
;
2729 map_keymap (map
, where_is_internal_1
, Qnil
, &data
, 0);
2732 if (nomenus
&& !noindirect
)
2733 { /* Remember for which keymaps this cache was built.
2734 We do it here (late) because we want to keep where_is_cache_keymaps
2735 set to t while the cache isn't fully filled. */
2736 where_is_cache_keymaps
= keymaps
;
2737 /* During cache-filling, data.sequences is not filled by
2738 where_is_internal_1. */
2739 return Fgethash (definition
, where_is_cache
, Qnil
);
2742 return data
.sequences
;
2745 static Lisp_Object Vwhere_is_preferred_modifier
;
2747 /* This function can GC if Flookup_key autoloads any keymaps. */
2749 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2750 doc
: /* Return list of keys that invoke DEFINITION.
2751 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2752 If KEYMAP is nil, search all the currently active keymaps.
2753 If KEYMAP is a list of keymaps, search only those keymaps.
2755 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2756 rather than a list of all possible key sequences.
2757 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2758 no matter what it is.
2759 If FIRSTONLY has another non-nil value, prefer bindings
2760 that use the modifier key specified in `where-is-preferred-modifier'
2761 \(or their meta variants) and entirely reject menu bindings.
2763 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2764 to other keymaps or slots. This makes it possible to search for an
2765 indirect definition itself.
2767 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2768 that invoke a command which is remapped to DEFINITION, but include the
2769 remapped command in the returned list. */)
2770 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2771 Lisp_Object definition
, keymap
;
2772 Lisp_Object firstonly
, noindirect
, no_remap
;
2774 /* The keymaps in which to search. */
2775 Lisp_Object keymaps
;
2776 /* Potentially relevant bindings in "shortest to longest" order. */
2777 Lisp_Object sequences
= Qnil
;
2778 /* Actually relevant bindings. */
2779 Lisp_Object found
= Qnil
;
2780 /* 1 means ignore all menu bindings entirely. */
2781 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2782 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
2783 /* List of sequences found via remapping. Keep them in a separate
2784 variable, so as to push them later, since we prefer
2785 non-remapped binding. */
2786 Lisp_Object remapped_sequences
= Qnil
;
2787 /* Whether or not we're handling remapped sequences. This is needed
2788 because remapping is not done recursively by Fcommand_remapping: you
2789 can't remap a remapped command. */
2791 Lisp_Object tem
= Qnil
;
2793 /* Refresh the C version of the modifier preference. */
2794 where_is_preferred_modifier
2795 = parse_solitary_modifier (Vwhere_is_preferred_modifier
);
2797 /* Find the relevant keymaps. */
2798 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2800 else if (!NILP (keymap
))
2801 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2803 keymaps
= Fcurrent_active_maps (Qnil
, Qnil
);
2805 GCPRO6 (definition
, keymaps
, found
, sequences
, remapped_sequences
, tem
);
2807 tem
= Fcommand_remapping (definition
, Qnil
, keymaps
);
2808 /* If `definition' is remapped to tem', then OT1H no key will run
2809 that command (since they will run `tem' instead), so we should
2810 return nil; but OTOH all keys bound to `definition' (or to `tem')
2811 will run the same command.
2812 So for menu-shortcut purposes, we want to find all the keys bound (maybe
2813 via remapping) to `tem'. But for the purpose of finding the keys that
2814 run `definition', then we'd want to just return nil.
2815 We choose to make it work right for menu-shortcuts, since it's the most
2817 Known bugs: if you remap switch-to-buffer to toto, C-h f switch-to-buffer
2818 will tell you that switch-to-buffer is bound to C-x b even though C-x b
2819 will run toto instead. And if `toto' is itself remapped to forward-char,
2820 then C-h f toto will tell you that it's bound to C-f even though C-f does
2821 not run toto and it won't tell you that C-x b does run toto. */
2822 if (NILP (no_remap
) && !NILP (tem
))
2825 if (SYMBOLP (definition
)
2826 && !NILP (firstonly
)
2827 && !NILP (tem
= Fget (definition
, QCadvertised_binding
)))
2829 /* We have a list of advertized bindings. */
2831 if (EQ (shadow_lookup (keymaps
, XCAR (tem
), Qnil
, 0), definition
))
2835 if (EQ (shadow_lookup (keymaps
, tem
, Qnil
, 0), definition
))
2839 sequences
= Freverse (where_is_internal (definition
, keymaps
,
2840 !NILP (noindirect
), nomenus
));
2842 while (CONSP (sequences
)
2843 /* If we're at the end of the `sequences' list and we haven't
2844 considered remapped sequences yet, copy them over and
2846 || (!remapped
&& (sequences
= remapped_sequences
,
2850 Lisp_Object sequence
, function
;
2852 sequence
= XCAR (sequences
);
2853 sequences
= XCDR (sequences
);
2855 /* Verify that this key binding is not shadowed by another
2856 binding for the same key, before we say it exists.
2858 Mechanism: look for local definition of this key and if
2859 it is defined and does not match what we found then
2862 Either nil or number as value from Flookup_key
2864 if (NILP (Fequal (shadow_lookup (keymaps
, sequence
, Qnil
, remapped
),
2868 /* If the current sequence is a command remapping with
2869 format [remap COMMAND], find the key sequences
2870 which run COMMAND, and use those sequences instead. */
2871 if (NILP (no_remap
) && !remapped
2872 && VECTORP (sequence
) && ASIZE (sequence
) == 2
2873 && EQ (AREF (sequence
, 0), Qremap
)
2874 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2876 Lisp_Object seqs
= where_is_internal (function
, keymaps
,
2877 !NILP (noindirect
), nomenus
);
2878 remapped_sequences
= nconc2 (Freverse (seqs
), remapped_sequences
);
2882 /* Don't annoy user with strings from a menu such as the
2883 entries from the "Edit => Paste from Kill Menu".
2884 Change them all to "(any string)", so that there
2885 seems to be only one menu item to report. */
2886 if (! NILP (sequence
))
2889 tem
= Faref (sequence
, make_number (ASIZE (sequence
) - 1));
2891 Faset (sequence
, make_number (ASIZE (sequence
) - 1),
2892 build_string ("(any string)"));
2895 /* It is a true unshadowed match. Record it, unless it's already
2896 been seen (as could happen when inheriting keymaps). */
2897 if (NILP (Fmember (sequence
, found
)))
2898 found
= Fcons (sequence
, found
);
2900 /* If firstonly is Qnon_ascii, then we can return the first
2901 binding we find. If firstonly is not Qnon_ascii but not
2902 nil, then we should return the first ascii-only binding
2904 if (EQ (firstonly
, Qnon_ascii
))
2905 RETURN_UNGCPRO (sequence
);
2906 else if (!NILP (firstonly
)
2907 && 2 == preferred_sequence_p (sequence
))
2908 RETURN_UNGCPRO (sequence
);
2913 found
= Fnreverse (found
);
2915 /* firstonly may have been t, but we may have gone all the way through
2916 the keymaps without finding an all-ASCII key sequence. So just
2917 return the best we could find. */
2918 if (NILP (firstonly
))
2920 else if (where_is_preferred_modifier
== 0)
2921 return Fcar (found
);
2923 { /* Maybe we did not find a preferred_modifier binding, but we did find
2924 some ASCII binding. */
2925 Lisp_Object bindings
= found
;
2926 while (CONSP (bindings
))
2927 if (preferred_sequence_p (XCAR (bindings
)))
2928 return XCAR (bindings
);
2930 bindings
= XCDR (bindings
);
2931 return Fcar (found
);
2935 /* This function can GC because get_keyelt can. */
2938 where_is_internal_1 (Lisp_Object key
, Lisp_Object binding
, Lisp_Object args
, void *data
)
2940 struct where_is_internal_data
*d
= data
; /* Cast! */
2941 Lisp_Object definition
= d
->definition
;
2942 int noindirect
= d
->noindirect
;
2943 Lisp_Object
this = d
->this;
2944 Lisp_Object last
= d
->last
;
2945 int last_is_meta
= d
->last_is_meta
;
2946 Lisp_Object sequence
;
2948 /* Search through indirections unless that's not wanted. */
2950 binding
= get_keyelt (binding
, 0);
2952 /* End this iteration if this element does not match
2955 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2956 || EQ (binding
, definition
)
2957 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2958 /* Doesn't match. */
2961 /* We have found a match. Construct the key sequence where we found it. */
2962 if (INTEGERP (key
) && last_is_meta
)
2964 sequence
= Fcopy_sequence (this);
2965 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2970 key
= Fcons (XCAR (key
), XCDR (key
));
2971 sequence
= append_key (this, key
);
2974 if (!NILP (where_is_cache
))
2976 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2977 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2980 d
->sequences
= Fcons (sequence
, d
->sequences
);
2983 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2985 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2986 doc
: /* Insert the list of all defined keys and their definitions.
2987 The list is inserted in the current buffer, while the bindings are
2988 looked up in BUFFER.
2989 The optional argument PREFIX, if non-nil, should be a key sequence;
2990 then we display only bindings that start with that prefix.
2991 The optional argument MENUS, if non-nil, says to mention menu bindings.
2992 \(Ordinarily these are omitted from the output.) */)
2993 (buffer
, prefix
, menus
)
2994 Lisp_Object buffer
, prefix
, menus
;
2996 Lisp_Object outbuf
, shadow
;
2997 int nomenu
= NILP (menus
);
2998 register Lisp_Object start1
;
2999 struct gcpro gcpro1
;
3001 char *alternate_heading
3003 Keyboard translations:\n\n\
3004 You type Translation\n\
3005 -------- -----------\n";
3007 CHECK_BUFFER (buffer
);
3012 outbuf
= Fcurrent_buffer ();
3014 /* Report on alternates for keys. */
3015 if (STRINGP (current_kboard
->Vkeyboard_translate_table
) && !NILP (prefix
))
3018 const unsigned char *translate
= SDATA (current_kboard
->Vkeyboard_translate_table
);
3019 int translate_len
= SCHARS (current_kboard
->Vkeyboard_translate_table
);
3021 for (c
= 0; c
< translate_len
; c
++)
3022 if (translate
[c
] != c
)
3024 char buf
[KEY_DESCRIPTION_SIZE
];
3027 if (alternate_heading
)
3029 insert_string (alternate_heading
);
3030 alternate_heading
= 0;
3033 bufend
= push_key_description (translate
[c
], buf
, 1);
3034 insert (buf
, bufend
- buf
);
3035 Findent_to (make_number (16), make_number (1));
3036 bufend
= push_key_description (c
, buf
, 1);
3037 insert (buf
, bufend
- buf
);
3041 /* Insert calls signal_after_change which may GC. */
3042 translate
= SDATA (current_kboard
->Vkeyboard_translate_table
);
3048 if (!NILP (Vkey_translation_map
))
3049 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
3050 "Key translations", nomenu
, 1, 0, 0);
3053 /* Print the (major mode) local map. */
3055 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
3056 start1
= current_kboard
->Voverriding_terminal_local_map
;
3057 else if (!NILP (Voverriding_local_map
))
3058 start1
= Voverriding_local_map
;
3062 describe_map_tree (start1
, 1, shadow
, prefix
,
3063 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
3064 shadow
= Fcons (start1
, shadow
);
3068 /* Print the minor mode and major mode keymaps. */
3070 Lisp_Object
*modes
, *maps
;
3072 /* Temporarily switch to `buffer', so that we can get that buffer's
3073 minor modes correctly. */
3074 Fset_buffer (buffer
);
3076 nmaps
= current_minor_maps (&modes
, &maps
);
3077 Fset_buffer (outbuf
);
3079 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3080 XBUFFER (buffer
), Qkeymap
);
3083 describe_map_tree (start1
, 1, shadow
, prefix
,
3084 "\f\n`keymap' Property Bindings", nomenu
,
3086 shadow
= Fcons (start1
, shadow
);
3089 /* Print the minor mode maps. */
3090 for (i
= 0; i
< nmaps
; i
++)
3092 /* The title for a minor mode keymap
3093 is constructed at run time.
3094 We let describe_map_tree do the actual insertion
3095 because it takes care of other features when doing so. */
3098 if (!SYMBOLP (modes
[i
]))
3101 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
3105 memcpy (p
, SDATA (SYMBOL_NAME (modes
[i
])),
3106 SCHARS (SYMBOL_NAME (modes
[i
])));
3107 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
3109 memcpy (p
, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
3110 p
+= strlen (" Minor Mode Bindings");
3113 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
3114 title
, nomenu
, 0, 0, 0);
3115 shadow
= Fcons (maps
[i
], shadow
);
3118 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
3119 XBUFFER (buffer
), Qlocal_map
);
3122 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
3123 describe_map_tree (start1
, 1, shadow
, prefix
,
3124 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
3126 describe_map_tree (start1
, 1, shadow
, prefix
,
3127 "\f\n`local-map' Property Bindings",
3130 shadow
= Fcons (start1
, shadow
);
3134 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
3135 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
3137 /* Print the function-key-map translations under this prefix. */
3138 if (!NILP (current_kboard
->Vlocal_function_key_map
))
3139 describe_map_tree (current_kboard
->Vlocal_function_key_map
, 0, Qnil
, prefix
,
3140 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
3142 /* Print the input-decode-map translations under this prefix. */
3143 if (!NILP (current_kboard
->Vinput_decode_map
))
3144 describe_map_tree (current_kboard
->Vinput_decode_map
, 0, Qnil
, prefix
,
3145 "\f\nInput decoding map translations", nomenu
, 1, 0, 0);
3151 /* Insert a description of the key bindings in STARTMAP,
3152 followed by those of all maps reachable through STARTMAP.
3153 If PARTIAL is nonzero, omit certain "uninteresting" commands
3154 (such as `undefined').
3155 If SHADOW is non-nil, it is a list of maps;
3156 don't mention keys which would be shadowed by any of them.
3157 PREFIX, if non-nil, says mention only keys that start with PREFIX.
3158 TITLE, if not 0, is a string to insert at the beginning.
3159 TITLE should not end with a colon or a newline; we supply that.
3160 If NOMENU is not 0, then omit menu-bar commands.
3162 If TRANSL is nonzero, the definitions are actually key translations
3163 so print strings and vectors differently.
3165 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
3168 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
3169 don't omit it; instead, mention it but say it is shadowed. */
3172 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
3173 always_title
, mention_shadow
)
3174 Lisp_Object startmap
, shadow
, prefix
;
3182 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
3183 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3190 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3193 GCPRO3 (maps
, seen
, sub_shadows
);
3199 /* Delete from MAPS each element that is for the menu bar. */
3200 for (list
= maps
; CONSP (list
); list
= XCDR (list
))
3202 Lisp_Object elt
, prefix
, tem
;
3205 prefix
= Fcar (elt
);
3206 if (XVECTOR (prefix
)->size
>= 1)
3208 tem
= Faref (prefix
, make_number (0));
3209 if (EQ (tem
, Qmenu_bar
))
3210 maps
= Fdelq (elt
, maps
);
3215 if (!NILP (maps
) || always_title
)
3219 insert_string (title
);
3222 insert_string (" Starting With ");
3223 insert1 (Fkey_description (prefix
, Qnil
));
3225 insert_string (":\n");
3227 insert_string (key_heading
);
3231 for (; CONSP (maps
); maps
= XCDR (maps
))
3233 register Lisp_Object elt
, prefix
, tail
;
3236 prefix
= Fcar (elt
);
3240 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3244 shmap
= XCAR (tail
);
3246 /* If the sequence by which we reach this keymap is zero-length,
3247 then the shadow map for this keymap is just SHADOW. */
3248 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3249 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3251 /* If the sequence by which we reach this keymap actually has
3252 some elements, then the sequence's definition in SHADOW is
3253 what we should use. */
3256 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3257 if (INTEGERP (shmap
))
3261 /* If shmap is not nil and not a keymap,
3262 it completely shadows this map, so don't
3263 describe this map at all. */
3264 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3268 sub_shadows
= Fcons (shmap
, sub_shadows
);
3271 /* Maps we have already listed in this loop shadow this map. */
3272 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3275 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3277 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3280 describe_map (Fcdr (elt
), prefix
,
3281 transl
? describe_translation
: describe_command
,
3282 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3288 insert_string ("\n");
3293 static int previous_description_column
;
3296 describe_command (Lisp_Object definition
, Lisp_Object args
)
3298 register Lisp_Object tem1
;
3299 int column
= (int) current_column (); /* iftc */
3300 int description_column
;
3302 /* If column 16 is no good, go to col 32;
3303 but don't push beyond that--go to next line instead. */
3307 description_column
= 32;
3309 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3310 description_column
= 32;
3312 description_column
= 16;
3314 Findent_to (make_number (description_column
), make_number (1));
3315 previous_description_column
= description_column
;
3317 if (SYMBOLP (definition
))
3319 tem1
= SYMBOL_NAME (definition
);
3321 insert_string ("\n");
3323 else if (STRINGP (definition
) || VECTORP (definition
))
3324 insert_string ("Keyboard Macro\n");
3325 else if (KEYMAPP (definition
))
3326 insert_string ("Prefix Command\n");
3328 insert_string ("??\n");
3332 describe_translation (Lisp_Object definition
, Lisp_Object args
)
3334 register Lisp_Object tem1
;
3336 Findent_to (make_number (16), make_number (1));
3338 if (SYMBOLP (definition
))
3340 tem1
= SYMBOL_NAME (definition
);
3342 insert_string ("\n");
3344 else if (STRINGP (definition
) || VECTORP (definition
))
3346 insert1 (Fkey_description (definition
, Qnil
));
3347 insert_string ("\n");
3349 else if (KEYMAPP (definition
))
3350 insert_string ("Prefix Command\n");
3352 insert_string ("??\n");
3355 /* describe_map puts all the usable elements of a sparse keymap
3356 into an array of `struct describe_map_elt',
3357 then sorts them by the events. */
3359 struct describe_map_elt
{ Lisp_Object event
; Lisp_Object definition
; int shadowed
; };
3361 /* qsort comparison function for sorting `struct describe_map_elt' by
3365 describe_map_compare (const void *aa
, const void *bb
)
3367 const struct describe_map_elt
*a
= aa
, *b
= bb
;
3368 if (INTEGERP (a
->event
) && INTEGERP (b
->event
))
3369 return ((XINT (a
->event
) > XINT (b
->event
))
3370 - (XINT (a
->event
) < XINT (b
->event
)));
3371 if (!INTEGERP (a
->event
) && INTEGERP (b
->event
))
3373 if (INTEGERP (a
->event
) && !INTEGERP (b
->event
))
3375 if (SYMBOLP (a
->event
) && SYMBOLP (b
->event
))
3376 return (!NILP (Fstring_lessp (a
->event
, b
->event
)) ? -1
3377 : !NILP (Fstring_lessp (b
->event
, a
->event
)) ? 1
3382 /* Describe the contents of map MAP, assuming that this map itself is
3383 reached by the sequence of prefix keys PREFIX (a string or vector).
3384 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3387 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3388 seen
, nomenu
, mention_shadow
)
3389 register Lisp_Object map
;
3391 void (*elt_describer
) (Lisp_Object
, Lisp_Object
);
3398 Lisp_Object tail
, definition
, event
;
3400 Lisp_Object suppress
;
3403 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3405 /* These accumulate the values from sparse keymap bindings,
3406 so we can sort them and handle them in order. */
3407 int length_needed
= 0;
3408 struct describe_map_elt
*vect
;
3415 suppress
= intern ("suppress-keymap");
3417 /* This vector gets used to present single keys to Flookup_key. Since
3418 that is done once per keymap element, we don't want to cons up a
3419 fresh vector every time. */
3420 kludge
= Fmake_vector (make_number (1), Qnil
);
3423 GCPRO3 (prefix
, definition
, kludge
);
3425 map
= call1 (Qkeymap_canonicalize
, map
);
3427 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3430 vect
= ((struct describe_map_elt
*)
3431 alloca (sizeof (struct describe_map_elt
) * length_needed
));
3433 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3437 if (VECTORP (XCAR (tail
))
3438 || CHAR_TABLE_P (XCAR (tail
)))
3439 describe_vector (XCAR (tail
),
3440 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3441 (int *)0, 0, 1, mention_shadow
);
3442 else if (CONSP (XCAR (tail
)))
3444 int this_shadowed
= 0;
3446 event
= XCAR (XCAR (tail
));
3448 /* Ignore bindings whose "prefix" are not really valid events.
3449 (We get these in the frames and buffers menu.) */
3450 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3453 if (nomenu
&& EQ (event
, Qmenu_bar
))
3456 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3458 /* Don't show undefined commands or suppressed commands. */
3459 if (NILP (definition
)) continue;
3460 if (SYMBOLP (definition
) && partial
)
3462 tem
= Fget (definition
, suppress
);
3467 /* Don't show a command that isn't really visible
3468 because a local definition of the same key shadows it. */
3470 ASET (kludge
, 0, event
);
3473 tem
= shadow_lookup (shadow
, kludge
, Qt
, 0);
3476 /* If both bindings are keymaps, this key is a prefix key,
3477 so don't say it is shadowed. */
3478 if (KEYMAPP (definition
) && KEYMAPP (tem
))
3480 /* Avoid generating duplicate entries if the
3481 shadowed binding has the same definition. */
3482 else if (mention_shadow
&& !EQ (tem
, definition
))
3489 tem
= Flookup_key (map
, kludge
, Qt
);
3490 if (!EQ (tem
, definition
)) continue;
3492 vect
[slots_used
].event
= event
;
3493 vect
[slots_used
].definition
= definition
;
3494 vect
[slots_used
].shadowed
= this_shadowed
;
3497 else if (EQ (XCAR (tail
), Qkeymap
))
3499 /* The same keymap might be in the structure twice, if we're
3500 using an inherited keymap. So skip anything we've already
3502 tem
= Fassq (tail
, *seen
);
3503 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3505 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3509 /* If we found some sparse map events, sort them. */
3511 qsort (vect
, slots_used
, sizeof (struct describe_map_elt
),
3512 describe_map_compare
);
3514 /* Now output them in sorted order. */
3516 for (i
= 0; i
< slots_used
; i
++)
3518 Lisp_Object start
, end
;
3522 previous_description_column
= 0;
3527 ASET (kludge
, 0, vect
[i
].event
);
3528 start
= vect
[i
].event
;
3531 definition
= vect
[i
].definition
;
3533 /* Find consecutive chars that are identically defined. */
3534 if (INTEGERP (vect
[i
].event
))
3536 while (i
+ 1 < slots_used
3537 && EQ (vect
[i
+1].event
, make_number (XINT (vect
[i
].event
) + 1))
3538 && !NILP (Fequal (vect
[i
+ 1].definition
, definition
))
3539 && vect
[i
].shadowed
== vect
[i
+ 1].shadowed
)
3541 end
= vect
[i
].event
;
3544 /* Now START .. END is the range to describe next. */
3546 /* Insert the string to describe the event START. */
3547 insert1 (Fkey_description (kludge
, prefix
));
3549 if (!EQ (start
, end
))
3553 ASET (kludge
, 0, end
);
3554 /* Insert the string to describe the character END. */
3555 insert1 (Fkey_description (kludge
, prefix
));
3558 /* Print a description of the definition of this character.
3559 elt_describer will take care of spacing out far enough
3560 for alignment purposes. */
3561 (*elt_describer
) (vect
[i
].definition
, Qnil
);
3563 if (vect
[i
].shadowed
)
3566 insert_string ("\n (that binding is currently shadowed by another mode)");
3575 describe_vector_princ (Lisp_Object elt
, Lisp_Object fun
)
3577 Findent_to (make_number (16), make_number (1));
3582 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3583 doc
: /* Insert a description of contents of VECTOR.
3584 This is text showing the elements of vector matched against indices.
3585 DESCRIBER is the output function used; nil means use `princ'. */)
3587 Lisp_Object vector
, describer
;
3589 int count
= SPECPDL_INDEX ();
3590 if (NILP (describer
))
3591 describer
= intern ("princ");
3592 specbind (Qstandard_output
, Fcurrent_buffer ());
3593 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3594 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3595 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3597 return unbind_to (count
, Qnil
);
3600 /* Insert in the current buffer a description of the contents of VECTOR.
3601 We call ELT_DESCRIBER to insert the description of one value found
3604 ELT_PREFIX describes what "comes before" the keys or indices defined
3605 by this vector. This is a human-readable string whose size
3606 is not necessarily related to the situation.
3608 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3609 leads to this keymap.
3611 If the vector is a chartable, ELT_PREFIX is the vector
3612 of bytes that lead to the character set or portion of a character
3613 set described by this chartable.
3615 If PARTIAL is nonzero, it means do not mention suppressed commands
3616 (that assumes the vector is in a keymap).
3618 SHADOW is a list of keymaps that shadow this map.
3619 If it is non-nil, then we look up the key in those maps
3620 and we don't mention it now if it is defined by any of them.
3622 ENTIRE_MAP is the keymap in which this vector appears.
3623 If the definition in effect in the whole map does not match
3624 the one in this vector, we ignore this one.
3626 ARGS is simply passed as the second argument to ELT_DESCRIBER.
3628 INDICES and CHAR_TABLE_DEPTH are ignored. They will be removed in
3631 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3633 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3636 describe_vector (vector
, prefix
, args
, elt_describer
,
3637 partial
, shadow
, entire_map
,
3638 indices
, char_table_depth
, keymap_p
,
3640 register Lisp_Object vector
;
3641 Lisp_Object prefix
, args
;
3642 void (*elt_describer
) (Lisp_Object
, Lisp_Object
);
3645 Lisp_Object entire_map
;
3647 int char_table_depth
;
3651 Lisp_Object definition
;
3653 Lisp_Object elt_prefix
= Qnil
;
3655 Lisp_Object suppress
;
3658 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3659 /* Range of elements to be handled. */
3661 Lisp_Object character
;
3670 /* Call Fkey_description first, to avoid GC bug for the other string. */
3671 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3674 tem
= Fkey_description (prefix
, Qnil
);
3675 elt_prefix
= concat2 (tem
, build_string (" "));
3680 /* This vector gets used to present single keys to Flookup_key. Since
3681 that is done once per vector element, we don't want to cons up a
3682 fresh vector every time. */
3683 kludge
= Fmake_vector (make_number (1), Qnil
);
3684 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3687 suppress
= intern ("suppress-keymap");
3690 if (CHAR_TABLE_P (vector
))
3691 stop
= MAX_5_BYTE_CHAR
+ 1, to
= MAX_CHAR
+ 1;
3693 stop
= to
= XVECTOR (vector
)->size
;
3695 for (i
= from
; ; i
++)
3697 int this_shadowed
= 0;
3698 int range_beg
, range_end
;
3712 if (CHAR_TABLE_P (vector
))
3716 val
= char_table_ref_and_range (vector
, range_beg
, &range_beg
, &i
);
3719 val
= AREF (vector
, i
);
3720 definition
= get_keyelt (val
, 0);
3722 if (NILP (definition
)) continue;
3724 /* Don't mention suppressed commands. */
3725 if (SYMBOLP (definition
) && partial
)
3729 tem
= Fget (definition
, suppress
);
3731 if (!NILP (tem
)) continue;
3734 character
= make_number (starting_i
);
3735 ASET (kludge
, 0, character
);
3737 /* If this binding is shadowed by some other map, ignore it. */
3742 tem
= shadow_lookup (shadow
, kludge
, Qt
, 0);
3753 /* Ignore this definition if it is shadowed by an earlier
3754 one in the same keymap. */
3755 if (!NILP (entire_map
))
3759 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3761 if (!EQ (tem
, definition
))
3771 /* Output the prefix that applies to every entry in this map. */
3772 if (!NILP (elt_prefix
))
3773 insert1 (elt_prefix
);
3775 insert1 (Fkey_description (kludge
, prefix
));
3777 /* Find all consecutive characters or rows that have the same
3778 definition. But, VECTOR is a char-table, we had better put a
3779 boundary between normal characters (-#x3FFF7F) and 8-bit
3780 characters (#x3FFF80-). */
3781 if (CHAR_TABLE_P (vector
))
3784 && (range_beg
= i
+ 1, range_end
= stop
- 1,
3785 val
= char_table_ref_and_range (vector
, range_beg
,
3786 &range_beg
, &range_end
),
3787 tem2
= get_keyelt (val
, 0),
3789 && !NILP (Fequal (tem2
, definition
)))
3794 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3796 && !NILP (Fequal (tem2
, definition
)))
3799 /* If we have a range of more than one character,
3800 print where the range reaches to. */
3802 if (i
!= starting_i
)
3806 ASET (kludge
, 0, make_number (i
));
3808 if (!NILP (elt_prefix
))
3809 insert1 (elt_prefix
);
3811 insert1 (Fkey_description (kludge
, prefix
));
3814 /* Print a description of the definition of this character.
3815 elt_describer will take care of spacing out far enough
3816 for alignment purposes. */
3817 (*elt_describer
) (definition
, args
);
3822 insert_string (" (binding currently shadowed)");
3827 if (CHAR_TABLE_P (vector
) && ! NILP (XCHAR_TABLE (vector
)->defalt
))
3829 if (!NILP (elt_prefix
))
3830 insert1 (elt_prefix
);
3831 insert ("default", 7);
3832 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3838 /* Apropos - finding all symbols whose names match a regexp. */
3839 static Lisp_Object apropos_predicate
;
3840 static Lisp_Object apropos_accumulate
;
3843 apropos_accum (Lisp_Object symbol
, Lisp_Object string
)
3845 register Lisp_Object tem
;
3847 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3848 if (!NILP (tem
) && !NILP (apropos_predicate
))
3849 tem
= call1 (apropos_predicate
, symbol
);
3851 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3854 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3855 doc
: /* Show all symbols whose names contain match for REGEXP.
3856 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3857 for each symbol and a symbol is mentioned only if that returns non-nil.
3858 Return list of symbols found. */)
3860 Lisp_Object regexp
, predicate
;
3863 CHECK_STRING (regexp
);
3864 apropos_predicate
= predicate
;
3865 apropos_accumulate
= Qnil
;
3866 map_obarray (Vobarray
, apropos_accum
, regexp
);
3867 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3868 apropos_accumulate
= Qnil
;
3869 apropos_predicate
= Qnil
;
3874 syms_of_keymap (void)
3876 Qkeymap
= intern_c_string ("keymap");
3877 staticpro (&Qkeymap
);
3878 staticpro (&apropos_predicate
);
3879 staticpro (&apropos_accumulate
);
3880 apropos_predicate
= Qnil
;
3881 apropos_accumulate
= Qnil
;
3883 Qkeymap_canonicalize
= intern_c_string ("keymap-canonicalize");
3884 staticpro (&Qkeymap_canonicalize
);
3886 /* Now we are ready to set up this property, so we can
3887 create char tables. */
3888 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3890 /* Initialize the keymaps standardly used.
3891 Each one is the value of a Lisp variable, and is also
3892 pointed to by a C variable */
3894 global_map
= Fmake_keymap (Qnil
);
3895 Fset (intern_c_string ("global-map"), global_map
);
3897 current_global_map
= global_map
;
3898 staticpro (&global_map
);
3899 staticpro (¤t_global_map
);
3901 meta_map
= Fmake_keymap (Qnil
);
3902 Fset (intern_c_string ("esc-map"), meta_map
);
3903 Ffset (intern_c_string ("ESC-prefix"), meta_map
);
3905 control_x_map
= Fmake_keymap (Qnil
);
3906 Fset (intern_c_string ("ctl-x-map"), control_x_map
);
3907 Ffset (intern_c_string ("Control-X-prefix"), control_x_map
);
3910 = pure_cons (pure_cons (make_pure_c_string ("DEL"), make_pure_c_string ("\\d")),
3911 pure_cons (pure_cons (make_pure_c_string ("TAB"), make_pure_c_string ("\\t")),
3912 pure_cons (pure_cons (make_pure_c_string ("RET"), make_pure_c_string ("\\r")),
3913 pure_cons (pure_cons (make_pure_c_string ("ESC"), make_pure_c_string ("\\e")),
3914 pure_cons (pure_cons (make_pure_c_string ("SPC"), make_pure_c_string (" ")),
3916 staticpro (&exclude_keys
);
3918 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3919 doc
: /* List of commands given new key bindings recently.
3920 This is used for internal purposes during Emacs startup;
3921 don't alter it yourself. */);
3922 Vdefine_key_rebound_commands
= Qt
;
3924 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3925 doc
: /* Default keymap to use when reading from the minibuffer. */);
3926 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3928 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3929 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3930 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3931 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3933 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3934 doc
: /* Local keymap for minibuffer input with completion. */);
3935 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3936 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3938 DEFVAR_LISP ("minibuffer-local-filename-completion-map",
3939 &Vminibuffer_local_filename_completion_map
,
3940 doc
: /* Local keymap for minibuffer input with completion for filenames. */);
3941 Vminibuffer_local_filename_completion_map
= Fmake_sparse_keymap (Qnil
);
3942 Fset_keymap_parent (Vminibuffer_local_filename_completion_map
,
3943 Vminibuffer_local_completion_map
);
3946 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3947 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3948 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3949 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3950 Vminibuffer_local_completion_map
);
3952 DEFVAR_LISP ("minibuffer-local-filename-must-match-map",
3953 &Vminibuffer_local_filename_must_match_map
,
3954 doc
: /* Local keymap for minibuffer input with completion for filenames with exact match. */);
3955 Vminibuffer_local_filename_must_match_map
= Fmake_sparse_keymap (Qnil
);
3956 Fset_keymap_parent (Vminibuffer_local_filename_must_match_map
,
3957 Vminibuffer_local_must_match_map
);
3959 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3960 doc
: /* Alist of keymaps to use for minor modes.
3961 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3962 key sequences and look up bindings if VARIABLE's value is non-nil.
3963 If two active keymaps bind the same key, the keymap appearing earlier
3964 in the list takes precedence. */);
3965 Vminor_mode_map_alist
= Qnil
;
3967 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3968 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3969 This variable is an alist just like `minor-mode-map-alist', and it is
3970 used the same way (and before `minor-mode-map-alist'); however,
3971 it is provided for major modes to bind locally. */);
3972 Vminor_mode_overriding_map_alist
= Qnil
;
3974 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3975 doc
: /* List of keymap alists to use for emulations modes.
3976 It is intended for modes or packages using multiple minor-mode keymaps.
3977 Each element is a keymap alist just like `minor-mode-map-alist', or a
3978 symbol with a variable binding which is a keymap alist, and it is used
3979 the same way. The "active" keymaps in each alist are used before
3980 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3981 Vemulation_mode_map_alists
= Qnil
;
3983 DEFVAR_LISP ("where-is-preferred-modifier", &Vwhere_is_preferred_modifier
,
3984 doc
: /* Preferred modifier to use for `where-is'.
3985 When a single binding is requested, `where-is' will return one that
3986 uses this modifier if possible. If nil, or if no such binding exists,
3987 bindings using keys without modifiers (or only with meta) will be
3989 Vwhere_is_preferred_modifier
= Qnil
;
3990 where_is_preferred_modifier
= 0;
3992 staticpro (&Vmouse_events
);
3993 Vmouse_events
= pure_cons (intern_c_string ("menu-bar"),
3994 pure_cons (intern_c_string ("tool-bar"),
3995 pure_cons (intern_c_string ("header-line"),
3996 pure_cons (intern_c_string ("mode-line"),
3997 pure_cons (intern_c_string ("mouse-1"),
3998 pure_cons (intern_c_string ("mouse-2"),
3999 pure_cons (intern_c_string ("mouse-3"),
4000 pure_cons (intern_c_string ("mouse-4"),
4001 pure_cons (intern_c_string ("mouse-5"),
4005 Qsingle_key_description
= intern_c_string ("single-key-description");
4006 staticpro (&Qsingle_key_description
);
4008 Qkey_description
= intern_c_string ("key-description");
4009 staticpro (&Qkey_description
);
4011 Qkeymapp
= intern_c_string ("keymapp");
4012 staticpro (&Qkeymapp
);
4014 Qnon_ascii
= intern_c_string ("non-ascii");
4015 staticpro (&Qnon_ascii
);
4017 Qmenu_item
= intern_c_string ("menu-item");
4018 staticpro (&Qmenu_item
);
4020 Qremap
= intern_c_string ("remap");
4021 staticpro (&Qremap
);
4023 QCadvertised_binding
= intern_c_string (":advertised-binding");
4024 staticpro (&QCadvertised_binding
);
4026 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
4027 staticpro (&command_remapping_vector
);
4029 where_is_cache_keymaps
= Qt
;
4030 where_is_cache
= Qnil
;
4031 staticpro (&where_is_cache
);
4032 staticpro (&where_is_cache_keymaps
);
4034 defsubr (&Skeymapp
);
4035 defsubr (&Skeymap_parent
);
4036 defsubr (&Skeymap_prompt
);
4037 defsubr (&Sset_keymap_parent
);
4038 defsubr (&Smake_keymap
);
4039 defsubr (&Smake_sparse_keymap
);
4040 defsubr (&Smap_keymap_internal
);
4041 defsubr (&Smap_keymap
);
4042 defsubr (&Scopy_keymap
);
4043 defsubr (&Scommand_remapping
);
4044 defsubr (&Skey_binding
);
4045 defsubr (&Slocal_key_binding
);
4046 defsubr (&Sglobal_key_binding
);
4047 defsubr (&Sminor_mode_key_binding
);
4048 defsubr (&Sdefine_key
);
4049 defsubr (&Slookup_key
);
4050 defsubr (&Sdefine_prefix_command
);
4051 defsubr (&Suse_global_map
);
4052 defsubr (&Suse_local_map
);
4053 defsubr (&Scurrent_local_map
);
4054 defsubr (&Scurrent_global_map
);
4055 defsubr (&Scurrent_minor_mode_maps
);
4056 defsubr (&Scurrent_active_maps
);
4057 defsubr (&Saccessible_keymaps
);
4058 defsubr (&Skey_description
);
4059 defsubr (&Sdescribe_vector
);
4060 defsubr (&Ssingle_key_description
);
4061 defsubr (&Stext_char_description
);
4062 defsubr (&Swhere_is_internal
);
4063 defsubr (&Sdescribe_buffer_bindings
);
4064 defsubr (&Sapropos_internal
);
4068 keys_of_keymap (void)
4070 initial_define_key (global_map
, 033, "ESC-prefix");
4071 initial_define_key (global_map
, Ctl ('X'), "Control-X-prefix");
4074 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
4075 (do not change this comment) */