1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
31 #include "termhooks.h"
32 #include "blockinput.h"
34 #include "intervals.h"
37 /* The number of elements in keymap vectors. */
38 #define DENSE_TABLE_SIZE (0200)
40 /* Actually allocate storage for these variables */
42 Lisp_Object current_global_map
; /* Current global keymap */
44 Lisp_Object global_map
; /* default global key bindings */
46 Lisp_Object meta_map
; /* The keymap used for globally bound
47 ESC-prefixed default commands */
49 Lisp_Object control_x_map
; /* The keymap used for globally bound
50 C-x-prefixed default commands */
52 /* was MinibufLocalMap */
53 Lisp_Object Vminibuffer_local_map
;
54 /* The keymap used by the minibuf for local
55 bindings when spaces are allowed in the
58 /* was MinibufLocalNSMap */
59 Lisp_Object Vminibuffer_local_ns_map
;
60 /* The keymap used by the minibuf for local
61 bindings when spaces are not encouraged
64 /* keymap used for minibuffers when doing completion */
65 /* was MinibufLocalCompletionMap */
66 Lisp_Object Vminibuffer_local_completion_map
;
68 /* keymap used for minibuffers when doing completion and require a match */
69 /* was MinibufLocalMustMatchMap */
70 Lisp_Object Vminibuffer_local_must_match_map
;
72 /* Alist of minor mode variables and keymaps. */
73 Lisp_Object Vminor_mode_map_alist
;
75 /* Alist of major-mode-specific overrides for
76 minor mode variables and keymaps. */
77 Lisp_Object Vminor_mode_overriding_map_alist
;
79 /* List of emulation mode keymap alists. */
80 Lisp_Object Vemulation_mode_map_alists
;
82 /* Keymap mapping ASCII function key sequences onto their preferred forms.
83 Initialized by the terminal-specific lisp files. See DEFVAR for more
85 Lisp_Object Vfunction_key_map
;
87 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
88 Lisp_Object Vkey_translation_map
;
90 /* A list of all commands given new bindings since a certain time
91 when nil was stored here.
92 This is used to speed up recomputation of menu key equivalents
93 when Emacs starts up. t means don't record anything here. */
94 Lisp_Object Vdefine_key_rebound_commands
;
96 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
, Qremap
;
98 /* Alist of elements like (DEL . "\d"). */
99 static Lisp_Object exclude_keys
;
101 /* Pre-allocated 2-element vector for Fcommand_remapping to use. */
102 static Lisp_Object command_remapping_vector
;
104 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
105 in a string key sequence is equivalent to prefixing with this
107 extern Lisp_Object meta_prefix_char
;
109 extern Lisp_Object Voverriding_local_map
;
111 /* Hash table used to cache a reverse-map to speed up calls to where-is. */
112 static Lisp_Object where_is_cache
;
113 /* Which keymaps are reverse-stored in the cache. */
114 static Lisp_Object where_is_cache_keymaps
;
116 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
117 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
119 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
120 static void describe_command
P_ ((Lisp_Object
, Lisp_Object
));
121 static void describe_translation
P_ ((Lisp_Object
, Lisp_Object
));
122 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
123 void (*) P_ ((Lisp_Object
, Lisp_Object
)),
124 int, Lisp_Object
, Lisp_Object
*, int, int));
125 static void describe_vector
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
126 void (*) (Lisp_Object
, Lisp_Object
), int,
127 Lisp_Object
, Lisp_Object
, int *,
129 static void silly_event_symbol_error
P_ ((Lisp_Object
));
131 /* Keymap object support - constructors and predicates. */
133 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
134 doc
: /* Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).
135 CHARTABLE is a char-table that holds the bindings for all characters
136 without modifiers. All entries in it are initially nil, meaning
137 "command undefined". ALIST is an assoc-list which holds bindings for
138 function keys, mouse events, and any other things that appear in the
139 input stream. Initially, ALIST is nil.
141 The optional arg STRING supplies a menu name for the keymap
142 in case you use it as a menu with `x-popup-menu'. */)
148 tail
= Fcons (string
, Qnil
);
151 return Fcons (Qkeymap
,
152 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
155 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
156 doc
: /* Construct and return a new sparse keymap.
157 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),
158 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),
159 which binds the function key or mouse event SYMBOL to DEFINITION.
160 Initially the alist is nil.
162 The optional arg STRING supplies a menu name for the keymap
163 in case you use it as a menu with `x-popup-menu'. */)
168 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
169 return Fcons (Qkeymap
, Qnil
);
172 /* This function is used for installing the standard key bindings
173 at initialization time.
177 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
180 initial_define_key (keymap
, key
, defname
)
185 store_in_keymap (keymap
, make_number (key
), intern (defname
));
189 initial_define_lispy_key (keymap
, keyname
, defname
)
194 store_in_keymap (keymap
, intern (keyname
), intern (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 (object
, error
, autoload
)
261 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
264 tem
= indirect_function (object
);
267 if (EQ (XCAR (tem
), Qkeymap
))
270 /* Should we do an autoload? Autoload forms for keymaps have
271 Qkeymap as their fifth element. */
272 if ((autoload
|| !error
) && EQ (XCAR (tem
), Qautoload
)
277 tail
= Fnth (make_number (4), tem
);
278 if (EQ (tail
, Qkeymap
))
282 struct gcpro gcpro1
, gcpro2
;
284 GCPRO2 (tem
, object
);
285 do_autoload (tem
, object
);
298 wrong_type_argument (Qkeymapp
, object
);
302 /* Return the parent map of KEYMAP, or nil if it has none.
303 We assume that KEYMAP is a valid keymap. */
306 keymap_parent (keymap
, autoload
)
312 keymap
= get_keymap (keymap
, 1, autoload
);
314 /* Skip past the initial element `keymap'. */
315 list
= XCDR (keymap
);
316 for (; CONSP (list
); list
= XCDR (list
))
318 /* See if there is another `keymap'. */
323 return get_keymap (list
, 0, autoload
);
326 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
327 doc
: /* Return the parent keymap of KEYMAP. */)
331 return keymap_parent (keymap
, 1);
334 /* Check whether MAP is one of MAPS parents. */
336 keymap_memberp (map
, maps
)
337 Lisp_Object map
, maps
;
339 if (NILP (map
)) return 0;
340 while (KEYMAPP (maps
) && !EQ (map
, maps
))
341 maps
= keymap_parent (maps
, 0);
342 return (EQ (map
, maps
));
345 /* Set the parent keymap of MAP to PARENT. */
347 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
348 doc
: /* Modify KEYMAP to set its parent map to PARENT.
349 Return PARENT. PARENT should be nil or another keymap. */)
351 Lisp_Object keymap
, parent
;
353 Lisp_Object list
, prev
;
354 struct gcpro gcpro1
, gcpro2
;
357 /* Force a keymap flush for the next call to where-is.
358 Since this can be called from within where-is, we don't set where_is_cache
359 directly but only where_is_cache_keymaps, since where_is_cache shouldn't
360 be changed during where-is, while where_is_cache_keymaps is only used at
361 the very beginning of where-is and can thus be changed here without any
363 This is a very minor correctness (rather than safety) issue. */
364 where_is_cache_keymaps
= Qt
;
366 GCPRO2 (keymap
, parent
);
367 keymap
= get_keymap (keymap
, 1, 1);
371 parent
= get_keymap (parent
, 1, 1);
373 /* Check for cycles. */
374 if (keymap_memberp (keymap
, parent
))
375 error ("Cyclic keymap inheritance");
378 /* Skip past the initial element `keymap'. */
383 /* If there is a parent keymap here, replace it.
384 If we came to the end, add the parent in PREV. */
385 if (!CONSP (list
) || KEYMAPP (list
))
387 /* If we already have the right parent, return now
388 so that we avoid the loops below. */
389 if (EQ (XCDR (prev
), parent
))
390 RETURN_UNGCPRO (parent
);
392 XSETCDR (prev
, parent
);
398 /* Scan through for submaps, and set their parents too. */
400 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
402 /* Stop the scan when we come to the parent. */
403 if (EQ (XCAR (list
), Qkeymap
))
406 /* If this element holds a prefix map, deal with it. */
407 if (CONSP (XCAR (list
))
408 && CONSP (XCDR (XCAR (list
))))
409 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
412 if (VECTORP (XCAR (list
)))
413 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
414 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
415 fix_submap_inheritance (keymap
, make_number (i
),
416 XVECTOR (XCAR (list
))->contents
[i
]);
418 if (CHAR_TABLE_P (XCAR (list
)))
420 Lisp_Object indices
[3];
422 map_char_table (fix_submap_inheritance
, Qnil
,
423 XCAR (list
), XCAR (list
),
428 RETURN_UNGCPRO (parent
);
431 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
432 if EVENT is also a prefix in MAP's parent,
433 make sure that SUBMAP inherits that definition as its own parent. */
436 fix_submap_inheritance (map
, event
, submap
)
437 Lisp_Object map
, event
, submap
;
439 Lisp_Object map_parent
, parent_entry
;
441 /* SUBMAP is a cons that we found as a key binding.
442 Discard the other things found in a menu key binding. */
444 submap
= get_keymap (get_keyelt (submap
, 0), 0, 0);
446 /* If it isn't a keymap now, there's no work to do. */
450 map_parent
= keymap_parent (map
, 0);
451 if (!NILP (map_parent
))
453 get_keymap (access_keymap (map_parent
, event
, 0, 0, 0), 0, 0);
457 /* If MAP's parent has something other than a keymap,
458 our own submap shadows it completely. */
459 if (!CONSP (parent_entry
))
462 if (! EQ (parent_entry
, submap
))
464 Lisp_Object submap_parent
;
465 submap_parent
= submap
;
470 tem
= keymap_parent (submap_parent
, 0);
474 if (keymap_memberp (tem
, parent_entry
))
475 /* Fset_keymap_parent could create a cycle. */
482 Fset_keymap_parent (submap_parent
, parent_entry
);
486 /* Look up IDX in MAP. IDX may be any sort of event.
487 Note that this does only one level of lookup; IDX must be a single
488 event, not a sequence.
490 If T_OK is non-zero, bindings for Qt are treated as default
491 bindings; any key left unmentioned by other tables and bindings is
492 given the binding of Qt.
494 If T_OK is zero, bindings for Qt are not treated specially.
496 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
499 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
508 /* Qunbound in VAL means we have found no binding yet. */
511 /* If idx is a list (some sort of mouse click, perhaps?),
512 the index we want to use is the car of the list, which
513 ought to be a symbol. */
514 idx
= EVENT_HEAD (idx
);
516 /* If idx is a symbol, it might have modifiers, which need to
517 be put in the canonical order. */
519 idx
= reorder_modifiers (idx
);
520 else if (INTEGERP (idx
))
521 /* Clobber the high bits that can be present on a machine
522 with more than 24 bits of integer. */
523 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
525 /* Handle the special meta -> esc mapping. */
526 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
528 /* See if there is a meta-map. If there's none, there is
529 no binding for IDX, unless a default binding exists in MAP. */
531 Lisp_Object meta_map
;
533 /* A strange value in which Meta is set would cause
534 infinite recursion. Protect against that. */
535 if (XINT (meta_prefix_char
) & CHAR_META
)
536 meta_prefix_char
= make_number (27);
537 meta_map
= get_keymap (access_keymap (map
, meta_prefix_char
,
538 t_ok
, noinherit
, autoload
),
541 if (CONSP (meta_map
))
544 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
547 /* Set IDX to t, so that we only find a default binding. */
550 /* We know there is no binding. */
554 /* t_binding is where we put a default binding that applies,
555 to use in case we do not find a binding specifically
556 for this key sequence. */
559 Lisp_Object t_binding
= Qnil
;
560 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
562 GCPRO4 (map
, tail
, idx
, t_binding
);
564 /* If `t_ok' is 2, both `t' and generic-char bindings are accepted.
565 If it is 1, only generic-char bindings are accepted.
566 Otherwise, neither are. */
569 for (tail
= XCDR (map
);
571 || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
)));
576 binding
= XCAR (tail
);
577 if (SYMBOLP (binding
))
579 /* If NOINHERIT, stop finding prefix definitions
580 after we pass a second occurrence of the `keymap' symbol. */
581 if (noinherit
&& EQ (binding
, Qkeymap
))
582 RETURN_UNGCPRO (Qnil
);
584 else if (CONSP (binding
))
586 Lisp_Object key
= XCAR (binding
);
589 val
= XCDR (binding
);
592 && (XINT (idx
) & CHAR_MODIFIER_MASK
) == 0
594 && (XINT (key
) & CHAR_MODIFIER_MASK
) == 0
595 && !SINGLE_BYTE_CHAR_P (XINT (idx
))
596 && !SINGLE_BYTE_CHAR_P (XINT (key
))
597 && CHAR_VALID_P (XINT (key
), 1)
598 && !CHAR_VALID_P (XINT (key
), 0)
599 && (CHAR_CHARSET (XINT (key
))
600 == CHAR_CHARSET (XINT (idx
))))
602 /* KEY is the generic character of the charset of IDX.
603 Use KEY's binding if there isn't a binding for IDX
605 t_binding
= XCDR (binding
);
608 else if (t_ok
> 1 && EQ (key
, Qt
))
610 t_binding
= XCDR (binding
);
614 else if (VECTORP (binding
))
616 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (binding
))
617 val
= AREF (binding
, XFASTINT (idx
));
619 else if (CHAR_TABLE_P (binding
))
621 /* Character codes with modifiers
622 are not included in a char-table.
623 All character codes without modifiers are included. */
624 if (NATNUMP (idx
) && (XFASTINT (idx
) & CHAR_MODIFIER_MASK
) == 0)
626 val
= Faref (binding
, idx
);
627 /* `nil' has a special meaning for char-tables, so
628 we use something else to record an explicitly
635 /* If we found a binding, clean it up and return it. */
636 if (!EQ (val
, Qunbound
))
639 /* A Qt binding is just like an explicit nil binding
640 (i.e. it shadows any parent binding but not bindings in
641 keymaps of lower precedence). */
643 val
= get_keyelt (val
, autoload
);
645 fix_submap_inheritance (map
, idx
, val
);
646 RETURN_UNGCPRO (val
);
651 return get_keyelt (t_binding
, autoload
);
656 map_keymap_item (fun
, args
, key
, val
, data
)
657 map_keymap_function_t fun
;
658 Lisp_Object args
, key
, val
;
661 /* We should maybe try to detect bindings shadowed by previous
662 ones and things like that. */
665 (*fun
) (key
, val
, args
, data
);
669 map_keymap_char_table_item (args
, key
, val
)
670 Lisp_Object args
, key
, val
;
674 map_keymap_function_t fun
= XSAVE_VALUE (XCAR (args
))->pointer
;
676 map_keymap_item (fun
, XCDR (args
), key
, val
,
677 XSAVE_VALUE (XCAR (args
))->pointer
);
681 /* Call FUN for every binding in MAP.
682 FUN is called with 4 arguments: FUN (KEY, BINDING, ARGS, DATA).
683 AUTOLOAD if non-zero means that we can autoload keymaps if necessary. */
685 map_keymap (map
, fun
, args
, data
, autoload
)
686 map_keymap_function_t fun
;
687 Lisp_Object map
, args
;
691 struct gcpro gcpro1
, gcpro2
, gcpro3
;
694 GCPRO3 (map
, args
, tail
);
695 map
= get_keymap (map
, 1, autoload
);
696 for (tail
= (CONSP (map
) && EQ (Qkeymap
, XCAR (map
))) ? XCDR (map
) : map
;
697 CONSP (tail
) || (tail
= get_keymap (tail
, 0, autoload
), CONSP (tail
));
700 Lisp_Object binding
= XCAR (tail
);
703 map_keymap_item (fun
, args
, XCAR (binding
), XCDR (binding
), data
);
704 else if (VECTORP (binding
))
706 /* Loop over the char values represented in the vector. */
707 int len
= ASIZE (binding
);
709 for (c
= 0; c
< len
; c
++)
711 Lisp_Object character
;
712 XSETFASTINT (character
, c
);
713 map_keymap_item (fun
, args
, character
, AREF (binding
, c
), data
);
716 else if (CHAR_TABLE_P (binding
))
718 Lisp_Object indices
[3];
719 map_char_table (map_keymap_char_table_item
, Qnil
, binding
, binding
,
720 Fcons (make_save_value (fun
, 0),
721 Fcons (make_save_value (data
, 0),
730 map_keymap_call (key
, val
, fun
, dummy
)
731 Lisp_Object key
, val
, fun
;
734 call2 (fun
, key
, val
);
737 DEFUN ("map-keymap", Fmap_keymap
, Smap_keymap
, 2, 3, 0,
738 doc
: /* Call FUNCTION for every binding in KEYMAP.
739 FUNCTION is called with two arguments: the event and its binding.
740 If KEYMAP has a parent, the parent's bindings are included as well.
741 This works recursively: if the parent has itself a parent, then the
742 grandparent's bindings are also included and so on.
743 usage: (map-keymap FUNCTION KEYMAP) */)
744 (function
, keymap
, sort_first
)
745 Lisp_Object function
, keymap
, sort_first
;
747 if (INTEGERP (function
))
748 /* We have to stop integers early since map_keymap gives them special
750 Fsignal (Qinvalid_function
, Fcons (function
, Qnil
));
751 if (! NILP (sort_first
))
752 return call3 (intern ("map-keymap-internal"), function
, keymap
, Qt
);
754 map_keymap (keymap
, map_keymap_call
, function
, NULL
, 1);
758 /* Given OBJECT which was found in a slot in a keymap,
759 trace indirect definitions to get the actual definition of that slot.
760 An indirect definition is a list of the form
761 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
762 and INDEX is the object to look up in KEYMAP to yield the definition.
764 Also if OBJECT has a menu string as the first element,
765 remove that. Also remove a menu help string as second element.
767 If AUTOLOAD is nonzero, load autoloadable keymaps
768 that are referred to with indirection.
770 This can GC because menu_item_eval_property calls Feval. */
773 get_keyelt (object
, autoload
)
779 if (!(CONSP (object
)))
780 /* This is really the value. */
783 /* If the keymap contents looks like (keymap ...) or (lambda ...)
785 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
788 /* If the keymap contents looks like (menu-item name . DEFN)
789 or (menu-item name DEFN ...) then use DEFN.
790 This is a new format menu item. */
791 else if (EQ (XCAR (object
), Qmenu_item
))
793 if (CONSP (XCDR (object
)))
797 object
= XCDR (XCDR (object
));
800 object
= XCAR (object
);
802 /* If there's a `:filter FILTER', apply FILTER to the
803 menu-item's definition to get the real definition to
805 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
806 if (EQ (XCAR (tem
), QCfilter
) && autoload
)
809 filter
= XCAR (XCDR (tem
));
810 filter
= list2 (filter
, list2 (Qquote
, object
));
811 object
= menu_item_eval_property (filter
);
816 /* Invalid keymap. */
820 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
821 Keymap alist elements like (CHAR MENUSTRING . DEFN)
822 will be used by HierarKey menus. */
823 else if (STRINGP (XCAR (object
)))
825 object
= XCDR (object
);
826 /* Also remove a menu help string, if any,
827 following the menu item name. */
828 if (CONSP (object
) && STRINGP (XCAR (object
)))
829 object
= XCDR (object
);
830 /* Also remove the sublist that caches key equivalences, if any. */
831 if (CONSP (object
) && CONSP (XCAR (object
)))
834 carcar
= XCAR (XCAR (object
));
835 if (NILP (carcar
) || VECTORP (carcar
))
836 object
= XCDR (object
);
840 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
846 map
= get_keymap (Fcar_safe (object
), 0, autoload
);
848 return (!CONSP (map
) ? object
/* Invalid keymap */
849 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
855 store_in_keymap (keymap
, idx
, def
)
857 register Lisp_Object idx
;
858 register Lisp_Object def
;
860 /* Flush any reverse-map cache. */
861 where_is_cache
= Qnil
;
862 where_is_cache_keymaps
= Qt
;
864 /* If we are preparing to dump, and DEF is a menu element
865 with a menu item indicator, copy it to ensure it is not pure. */
866 if (CONSP (def
) && PURE_P (def
)
867 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
868 def
= Fcons (XCAR (def
), XCDR (def
));
870 if (!CONSP (keymap
) || !EQ (XCAR (keymap
), Qkeymap
))
871 error ("attempt to define a key in a non-keymap");
873 /* If idx is a list (some sort of mouse click, perhaps?),
874 the index we want to use is the car of the list, which
875 ought to be a symbol. */
876 idx
= EVENT_HEAD (idx
);
878 /* If idx is a symbol, it might have modifiers, which need to
879 be put in the canonical order. */
881 idx
= reorder_modifiers (idx
);
882 else if (INTEGERP (idx
))
883 /* Clobber the high bits that can be present on a machine
884 with more than 24 bits of integer. */
885 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
887 /* Scan the keymap for a binding of idx. */
891 /* The cons after which we should insert new bindings. If the
892 keymap has a table element, we record its position here, so new
893 bindings will go after it; this way, the table will stay
894 towards the front of the alist and character lookups in dense
895 keymaps will remain fast. Otherwise, this just points at the
896 front of the keymap. */
897 Lisp_Object insertion_point
;
899 insertion_point
= keymap
;
900 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
907 if (NATNUMP (idx
) && XFASTINT (idx
) < ASIZE (elt
))
909 ASET (elt
, XFASTINT (idx
), def
);
912 insertion_point
= tail
;
914 else if (CHAR_TABLE_P (elt
))
916 /* Character codes with modifiers
917 are not included in a char-table.
918 All character codes without modifiers are included. */
919 if (NATNUMP (idx
) && !(XFASTINT (idx
) & CHAR_MODIFIER_MASK
))
922 /* `nil' has a special meaning for char-tables, so
923 we use something else to record an explicitly
925 NILP (def
) ? Qt
: def
);
928 insertion_point
= tail
;
930 else if (CONSP (elt
))
932 if (EQ (idx
, XCAR (elt
)))
938 else if (EQ (elt
, Qkeymap
))
939 /* If we find a 'keymap' symbol in the spine of KEYMAP,
940 then we must have found the start of a second keymap
941 being used as the tail of KEYMAP, and a binding for IDX
942 should be inserted before it. */
949 /* We have scanned the entire keymap, and not found a binding for
950 IDX. Let's add one. */
951 XSETCDR (insertion_point
,
952 Fcons (Fcons (idx
, def
), XCDR (insertion_point
)));
958 EXFUN (Fcopy_keymap
, 1);
961 copy_keymap_item (elt
)
964 Lisp_Object res
, tem
;
971 /* Is this a new format menu item. */
972 if (EQ (XCAR (tem
), Qmenu_item
))
974 /* Copy cell with menu-item marker. */
975 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
979 /* Copy cell with menu-item name. */
980 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
986 /* Copy cell with binding and if the binding is a keymap,
988 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
991 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
992 XSETCAR (elt
, Fcopy_keymap (tem
));
994 if (CONSP (tem
) && CONSP (XCAR (tem
)))
995 /* Delete cache for key equivalences. */
996 XSETCDR (elt
, XCDR (tem
));
1001 /* It may be an old fomat menu item.
1002 Skip the optional menu string. */
1003 if (STRINGP (XCAR (tem
)))
1005 /* Copy the cell, since copy-alist didn't go this deep. */
1006 res
= elt
= Fcons (XCAR (tem
), XCDR (tem
));
1008 /* Also skip the optional menu help string. */
1009 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
1011 XSETCDR (elt
, Fcons (XCAR (tem
), XCDR (tem
)));
1015 /* There may also be a list that caches key equivalences.
1016 Just delete it for the new keymap. */
1018 && CONSP (XCAR (tem
))
1019 && (NILP (XCAR (XCAR (tem
)))
1020 || VECTORP (XCAR (XCAR (tem
)))))
1022 XSETCDR (elt
, XCDR (tem
));
1025 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
1026 XSETCDR (elt
, Fcopy_keymap (tem
));
1028 else if (EQ (XCAR (tem
), Qkeymap
))
1029 res
= Fcopy_keymap (elt
);
1035 copy_keymap_1 (chartable
, idx
, elt
)
1036 Lisp_Object chartable
, idx
, elt
;
1038 Faset (chartable
, idx
, copy_keymap_item (elt
));
1041 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
1042 doc
: /* Return a copy of the keymap KEYMAP.
1043 The copy starts out with the same definitions of KEYMAP,
1044 but changing either the copy or KEYMAP does not affect the other.
1045 Any key definitions that are subkeymaps are recursively copied.
1046 However, a key definition which is a symbol whose definition is a keymap
1051 register Lisp_Object copy
, tail
;
1052 keymap
= get_keymap (keymap
, 1, 0);
1053 copy
= tail
= Fcons (Qkeymap
, Qnil
);
1054 keymap
= XCDR (keymap
); /* Skip the `keymap' symbol. */
1056 while (CONSP (keymap
) && !EQ (XCAR (keymap
), Qkeymap
))
1058 Lisp_Object elt
= XCAR (keymap
);
1059 if (CHAR_TABLE_P (elt
))
1061 Lisp_Object indices
[3];
1062 elt
= Fcopy_sequence (elt
);
1063 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, elt
, 0, indices
);
1065 else if (VECTORP (elt
))
1068 elt
= Fcopy_sequence (elt
);
1069 for (i
= 0; i
< ASIZE (elt
); i
++)
1070 ASET (elt
, i
, copy_keymap_item (AREF (elt
, i
)));
1072 else if (CONSP (elt
))
1073 elt
= Fcons (XCAR (elt
), copy_keymap_item (XCDR (elt
)));
1074 XSETCDR (tail
, Fcons (elt
, Qnil
));
1076 keymap
= XCDR (keymap
);
1078 XSETCDR (tail
, keymap
);
1082 /* Simple Keymap mutators and accessors. */
1084 /* GC is possible in this function if it autoloads a keymap. */
1086 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
1087 doc
: /* In KEYMAP, define key sequence KEY as DEF.
1090 KEY is a string or a vector of symbols and characters meaning a
1091 sequence of keystrokes and events. Non-ASCII characters with codes
1092 above 127 (such as ISO Latin-1) can be included if you use a vector.
1093 Using [t] for KEY creates a default definition, which applies to any
1094 event type that has no other definition in this keymap.
1096 DEF is anything that can be a key's definition:
1097 nil (means key is undefined in this keymap),
1098 a command (a Lisp function suitable for interactive calling),
1099 a string (treated as a keyboard macro),
1100 a keymap (to define a prefix key),
1101 a symbol (when the key is looked up, the symbol will stand for its
1102 function definition, which should at that time be one of the above,
1103 or another symbol whose function definition is used, etc.),
1104 a cons (STRING . DEFN), meaning that DEFN is the definition
1105 (DEFN should be a valid definition in its own right),
1106 or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP.
1108 If KEYMAP is a sparse keymap with a binding for KEY, the existing
1109 binding is altered. If there is no binding for KEY, the new pair
1110 binding KEY to DEF is added at the front of KEYMAP. */)
1117 register Lisp_Object c
;
1118 register Lisp_Object cmd
;
1122 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1124 GCPRO3 (keymap
, key
, def
);
1125 keymap
= get_keymap (keymap
, 1, 1);
1127 if (!VECTORP (key
) && !STRINGP (key
))
1128 key
= wrong_type_argument (Qarrayp
, key
);
1130 length
= XFASTINT (Flength (key
));
1132 RETURN_UNGCPRO (Qnil
);
1134 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
1135 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
1137 meta_bit
= VECTORP (key
) ? meta_modifier
: 0x80;
1142 c
= Faref (key
, make_number (idx
));
1144 if (CONSP (c
) && lucid_event_type_list_p (c
))
1145 c
= Fevent_convert_list (c
);
1148 silly_event_symbol_error (c
);
1151 && (XINT (c
) & meta_bit
)
1154 c
= meta_prefix_char
;
1160 XSETINT (c
, XINT (c
) & ~meta_bit
);
1166 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
))
1167 error ("Key sequence contains invalid event");
1170 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
1172 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
1174 /* If this key is undefined, make it a prefix. */
1176 cmd
= define_as_prefix (keymap
, c
);
1178 keymap
= get_keymap (cmd
, 0, 1);
1179 if (!CONSP (keymap
))
1180 /* We must use Fkey_description rather than just passing key to
1181 error; key might be a vector, not a string. */
1182 error ("Key sequence %s uses invalid prefix characters",
1183 SDATA (Fkey_description (key
, Qnil
)));
1187 /* This function may GC (it calls Fkey_binding). */
1189 DEFUN ("command-remapping", Fcommand_remapping
, Scommand_remapping
, 1, 1, 0,
1190 doc
: /* Return the remapping for command COMMAND in current keymaps.
1191 Returns nil if COMMAND is not remapped (or not a symbol). */)
1193 Lisp_Object command
;
1195 if (!SYMBOLP (command
))
1198 ASET (command_remapping_vector
, 1, command
);
1199 return Fkey_binding (command_remapping_vector
, Qnil
, Qt
);
1202 /* Value is number if KEY is too long; nil if valid but has no definition. */
1203 /* GC is possible in this function if it autoloads a keymap. */
1205 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1206 doc
: /* In keymap KEYMAP, look up key sequence KEY. Return the definition.
1207 nil means undefined. See doc of `define-key' for kinds of definitions.
1209 A number as value means KEY is "too long";
1210 that is, characters or symbols in it except for the last one
1211 fail to be a valid sequence of prefix characters in KEYMAP.
1212 The number is how many characters at the front of KEY
1213 it takes to reach a non-prefix command.
1215 Normally, `lookup-key' ignores bindings for t, which act as default
1216 bindings, used when nothing else in the keymap applies; this makes it
1217 usable as a general function for probing keymaps. However, if the
1218 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will
1219 recognize the default bindings, just as `read-key-sequence' does. */)
1220 (keymap
, key
, accept_default
)
1223 Lisp_Object accept_default
;
1226 register Lisp_Object cmd
;
1227 register Lisp_Object c
;
1229 int t_ok
= !NILP (accept_default
);
1230 struct gcpro gcpro1
, gcpro2
;
1232 GCPRO2 (keymap
, key
);
1233 keymap
= get_keymap (keymap
, 1, 1);
1235 if (!VECTORP (key
) && !STRINGP (key
))
1236 key
= wrong_type_argument (Qarrayp
, key
);
1238 length
= XFASTINT (Flength (key
));
1240 RETURN_UNGCPRO (keymap
);
1245 c
= Faref (key
, make_number (idx
++));
1247 if (CONSP (c
) && lucid_event_type_list_p (c
))
1248 c
= Fevent_convert_list (c
);
1250 /* Turn the 8th bit of string chars into a meta modifier. */
1251 if (INTEGERP (c
) && XINT (c
) & 0x80 && STRINGP (key
))
1252 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1254 /* Allow string since binding for `menu-bar-select-buffer'
1255 includes the buffer name in the key sequence. */
1256 if (!INTEGERP (c
) && !SYMBOLP (c
) && !CONSP (c
) && !STRINGP (c
))
1257 error ("Key sequence contains invalid event");
1259 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1261 RETURN_UNGCPRO (cmd
);
1263 keymap
= get_keymap (cmd
, 0, 1);
1264 if (!CONSP (keymap
))
1265 RETURN_UNGCPRO (make_number (idx
));
1271 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1272 Assume that currently it does not define C at all.
1273 Return the keymap. */
1276 define_as_prefix (keymap
, c
)
1277 Lisp_Object keymap
, c
;
1281 cmd
= Fmake_sparse_keymap (Qnil
);
1282 /* If this key is defined as a prefix in an inherited keymap,
1283 make it a prefix in this map, and make its definition
1284 inherit the other prefix definition. */
1285 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1286 store_in_keymap (keymap
, c
, cmd
);
1291 /* Append a key to the end of a key sequence. We always make a vector. */
1294 append_key (key_sequence
, key
)
1295 Lisp_Object key_sequence
, key
;
1297 Lisp_Object args
[2];
1299 args
[0] = key_sequence
;
1301 args
[1] = Fcons (key
, Qnil
);
1302 return Fvconcat (2, args
);
1305 /* Given a event type C which is a symbol,
1306 signal an error if is a mistake such as RET or M-RET or C-DEL, etc. */
1309 silly_event_symbol_error (c
)
1312 Lisp_Object parsed
, base
, name
, assoc
;
1315 parsed
= parse_modifiers (c
);
1316 modifiers
= (int) XUINT (XCAR (XCDR (parsed
)));
1317 base
= XCAR (parsed
);
1318 name
= Fsymbol_name (base
);
1319 /* This alist includes elements such as ("RET" . "\\r"). */
1320 assoc
= Fassoc (name
, exclude_keys
);
1324 char new_mods
[sizeof ("\\A-\\C-\\H-\\M-\\S-\\s-")];
1326 Lisp_Object keystring
;
1327 if (modifiers
& alt_modifier
)
1328 { *p
++ = '\\'; *p
++ = 'A'; *p
++ = '-'; }
1329 if (modifiers
& ctrl_modifier
)
1330 { *p
++ = '\\'; *p
++ = 'C'; *p
++ = '-'; }
1331 if (modifiers
& hyper_modifier
)
1332 { *p
++ = '\\'; *p
++ = 'H'; *p
++ = '-'; }
1333 if (modifiers
& meta_modifier
)
1334 { *p
++ = '\\'; *p
++ = 'M'; *p
++ = '-'; }
1335 if (modifiers
& shift_modifier
)
1336 { *p
++ = '\\'; *p
++ = 'S'; *p
++ = '-'; }
1337 if (modifiers
& super_modifier
)
1338 { *p
++ = '\\'; *p
++ = 's'; *p
++ = '-'; }
1341 c
= reorder_modifiers (c
);
1342 keystring
= concat2 (build_string (new_mods
), XCDR (assoc
));
1344 error ((modifiers
& ~meta_modifier
1345 ? "To bind the key %s, use [?%s], not [%s]"
1346 : "To bind the key %s, use \"%s\", not [%s]"),
1347 SDATA (SYMBOL_NAME (c
)), SDATA (keystring
),
1348 SDATA (SYMBOL_NAME (c
)));
1352 /* Global, local, and minor mode keymap stuff. */
1354 /* We can't put these variables inside current_minor_maps, since under
1355 some systems, static gets macro-defined to be the empty string.
1357 static Lisp_Object
*cmm_modes
= NULL
, *cmm_maps
= NULL
;
1358 static int cmm_size
= 0;
1360 /* Error handler used in current_minor_maps. */
1362 current_minor_maps_error ()
1367 /* Store a pointer to an array of the keymaps of the currently active
1368 minor modes in *buf, and return the number of maps it contains.
1370 This function always returns a pointer to the same buffer, and may
1371 free or reallocate it, so if you want to keep it for a long time or
1372 hand it out to lisp code, copy it. This procedure will be called
1373 for every key sequence read, so the nice lispy approach (return a
1374 new assoclist, list, what have you) for each invocation would
1375 result in a lot of consing over time.
1377 If we used xrealloc/xmalloc and ran out of memory, they would throw
1378 back to the command loop, which would try to read a key sequence,
1379 which would call this function again, resulting in an infinite
1380 loop. Instead, we'll use realloc/malloc and silently truncate the
1381 list, let the key sequence be read, and hope some other piece of
1382 code signals the error. */
1384 current_minor_maps (modeptr
, mapptr
)
1385 Lisp_Object
**modeptr
, **mapptr
;
1388 int list_number
= 0;
1389 Lisp_Object alist
, assoc
, var
, val
;
1390 Lisp_Object emulation_alists
;
1391 Lisp_Object lists
[2];
1393 emulation_alists
= Vemulation_mode_map_alists
;
1394 lists
[0] = Vminor_mode_overriding_map_alist
;
1395 lists
[1] = Vminor_mode_map_alist
;
1397 for (list_number
= 0; list_number
< 2; list_number
++)
1399 if (CONSP (emulation_alists
))
1401 alist
= XCAR (emulation_alists
);
1402 emulation_alists
= XCDR (emulation_alists
);
1403 if (SYMBOLP (alist
))
1404 alist
= find_symbol_value (alist
);
1408 alist
= lists
[list_number
];
1410 for ( ; CONSP (alist
); alist
= XCDR (alist
))
1411 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1412 && (var
= XCAR (assoc
), SYMBOLP (var
))
1413 && (val
= find_symbol_value (var
), !EQ (val
, Qunbound
))
1418 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1419 and also an entry in Vminor_mode_map_alist,
1420 ignore the latter. */
1421 if (list_number
== 1)
1423 val
= assq_no_quit (var
, lists
[0]);
1430 int newsize
, allocsize
;
1431 Lisp_Object
*newmodes
, *newmaps
;
1433 newsize
= cmm_size
== 0 ? 30 : cmm_size
* 2;
1434 allocsize
= newsize
* sizeof *newmodes
;
1436 /* Use malloc here. See the comment above this function.
1437 Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
1439 newmodes
= (Lisp_Object
*) malloc (allocsize
);
1444 bcopy (cmm_modes
, newmodes
, cmm_size
* sizeof cmm_modes
[0]);
1447 cmm_modes
= newmodes
;
1450 newmaps
= (Lisp_Object
*) malloc (allocsize
);
1455 bcopy (cmm_maps
, newmaps
, cmm_size
* sizeof cmm_maps
[0]);
1462 if (newmodes
== NULL
|| newmaps
== NULL
)
1467 /* Get the keymap definition--or nil if it is not defined. */
1468 temp
= internal_condition_case_1 (Findirect_function
,
1470 Qerror
, current_minor_maps_error
);
1474 cmm_maps
[i
] = temp
;
1480 if (modeptr
) *modeptr
= cmm_modes
;
1481 if (mapptr
) *mapptr
= cmm_maps
;
1485 DEFUN ("current-active-maps", Fcurrent_active_maps
, Scurrent_active_maps
,
1487 doc
: /* Return a list of the currently active keymaps.
1488 OLP if non-nil indicates that we should obey `overriding-local-map' and
1489 `overriding-terminal-local-map'. */)
1493 Lisp_Object keymaps
= Fcons (current_global_map
, Qnil
);
1497 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1498 keymaps
= Fcons (current_kboard
->Voverriding_terminal_local_map
, keymaps
);
1499 /* The doc said that overriding-terminal-local-map should
1500 override overriding-local-map. The code used them both,
1501 but it seems clearer to use just one. rms, jan 2005. */
1502 else if (!NILP (Voverriding_local_map
))
1503 keymaps
= Fcons (Voverriding_local_map
, keymaps
);
1505 if (NILP (XCDR (keymaps
)))
1511 /* This usually returns the buffer's local map,
1512 but that can be overridden by a `local-map' property. */
1513 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1515 keymaps
= Fcons (local
, keymaps
);
1517 /* Now put all the minor mode keymaps on the list. */
1518 nmaps
= current_minor_maps (0, &maps
);
1520 for (i
= --nmaps
; i
>= 0; i
--)
1521 if (!NILP (maps
[i
]))
1522 keymaps
= Fcons (maps
[i
], keymaps
);
1524 /* This returns nil unless there is a `keymap' property. */
1525 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1527 keymaps
= Fcons (local
, keymaps
);
1533 /* GC is possible in this function if it autoloads a keymap. */
1535 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 3, 0,
1536 doc
: /* Return the binding for command KEY in current keymaps.
1537 KEY is a string or vector, a sequence of keystrokes.
1538 The binding is probably a symbol with a function definition.
1540 Normally, `key-binding' ignores bindings for t, which act as default
1541 bindings, used when nothing else in the keymap applies; this makes it
1542 usable as a general function for probing keymaps. However, if the
1543 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does
1544 recognize the default bindings, just as `read-key-sequence' does.
1546 Like the normal command loop, `key-binding' will remap the command
1547 resulting from looking up KEY by looking up the command in the
1548 current keymaps. However, if the optional third argument NO-REMAP
1549 is non-nil, `key-binding' returns the unmapped command. */)
1550 (key
, accept_default
, no_remap
)
1551 Lisp_Object key
, accept_default
, no_remap
;
1553 Lisp_Object
*maps
, value
;
1555 struct gcpro gcpro1
;
1559 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1561 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1562 key
, accept_default
);
1563 if (! NILP (value
) && !INTEGERP (value
))
1566 else if (!NILP (Voverriding_local_map
))
1568 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1569 if (! NILP (value
) && !INTEGERP (value
))
1576 local
= get_local_map (PT
, current_buffer
, Qkeymap
);
1579 value
= Flookup_key (local
, key
, accept_default
);
1580 if (! NILP (value
) && !INTEGERP (value
))
1584 nmaps
= current_minor_maps (0, &maps
);
1585 /* Note that all these maps are GCPRO'd
1586 in the places where we found them. */
1588 for (i
= 0; i
< nmaps
; i
++)
1589 if (! NILP (maps
[i
]))
1591 value
= Flookup_key (maps
[i
], key
, accept_default
);
1592 if (! NILP (value
) && !INTEGERP (value
))
1596 local
= get_local_map (PT
, current_buffer
, Qlocal_map
);
1599 value
= Flookup_key (local
, key
, accept_default
);
1600 if (! NILP (value
) && !INTEGERP (value
))
1605 value
= Flookup_key (current_global_map
, key
, accept_default
);
1609 if (NILP (value
) || INTEGERP (value
))
1612 /* If the result of the ordinary keymap lookup is an interactive
1613 command, look for a key binding (ie. remapping) for that command. */
1615 if (NILP (no_remap
) && SYMBOLP (value
))
1618 if (value1
= Fcommand_remapping (value
), !NILP (value1
))
1625 /* GC is possible in this function if it autoloads a keymap. */
1627 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1628 doc
: /* Return the binding for command KEYS in current local keymap only.
1629 KEYS is a string or vector, a sequence of keystrokes.
1630 The binding is probably a symbol with a function definition.
1632 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1633 bindings; see the description of `lookup-key' for more details about this. */)
1634 (keys
, accept_default
)
1635 Lisp_Object keys
, accept_default
;
1637 register Lisp_Object map
;
1638 map
= current_buffer
->keymap
;
1641 return Flookup_key (map
, keys
, accept_default
);
1644 /* GC is possible in this function if it autoloads a keymap. */
1646 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1647 doc
: /* Return the binding for command KEYS in current global keymap only.
1648 KEYS is a string or vector, a sequence of keystrokes.
1649 The binding is probably a symbol with a function definition.
1650 This function's return values are the same as those of `lookup-key'
1653 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1654 bindings; see the description of `lookup-key' for more details about this. */)
1655 (keys
, accept_default
)
1656 Lisp_Object keys
, accept_default
;
1658 return Flookup_key (current_global_map
, keys
, accept_default
);
1661 /* GC is possible in this function if it autoloads a keymap. */
1663 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1664 doc
: /* Find the visible minor mode bindings of KEY.
1665 Return an alist of pairs (MODENAME . BINDING), where MODENAME is
1666 the symbol which names the minor mode binding KEY, and BINDING is
1667 KEY's definition in that mode. In particular, if KEY has no
1668 minor-mode bindings, return nil. If the first binding is a
1669 non-prefix, all subsequent bindings will be omitted, since they would
1670 be ignored. Similarly, the list doesn't include non-prefix bindings
1671 that come after prefix bindings.
1673 If optional argument ACCEPT-DEFAULT is non-nil, recognize default
1674 bindings; see the description of `lookup-key' for more details about this. */)
1675 (key
, accept_default
)
1676 Lisp_Object key
, accept_default
;
1678 Lisp_Object
*modes
, *maps
;
1680 Lisp_Object binding
;
1682 struct gcpro gcpro1
, gcpro2
;
1684 nmaps
= current_minor_maps (&modes
, &maps
);
1685 /* Note that all these maps are GCPRO'd
1686 in the places where we found them. */
1689 GCPRO2 (key
, binding
);
1691 for (i
= j
= 0; i
< nmaps
; i
++)
1693 && !NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1694 && !INTEGERP (binding
))
1696 if (KEYMAPP (binding
))
1697 maps
[j
++] = Fcons (modes
[i
], binding
);
1699 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1703 return Flist (j
, maps
);
1706 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1707 doc
: /* Define COMMAND as a prefix command. COMMAND should be a symbol.
1708 A new sparse keymap is stored as COMMAND's function definition and its value.
1709 If a second optional argument MAPVAR is given, the map is stored as
1710 its value instead of as COMMAND's value; but COMMAND is still defined
1712 The third optional argument NAME, if given, supplies a menu name
1713 string for the map. This is required to use the keymap as a menu.
1714 This function returns COMMAND. */)
1715 (command
, mapvar
, name
)
1716 Lisp_Object command
, mapvar
, name
;
1719 map
= Fmake_sparse_keymap (name
);
1720 Ffset (command
, map
);
1724 Fset (command
, map
);
1728 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1729 doc
: /* Select KEYMAP as the global keymap. */)
1733 keymap
= get_keymap (keymap
, 1, 1);
1734 current_global_map
= keymap
;
1739 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1740 doc
: /* Select KEYMAP as the local keymap.
1741 If KEYMAP is nil, that means no local keymap. */)
1746 keymap
= get_keymap (keymap
, 1, 1);
1748 current_buffer
->keymap
= keymap
;
1753 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1754 doc
: /* Return current buffer's local keymap, or nil if it has none. */)
1757 return current_buffer
->keymap
;
1760 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1761 doc
: /* Return the current global keymap. */)
1764 return current_global_map
;
1767 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1768 doc
: /* Return a list of keymaps for the minor modes of the current buffer. */)
1772 int nmaps
= current_minor_maps (0, &maps
);
1774 return Flist (nmaps
, maps
);
1777 /* Help functions for describing and documenting keymaps. */
1781 accessible_keymaps_1 (key
, cmd
, maps
, tail
, thisseq
, is_metized
)
1782 Lisp_Object maps
, tail
, thisseq
, key
, cmd
;
1783 int is_metized
; /* If 1, `key' is assumed to be INTEGERP. */
1787 cmd
= get_keymap (get_keyelt (cmd
, 0), 0, 0);
1791 /* Look for and break cycles. */
1792 while (!NILP (tem
= Frassq (cmd
, maps
)))
1794 Lisp_Object prefix
= XCAR (tem
);
1795 int lim
= XINT (Flength (XCAR (tem
)));
1796 if (lim
<= XINT (Flength (thisseq
)))
1797 { /* This keymap was already seen with a smaller prefix. */
1799 while (i
< lim
&& EQ (Faref (prefix
, make_number (i
)),
1800 Faref (thisseq
, make_number (i
))))
1803 /* `prefix' is a prefix of `thisseq' => there's a cycle. */
1806 /* This occurrence of `cmd' in `maps' does not correspond to a cycle,
1807 but maybe `cmd' occurs again further down in `maps', so keep
1809 maps
= XCDR (Fmemq (tem
, maps
));
1812 /* If the last key in thisseq is meta-prefix-char,
1813 turn it into a meta-ized keystroke. We know
1814 that the event we're about to append is an
1815 ascii keystroke since we're processing a
1819 int meta_bit
= meta_modifier
;
1820 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1821 tem
= Fcopy_sequence (thisseq
);
1823 Faset (tem
, last
, make_number (XINT (key
) | meta_bit
));
1825 /* This new sequence is the same length as
1826 thisseq, so stick it in the list right
1829 Fcons (Fcons (tem
, cmd
), XCDR (tail
)));
1833 tem
= append_key (thisseq
, key
);
1834 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1839 accessible_keymaps_char_table (args
, index
, cmd
)
1840 Lisp_Object args
, index
, cmd
;
1842 accessible_keymaps_1 (index
, cmd
,
1846 XINT (XCDR (XCAR (args
))));
1849 /* This function cannot GC. */
1851 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1853 doc
: /* Find all keymaps accessible via prefix characters from KEYMAP.
1854 Returns a list of elements of the form (KEYS . MAP), where the sequence
1855 KEYS starting from KEYMAP gets you to MAP. These elements are ordered
1856 so that the KEYS increase in length. The first element is ([] . KEYMAP).
1857 An optional argument PREFIX, if non-nil, should be a key sequence;
1858 then the value includes only maps for prefixes that start with PREFIX. */)
1860 Lisp_Object keymap
, prefix
;
1862 Lisp_Object maps
, tail
;
1865 /* no need for gcpro because we don't autoload any keymaps. */
1868 prefixlen
= XINT (Flength (prefix
));
1872 /* If a prefix was specified, start with the keymap (if any) for
1873 that prefix, so we don't waste time considering other prefixes. */
1875 tem
= Flookup_key (keymap
, prefix
, Qt
);
1876 /* Flookup_key may give us nil, or a number,
1877 if the prefix is not defined in this particular map.
1878 It might even give us a list that isn't a keymap. */
1879 tem
= get_keymap (tem
, 0, 0);
1882 /* Convert PREFIX to a vector now, so that later on
1883 we don't have to deal with the possibility of a string. */
1884 if (STRINGP (prefix
))
1889 copy
= Fmake_vector (make_number (SCHARS (prefix
)), Qnil
);
1890 for (i
= 0, i_byte
= 0; i
< SCHARS (prefix
);)
1894 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1895 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1896 c
^= 0200 | meta_modifier
;
1897 ASET (copy
, i_before
, make_number (c
));
1901 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1907 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1908 get_keymap (keymap
, 1, 0)),
1911 /* For each map in the list maps,
1912 look at any other maps it points to,
1913 and stick them at the end if they are not already in the list.
1915 This is a breadth-first traversal, where tail is the queue of
1916 nodes, and maps accumulates a list of all nodes visited. */
1918 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1920 register Lisp_Object thisseq
, thismap
;
1922 /* Does the current sequence end in the meta-prefix-char? */
1925 thisseq
= Fcar (Fcar (tail
));
1926 thismap
= Fcdr (Fcar (tail
));
1927 last
= make_number (XINT (Flength (thisseq
)) - 1);
1928 is_metized
= (XINT (last
) >= 0
1929 /* Don't metize the last char of PREFIX. */
1930 && XINT (last
) >= prefixlen
1931 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1933 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1937 elt
= XCAR (thismap
);
1941 if (CHAR_TABLE_P (elt
))
1943 Lisp_Object indices
[3];
1945 map_char_table (accessible_keymaps_char_table
, Qnil
, elt
,
1946 elt
, Fcons (Fcons (maps
, make_number (is_metized
)),
1947 Fcons (tail
, thisseq
)),
1950 else if (VECTORP (elt
))
1954 /* Vector keymap. Scan all the elements. */
1955 for (i
= 0; i
< ASIZE (elt
); i
++)
1956 accessible_keymaps_1 (make_number (i
), AREF (elt
, i
),
1957 maps
, tail
, thisseq
, is_metized
);
1960 else if (CONSP (elt
))
1961 accessible_keymaps_1 (XCAR (elt
), XCDR (elt
),
1962 maps
, tail
, thisseq
,
1963 is_metized
&& INTEGERP (XCAR (elt
)));
1971 Lisp_Object Qsingle_key_description
, Qkey_description
;
1973 /* This function cannot GC. */
1975 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 2, 0,
1976 doc
: /* Return a pretty description of key-sequence KEYS.
1977 Optional arg PREFIX is the sequence of keys leading up to KEYS.
1978 Control characters turn into "C-foo" sequences, meta into "M-foo",
1979 spaces are put between sequence elements, etc. */)
1981 Lisp_Object keys
, prefix
;
1986 int size
= XINT (Flength (keys
));
1988 Lisp_Object sep
= build_string (" ");
1993 size
+= XINT (Flength (prefix
));
1995 /* This has one extra element at the end that we don't pass to Fconcat. */
1996 args
= (Lisp_Object
*) alloca (size
* 4 * sizeof (Lisp_Object
));
1998 /* In effect, this computes
1999 (mapconcat 'single-key-description keys " ")
2000 but we shouldn't use mapconcat because it can do GC. */
2004 list
= prefix
, prefix
= Qnil
;
2005 else if (!NILP (keys
))
2006 list
= keys
, keys
= Qnil
;
2011 args
[len
] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2015 return empty_string
;
2016 return Fconcat (len
- 1, args
);
2020 size
= SCHARS (list
);
2021 else if (VECTORP (list
))
2022 size
= XVECTOR (list
)->size
;
2023 else if (CONSP (list
))
2024 size
= XINT (Flength (list
));
2026 wrong_type_argument (Qarrayp
, list
);
2035 FETCH_STRING_CHAR_ADVANCE (c
, list
, i
, i_byte
);
2036 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
2037 c
^= 0200 | meta_modifier
;
2038 XSETFASTINT (key
, c
);
2040 else if (VECTORP (list
))
2042 key
= AREF (list
, i
++);
2054 || EQ (key
, meta_prefix_char
)
2055 || (XINT (key
) & meta_modifier
))
2057 args
[len
++] = Fsingle_key_description (meta_prefix_char
, Qnil
);
2059 if (EQ (key
, meta_prefix_char
))
2063 XSETINT (key
, (XINT (key
) | meta_modifier
) & ~0x80);
2066 else if (EQ (key
, meta_prefix_char
))
2071 args
[len
++] = Fsingle_key_description (key
, Qnil
);
2079 push_key_description (c
, p
, force_multibyte
)
2080 register unsigned int c
;
2082 int force_multibyte
;
2086 /* Clear all the meaningless bits above the meta bit. */
2087 c
&= meta_modifier
| ~ - meta_modifier
;
2088 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
2089 | meta_modifier
| shift_modifier
| super_modifier
);
2091 if (c
& alt_modifier
)
2097 if ((c
& ctrl_modifier
) != 0
2098 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
2102 c
&= ~ctrl_modifier
;
2104 if (c
& hyper_modifier
)
2108 c
-= hyper_modifier
;
2110 if (c
& meta_modifier
)
2116 if (c
& shift_modifier
)
2120 c
-= shift_modifier
;
2122 if (c
& super_modifier
)
2126 c
-= super_modifier
;
2142 else if (c
== Ctl ('M'))
2150 /* `C-' already added above. */
2151 if (c
> 0 && c
<= Ctl ('Z'))
2170 || (NILP (current_buffer
->enable_multibyte_characters
)
2171 && SINGLE_BYTE_CHAR_P (c
)
2172 && !force_multibyte
))
2178 int valid_p
= SINGLE_BYTE_CHAR_P (c
) || char_valid_p (c
, 0);
2180 if (force_multibyte
&& valid_p
)
2182 if (SINGLE_BYTE_CHAR_P (c
))
2183 c
= unibyte_char_to_multibyte (c
);
2184 p
+= CHAR_STRING (c
, p
);
2186 else if (NILP (current_buffer
->enable_multibyte_characters
)
2191 /* The biggest character code uses 19 bits. */
2192 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
2194 if (c
>= (1 << bit_offset
))
2195 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
2199 p
+= CHAR_STRING (c
, p
);
2205 /* This function cannot GC. */
2207 DEFUN ("single-key-description", Fsingle_key_description
,
2208 Ssingle_key_description
, 1, 2, 0,
2209 doc
: /* Return a pretty description of command character KEY.
2210 Control characters turn into C-whatever, etc.
2211 Optional argument NO-ANGLES non-nil means don't put angle brackets
2212 around function keys and event symbols. */)
2214 Lisp_Object key
, no_angles
;
2216 if (CONSP (key
) && lucid_event_type_list_p (key
))
2217 key
= Fevent_convert_list (key
);
2219 key
= EVENT_HEAD (key
);
2221 if (INTEGERP (key
)) /* Normal character */
2223 unsigned int charset
, c1
, c2
;
2224 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
2226 if (SINGLE_BYTE_CHAR_P (without_bits
))
2229 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
2232 && CHARSET_DEFINED_P (charset
)
2233 && ((c1
>= 0 && c1
< 32)
2234 || (c2
>= 0 && c2
< 32)))
2236 /* Handle a generic character. */
2238 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
2239 CHECK_STRING (name
);
2240 return concat2 (build_string ("Character set "), name
);
2244 char tem
[KEY_DESCRIPTION_SIZE
], *end
;
2248 end
= push_key_description (XUINT (key
), tem
, 1);
2250 nchars
= multibyte_chars_in_text (tem
, nbytes
);
2251 if (nchars
== nbytes
)
2254 string
= build_string (tem
);
2257 string
= make_multibyte_string (tem
, nchars
, nbytes
);
2261 else if (SYMBOLP (key
)) /* Function key or event-symbol */
2263 if (NILP (no_angles
))
2266 = (char *) alloca (SBYTES (SYMBOL_NAME (key
)) + 5);
2267 sprintf (buffer
, "<%s>", SDATA (SYMBOL_NAME (key
)));
2268 return build_string (buffer
);
2271 return Fsymbol_name (key
);
2273 else if (STRINGP (key
)) /* Buffer names in the menubar. */
2274 return Fcopy_sequence (key
);
2276 error ("KEY must be an integer, cons, symbol, or string");
2281 push_text_char_description (c
, p
)
2282 register unsigned int c
;
2294 *p
++ = c
+ 64; /* 'A' - 1 */
2306 /* This function cannot GC. */
2308 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
2309 doc
: /* Return a pretty description of file-character CHARACTER.
2310 Control characters turn into "^char", etc. This differs from
2311 `single-key-description' which turns them into "C-char".
2312 Also, this function recognizes the 2**7 bit as the Meta character,
2313 whereas `single-key-description' uses the 2**27 bit for Meta.
2314 See Info node `(elisp)Describing Characters' for examples. */)
2316 Lisp_Object character
;
2318 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2319 unsigned char str
[6];
2322 CHECK_NUMBER (character
);
2324 c
= XINT (character
);
2325 if (!SINGLE_BYTE_CHAR_P (c
))
2327 int len
= CHAR_STRING (c
, str
);
2329 return make_multibyte_string (str
, 1, len
);
2332 *push_text_char_description (c
& 0377, str
) = 0;
2334 return build_string (str
);
2337 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2340 ascii_sequence_p (seq
)
2344 int len
= XINT (Flength (seq
));
2346 for (i
= 0; i
< len
; i
++)
2348 Lisp_Object ii
, elt
;
2350 XSETFASTINT (ii
, i
);
2351 elt
= Faref (seq
, ii
);
2354 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2362 /* where-is - finding a command in a set of keymaps. */
2364 static Lisp_Object
where_is_internal ();
2365 static Lisp_Object
where_is_internal_1 ();
2366 static void where_is_internal_2 ();
2368 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2369 Returns the first non-nil binding found in any of those maps. */
2372 shadow_lookup (shadow
, key
, flag
)
2373 Lisp_Object shadow
, key
, flag
;
2375 Lisp_Object tail
, value
;
2377 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2379 value
= Flookup_key (XCAR (tail
), key
, flag
);
2380 if (NATNUMP (value
))
2382 value
= Flookup_key (XCAR (tail
), Fsubstring (key
, 0, value
), flag
);
2386 else if (!NILP (value
))
2392 static Lisp_Object Vmouse_events
;
2394 /* This function can GC if Flookup_key autoloads any keymaps. */
2397 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
)
2398 Lisp_Object definition
, keymaps
;
2399 Lisp_Object firstonly
, noindirect
, no_remap
;
2401 Lisp_Object maps
= Qnil
;
2402 Lisp_Object found
, sequences
;
2403 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2404 /* 1 means ignore all menu bindings entirely. */
2405 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2407 /* If this command is remapped, then it has no key bindings
2409 if (NILP (no_remap
) && SYMBOLP (definition
))
2412 if (tem
= Fcommand_remapping (definition
), !NILP (tem
))
2417 while (CONSP (found
))
2421 Faccessible_keymaps (get_keymap (XCAR (found
), 1, 0), Qnil
));
2422 found
= XCDR (found
);
2425 GCPRO5 (definition
, keymaps
, maps
, found
, sequences
);
2429 for (; !NILP (maps
); maps
= Fcdr (maps
))
2431 /* Key sequence to reach map, and the map that it reaches */
2432 register Lisp_Object
this, map
, tem
;
2434 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2435 [M-CHAR] sequences, check if last character of the sequence
2436 is the meta-prefix char. */
2440 this = Fcar (Fcar (maps
));
2441 map
= Fcdr (Fcar (maps
));
2442 last
= make_number (XINT (Flength (this)) - 1);
2443 last_is_meta
= (XINT (last
) >= 0
2444 && EQ (Faref (this, last
), meta_prefix_char
));
2446 /* if (nomenus && !ascii_sequence_p (this)) */
2447 if (nomenus
&& XINT (last
) >= 0
2448 && SYMBOLP (tem
= Faref (this, make_number (0)))
2449 && !NILP (Fmemq (XCAR (parse_modifiers (tem
)), Vmouse_events
)))
2450 /* If no menu entries should be returned, skip over the
2451 keymaps bound to `menu-bar' and `tool-bar' and other
2452 non-ascii prefixes like `C-down-mouse-2'. */
2459 /* Because the code we want to run on each binding is rather
2460 large, we don't want to have two separate loop bodies for
2461 sparse keymap bindings and tables; we want to iterate one
2462 loop body over both keymap and vector bindings.
2464 For this reason, if Fcar (map) is a vector, we don't
2465 advance map to the next element until i indicates that we
2466 have finished off the vector. */
2467 Lisp_Object elt
, key
, binding
;
2475 /* Set key and binding to the current key and binding, and
2476 advance map and i to the next binding. */
2479 Lisp_Object sequence
;
2481 /* In a vector, look at each element. */
2482 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2484 binding
= AREF (elt
, i
);
2485 XSETFASTINT (key
, i
);
2486 sequence
= where_is_internal_1 (binding
, key
, definition
,
2488 last
, nomenus
, last_is_meta
);
2489 if (!NILP (sequence
))
2490 sequences
= Fcons (sequence
, sequences
);
2493 else if (CHAR_TABLE_P (elt
))
2495 Lisp_Object indices
[3];
2498 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2499 Qnil
), /* Result accumulator. */
2500 Fcons (Fcons (this, last
),
2501 Fcons (make_number (nomenus
),
2502 make_number (last_is_meta
))));
2503 map_char_table (where_is_internal_2
, Qnil
, elt
, elt
, args
,
2505 sequences
= XCDR (XCAR (args
));
2507 else if (CONSP (elt
))
2509 Lisp_Object sequence
;
2512 binding
= XCDR (elt
);
2514 sequence
= where_is_internal_1 (binding
, key
, definition
,
2516 last
, nomenus
, last_is_meta
);
2517 if (!NILP (sequence
))
2518 sequences
= Fcons (sequence
, sequences
);
2522 while (!NILP (sequences
))
2524 Lisp_Object sequence
, remapped
, function
;
2526 sequence
= XCAR (sequences
);
2527 sequences
= XCDR (sequences
);
2529 /* If the current sequence is a command remapping with
2530 format [remap COMMAND], find the key sequences
2531 which run COMMAND, and use those sequences instead. */
2534 && VECTORP (sequence
) && XVECTOR (sequence
)->size
== 2
2535 && EQ (AREF (sequence
, 0), Qremap
)
2536 && (function
= AREF (sequence
, 1), SYMBOLP (function
)))
2538 Lisp_Object remapped1
;
2540 remapped1
= where_is_internal (function
, keymaps
, firstonly
, noindirect
, Qt
);
2541 if (CONSP (remapped1
))
2543 /* Verify that this key binding actually maps to the
2544 remapped command (see below). */
2545 if (!EQ (shadow_lookup (keymaps
, XCAR (remapped1
), Qnil
), function
))
2547 sequence
= XCAR (remapped1
);
2548 remapped
= XCDR (remapped1
);
2549 goto record_sequence
;
2553 /* Verify that this key binding is not shadowed by another
2554 binding for the same key, before we say it exists.
2556 Mechanism: look for local definition of this key and if
2557 it is defined and does not match what we found then
2560 Either nil or number as value from Flookup_key
2562 if (!EQ (shadow_lookup (keymaps
, sequence
, Qnil
), definition
))
2566 /* Don't annoy user with strings from a menu such as
2567 Select Paste. Change them all to "(any string)",
2568 so that there seems to be only one menu item
2570 if (! NILP (sequence
))
2573 tem
= Faref (sequence
, make_number (XVECTOR (sequence
)->size
- 1));
2575 Faset (sequence
, make_number (XVECTOR (sequence
)->size
- 1),
2576 build_string ("(any string)"));
2579 /* It is a true unshadowed match. Record it, unless it's already
2580 been seen (as could happen when inheriting keymaps). */
2581 if (NILP (Fmember (sequence
, found
)))
2582 found
= Fcons (sequence
, found
);
2584 /* If firstonly is Qnon_ascii, then we can return the first
2585 binding we find. If firstonly is not Qnon_ascii but not
2586 nil, then we should return the first ascii-only binding
2588 if (EQ (firstonly
, Qnon_ascii
))
2589 RETURN_UNGCPRO (sequence
);
2590 else if (!NILP (firstonly
) && ascii_sequence_p (sequence
))
2591 RETURN_UNGCPRO (sequence
);
2593 if (CONSP (remapped
))
2595 sequence
= XCAR (remapped
);
2596 remapped
= XCDR (remapped
);
2597 goto record_sequence
;
2605 found
= Fnreverse (found
);
2607 /* firstonly may have been t, but we may have gone all the way through
2608 the keymaps without finding an all-ASCII key sequence. So just
2609 return the best we could find. */
2610 if (!NILP (firstonly
))
2611 return Fcar (found
);
2616 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
2617 doc
: /* Return list of keys that invoke DEFINITION.
2618 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
2619 If KEYMAP is nil, search all the currently active keymaps.
2620 If KEYMAP is a list of keymaps, search only those keymaps.
2622 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
2623 rather than a list of all possible key sequences.
2624 If FIRSTONLY is the symbol `non-ascii', return the first binding found,
2625 no matter what it is.
2626 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters
2627 \(or their meta variants) and entirely reject menu bindings.
2629 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
2630 to other keymaps or slots. This makes it possible to search for an
2631 indirect definition itself.
2633 If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
2634 that invoke a command which is remapped to DEFINITION, but include the
2635 remapped command in the returned list. */)
2636 (definition
, keymap
, firstonly
, noindirect
, no_remap
)
2637 Lisp_Object definition
, keymap
;
2638 Lisp_Object firstonly
, noindirect
, no_remap
;
2640 Lisp_Object sequences
, keymaps
;
2641 /* 1 means ignore all menu bindings entirely. */
2642 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2645 /* Find the relevant keymaps. */
2646 if (CONSP (keymap
) && KEYMAPP (XCAR (keymap
)))
2648 else if (!NILP (keymap
))
2649 keymaps
= Fcons (keymap
, Fcons (current_global_map
, Qnil
));
2651 keymaps
= Fcurrent_active_maps (Qnil
);
2653 /* Only use caching for the menubar (i.e. called with (def nil t nil).
2654 We don't really need to check `keymap'. */
2655 if (nomenus
&& NILP (noindirect
) && NILP (keymap
))
2659 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2661 /* Check heuristic-consistency of the cache. */
2662 if (NILP (Fequal (keymaps
, where_is_cache_keymaps
)))
2663 where_is_cache
= Qnil
;
2665 if (NILP (where_is_cache
))
2667 /* We need to create the cache. */
2668 Lisp_Object args
[2];
2669 where_is_cache
= Fmake_hash_table (0, args
);
2670 where_is_cache_keymaps
= Qt
;
2672 /* Fill in the cache. */
2673 GCPRO5 (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2674 where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2677 where_is_cache_keymaps
= keymaps
;
2680 /* We want to process definitions from the last to the first.
2681 Instead of consing, copy definitions to a vector and step
2682 over that vector. */
2683 sequences
= Fgethash (definition
, where_is_cache
, Qnil
);
2684 n
= XINT (Flength (sequences
));
2685 defns
= (Lisp_Object
*) alloca (n
* sizeof *defns
);
2686 for (i
= 0; CONSP (sequences
); sequences
= XCDR (sequences
))
2687 defns
[i
++] = XCAR (sequences
);
2689 /* Verify that the key bindings are not shadowed. Note that
2690 the following can GC. */
2691 GCPRO2 (definition
, keymaps
);
2694 for (i
= n
- 1; i
>= 0; --i
)
2695 if (EQ (shadow_lookup (keymaps
, defns
[i
], Qnil
), definition
))
2697 if (ascii_sequence_p (defns
[i
]))
2703 result
= i
>= 0 ? defns
[i
] : (j
>= 0 ? defns
[j
] : Qnil
);
2708 /* Kill the cache so that where_is_internal_1 doesn't think
2709 we're filling it up. */
2710 where_is_cache
= Qnil
;
2711 result
= where_is_internal (definition
, keymaps
, firstonly
, noindirect
, no_remap
);
2717 /* This is the function that Fwhere_is_internal calls using map_char_table.
2719 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2721 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2722 Since map_char_table doesn't really use the return value from this function,
2723 we the result append to RESULT, the slot in ARGS.
2725 This function can GC because it calls where_is_internal_1 which can
2729 where_is_internal_2 (args
, key
, binding
)
2730 Lisp_Object args
, key
, binding
;
2732 Lisp_Object definition
, noindirect
, this, last
;
2733 Lisp_Object result
, sequence
;
2734 int nomenus
, last_is_meta
;
2735 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2737 GCPRO3 (args
, key
, binding
);
2738 result
= XCDR (XCAR (args
));
2739 definition
= XCAR (XCAR (XCAR (args
)));
2740 noindirect
= XCDR (XCAR (XCAR (args
)));
2741 this = XCAR (XCAR (XCDR (args
)));
2742 last
= XCDR (XCAR (XCDR (args
)));
2743 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2744 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2746 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
,
2747 this, last
, nomenus
, last_is_meta
);
2749 if (!NILP (sequence
))
2750 XSETCDR (XCAR (args
), Fcons (sequence
, result
));
2756 /* This function can GC because get_keyelt can. */
2759 where_is_internal_1 (binding
, key
, definition
, noindirect
, this, last
,
2760 nomenus
, last_is_meta
)
2761 Lisp_Object binding
, key
, definition
, noindirect
, this, last
;
2762 int nomenus
, last_is_meta
;
2764 Lisp_Object sequence
;
2766 /* Search through indirections unless that's not wanted. */
2767 if (NILP (noindirect
))
2768 binding
= get_keyelt (binding
, 0);
2770 /* End this iteration if this element does not match
2773 if (!(!NILP (where_is_cache
) /* everything "matches" during cache-fill. */
2774 || EQ (binding
, definition
)
2775 || (CONSP (definition
) && !NILP (Fequal (binding
, definition
)))))
2776 /* Doesn't match. */
2779 /* We have found a match. Construct the key sequence where we found it. */
2780 if (INTEGERP (key
) && last_is_meta
)
2782 sequence
= Fcopy_sequence (this);
2783 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2786 sequence
= append_key (this, key
);
2788 if (!NILP (where_is_cache
))
2790 Lisp_Object sequences
= Fgethash (binding
, where_is_cache
, Qnil
);
2791 Fputhash (binding
, Fcons (sequence
, sequences
), where_is_cache
);
2798 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2800 DEFUN ("describe-buffer-bindings", Fdescribe_buffer_bindings
, Sdescribe_buffer_bindings
, 1, 3, 0,
2801 doc
: /* Insert the list of all defined keys and their definitions.
2802 The list is inserted in the current buffer, while the bindings are
2803 looked up in BUFFER.
2804 The optional argument PREFIX, if non-nil, should be a key sequence;
2805 then we display only bindings that start with that prefix.
2806 The optional argument MENUS, if non-nil, says to mention menu bindings.
2807 \(Ordinarily these are omitted from the output.) */)
2808 (buffer
, prefix
, menus
)
2809 Lisp_Object buffer
, prefix
, menus
;
2811 Lisp_Object outbuf
, shadow
;
2812 int nomenu
= NILP (menus
);
2813 register Lisp_Object start1
;
2814 struct gcpro gcpro1
;
2816 char *alternate_heading
2818 Keyboard translations:\n\n\
2819 You type Translation\n\
2820 -------- -----------\n";
2825 outbuf
= Fcurrent_buffer ();
2827 /* Report on alternates for keys. */
2828 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2831 const unsigned char *translate
= SDATA (Vkeyboard_translate_table
);
2832 int translate_len
= SCHARS (Vkeyboard_translate_table
);
2834 for (c
= 0; c
< translate_len
; c
++)
2835 if (translate
[c
] != c
)
2837 char buf
[KEY_DESCRIPTION_SIZE
];
2840 if (alternate_heading
)
2842 insert_string (alternate_heading
);
2843 alternate_heading
= 0;
2846 bufend
= push_key_description (translate
[c
], buf
, 1);
2847 insert (buf
, bufend
- buf
);
2848 Findent_to (make_number (16), make_number (1));
2849 bufend
= push_key_description (c
, buf
, 1);
2850 insert (buf
, bufend
- buf
);
2854 /* Insert calls signal_after_change which may GC. */
2855 translate
= SDATA (Vkeyboard_translate_table
);
2861 if (!NILP (Vkey_translation_map
))
2862 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2863 "Key translations", nomenu
, 1, 0, 0);
2866 /* Print the (major mode) local map. */
2868 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2869 start1
= current_kboard
->Voverriding_terminal_local_map
;
2870 else if (!NILP (Voverriding_local_map
))
2871 start1
= Voverriding_local_map
;
2875 describe_map_tree (start1
, 1, shadow
, prefix
,
2876 "\f\nOverriding Bindings", nomenu
, 0, 0, 0);
2877 shadow
= Fcons (start1
, shadow
);
2881 /* Print the minor mode and major mode keymaps. */
2883 Lisp_Object
*modes
, *maps
;
2885 /* Temporarily switch to `buffer', so that we can get that buffer's
2886 minor modes correctly. */
2887 Fset_buffer (buffer
);
2889 nmaps
= current_minor_maps (&modes
, &maps
);
2890 Fset_buffer (outbuf
);
2892 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2893 XBUFFER (buffer
), Qkeymap
);
2896 describe_map_tree (start1
, 1, shadow
, prefix
,
2897 "\f\n`keymap' Property Bindings", nomenu
,
2899 shadow
= Fcons (start1
, shadow
);
2902 /* Print the minor mode maps. */
2903 for (i
= 0; i
< nmaps
; i
++)
2905 /* The title for a minor mode keymap
2906 is constructed at run time.
2907 We let describe_map_tree do the actual insertion
2908 because it takes care of other features when doing so. */
2911 if (!SYMBOLP (modes
[i
]))
2914 p
= title
= (char *) alloca (42 + SCHARS (SYMBOL_NAME (modes
[i
])));
2918 bcopy (SDATA (SYMBOL_NAME (modes
[i
])), p
,
2919 SCHARS (SYMBOL_NAME (modes
[i
])));
2920 p
+= SCHARS (SYMBOL_NAME (modes
[i
]));
2922 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2923 p
+= sizeof (" Minor Mode Bindings") - 1;
2926 describe_map_tree (maps
[i
], 1, shadow
, prefix
,
2927 title
, nomenu
, 0, 0, 0);
2928 shadow
= Fcons (maps
[i
], shadow
);
2931 start1
= get_local_map (BUF_PT (XBUFFER (buffer
)),
2932 XBUFFER (buffer
), Qlocal_map
);
2935 if (EQ (start1
, XBUFFER (buffer
)->keymap
))
2936 describe_map_tree (start1
, 1, shadow
, prefix
,
2937 "\f\nMajor Mode Bindings", nomenu
, 0, 0, 0);
2939 describe_map_tree (start1
, 1, shadow
, prefix
,
2940 "\f\n`local-map' Property Bindings",
2943 shadow
= Fcons (start1
, shadow
);
2947 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2948 "\f\nGlobal Bindings", nomenu
, 0, 1, 0);
2950 /* Print the function-key-map translations under this prefix. */
2951 if (!NILP (Vfunction_key_map
))
2952 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2953 "\f\nFunction key map translations", nomenu
, 1, 0, 0);
2959 /* Insert a description of the key bindings in STARTMAP,
2960 followed by those of all maps reachable through STARTMAP.
2961 If PARTIAL is nonzero, omit certain "uninteresting" commands
2962 (such as `undefined').
2963 If SHADOW is non-nil, it is a list of maps;
2964 don't mention keys which would be shadowed by any of them.
2965 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2966 TITLE, if not 0, is a string to insert at the beginning.
2967 TITLE should not end with a colon or a newline; we supply that.
2968 If NOMENU is not 0, then omit menu-bar commands.
2970 If TRANSL is nonzero, the definitions are actually key translations
2971 so print strings and vectors differently.
2973 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2976 If MENTION_SHADOW is nonzero, then when something is shadowed by SHADOW,
2977 don't omit it; instead, mention it but say it is shadowed. */
2980 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2981 always_title
, mention_shadow
)
2982 Lisp_Object startmap
, shadow
, prefix
;
2990 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2991 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2998 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
3001 GCPRO3 (maps
, seen
, sub_shadows
);
3007 /* Delete from MAPS each element that is for the menu bar. */
3008 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
3010 Lisp_Object elt
, prefix
, tem
;
3013 prefix
= Fcar (elt
);
3014 if (XVECTOR (prefix
)->size
>= 1)
3016 tem
= Faref (prefix
, make_number (0));
3017 if (EQ (tem
, Qmenu_bar
))
3018 maps
= Fdelq (elt
, maps
);
3023 if (!NILP (maps
) || always_title
)
3027 insert_string (title
);
3030 insert_string (" Starting With ");
3031 insert1 (Fkey_description (prefix
, Qnil
));
3033 insert_string (":\n");
3035 insert_string (key_heading
);
3039 for (; !NILP (maps
); maps
= Fcdr (maps
))
3041 register Lisp_Object elt
, prefix
, tail
;
3044 prefix
= Fcar (elt
);
3048 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
3052 shmap
= XCAR (tail
);
3054 /* If the sequence by which we reach this keymap is zero-length,
3055 then the shadow map for this keymap is just SHADOW. */
3056 if ((STRINGP (prefix
) && SCHARS (prefix
) == 0)
3057 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
3059 /* If the sequence by which we reach this keymap actually has
3060 some elements, then the sequence's definition in SHADOW is
3061 what we should use. */
3064 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
3065 if (INTEGERP (shmap
))
3069 /* If shmap is not nil and not a keymap,
3070 it completely shadows this map, so don't
3071 describe this map at all. */
3072 if (!NILP (shmap
) && !KEYMAPP (shmap
))
3076 sub_shadows
= Fcons (shmap
, sub_shadows
);
3079 /* Maps we have already listed in this loop shadow this map. */
3080 for (tail
= orig_maps
; !EQ (tail
, maps
); tail
= XCDR (tail
))
3083 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
3085 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
3088 describe_map (Fcdr (elt
), prefix
,
3089 transl
? describe_translation
: describe_command
,
3090 partial
, sub_shadows
, &seen
, nomenu
, mention_shadow
);
3096 insert_string ("\n");
3101 static int previous_description_column
;
3104 describe_command (definition
, args
)
3105 Lisp_Object definition
, args
;
3107 register Lisp_Object tem1
;
3108 int column
= (int) current_column (); /* iftc */
3109 int description_column
;
3111 /* If column 16 is no good, go to col 32;
3112 but don't push beyond that--go to next line instead. */
3116 description_column
= 32;
3118 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
3119 description_column
= 32;
3121 description_column
= 16;
3123 Findent_to (make_number (description_column
), make_number (1));
3124 previous_description_column
= description_column
;
3126 if (SYMBOLP (definition
))
3128 tem1
= SYMBOL_NAME (definition
);
3130 insert_string ("\n");
3132 else if (STRINGP (definition
) || VECTORP (definition
))
3133 insert_string ("Keyboard Macro\n");
3134 else if (KEYMAPP (definition
))
3135 insert_string ("Prefix Command\n");
3137 insert_string ("??\n");
3141 describe_translation (definition
, args
)
3142 Lisp_Object definition
, args
;
3144 register Lisp_Object tem1
;
3146 Findent_to (make_number (16), make_number (1));
3148 if (SYMBOLP (definition
))
3150 tem1
= SYMBOL_NAME (definition
);
3152 insert_string ("\n");
3154 else if (STRINGP (definition
) || VECTORP (definition
))
3156 insert1 (Fkey_description (definition
, Qnil
));
3157 insert_string ("\n");
3159 else if (KEYMAPP (definition
))
3160 insert_string ("Prefix Command\n");
3162 insert_string ("??\n");
3165 /* Describe the contents of map MAP, assuming that this map itself is
3166 reached by the sequence of prefix keys PREFIX (a string or vector).
3167 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
3170 describe_map (map
, prefix
, elt_describer
, partial
, shadow
,
3171 seen
, nomenu
, mention_shadow
)
3172 register Lisp_Object map
;
3174 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3181 Lisp_Object tail
, definition
, event
;
3183 Lisp_Object suppress
;
3186 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3191 suppress
= intern ("suppress-keymap");
3193 /* This vector gets used to present single keys to Flookup_key. Since
3194 that is done once per keymap element, we don't want to cons up a
3195 fresh vector every time. */
3196 kludge
= Fmake_vector (make_number (1), Qnil
);
3199 GCPRO3 (prefix
, definition
, kludge
);
3201 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
3205 if (VECTORP (XCAR (tail
))
3206 || CHAR_TABLE_P (XCAR (tail
)))
3207 describe_vector (XCAR (tail
),
3208 prefix
, Qnil
, elt_describer
, partial
, shadow
, map
,
3209 (int *)0, 0, 1, mention_shadow
);
3210 else if (CONSP (XCAR (tail
)))
3212 int this_shadowed
= 0;
3213 event
= XCAR (XCAR (tail
));
3215 /* Ignore bindings whose "prefix" are not really valid events.
3216 (We get these in the frames and buffers menu.) */
3217 if (!(SYMBOLP (event
) || INTEGERP (event
)))
3220 if (nomenu
&& EQ (event
, Qmenu_bar
))
3223 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
3225 /* Don't show undefined commands or suppressed commands. */
3226 if (NILP (definition
)) continue;
3227 if (SYMBOLP (definition
) && partial
)
3229 tem
= Fget (definition
, suppress
);
3234 /* Don't show a command that isn't really visible
3235 because a local definition of the same key shadows it. */
3237 ASET (kludge
, 0, event
);
3240 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3250 tem
= Flookup_key (map
, kludge
, Qt
);
3251 if (!EQ (tem
, definition
)) continue;
3255 previous_description_column
= 0;
3260 /* THIS gets the string to describe the character EVENT. */
3261 insert1 (Fkey_description (kludge
, prefix
));
3263 /* Print a description of the definition of this character.
3264 elt_describer will take care of spacing out far enough
3265 for alignment purposes. */
3266 (*elt_describer
) (definition
, Qnil
);
3271 insert_string (" (binding currently shadowed)");
3275 else if (EQ (XCAR (tail
), Qkeymap
))
3277 /* The same keymap might be in the structure twice, if we're
3278 using an inherited keymap. So skip anything we've already
3280 tem
= Fassq (tail
, *seen
);
3281 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), prefix
)))
3283 *seen
= Fcons (Fcons (tail
, prefix
), *seen
);
3291 describe_vector_princ (elt
, fun
)
3292 Lisp_Object elt
, fun
;
3294 Findent_to (make_number (16), make_number (1));
3299 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 2, 0,
3300 doc
: /* Insert a description of contents of VECTOR.
3301 This is text showing the elements of vector matched against indices.
3302 DESCRIBER is the output function used; nil means use `princ'. */)
3304 Lisp_Object vector
, describer
;
3306 int count
= SPECPDL_INDEX ();
3307 if (NILP (describer
))
3308 describer
= intern ("princ");
3309 specbind (Qstandard_output
, Fcurrent_buffer ());
3310 CHECK_VECTOR_OR_CHAR_TABLE (vector
);
3311 describe_vector (vector
, Qnil
, describer
, describe_vector_princ
, 0,
3312 Qnil
, Qnil
, (int *)0, 0, 0, 0);
3314 return unbind_to (count
, Qnil
);
3317 /* Insert in the current buffer a description of the contents of VECTOR.
3318 We call ELT_DESCRIBER to insert the description of one value found
3321 ELT_PREFIX describes what "comes before" the keys or indices defined
3322 by this vector. This is a human-readable string whose size
3323 is not necessarily related to the situation.
3325 If the vector is in a keymap, ELT_PREFIX is a prefix key which
3326 leads to this keymap.
3328 If the vector is a chartable, ELT_PREFIX is the vector
3329 of bytes that lead to the character set or portion of a character
3330 set described by this chartable.
3332 If PARTIAL is nonzero, it means do not mention suppressed commands
3333 (that assumes the vector is in a keymap).
3335 SHADOW is a list of keymaps that shadow this map.
3336 If it is non-nil, then we look up the key in those maps
3337 and we don't mention it now if it is defined by any of them.
3339 ENTIRE_MAP is the keymap in which this vector appears.
3340 If the definition in effect in the whole map does not match
3341 the one in this vector, we ignore this one.
3343 When describing a sub-char-table, INDICES is a list of
3344 indices at higher levels in this char-table,
3345 and CHAR_TABLE_DEPTH says how many levels down we have gone.
3347 KEYMAP_P is 1 if vector is known to be a keymap, so map ESC to M-.
3349 ARGS is simply passed as the second argument to ELT_DESCRIBER. */
3352 describe_vector (vector
, prefix
, args
, elt_describer
,
3353 partial
, shadow
, entire_map
,
3354 indices
, char_table_depth
, keymap_p
,
3356 register Lisp_Object vector
;
3357 Lisp_Object prefix
, args
;
3358 void (*elt_describer
) P_ ((Lisp_Object
, Lisp_Object
));
3361 Lisp_Object entire_map
;
3363 int char_table_depth
;
3367 Lisp_Object definition
;
3369 Lisp_Object elt_prefix
= Qnil
;
3371 Lisp_Object suppress
;
3374 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3375 /* Range of elements to be handled. */
3377 /* A flag to tell if a leaf in this level of char-table is not a
3378 generic character (i.e. a complete multibyte character). */
3386 indices
= (int *) alloca (3 * sizeof (int));
3392 /* Call Fkey_description first, to avoid GC bug for the other string. */
3393 if (!NILP (prefix
) && XFASTINT (Flength (prefix
)) > 0)
3396 tem
= Fkey_description (prefix
, Qnil
);
3397 elt_prefix
= concat2 (tem
, build_string (" "));
3402 /* This vector gets used to present single keys to Flookup_key. Since
3403 that is done once per vector element, we don't want to cons up a
3404 fresh vector every time. */
3405 kludge
= Fmake_vector (make_number (1), Qnil
);
3406 GCPRO4 (elt_prefix
, prefix
, definition
, kludge
);
3409 suppress
= intern ("suppress-keymap");
3411 if (CHAR_TABLE_P (vector
))
3413 if (char_table_depth
== 0)
3415 /* VECTOR is a top level char-table. */
3418 to
= CHAR_TABLE_ORDINARY_SLOTS
;
3422 /* VECTOR is a sub char-table. */
3423 if (char_table_depth
>= 3)
3424 /* A char-table is never that deep. */
3425 error ("Too deep char table");
3428 = (CHARSET_VALID_P (indices
[0])
3429 && ((CHARSET_DIMENSION (indices
[0]) == 1
3430 && char_table_depth
== 1)
3431 || char_table_depth
== 2));
3433 /* Meaningful elements are from 32th to 127th. */
3435 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3440 /* This does the right thing for ordinary vectors. */
3444 to
= XVECTOR (vector
)->size
;
3447 for (i
= from
; i
< to
; i
++)
3449 int this_shadowed
= 0;
3452 if (CHAR_TABLE_P (vector
))
3454 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3457 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3458 && !CHARSET_DEFINED_P (i
- 128))
3462 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3465 definition
= get_keyelt (AREF (vector
, i
), 0);
3467 if (NILP (definition
)) continue;
3469 /* Don't mention suppressed commands. */
3470 if (SYMBOLP (definition
) && partial
)
3474 tem
= Fget (definition
, suppress
);
3476 if (!NILP (tem
)) continue;
3479 /* Set CHARACTER to the character this entry describes, if any.
3480 Also update *INDICES. */
3481 if (CHAR_TABLE_P (vector
))
3483 indices
[char_table_depth
] = i
;
3485 if (char_table_depth
== 0)
3488 indices
[0] = i
- 128;
3490 else if (complete_char
)
3492 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3500 ASET (kludge
, 0, make_number (character
));
3502 /* If this binding is shadowed by some other map, ignore it. */
3503 if (!NILP (shadow
) && complete_char
)
3507 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3518 /* Ignore this definition if it is shadowed by an earlier
3519 one in the same keymap. */
3520 if (!NILP (entire_map
) && complete_char
)
3524 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3526 if (!EQ (tem
, definition
))
3532 if (char_table_depth
== 0)
3537 /* For a sub char-table, show the depth by indentation.
3538 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3539 if (char_table_depth
> 0)
3540 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3542 /* Output the prefix that applies to every entry in this map. */
3543 if (!NILP (elt_prefix
))
3544 insert1 (elt_prefix
);
3546 /* Insert or describe the character this slot is for,
3547 or a description of what it is for. */
3548 if (SUB_CHAR_TABLE_P (vector
))
3551 insert_char (character
);
3554 /* We need an octal representation for this block of
3557 sprintf (work
, "(row %d)", i
);
3558 insert (work
, strlen (work
));
3561 else if (CHAR_TABLE_P (vector
))
3564 insert1 (Fkey_description (kludge
, prefix
));
3567 /* Print the information for this character set. */
3568 insert_string ("<");
3569 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3571 insert_from_string (tem2
, 0, 0, SCHARS (tem2
),
3580 insert1 (Fkey_description (kludge
, prefix
));
3583 /* If we find a sub char-table within a char-table,
3584 scan it recursively; it defines the details for
3585 a character set or a portion of a character set. */
3586 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3589 describe_vector (definition
, prefix
, args
, elt_describer
,
3590 partial
, shadow
, entire_map
,
3591 indices
, char_table_depth
+ 1, keymap_p
,
3598 /* Find all consecutive characters or rows that have the same
3599 definition. But, for elements of a top level char table, if
3600 they are for charsets, we had better describe one by one even
3601 if they have the same definition. */
3602 if (CHAR_TABLE_P (vector
))
3606 if (char_table_depth
== 0)
3607 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3609 while (i
+ 1 < limit
3610 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3612 && !NILP (Fequal (tem2
, definition
)))
3617 && (tem2
= get_keyelt (AREF (vector
, i
+ 1), 0),
3619 && !NILP (Fequal (tem2
, definition
)))
3623 /* If we have a range of more than one character,
3624 print where the range reaches to. */
3626 if (i
!= starting_i
)
3630 ASET (kludge
, 0, make_number (i
));
3632 if (!NILP (elt_prefix
))
3633 insert1 (elt_prefix
);
3635 if (CHAR_TABLE_P (vector
))
3637 if (char_table_depth
== 0)
3639 insert1 (Fkey_description (kludge
, prefix
));
3641 else if (complete_char
)
3643 indices
[char_table_depth
] = i
;
3644 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3645 insert_char (character
);
3649 /* We need an octal representation for this block of
3652 sprintf (work
, "(row %d)", i
);
3653 insert (work
, strlen (work
));
3658 insert1 (Fkey_description (kludge
, prefix
));
3662 /* Print a description of the definition of this character.
3663 elt_describer will take care of spacing out far enough
3664 for alignment purposes. */
3665 (*elt_describer
) (definition
, args
);
3670 insert_string (" (binding currently shadowed)");
3675 /* For (sub) char-table, print `defalt' slot at last. */
3676 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3678 insert (" ", char_table_depth
* 2);
3679 insert_string ("<<default>>");
3680 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
, args
);
3686 /* Apropos - finding all symbols whose names match a regexp. */
3687 static Lisp_Object apropos_predicate
;
3688 static Lisp_Object apropos_accumulate
;
3691 apropos_accum (symbol
, string
)
3692 Lisp_Object symbol
, string
;
3694 register Lisp_Object tem
;
3696 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3697 if (!NILP (tem
) && !NILP (apropos_predicate
))
3698 tem
= call1 (apropos_predicate
, symbol
);
3700 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3703 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3704 doc
: /* Show all symbols whose names contain match for REGEXP.
3705 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done
3706 for each symbol and a symbol is mentioned only if that returns non-nil.
3707 Return list of symbols found. */)
3709 Lisp_Object regexp
, predicate
;
3712 CHECK_STRING (regexp
);
3713 apropos_predicate
= predicate
;
3714 apropos_accumulate
= Qnil
;
3715 map_obarray (Vobarray
, apropos_accum
, regexp
);
3716 tem
= Fsort (apropos_accumulate
, Qstring_lessp
);
3717 apropos_accumulate
= Qnil
;
3718 apropos_predicate
= Qnil
;
3725 Qkeymap
= intern ("keymap");
3726 staticpro (&Qkeymap
);
3727 staticpro (&apropos_predicate
);
3728 staticpro (&apropos_accumulate
);
3729 apropos_predicate
= Qnil
;
3730 apropos_accumulate
= Qnil
;
3732 /* Now we are ready to set up this property, so we can
3733 create char tables. */
3734 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3736 /* Initialize the keymaps standardly used.
3737 Each one is the value of a Lisp variable, and is also
3738 pointed to by a C variable */
3740 global_map
= Fmake_keymap (Qnil
);
3741 Fset (intern ("global-map"), global_map
);
3743 current_global_map
= global_map
;
3744 staticpro (&global_map
);
3745 staticpro (¤t_global_map
);
3747 meta_map
= Fmake_keymap (Qnil
);
3748 Fset (intern ("esc-map"), meta_map
);
3749 Ffset (intern ("ESC-prefix"), meta_map
);
3751 control_x_map
= Fmake_keymap (Qnil
);
3752 Fset (intern ("ctl-x-map"), control_x_map
);
3753 Ffset (intern ("Control-X-prefix"), control_x_map
);
3756 = Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
3757 Fcons (Fcons (build_string ("TAB"), build_string ("\\t")),
3758 Fcons (Fcons (build_string ("RET"), build_string ("\\r")),
3759 Fcons (Fcons (build_string ("ESC"), build_string ("\\e")),
3760 Fcons (Fcons (build_string ("SPC"), build_string (" ")),
3762 staticpro (&exclude_keys
);
3764 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3765 doc
: /* List of commands given new key bindings recently.
3766 This is used for internal purposes during Emacs startup;
3767 don't alter it yourself. */);
3768 Vdefine_key_rebound_commands
= Qt
;
3770 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3771 doc
: /* Default keymap to use when reading from the minibuffer. */);
3772 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3774 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3775 doc
: /* Local keymap for the minibuffer when spaces are not allowed. */);
3776 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3777 Fset_keymap_parent (Vminibuffer_local_ns_map
, Vminibuffer_local_map
);
3779 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3780 doc
: /* Local keymap for minibuffer input with completion. */);
3781 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3782 Fset_keymap_parent (Vminibuffer_local_completion_map
, Vminibuffer_local_map
);
3784 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3785 doc
: /* Local keymap for minibuffer input with completion, for exact match. */);
3786 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3787 Fset_keymap_parent (Vminibuffer_local_must_match_map
,
3788 Vminibuffer_local_completion_map
);
3790 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3791 doc
: /* Alist of keymaps to use for minor modes.
3792 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read
3793 key sequences and look up bindings iff VARIABLE's value is non-nil.
3794 If two active keymaps bind the same key, the keymap appearing earlier
3795 in the list takes precedence. */);
3796 Vminor_mode_map_alist
= Qnil
;
3798 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3799 doc
: /* Alist of keymaps to use for minor modes, in current major mode.
3800 This variable is an alist just like `minor-mode-map-alist', and it is
3801 used the same way (and before `minor-mode-map-alist'); however,
3802 it is provided for major modes to bind locally. */);
3803 Vminor_mode_overriding_map_alist
= Qnil
;
3805 DEFVAR_LISP ("emulation-mode-map-alists", &Vemulation_mode_map_alists
,
3806 doc
: /* List of keymap alists to use for emulations modes.
3807 It is intended for modes or packages using multiple minor-mode keymaps.
3808 Each element is a keymap alist just like `minor-mode-map-alist', or a
3809 symbol with a variable binding which is a keymap alist, and it is used
3810 the same way. The "active" keymaps in each alist are used before
3811 `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
3812 Vemulation_mode_map_alists
= Qnil
;
3815 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3816 doc
: /* Keymap mapping ASCII function key sequences onto their preferred forms.
3817 This allows Emacs to recognize function keys sent from ASCII
3818 terminals at any point in a key sequence.
3820 The `read-key-sequence' function replaces any subsequence bound by
3821 `function-key-map' with its binding. More precisely, when the active
3822 keymaps have no binding for the current key sequence but
3823 `function-key-map' binds a suffix of the sequence to a vector or string,
3824 `read-key-sequence' replaces the matching suffix with its binding, and
3825 continues with the new sequence.
3827 The events that come from bindings in `function-key-map' are not
3828 themselves looked up in `function-key-map'.
3830 For example, suppose `function-key-map' binds `ESC O P' to [f1].
3831 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
3832 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
3833 key, typing `ESC O P x' would return [f1 x]. */);
3834 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3836 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3837 doc
: /* Keymap of key translations that can override keymaps.
3838 This keymap works like `function-key-map', but comes after that,
3839 and its non-prefix bindings override ordinary bindings. */);
3840 Vkey_translation_map
= Qnil
;
3842 staticpro (&Vmouse_events
);
3843 Vmouse_events
= Fcons (intern ("menu-bar"),
3844 Fcons (intern ("tool-bar"),
3845 Fcons (intern ("header-line"),
3846 Fcons (intern ("mode-line"),
3847 Fcons (intern ("mouse-1"),
3848 Fcons (intern ("mouse-2"),
3849 Fcons (intern ("mouse-3"),
3850 Fcons (intern ("mouse-4"),
3851 Fcons (intern ("mouse-5"),
3855 Qsingle_key_description
= intern ("single-key-description");
3856 staticpro (&Qsingle_key_description
);
3858 Qkey_description
= intern ("key-description");
3859 staticpro (&Qkey_description
);
3861 Qkeymapp
= intern ("keymapp");
3862 staticpro (&Qkeymapp
);
3864 Qnon_ascii
= intern ("non-ascii");
3865 staticpro (&Qnon_ascii
);
3867 Qmenu_item
= intern ("menu-item");
3868 staticpro (&Qmenu_item
);
3870 Qremap
= intern ("remap");
3871 staticpro (&Qremap
);
3873 command_remapping_vector
= Fmake_vector (make_number (2), Qremap
);
3874 staticpro (&command_remapping_vector
);
3876 where_is_cache_keymaps
= Qt
;
3877 where_is_cache
= Qnil
;
3878 staticpro (&where_is_cache
);
3879 staticpro (&where_is_cache_keymaps
);
3881 defsubr (&Skeymapp
);
3882 defsubr (&Skeymap_parent
);
3883 defsubr (&Skeymap_prompt
);
3884 defsubr (&Sset_keymap_parent
);
3885 defsubr (&Smake_keymap
);
3886 defsubr (&Smake_sparse_keymap
);
3887 defsubr (&Smap_keymap
);
3888 defsubr (&Scopy_keymap
);
3889 defsubr (&Scommand_remapping
);
3890 defsubr (&Skey_binding
);
3891 defsubr (&Slocal_key_binding
);
3892 defsubr (&Sglobal_key_binding
);
3893 defsubr (&Sminor_mode_key_binding
);
3894 defsubr (&Sdefine_key
);
3895 defsubr (&Slookup_key
);
3896 defsubr (&Sdefine_prefix_command
);
3897 defsubr (&Suse_global_map
);
3898 defsubr (&Suse_local_map
);
3899 defsubr (&Scurrent_local_map
);
3900 defsubr (&Scurrent_global_map
);
3901 defsubr (&Scurrent_minor_mode_maps
);
3902 defsubr (&Scurrent_active_maps
);
3903 defsubr (&Saccessible_keymaps
);
3904 defsubr (&Skey_description
);
3905 defsubr (&Sdescribe_vector
);
3906 defsubr (&Ssingle_key_description
);
3907 defsubr (&Stext_char_description
);
3908 defsubr (&Swhere_is_internal
);
3909 defsubr (&Sdescribe_buffer_bindings
);
3910 defsubr (&Sapropos_internal
);
3916 initial_define_key (global_map
, 033, "ESC-prefix");
3917 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");
3920 /* arch-tag: 6dd15c26-7cf1-41c4-b904-f42f7ddda463
3921 (do not change this comment) */