1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
28 #include "termhooks.h"
29 #include "blockinput.h"
31 #define min(a, b) ((a) < (b) ? (a) : (b))
33 /* The number of elements in keymap vectors. */
34 #define DENSE_TABLE_SIZE (0200)
36 /* Actually allocate storage for these variables */
38 Lisp_Object current_global_map
; /* Current global keymap */
40 Lisp_Object global_map
; /* default global key bindings */
42 Lisp_Object meta_map
; /* The keymap used for globally bound
43 ESC-prefixed default commands */
45 Lisp_Object control_x_map
; /* The keymap used for globally bound
46 C-x-prefixed default commands */
48 /* was MinibufLocalMap */
49 Lisp_Object Vminibuffer_local_map
;
50 /* The keymap used by the minibuf for local
51 bindings when spaces are allowed in the
54 /* was MinibufLocalNSMap */
55 Lisp_Object Vminibuffer_local_ns_map
;
56 /* The keymap used by the minibuf for local
57 bindings when spaces are not encouraged
60 /* keymap used for minibuffers when doing completion */
61 /* was MinibufLocalCompletionMap */
62 Lisp_Object Vminibuffer_local_completion_map
;
64 /* keymap used for minibuffers when doing completion and require a match */
65 /* was MinibufLocalMustMatchMap */
66 Lisp_Object Vminibuffer_local_must_match_map
;
68 /* Alist of minor mode variables and keymaps. */
69 Lisp_Object Vminor_mode_map_alist
;
71 /* Keymap mapping ASCII function key sequences onto their preferred forms.
72 Initialized by the terminal-specific lisp files. See DEFVAR for more
74 Lisp_Object Vfunction_key_map
;
76 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
;
78 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
79 in a string key sequence is equivalent to prefixing with this
81 extern Lisp_Object meta_prefix_char
;
83 void describe_map_tree ();
84 static Lisp_Object
define_as_prefix ();
85 static Lisp_Object
describe_buffer_bindings ();
86 static void describe_command ();
87 static void describe_map ();
88 static void describe_map_2 ();
90 /* Keymap object support - constructors and predicates. */
92 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
93 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
94 VECTOR is a vector which holds the bindings for the ASCII\n\
95 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
96 mouse events, and any other things that appear in the input stream.\n\
97 All entries in it are initially nil, meaning \"command undefined\".\n\n\
98 The optional arg STRING supplies a menu name for the keymap\n\
99 in case you use it as a menu with `x-popup-menu'.")
105 tail
= Fcons (string
, Qnil
);
108 return Fcons (Qkeymap
,
109 Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE
), Qnil
),
113 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
114 "Construct and return a new sparse-keymap list.\n\
115 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
116 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
117 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
118 Initially the alist is nil.\n\n\
119 The optional arg STRING supplies a menu name for the keymap\n\
120 in case you use it as a menu with `x-popup-menu'.")
125 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
126 return Fcons (Qkeymap
, Qnil
);
129 /* This function is used for installing the standard key bindings
130 at initialization time.
134 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
137 initial_define_key (keymap
, key
, defname
)
142 store_in_keymap (keymap
, make_number (key
), intern (defname
));
146 initial_define_lispy_key (keymap
, keyname
, defname
)
151 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
154 /* Define character fromchar in map frommap as an alias for character
155 tochar in map tomap. Subsequent redefinitions of the latter WILL
156 affect the former. */
160 synkey (frommap
, fromchar
, tomap
, tochar
)
161 struct Lisp_Vector
*frommap
, *tomap
;
162 int fromchar
, tochar
;
165 XSET (v
, Lisp_Vector
, tomap
);
166 XFASTINT (c
) = tochar
;
167 frommap
->contents
[fromchar
] = Fcons (v
, c
);
171 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
172 "Return t if ARG is a keymap.\n\
174 A keymap is a list (keymap . ALIST),\n\
175 or a symbol whose function definition is a keymap is itself a keymap.\n\
176 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
177 a vector of densely packed bindings for small character codes\n\
178 is also allowed as an element.")
182 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
185 /* Check that OBJECT is a keymap (after dereferencing through any
186 symbols). If it is, return it.
188 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
189 is an autoload form, do the autoload and try again.
191 ERROR controls how we respond if OBJECT isn't a keymap.
192 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
194 Note that most of the time, we don't want to pursue autoloads.
195 Functions like Faccessible_keymaps which scan entire keymap trees
196 shouldn't load every autoloaded keymap. I'm not sure about this,
197 but it seems to me that only read_key_sequence, Flookup_key, and
198 Fdefine_key should cause keymaps to be autoloaded. */
201 get_keymap_1 (object
, error
, autoload
)
208 tem
= indirect_function (object
);
209 if (CONSP (tem
) && EQ (XCONS (tem
)->car
, Qkeymap
))
212 /* Should we do an autoload? Autoload forms for keymaps have
213 Qkeymap as their fifth element. */
215 && XTYPE (object
) == Lisp_Symbol
217 && EQ (XCONS (tem
)->car
, Qautoload
))
221 tail
= Fnth (make_number (4), tem
);
222 if (EQ (tail
, Qkeymap
))
224 struct gcpro gcpro1
, gcpro2
;
226 GCPRO2 (tem
, object
);
227 do_autoload (tem
, object
);
235 wrong_type_argument (Qkeymapp
, object
);
241 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
242 If OBJECT doesn't denote a keymap at all, signal an error. */
247 return get_keymap_1 (object
, 0, 0);
251 /* Look up IDX in MAP. IDX may be any sort of event.
252 Note that this does only one level of lookup; IDX must be a single
253 event, not a sequence.
255 If T_OK is non-zero, bindings for Qt are treated as default
256 bindings; any key left unmentioned by other tables and bindings is
257 given the binding of Qt.
259 If T_OK is zero, bindings for Qt are not treated specially.
261 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
264 access_keymap (map
, idx
, t_ok
, noinherit
)
273 /* If idx is a list (some sort of mouse click, perhaps?),
274 the index we want to use is the car of the list, which
275 ought to be a symbol. */
276 idx
= EVENT_HEAD (idx
);
278 /* If idx is a symbol, it might have modifiers, which need to
279 be put in the canonical order. */
280 if (XTYPE (idx
) == Lisp_Symbol
)
281 idx
= reorder_modifiers (idx
);
282 else if (INTEGERP (idx
))
283 /* Clobber the high bits that can be present on a machine
284 with more than 24 bits of integer. */
285 XFASTINT (idx
) = XINT (idx
) & (CHAR_META
| (CHAR_META
- 1));
289 Lisp_Object t_binding
= Qnil
;
291 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
293 Lisp_Object binding
= XCONS (tail
)->car
;
295 switch (XTYPE (binding
))
298 /* If NOINHERIT, stop finding prefix definitions
299 after we pass a second occurrence of the `keymap' symbol. */
300 if (noinherit
&& EQ (binding
, Qkeymap
) && ! EQ (tail
, map
))
305 if (EQ (XCONS (binding
)->car
, idx
))
307 val
= XCONS (binding
)->cdr
;
308 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
312 if (t_ok
&& EQ (XCONS (binding
)->car
, Qt
))
313 t_binding
= XCONS (binding
)->cdr
;
317 if (XTYPE (idx
) == Lisp_Int
319 && XINT (idx
) < XVECTOR (binding
)->size
)
321 val
= XVECTOR (binding
)->contents
[XINT (idx
)];
322 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
336 /* Given OBJECT which was found in a slot in a keymap,
337 trace indirect definitions to get the actual definition of that slot.
338 An indirect definition is a list of the form
339 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
340 and INDEX is the object to look up in KEYMAP to yield the definition.
342 Also if OBJECT has a menu string as the first element,
343 remove that. Also remove a menu help string as second element. */
347 register Lisp_Object object
;
351 register Lisp_Object map
, tem
;
353 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
354 map
= get_keymap_1 (Fcar_safe (object
), 0, 0);
355 tem
= Fkeymapp (map
);
357 object
= access_keymap (map
, Fcdr (object
), 0, 0);
359 /* If the keymap contents looks like (STRING . DEFN),
361 Keymap alist elements like (CHAR MENUSTRING . DEFN)
362 will be used by HierarKey menus. */
363 else if (XTYPE (object
) == Lisp_Cons
364 && XTYPE (XCONS (object
)->car
) == Lisp_String
)
366 object
= XCONS (object
)->cdr
;
367 /* Also remove a menu help string, if any,
368 following the menu item name. */
369 if (XTYPE (object
) == Lisp_Cons
370 && XTYPE (XCONS (object
)->car
) == Lisp_String
)
371 object
= XCONS (object
)->cdr
;
375 /* Anything else is really the value. */
381 store_in_keymap (keymap
, idx
, def
)
383 register Lisp_Object idx
;
384 register Lisp_Object def
;
386 if (XTYPE (keymap
) != Lisp_Cons
387 || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
388 error ("attempt to define a key in a non-keymap");
390 /* If idx is a list (some sort of mouse click, perhaps?),
391 the index we want to use is the car of the list, which
392 ought to be a symbol. */
393 idx
= EVENT_HEAD (idx
);
395 /* If idx is a symbol, it might have modifiers, which need to
396 be put in the canonical order. */
397 if (XTYPE (idx
) == Lisp_Symbol
)
398 idx
= reorder_modifiers (idx
);
399 else if (INTEGERP (idx
))
400 /* Clobber the high bits that can be present on a machine
401 with more than 24 bits of integer. */
402 XFASTINT (idx
) = XINT (idx
) & (CHAR_META
| (CHAR_META
- 1));
404 /* Scan the keymap for a binding of idx. */
408 /* The cons after which we should insert new bindings. If the
409 keymap has a table element, we record its position here, so new
410 bindings will go after it; this way, the table will stay
411 towards the front of the alist and character lookups in dense
412 keymaps will remain fast. Otherwise, this just points at the
413 front of the keymap. */
414 Lisp_Object insertion_point
= keymap
;
416 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
418 Lisp_Object elt
= XCONS (tail
)->car
;
423 if (XTYPE (idx
) == Lisp_Int
424 && XINT (idx
) >= 0 && XINT (idx
) < XVECTOR (elt
)->size
)
426 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
429 insertion_point
= tail
;
433 if (EQ (idx
, XCONS (elt
)->car
))
435 XCONS (elt
)->cdr
= def
;
441 /* If we find a 'keymap' symbol in the spine of KEYMAP,
442 then we must have found the start of a second keymap
443 being used as the tail of KEYMAP, and a binding for IDX
444 should be inserted before it. */
445 if (EQ (elt
, Qkeymap
))
454 /* We have scanned the entire keymap, and not found a binding for
455 IDX. Let's add one. */
456 XCONS (insertion_point
)->cdr
=
457 Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
464 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
465 "Return a copy of the keymap KEYMAP.\n\
466 The copy starts out with the same definitions of KEYMAP,\n\
467 but changing either the copy or KEYMAP does not affect the other.\n\
468 Any key definitions that are subkeymaps are recursively copied.\n\
469 However, a key definition which is a symbol whose definition is a keymap\n\
474 register Lisp_Object copy
, tail
;
476 copy
= Fcopy_alist (get_keymap (keymap
));
478 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
480 Lisp_Object elt
= XCONS (tail
)->car
;
482 if (XTYPE (elt
) == Lisp_Vector
)
486 elt
= Fcopy_sequence (elt
);
487 XCONS (tail
)->car
= elt
;
489 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
490 if (XTYPE (XVECTOR (elt
)->contents
[i
]) != Lisp_Symbol
491 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
492 XVECTOR (elt
)->contents
[i
] =
493 Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
496 && XTYPE (XCONS (elt
)->cdr
) != Lisp_Symbol
497 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
498 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
504 /* Simple Keymap mutators and accessors. */
506 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
507 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
508 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
509 meaning a sequence of keystrokes and events.\n\
510 DEF is anything that can be a key's definition:\n\
511 nil (means key is undefined in this keymap),\n\
512 a command (a Lisp function suitable for interactive calling)\n\
513 a string (treated as a keyboard macro),\n\
514 a keymap (to define a prefix key),\n\
515 a symbol. When the key is looked up, the symbol will stand for its\n\
516 function definition, which should at that time be one of the above,\n\
517 or another symbol whose function definition is used, etc.\n\
518 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
519 (DEFN should be a valid definition in its own right),\n\
520 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
522 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
523 the front of KEYMAP.")
530 register Lisp_Object c
;
531 register Lisp_Object tem
;
532 register Lisp_Object cmd
;
536 struct gcpro gcpro1
, gcpro2
, gcpro3
;
538 keymap
= get_keymap (keymap
);
540 if (XTYPE (key
) != Lisp_Vector
541 && XTYPE (key
) != Lisp_String
)
542 key
= wrong_type_argument (Qarrayp
, key
);
544 length
= XFASTINT (Flength (key
));
548 GCPRO3 (keymap
, key
, def
);
550 if (XTYPE (key
) == Lisp_Vector
)
551 meta_bit
= meta_modifier
;
558 c
= Faref (key
, make_number (idx
));
560 if (XTYPE (c
) == Lisp_Int
561 && (XINT (c
) & meta_bit
)
564 c
= meta_prefix_char
;
569 if (XTYPE (c
) == Lisp_Int
)
570 XSETINT (c
, XINT (c
) & ~meta_bit
);
577 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
579 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1));
581 /* If this key is undefined, make it a prefix. */
583 cmd
= define_as_prefix (keymap
, c
);
585 keymap
= get_keymap_1 (cmd
, 0, 1);
588 /* We must use Fkey_description rather than just passing key to
589 error; key might be a vector, not a string. */
590 Lisp_Object description
= Fkey_description (key
);
592 error ("Key sequence %s uses invalid prefix characters",
593 XSTRING (description
)->data
);
598 /* Value is number if KEY is too long; NIL if valid but has no definition. */
600 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
601 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
602 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
604 A number as value means KEY is \"too long\";\n\
605 that is, characters or symbols in it except for the last one\n\
606 fail to be a valid sequence of prefix characters in KEYMAP.\n\
607 The number is how many characters at the front of KEY\n\
608 it takes to reach a non-prefix command.\n\
610 Normally, `lookup-key' ignores bindings for t, which act as default\n\
611 bindings, used when nothing else in the keymap applies; this makes it\n\
612 useable as a general function for probing keymaps. However, if the\n\
613 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
614 recognize the default bindings, just as `read-key-sequence' does.")
615 (keymap
, key
, accept_default
)
616 register Lisp_Object keymap
;
618 Lisp_Object accept_default
;
621 register Lisp_Object tem
;
622 register Lisp_Object cmd
;
623 register Lisp_Object c
;
626 int t_ok
= ! NILP (accept_default
);
629 keymap
= get_keymap (keymap
);
631 if (XTYPE (key
) != Lisp_Vector
632 && XTYPE (key
) != Lisp_String
)
633 key
= wrong_type_argument (Qarrayp
, key
);
635 length
= XFASTINT (Flength (key
));
639 if (XTYPE (key
) == Lisp_Vector
)
640 meta_bit
= meta_modifier
;
647 c
= Faref (key
, make_number (idx
));
649 if (XTYPE (c
) == Lisp_Int
650 && (XINT (c
) & meta_bit
)
653 c
= meta_prefix_char
;
658 if (XTYPE (c
) == Lisp_Int
)
659 XSETINT (c
, XINT (c
) & ~meta_bit
);
665 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0));
669 keymap
= get_keymap_1 (cmd
, 0, 0);
671 return make_number (idx
);
677 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
678 Assume that currently it does not define C at all.
679 Return the keymap. */
682 define_as_prefix (keymap
, c
)
683 Lisp_Object keymap
, c
;
685 Lisp_Object inherit
, cmd
;
687 cmd
= Fmake_sparse_keymap (Qnil
);
688 /* If this key is defined as a prefix in an inherited keymap,
689 make it a prefix in this map, and make its definition
690 inherit the other prefix definition. */
691 inherit
= access_keymap (keymap
, c
, 0, 0);
694 /* If there's an inherited keymap
695 and it doesn't define this key,
696 make it define this key. */
699 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
700 if (EQ (XCONS (tail
)->car
, Qkeymap
))
704 inherit
= define_as_prefix (tail
, c
);
707 cmd
= nconc2 (cmd
, inherit
);
708 store_in_keymap (keymap
, c
, cmd
);
713 /* Append a key to the end of a key sequence. We always make a vector. */
716 append_key (key_sequence
, key
)
717 Lisp_Object key_sequence
, key
;
721 args
[0] = key_sequence
;
723 args
[1] = Fcons (key
, Qnil
);
724 return Fvconcat (2, args
);
728 /* Global, local, and minor mode keymap stuff. */
730 /* We can't put these variables inside current_minor_maps, since under
731 some systems, static gets macro-defined to be the empty string.
733 static Lisp_Object
*cmm_modes
, *cmm_maps
;
736 /* Store a pointer to an array of the keymaps of the currently active
737 minor modes in *buf, and return the number of maps it contains.
739 This function always returns a pointer to the same buffer, and may
740 free or reallocate it, so if you want to keep it for a long time or
741 hand it out to lisp code, copy it. This procedure will be called
742 for every key sequence read, so the nice lispy approach (return a
743 new assoclist, list, what have you) for each invocation would
744 result in a lot of consing over time.
746 If we used xrealloc/xmalloc and ran out of memory, they would throw
747 back to the command loop, which would try to read a key sequence,
748 which would call this function again, resulting in an infinite
749 loop. Instead, we'll use realloc/malloc and silently truncate the
750 list, let the key sequence be read, and hope some other piece of
751 code signals the error. */
753 current_minor_maps (modeptr
, mapptr
)
754 Lisp_Object
**modeptr
, **mapptr
;
757 Lisp_Object alist
, assoc
, var
, val
;
759 for (alist
= Vminor_mode_map_alist
;
761 alist
= XCONS (alist
)->cdr
)
762 if (CONSP (assoc
= XCONS (alist
)->car
)
763 && XTYPE (var
= XCONS (assoc
)->car
) == Lisp_Symbol
764 && ! EQ ((val
= find_symbol_value (var
)), Qunbound
)
769 Lisp_Object
*newmodes
, *newmaps
;
774 newmodes
= (Lisp_Object
*) realloc (cmm_modes
, cmm_size
*= 2);
775 newmaps
= (Lisp_Object
*) realloc (cmm_maps
, cmm_size
);
781 newmodes
= (Lisp_Object
*) malloc (cmm_size
= 30);
782 newmaps
= (Lisp_Object
*) malloc (cmm_size
);
786 if (newmaps
&& newmodes
)
788 cmm_modes
= newmodes
;
795 cmm_maps
[i
] = Findirect_function (XCONS (assoc
)->cdr
);
799 if (modeptr
) *modeptr
= cmm_modes
;
800 if (mapptr
) *mapptr
= cmm_maps
;
804 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
805 "Return the binding for command KEY in current keymaps.\n\
806 KEY is a string or vector, a sequence of keystrokes.\n\
807 The binding is probably a symbol with a function definition.\n\
809 Normally, `key-binding' ignores bindings for t, which act as default\n\
810 bindings, used when nothing else in the keymap applies; this makes it\n\
811 useable as a general function for probing keymaps. However, if the\n\
812 third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will\n\
813 recognize the default bindings, just as `read-key-sequence' does.")
814 (key
, accept_default
)
817 Lisp_Object
*maps
, value
;
820 nmaps
= current_minor_maps (0, &maps
);
821 for (i
= 0; i
< nmaps
; i
++)
822 if (! NILP (maps
[i
]))
824 value
= Flookup_key (maps
[i
], key
, accept_default
);
825 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
829 if (! NILP (current_buffer
->keymap
))
831 value
= Flookup_key (current_buffer
->keymap
, key
, accept_default
);
832 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
836 value
= Flookup_key (current_global_map
, key
, accept_default
);
837 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
843 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
844 "Return the binding for command KEYS in current local keymap only.\n\
845 KEYS is a string, a sequence of keystrokes.\n\
846 The binding is probably a symbol with a function definition.\n\
848 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
849 bindings; see the description of `lookup-key' for more details about this.")
850 (keys
, accept_default
)
851 Lisp_Object keys
, accept_default
;
853 register Lisp_Object map
;
854 map
= current_buffer
->keymap
;
857 return Flookup_key (map
, keys
, accept_default
);
860 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
861 "Return the binding for command KEYS in current global keymap only.\n\
862 KEYS is a string, a sequence of keystrokes.\n\
863 The binding is probably a symbol with a function definition.\n\
864 This function's return values are the same as those of lookup-key\n\
867 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
868 bindings; see the description of `lookup-key' for more details about this.")
869 (keys
, accept_default
)
870 Lisp_Object keys
, accept_default
;
872 return Flookup_key (current_global_map
, keys
, accept_default
);
875 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
876 "Find the visible minor mode bindings of KEY.\n\
877 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
878 the symbol which names the minor mode binding KEY, and BINDING is\n\
879 KEY's definition in that mode. In particular, if KEY has no\n\
880 minor-mode bindings, return nil. If the first binding is a\n\
881 non-prefix, all subsequent bindings will be omitted, since they would\n\
882 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
883 that come after prefix bindings.\n\
885 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
886 bindings; see the description of `lookup-key' for more details about this.")
887 (key
, accept_default
)
888 Lisp_Object key
, accept_default
;
890 Lisp_Object
*modes
, *maps
;
895 nmaps
= current_minor_maps (&modes
, &maps
);
897 for (i
= j
= 0; i
< nmaps
; i
++)
899 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
900 && XTYPE (binding
) != Lisp_Int
)
902 if (! NILP (get_keymap (binding
)))
903 maps
[j
++] = Fcons (modes
[i
], binding
);
905 return Fcons (Fcons (modes
[i
], binding
), Qnil
);
908 return Flist (j
, maps
);
911 DEFUN ("global-set-key", Fglobal_set_key
, Sglobal_set_key
, 2, 2,
912 "kSet key globally: \nCSet key %s to command: ",
913 "Give KEY a global binding as COMMAND.\n\
914 COMMAND is a symbol naming an interactively-callable function.\n\
915 KEY is a key sequence (a string or vector of characters or event types).\n\
916 Note that if KEY has a local binding in the current buffer\n\
917 that local binding will continue to shadow any global binding.")
919 Lisp_Object keys
, function
;
921 if (XTYPE (keys
) != Lisp_Vector
922 && XTYPE (keys
) != Lisp_String
)
923 keys
= wrong_type_argument (Qarrayp
, keys
);
925 Fdefine_key (current_global_map
, keys
, function
);
929 DEFUN ("local-set-key", Flocal_set_key
, Slocal_set_key
, 2, 2,
930 "kSet key locally: \nCSet key %s locally to command: ",
931 "Give KEY a local binding as COMMAND.\n\
932 COMMAND is a symbol naming an interactively-callable function.\n\
933 KEY is a key sequence (a string or vector of characters or event types).\n\
934 The binding goes in the current buffer's local map,\n\
935 which is shared with other buffers in the same major mode.")
937 Lisp_Object keys
, function
;
939 register Lisp_Object map
;
940 map
= current_buffer
->keymap
;
943 map
= Fmake_sparse_keymap (Qnil
);
944 current_buffer
->keymap
= map
;
947 if (XTYPE (keys
) != Lisp_Vector
948 && XTYPE (keys
) != Lisp_String
)
949 keys
= wrong_type_argument (Qarrayp
, keys
);
951 Fdefine_key (map
, keys
, function
);
955 DEFUN ("global-unset-key", Fglobal_unset_key
, Sglobal_unset_key
,
956 1, 1, "kUnset key globally: ",
957 "Remove global binding of KEY.\n\
958 KEY is a string representing a sequence of keystrokes.")
962 return Fglobal_set_key (keys
, Qnil
);
965 DEFUN ("local-unset-key", Flocal_unset_key
, Slocal_unset_key
, 1, 1,
966 "kUnset key locally: ",
967 "Remove local binding of KEY.\n\
968 KEY is a string representing a sequence of keystrokes.")
972 if (!NILP (current_buffer
->keymap
))
973 Flocal_set_key (keys
, Qnil
);
977 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
978 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
979 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
980 If a second optional argument MAPVAR is given, the map is stored as\n\
981 its value instead of as COMMAND's value; but COMMAND is still defined\n\
984 Lisp_Object name
, mapvar
;
987 map
= Fmake_sparse_keymap (Qnil
);
996 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
997 "Select KEYMAP as the global keymap.")
1001 keymap
= get_keymap (keymap
);
1002 current_global_map
= keymap
;
1006 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1007 "Select KEYMAP as the local keymap.\n\
1008 If KEYMAP is nil, that means no local keymap.")
1013 keymap
= get_keymap (keymap
);
1015 current_buffer
->keymap
= keymap
;
1020 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1021 "Return current buffer's local keymap, or nil if it has none.")
1024 return current_buffer
->keymap
;
1027 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1028 "Return the current global keymap.")
1031 return current_global_map
;
1034 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1035 "Return a list of keymaps for the minor modes of the current buffer.")
1039 int nmaps
= current_minor_maps (0, &maps
);
1041 return Flist (nmaps
, maps
);
1044 /* Help functions for describing and documenting keymaps. */
1046 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1048 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1049 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1050 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1051 so that the KEYS increase in length. The first element is (\"\" . KEYMAP).")
1053 Lisp_Object startmap
;
1055 Lisp_Object maps
, tail
;
1057 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1058 get_keymap (startmap
)),
1061 /* For each map in the list maps,
1062 look at any other maps it points to,
1063 and stick them at the end if they are not already in the list.
1065 This is a breadth-first traversal, where tail is the queue of
1066 nodes, and maps accumulates a list of all nodes visited. */
1068 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1070 register Lisp_Object thisseq
= Fcar (Fcar (tail
));
1071 register Lisp_Object thismap
= Fcdr (Fcar (tail
));
1072 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1074 /* Does the current sequence end in the meta-prefix-char? */
1075 int is_metized
= (XINT (last
) >= 0
1076 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1078 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1080 Lisp_Object elt
= XCONS (thismap
)->car
;
1084 if (XTYPE (elt
) == Lisp_Vector
)
1088 /* Vector keymap. Scan all the elements. */
1089 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1091 register Lisp_Object tem
;
1092 register Lisp_Object cmd
;
1094 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
]);
1095 if (NILP (cmd
)) continue;
1096 tem
= Fkeymapp (cmd
);
1099 cmd
= get_keymap (cmd
);
1100 /* Ignore keymaps that are already added to maps. */
1101 tem
= Frassq (cmd
, maps
);
1104 /* If the last key in thisseq is meta-prefix-char,
1105 turn it into a meta-ized keystroke. We know
1106 that the event we're about to append is an
1107 ascii keystroke since we're processing a
1111 int meta_bit
= meta_modifier
;
1112 tem
= Fcopy_sequence (thisseq
);
1114 Faset (tem
, last
, make_number (i
| meta_bit
));
1116 /* This new sequence is the same length as
1117 thisseq, so stick it in the list right
1120 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1124 tem
= append_key (thisseq
, make_number (i
));
1125 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1131 else if (CONSP (elt
))
1133 register Lisp_Object cmd
= get_keyelt (XCONS (elt
)->cdr
);
1134 register Lisp_Object tem
;
1136 /* Ignore definitions that aren't keymaps themselves. */
1137 tem
= Fkeymapp (cmd
);
1140 /* Ignore keymaps that have been seen already. */
1141 cmd
= get_keymap (cmd
);
1142 tem
= Frassq (cmd
, maps
);
1145 /* let elt be the event defined by this map entry. */
1146 elt
= XCONS (elt
)->car
;
1148 /* If the last key in thisseq is meta-prefix-char, and
1149 this entry is a binding for an ascii keystroke,
1150 turn it into a meta-ized keystroke. */
1151 if (is_metized
&& XTYPE (elt
) == Lisp_Int
)
1153 tem
= Fcopy_sequence (thisseq
);
1155 make_number (XINT (elt
) | meta_modifier
));
1157 /* This new sequence is the same length as
1158 thisseq, so stick it in the list right
1161 Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1165 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1176 Lisp_Object Qsingle_key_description
, Qkey_description
;
1178 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1179 "Return a pretty description of key-sequence KEYS.\n\
1180 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1181 spaces are put between sequence elements, etc.")
1185 if (XTYPE (keys
) == Lisp_String
)
1189 vector
= Fmake_vector (Flength (keys
), Qnil
);
1190 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1192 if (XSTRING (keys
)->data
[i
] & 0x80)
1193 XFASTINT (XVECTOR (vector
)->contents
[i
])
1194 = meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80);
1196 XFASTINT (XVECTOR (vector
)->contents
[i
])
1197 = XSTRING (keys
)->data
[i
];
1201 return Fmapconcat (Qsingle_key_description
, keys
, build_string (" "));
1205 push_key_description (c
, p
)
1206 register unsigned int c
;
1209 /* Clear all the meaningless bits above the meta bit. */
1210 c
&= meta_modifier
| ~ - meta_modifier
;
1212 if (c
& alt_modifier
)
1218 if (c
& ctrl_modifier
)
1224 if (c
& hyper_modifier
)
1228 c
-= hyper_modifier
;
1230 if (c
& meta_modifier
)
1236 if (c
& shift_modifier
)
1240 c
-= shift_modifier
;
1242 if (c
& super_modifier
)
1246 c
-= super_modifier
;
1262 else if (c
== Ctl('J'))
1268 else if (c
== Ctl('M'))
1278 if (c
> 0 && c
<= Ctl ('Z'))
1301 *p
++ = (7 & (c
>> 15)) + '0';
1302 *p
++ = (7 & (c
>> 12)) + '0';
1303 *p
++ = (7 & (c
>> 9)) + '0';
1304 *p
++ = (7 & (c
>> 6)) + '0';
1305 *p
++ = (7 & (c
>> 3)) + '0';
1306 *p
++ = (7 & (c
>> 0)) + '0';
1312 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1313 "Return a pretty description of command character KEY.\n\
1314 Control characters turn into C-whatever, etc.")
1320 key
= EVENT_HEAD (key
);
1322 switch (XTYPE (key
))
1324 case Lisp_Int
: /* Normal character */
1325 *push_key_description (XUINT (key
), tem
) = 0;
1326 return build_string (tem
);
1328 case Lisp_Symbol
: /* Function key or event-symbol */
1329 return Fsymbol_name (key
);
1332 error ("KEY must be an integer, cons, or symbol.");
1337 push_text_char_description (c
, p
)
1338 register unsigned int c
;
1350 *p
++ = c
+ 64; /* 'A' - 1 */
1362 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1363 "Return a pretty description of file-character CHAR.\n\
1364 Control characters turn into \"^char\", etc.")
1370 CHECK_NUMBER (chr
, 0);
1372 *push_text_char_description (XINT (chr
) & 0377, tem
) = 0;
1374 return build_string (tem
);
1377 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1380 ascii_sequence_p (seq
)
1384 int len
= XINT (Flength (seq
));
1386 for (XFASTINT (i
) = 0; XFASTINT (i
) < len
; XFASTINT (i
)++)
1388 Lisp_Object elt
= Faref (seq
, i
);
1390 if (XTYPE (elt
) != Lisp_Int
1391 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1399 /* where-is - finding a command in a set of keymaps. */
1401 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
1402 "Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.\n\
1403 If KEYMAP is nil, search only KEYMAP1.\n\
1404 If KEYMAP1 is nil, use the current global map.\n\
1406 If optional 4th arg FIRSTONLY is non-nil, return a string representing\n\
1407 the first key sequence found, rather than a list of all possible key\n\
1408 sequences. If FIRSTONLY is t, avoid key sequences which use non-ASCII\n\
1409 keys and therefore may not be usable on ASCII terminals. If FIRSTONLY\n\
1410 is the symbol `non-ascii', return the first binding found, no matter\n\
1411 what its components.\n\
1413 If optional 5th arg NOINDIRECT is non-nil, don't follow indirections\n\
1414 to other keymaps or slots. This makes it possible to search for an\n\
1415 indirect definition itself.")
1416 (definition
, local_keymap
, global_keymap
, firstonly
, noindirect
)
1417 Lisp_Object definition
, local_keymap
, global_keymap
;
1418 Lisp_Object firstonly
, noindirect
;
1420 register Lisp_Object maps
;
1423 if (NILP (global_keymap
))
1424 global_keymap
= current_global_map
;
1426 if (!NILP (local_keymap
))
1427 maps
= nconc2 (Faccessible_keymaps (get_keymap (local_keymap
)),
1428 Faccessible_keymaps (get_keymap (global_keymap
)));
1430 maps
= Faccessible_keymaps (get_keymap (global_keymap
));
1434 for (; !NILP (maps
); maps
= Fcdr (maps
))
1436 /* Key sequence to reach map */
1437 register Lisp_Object
this = Fcar (Fcar (maps
));
1439 /* The map that it reaches */
1440 register Lisp_Object map
= Fcdr (Fcar (maps
));
1442 /* If Fcar (map) is a VECTOR, the current element within that vector. */
1445 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1446 [M-CHAR] sequences, check if last character of the sequence
1447 is the meta-prefix char. */
1448 Lisp_Object last
= make_number (XINT (Flength (this)) - 1);
1449 int last_is_meta
= (XINT (last
) >= 0
1450 && EQ (Faref (this, last
), meta_prefix_char
));
1456 /* Because the code we want to run on each binding is rather
1457 large, we don't want to have two separate loop bodies for
1458 sparse keymap bindings and tables; we want to iterate one
1459 loop body over both keymap and vector bindings.
1461 For this reason, if Fcar (map) is a vector, we don't
1462 advance map to the next element until i indicates that we
1463 have finished off the vector. */
1465 Lisp_Object elt
= XCONS (map
)->car
;
1466 Lisp_Object key
, binding
, sequence
;
1470 /* Set key and binding to the current key and binding, and
1471 advance map and i to the next binding. */
1472 if (XTYPE (elt
) == Lisp_Vector
)
1474 /* In a vector, look at each element. */
1475 binding
= XVECTOR (elt
)->contents
[i
];
1479 /* If we've just finished scanning a vector, advance map
1480 to the next element, and reset i in anticipation of the
1481 next vector we may find. */
1482 if (i
>= XVECTOR (elt
)->size
)
1484 map
= XCONS (map
)->cdr
;
1488 else if (CONSP (elt
))
1490 key
= Fcar (Fcar (map
));
1491 binding
= Fcdr (Fcar (map
));
1493 map
= XCONS (map
)->cdr
;
1496 /* We want to ignore keymap elements that are neither
1497 vectors nor conses. */
1499 map
= XCONS (map
)->cdr
;
1503 /* Search through indirections unless that's not wanted. */
1504 if (NILP (noindirect
))
1505 binding
= get_keyelt (binding
);
1507 /* End this iteration if this element does not match
1510 if (XTYPE (definition
) == Lisp_Cons
)
1513 tem
= Fequal (binding
, definition
);
1518 if (!EQ (binding
, definition
))
1521 /* We have found a match.
1522 Construct the key sequence where we found it. */
1523 if (XTYPE (key
) == Lisp_Int
&& last_is_meta
)
1525 sequence
= Fcopy_sequence (this);
1526 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
1529 sequence
= append_key (this, key
);
1531 /* Verify that this key binding is not shadowed by another
1532 binding for the same key, before we say it exists.
1534 Mechanism: look for local definition of this key and if
1535 it is defined and does not match what we found then
1538 Either nil or number as value from Flookup_key
1540 if (!NILP (local_keymap
))
1542 binding
= Flookup_key (local_keymap
, sequence
, Qnil
);
1543 if (!NILP (binding
) && XTYPE (binding
) != Lisp_Int
)
1545 if (XTYPE (definition
) == Lisp_Cons
)
1548 tem
= Fequal (binding
, definition
);
1553 if (!EQ (binding
, definition
))
1558 /* It is a true unshadowed match. Record it. */
1559 found
= Fcons (sequence
, found
);
1561 /* If firstonly is Qnon_ascii, then we can return the first
1562 binding we find. If firstonly is not Qnon_ascii but not
1563 nil, then we should return the first ascii-only binding
1565 if (EQ (firstonly
, Qnon_ascii
))
1567 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
1572 found
= Fnreverse (found
);
1574 /* firstonly may have been t, but we may have gone all the way through
1575 the keymaps without finding an all-ASCII key sequence. So just
1576 return the best we could find. */
1577 if (! NILP (firstonly
))
1578 return Fcar (found
);
1583 /* Return a string listing the keys and buttons that run DEFINITION. */
1586 where_is_string (definition
)
1587 Lisp_Object definition
;
1589 register Lisp_Object keys
, keys1
;
1591 keys
= Fwhere_is_internal (definition
,
1592 current_buffer
->keymap
, Qnil
, Qnil
, Qnil
);
1593 keys1
= Fmapconcat (Qkey_description
, keys
, build_string (", "));
1598 DEFUN ("where-is", Fwhere_is
, Swhere_is
, 1, 1, "CWhere is command: ",
1599 "Print message listing key sequences that invoke specified command.\n\
1600 Argument is a command definition, usually a symbol with a function definition.")
1602 Lisp_Object definition
;
1604 register Lisp_Object string
;
1606 CHECK_SYMBOL (definition
, 0);
1607 string
= where_is_string (definition
);
1609 if (XSTRING (string
)->size
)
1610 message ("%s is on %s", XSYMBOL (definition
)->name
->data
,
1611 XSTRING (string
)->data
);
1613 message ("%s is not on any key", XSYMBOL (definition
)->name
->data
);
1617 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
1619 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 0, "",
1620 "Show a list of all defined keys, and their definitions.\n\
1621 The list is put in a buffer, which is displayed.")
1624 register Lisp_Object thisbuf
;
1625 XSET (thisbuf
, Lisp_Buffer
, current_buffer
);
1626 internal_with_output_to_temp_buffer ("*Help*",
1627 describe_buffer_bindings
,
1633 describe_buffer_bindings (descbuf
)
1634 Lisp_Object descbuf
;
1636 register Lisp_Object start1
, start2
;
1642 char *alternate_heading
1644 Alternate Characters (use anywhere the nominal character is listed):\n\
1645 nominal alternate\n\
1646 ------- ---------\n";
1648 Fset_buffer (Vstandard_output
);
1650 /* Report on alternates for keys. */
1651 if (XTYPE (Vkeyboard_translate_table
) == Lisp_String
)
1654 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
1655 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
1657 for (c
= 0; c
< translate_len
; c
++)
1658 if (translate
[c
] != c
)
1663 if (alternate_heading
)
1665 insert_string (alternate_heading
);
1666 alternate_heading
= 0;
1669 bufend
= push_key_description (translate
[c
], buf
);
1670 insert (buf
, bufend
- buf
);
1671 Findent_to (make_number (16), make_number (1));
1672 bufend
= push_key_description (c
, buf
);
1673 insert (buf
, bufend
- buf
);
1683 Lisp_Object
*modes
, *maps
;
1685 /* Temporarily switch to descbuf, so that we can get that buffer's
1686 minor modes correctly. */
1687 Fset_buffer (descbuf
);
1688 nmaps
= current_minor_maps (&modes
, &maps
);
1689 Fset_buffer (Vstandard_output
);
1691 for (i
= 0; i
< nmaps
; i
++)
1693 if (XTYPE (modes
[i
]) == Lisp_Symbol
)
1696 insert_string (XSYMBOL (modes
[i
])->name
->data
);
1700 insert_string ("Strangely Named");
1701 insert_string (" Minor Mode Bindings:\n");
1702 insert_string (key_heading
);
1703 describe_map_tree (maps
[i
], 0, Qnil
);
1708 start1
= XBUFFER (descbuf
)->keymap
;
1711 insert_string ("Local Bindings:\n");
1712 insert_string (key_heading
);
1713 describe_map_tree (start1
, 0, Qnil
);
1714 insert_string ("\n");
1717 insert_string ("Global Bindings:\n");
1719 insert_string (key_heading
);
1721 describe_map_tree (current_global_map
, 0, XBUFFER (descbuf
)->keymap
);
1723 Fset_buffer (descbuf
);
1727 /* Insert a desription of the key bindings in STARTMAP,
1728 followed by those of all maps reachable through STARTMAP.
1729 If PARTIAL is nonzero, omit certain "uninteresting" commands
1730 (such as `undefined').
1731 If SHADOW is non-nil, it is another map;
1732 don't mention keys which would be shadowed by it. */
1735 describe_map_tree (startmap
, partial
, shadow
)
1736 Lisp_Object startmap
, shadow
;
1739 register Lisp_Object elt
, sh
;
1741 struct gcpro gcpro1
;
1743 maps
= Faccessible_keymaps (startmap
);
1746 for (; !NILP (maps
); maps
= Fcdr (maps
))
1751 /* If there is no shadow keymap given, don't shadow. */
1755 /* If the sequence by which we reach this keymap is zero-length,
1756 then the shadow map for this keymap is just SHADOW. */
1757 else if ((XTYPE (sh
) == Lisp_String
1758 && XSTRING (sh
)->size
== 0)
1759 || (XTYPE (sh
) == Lisp_Vector
1760 && XVECTOR (sh
)->size
== 0))
1763 /* If the sequence by which we reach this keymap actually has
1764 some elements, then the sequence's definition in SHADOW is
1765 what we should use. */
1768 sh
= Flookup_key (shadow
, Fcar (elt
), Qt
);
1769 if (XTYPE (sh
) == Lisp_Int
)
1773 /* If sh is null (meaning that the current map is not shadowed),
1774 or a keymap (meaning that bindings from the current map might
1775 show through), describe the map. Otherwise, sh is a command
1776 that completely shadows the current map, and we shouldn't
1778 if (NILP (sh
) || !NILP (Fkeymapp (sh
)))
1779 describe_map (Fcdr (elt
), Fcar (elt
), partial
, sh
);
1786 describe_command (definition
)
1787 Lisp_Object definition
;
1789 register Lisp_Object tem1
;
1791 Findent_to (make_number (16), make_number (1));
1793 if (XTYPE (definition
) == Lisp_Symbol
)
1795 XSET (tem1
, Lisp_String
, XSYMBOL (definition
)->name
);
1797 insert_string ("\n");
1801 tem1
= Fkeymapp (definition
);
1803 insert_string ("Prefix Command\n");
1805 insert_string ("??\n");
1809 /* Describe the contents of map MAP, assuming that this map itself is
1810 reached by the sequence of prefix keys KEYS (a string or vector).
1811 PARTIAL, SHADOW is as in `describe_map_tree' above. */
1814 describe_map (map
, keys
, partial
, shadow
)
1815 Lisp_Object map
, keys
;
1819 register Lisp_Object keysdesc
;
1821 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
1824 /* Call Fkey_description first, to avoid GC bug for the other string. */
1825 tem
= Fkey_description (keys
);
1826 keysdesc
= concat2 (tem
, build_string (" "));
1831 describe_map_2 (map
, keysdesc
, describe_command
, partial
, shadow
);
1834 /* Insert a description of KEYMAP into the current buffer. */
1837 describe_map_2 (keymap
, elt_prefix
, elt_describer
, partial
, shadow
)
1838 register Lisp_Object keymap
;
1839 Lisp_Object elt_prefix
;
1840 int (*elt_describer
) ();
1845 Lisp_Object tem1
, tem2
= Qnil
;
1846 Lisp_Object suppress
;
1849 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1852 suppress
= intern ("suppress-keymap");
1854 /* This vector gets used to present single keys to Flookup_key. Since
1855 that is done once per keymap element, we don't want to cons up a
1856 fresh vector every time. */
1857 kludge
= Fmake_vector (make_number (1), Qnil
);
1859 GCPRO3 (elt_prefix
, tem2
, kludge
);
1861 for (; CONSP (keymap
); keymap
= Fcdr (keymap
))
1865 if (XTYPE (XCONS (keymap
)->car
) == Lisp_Vector
)
1866 describe_vector (XCONS (keymap
)->car
,
1867 elt_prefix
, elt_describer
, partial
, shadow
);
1870 tem1
= Fcar_safe (Fcar (keymap
));
1871 tem2
= get_keyelt (Fcdr_safe (Fcar (keymap
)));
1873 /* Don't show undefined commands or suppressed commands. */
1874 if (NILP (tem2
)) continue;
1875 if (XTYPE (tem2
) == Lisp_Symbol
&& partial
)
1877 this = Fget (tem2
, suppress
);
1882 /* Don't show a command that isn't really visible
1883 because a local definition of the same key shadows it. */
1889 XVECTOR (kludge
)->contents
[0] = tem1
;
1890 tem
= Flookup_key (shadow
, kludge
, Qt
);
1891 if (!NILP (tem
)) continue;
1900 if (!NILP (elt_prefix
))
1901 insert1 (elt_prefix
);
1903 /* THIS gets the string to describe the character TEM1. */
1904 this = Fsingle_key_description (tem1
);
1907 /* Print a description of the definition of this character.
1908 elt_describer will take care of spacing out far enough
1909 for alignment purposes. */
1910 (*elt_describer
) (tem2
);
1918 describe_vector_princ (elt
)
1921 Findent_to (make_number (16), make_number (1));
1926 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
1927 "Insert a description of contents of VECTOR.\n\
1928 This is text showing the elements of vector matched against indices.")
1932 int count
= specpdl_ptr
- specpdl
;
1934 specbind (Qstandard_output
, Fcurrent_buffer ());
1935 CHECK_VECTOR (vector
, 0);
1936 describe_vector (vector
, Qnil
, describe_vector_princ
, 0, Qnil
);
1938 return unbind_to (count
, Qnil
);
1941 describe_vector (vector
, elt_prefix
, elt_describer
, partial
, shadow
)
1942 register Lisp_Object vector
;
1943 Lisp_Object elt_prefix
;
1944 int (*elt_describer
) ();
1950 Lisp_Object tem1
, tem2
;
1952 Lisp_Object suppress
;
1955 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1959 /* This vector gets used to present single keys to Flookup_key. Since
1960 that is done once per vector element, we don't want to cons up a
1961 fresh vector every time. */
1962 kludge
= Fmake_vector (make_number (1), Qnil
);
1963 GCPRO3 (elt_prefix
, tem1
, kludge
);
1966 suppress
= intern ("suppress-keymap");
1968 for (i
= 0; i
< XVECTOR (vector
)->size
; i
++)
1971 tem1
= get_keyelt (XVECTOR (vector
)->contents
[i
]);
1973 if (NILP (tem1
)) continue;
1975 /* Don't mention suppressed commands. */
1976 if (XTYPE (tem1
) == Lisp_Symbol
&& partial
)
1978 this = Fget (tem1
, suppress
);
1983 /* If this command in this map is shadowed by some other map,
1989 XVECTOR (kludge
)->contents
[0] = make_number (i
);
1990 tem
= Flookup_key (shadow
, kludge
, Qt
);
1992 if (!NILP (tem
)) continue;
2001 /* Output the prefix that applies to every entry in this map. */
2002 if (!NILP (elt_prefix
))
2003 insert1 (elt_prefix
);
2005 /* Get the string to describe the character I, and print it. */
2006 XFASTINT (dummy
) = i
;
2008 /* THIS gets the string to describe the character DUMMY. */
2009 this = Fsingle_key_description (dummy
);
2012 /* Find all consecutive characters that have the same definition. */
2013 while (i
+ 1 < XVECTOR (vector
)->size
2014 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+1]),
2018 /* If we have a range of more than one character,
2019 print where the range reaches to. */
2021 if (i
!= XINT (dummy
))
2024 if (!NILP (elt_prefix
))
2025 insert1 (elt_prefix
);
2027 XFASTINT (dummy
) = i
;
2028 insert1 (Fsingle_key_description (dummy
));
2031 /* Print a description of the definition of this character.
2032 elt_describer will take care of spacing out far enough
2033 for alignment purposes. */
2034 (*elt_describer
) (tem1
);
2040 /* Apropos - finding all symbols whose names match a regexp. */
2041 Lisp_Object apropos_predicate
;
2042 Lisp_Object apropos_accumulate
;
2045 apropos_accum (symbol
, string
)
2046 Lisp_Object symbol
, string
;
2048 register Lisp_Object tem
;
2050 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
2051 if (!NILP (tem
) && !NILP (apropos_predicate
))
2052 tem
= call1 (apropos_predicate
, symbol
);
2054 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
2057 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
2058 "Show all symbols whose names contain match for REGEXP.\n\
2059 If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done\n\
2060 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
2061 Return list of symbols found.")
2063 Lisp_Object string
, pred
;
2065 struct gcpro gcpro1
, gcpro2
;
2066 CHECK_STRING (string
, 0);
2067 apropos_predicate
= pred
;
2068 GCPRO2 (apropos_predicate
, apropos_accumulate
);
2069 apropos_accumulate
= Qnil
;
2070 map_obarray (Vobarray
, apropos_accum
, string
);
2071 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
2073 return apropos_accumulate
;
2080 Qkeymap
= intern ("keymap");
2081 staticpro (&Qkeymap
);
2083 /* Initialize the keymaps standardly used.
2084 Each one is the value of a Lisp variable, and is also
2085 pointed to by a C variable */
2087 global_map
= Fcons (Qkeymap
,
2088 Fcons (Fmake_vector (make_number (0400), Qnil
), Qnil
));
2089 Fset (intern ("global-map"), global_map
);
2091 meta_map
= Fmake_keymap (Qnil
);
2092 Fset (intern ("esc-map"), meta_map
);
2093 Ffset (intern ("ESC-prefix"), meta_map
);
2095 control_x_map
= Fmake_keymap (Qnil
);
2096 Fset (intern ("ctl-x-map"), control_x_map
);
2097 Ffset (intern ("Control-X-prefix"), control_x_map
);
2099 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
2100 "Default keymap to use when reading from the minibuffer.");
2101 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
2103 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
2104 "Local keymap for the minibuffer when spaces are not allowed.");
2105 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
2107 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
2108 "Local keymap for minibuffer input with completion.");
2109 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
2111 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
2112 "Local keymap for minibuffer input with completion, for exact match.");
2113 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
2115 current_global_map
= global_map
;
2117 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
2118 "Alist of keymaps to use for minor modes.\n\
2119 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
2120 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
2121 If two active keymaps bind the same key, the keymap appearing earlier\n\
2122 in the list takes precedence.");
2123 Vminor_mode_map_alist
= Qnil
;
2125 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
2126 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
2127 This allows Emacs to recognize function keys sent from ASCII\n\
2128 terminals at any point in a key sequence.\n\
2130 The read-key-sequence function replaces subsequences bound by\n\
2131 function-key-map with their bindings. When the current local and global\n\
2132 keymaps have no binding for the current key sequence but\n\
2133 function-key-map binds a suffix of the sequence to a vector,\n\
2134 read-key-sequence replaces the matching suffix with its binding, and\n\
2135 continues with the new sequence.\n\
2137 For example, suppose function-key-map binds `ESC O P' to [pf1].\n\
2138 Typing `ESC O P' to read-key-sequence would return [pf1]. Typing\n\
2139 `C-x ESC O P' would return [?\C-x pf1]. If [pf1] were a prefix\n\
2140 key, typing `ESC O P x' would return [pf1 x].");
2141 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
2143 Qsingle_key_description
= intern ("single-key-description");
2144 staticpro (&Qsingle_key_description
);
2146 Qkey_description
= intern ("key-description");
2147 staticpro (&Qkey_description
);
2149 Qkeymapp
= intern ("keymapp");
2150 staticpro (&Qkeymapp
);
2152 Qnon_ascii
= intern ("non-ascii");
2153 staticpro (&Qnon_ascii
);
2155 defsubr (&Skeymapp
);
2156 defsubr (&Smake_keymap
);
2157 defsubr (&Smake_sparse_keymap
);
2158 defsubr (&Scopy_keymap
);
2159 defsubr (&Skey_binding
);
2160 defsubr (&Slocal_key_binding
);
2161 defsubr (&Sglobal_key_binding
);
2162 defsubr (&Sminor_mode_key_binding
);
2163 defsubr (&Sglobal_set_key
);
2164 defsubr (&Slocal_set_key
);
2165 defsubr (&Sdefine_key
);
2166 defsubr (&Slookup_key
);
2167 defsubr (&Sglobal_unset_key
);
2168 defsubr (&Slocal_unset_key
);
2169 defsubr (&Sdefine_prefix_command
);
2170 defsubr (&Suse_global_map
);
2171 defsubr (&Suse_local_map
);
2172 defsubr (&Scurrent_local_map
);
2173 defsubr (&Scurrent_global_map
);
2174 defsubr (&Scurrent_minor_mode_maps
);
2175 defsubr (&Saccessible_keymaps
);
2176 defsubr (&Skey_description
);
2177 defsubr (&Sdescribe_vector
);
2178 defsubr (&Ssingle_key_description
);
2179 defsubr (&Stext_char_description
);
2180 defsubr (&Swhere_is_internal
);
2181 defsubr (&Swhere_is
);
2182 defsubr (&Sdescribe_bindings
);
2183 defsubr (&Sapropos_internal
);
2190 initial_define_key (global_map
, 033, "ESC-prefix");
2191 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");