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
describe_buffer_bindings ();
85 static void describe_command ();
86 static void describe_map ();
87 static void describe_map_2 ();
89 /* Keymap object support - constructors and predicates. */
91 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
92 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
93 VECTOR is a vector which holds the bindings for the ASCII\n\
94 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
95 mouse events, and any other things that appear in the input stream.\n\
96 All entries in it are initially nil, meaning \"command undefined\".\n\n\
97 The optional arg STRING supplies a menu name for the keymap\n\
98 in case you use it as a menu with `x-popup-menu'.")
104 tail
= Fcons (string
, Qnil
);
107 return Fcons (Qkeymap
,
108 Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE
), Qnil
),
112 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
113 "Construct and return a new sparse-keymap list.\n\
114 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
115 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
116 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
117 Initially the alist is nil.\n\n\
118 The optional arg STRING supplies a menu name for the keymap\n\
119 in case you use it as a menu with `x-popup-menu'.")
124 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
125 return Fcons (Qkeymap
, Qnil
);
128 /* This function is used for installing the standard key bindings
129 at initialization time.
133 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
136 initial_define_key (keymap
, key
, defname
)
141 store_in_keymap (keymap
, make_number (key
), intern (defname
));
145 initial_define_lispy_key (keymap
, keyname
, defname
)
150 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
153 /* Define character fromchar in map frommap as an alias for character
154 tochar in map tomap. Subsequent redefinitions of the latter WILL
155 affect the former. */
159 synkey (frommap
, fromchar
, tomap
, tochar
)
160 struct Lisp_Vector
*frommap
, *tomap
;
161 int fromchar
, tochar
;
164 XSET (v
, Lisp_Vector
, tomap
);
165 XFASTINT (c
) = tochar
;
166 frommap
->contents
[fromchar
] = Fcons (v
, c
);
170 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
171 "Return t if ARG is a keymap.\n\
173 A keymap is a list (keymap . ALIST),\n\
174 or a symbol whose function definition is a keymap is itself a keymap.\n\
175 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
176 a vector of densely packed bindings for small character codes\n\
177 is also allowed as an element.")
181 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
184 /* Check that OBJECT is a keymap (after dereferencing through any
185 symbols). If it is, return it.
187 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
188 is an autoload form, do the autoload and try again.
190 ERROR controls how we respond if OBJECT isn't a keymap.
191 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
193 Note that most of the time, we don't want to pursue autoloads.
194 Functions like Faccessible_keymaps which scan entire keymap trees
195 shouldn't load every autoloaded keymap. I'm not sure about this,
196 but it seems to me that only read_key_sequence, Flookup_key, and
197 Fdefine_key should cause keymaps to be autoloaded. */
200 get_keymap_1 (object
, error
, autoload
)
207 tem
= indirect_function (object
);
208 if (CONSP (tem
) && EQ (XCONS (tem
)->car
, Qkeymap
))
211 /* Should we do an autoload? Autoload forms for keymaps have
212 Qkeymap as their fifth element. */
214 && XTYPE (object
) == Lisp_Symbol
216 && EQ (XCONS (tem
)->car
, Qautoload
))
220 tail
= Fnth (make_number (4), tem
);
221 if (EQ (tail
, Qkeymap
))
223 struct gcpro gcpro1
, gcpro2
;
226 do_autoload (tem
, object
);
234 wrong_type_argument (Qkeymapp
, object
);
240 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
241 If OBJECT doesn't denote a keymap at all, signal an error. */
246 return get_keymap_1 (object
, 0, 0);
250 /* Look up IDX in MAP. IDX may be any sort of event.
251 Note that this does only one level of lookup; IDX must be a single
252 event, not a sequence.
254 If T_OK is non-zero, bindings for Qt are treated as default
255 bindings; any key left unmentioned by other tables and bindings is
256 given the binding of Qt.
258 If T_OK is zero, bindings for Qt are not treated specially. */
261 access_keymap (map
, idx
, t_ok
)
266 /* If idx is a list (some sort of mouse click, perhaps?),
267 the index we want to use is the car of the list, which
268 ought to be a symbol. */
269 idx
= EVENT_HEAD (idx
);
271 /* If idx is a symbol, it might have modifiers, which need to
272 be put in the canonical order. */
273 if (XTYPE (idx
) == Lisp_Symbol
)
274 idx
= reorder_modifiers (idx
);
275 else if (INTEGERP (idx
))
276 /* Clobber the high bits that can be present on a machine
277 with more than 24 bits of integer. */
278 XFASTINT (idx
) = XINT (idx
) & ((1 << 24) - 1);
282 Lisp_Object t_binding
= Qnil
;
284 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
286 Lisp_Object binding
= XCONS (tail
)->car
;
288 switch (XTYPE (binding
))
291 if (EQ (XCONS (binding
)->car
, idx
))
292 return XCONS (binding
)->cdr
;
293 if (t_ok
&& EQ (XCONS (binding
)->car
, Qt
))
294 t_binding
= XCONS (binding
)->cdr
;
298 if (XTYPE (idx
) == Lisp_Int
300 && XINT (idx
) < XVECTOR (binding
)->size
)
301 return XVECTOR (binding
)->contents
[XINT (idx
)];
312 /* Given OBJECT which was found in a slot in a keymap,
313 trace indirect definitions to get the actual definition of that slot.
314 An indirect definition is a list of the form
315 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
316 and INDEX is the object to look up in KEYMAP to yield the definition.
318 Also if OBJECT has a menu string as the first element,
319 remove that. Also remove a menu help string as second element. */
323 register Lisp_Object object
;
327 register Lisp_Object map
, tem
;
329 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
330 map
= get_keymap_1 (Fcar_safe (object
), 0, 0);
331 tem
= Fkeymapp (map
);
333 object
= access_keymap (map
, Fcdr (object
), 0);
335 /* If the keymap contents looks like (STRING . DEFN),
337 Keymap alist elements like (CHAR MENUSTRING . DEFN)
338 will be used by HierarKey menus. */
339 else if (XTYPE (object
) == Lisp_Cons
340 && XTYPE (XCONS (object
)->car
) == Lisp_String
)
342 object
= XCONS (object
)->cdr
;
343 /* Also remove a menu help string, if any,
344 following the menu item name. */
345 if (XTYPE (object
) == Lisp_Cons
346 && XTYPE (XCONS (object
)->car
) == Lisp_String
)
347 object
= XCONS (object
)->cdr
;
351 /* Anything else is really the value. */
357 store_in_keymap (keymap
, idx
, def
)
359 register Lisp_Object idx
;
360 register Lisp_Object def
;
362 if (XTYPE (keymap
) != Lisp_Cons
363 || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
364 error ("attempt to define a key in a non-keymap");
366 /* If idx is a list (some sort of mouse click, perhaps?),
367 the index we want to use is the car of the list, which
368 ought to be a symbol. */
369 idx
= EVENT_HEAD (idx
);
371 /* If idx is a symbol, it might have modifiers, which need to
372 be put in the canonical order. */
373 if (XTYPE (idx
) == Lisp_Symbol
)
374 idx
= reorder_modifiers (idx
);
375 else if (INTEGERP (idx
))
376 /* Clobber the high bits that can be present on a machine
377 with more than 24 bits of integer. */
378 XFASTINT (idx
) = XINT (idx
) & ((1 << 24) - 1);
380 /* Scan the keymap for a binding of idx. */
384 /* The cons after which we should insert new bindings. If the
385 keymap has a table element, we record its position here, so new
386 bindings will go after it; this way, the table will stay
387 towards the front of the alist and character lookups in dense
388 keymaps will remain fast. Otherwise, this just points at the
389 front of the keymap. */
390 Lisp_Object insertion_point
= keymap
;
392 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
394 Lisp_Object elt
= XCONS (tail
)->car
;
399 if (XTYPE (idx
) == Lisp_Int
400 && XINT (idx
) >= 0 && XINT (idx
) < XVECTOR (elt
)->size
)
402 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
405 insertion_point
= tail
;
409 if (EQ (idx
, XCONS (elt
)->car
))
411 XCONS (elt
)->cdr
= def
;
417 /* If we find a 'keymap' symbol in the spine of KEYMAP,
418 then we must have found the start of a second keymap
419 being used as the tail of KEYMAP, and a binding for IDX
420 should be inserted before it. */
421 if (EQ (elt
, Qkeymap
))
430 /* We have scanned the entire keymap, and not found a binding for
431 IDX. Let's add one. */
432 XCONS (insertion_point
)->cdr
=
433 Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
440 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
441 "Return a copy of the keymap KEYMAP.\n\
442 The copy starts out with the same definitions of KEYMAP,\n\
443 but changing either the copy or KEYMAP does not affect the other.\n\
444 Any key definitions that are subkeymaps are recursively copied.\n\
445 However, a key definition which is a symbol whose definition is a keymap\n\
450 register Lisp_Object copy
, tail
;
452 copy
= Fcopy_alist (get_keymap (keymap
));
454 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
456 Lisp_Object elt
= XCONS (tail
)->car
;
458 if (XTYPE (elt
) == Lisp_Vector
)
462 elt
= Fcopy_sequence (elt
);
463 XCONS (tail
)->car
= elt
;
465 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
466 if (XTYPE (XVECTOR (elt
)->contents
[i
]) != Lisp_Symbol
467 && Fkeymapp (XVECTOR (elt
)->contents
[i
]))
468 XVECTOR (elt
)->contents
[i
] =
469 Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
472 && XTYPE (XCONS (elt
)->cdr
) != Lisp_Symbol
473 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
474 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
480 /* Simple Keymap mutators and accessors. */
482 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
483 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
484 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
485 meaning a sequence of keystrokes and events.\n\
486 DEF is anything that can be a key's definition:\n\
487 nil (means key is undefined in this keymap),\n\
488 a command (a Lisp function suitable for interactive calling)\n\
489 a string (treated as a keyboard macro),\n\
490 a keymap (to define a prefix key),\n\
491 a symbol. When the key is looked up, the symbol will stand for its\n\
492 function definition, which should at that time be one of the above,\n\
493 or another symbol whose function definition is used, etc.\n\
494 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
495 (DEFN should be a valid definition in its own right),\n\
496 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
498 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
499 the front of KEYMAP.")
506 register Lisp_Object c
;
507 register Lisp_Object tem
;
508 register Lisp_Object cmd
;
512 struct gcpro gcpro1
, gcpro2
, gcpro3
;
514 keymap
= get_keymap (keymap
);
516 if (XTYPE (key
) != Lisp_Vector
517 && XTYPE (key
) != Lisp_String
)
518 key
= wrong_type_argument (Qarrayp
, key
);
520 length
= XFASTINT (Flength (key
));
524 GCPRO3 (keymap
, key
, def
);
526 if (XTYPE (key
) == Lisp_Vector
)
527 meta_bit
= meta_modifier
;
534 c
= Faref (key
, make_number (idx
));
536 if (XTYPE (c
) == Lisp_Int
537 && (XINT (c
) & meta_bit
)
540 c
= meta_prefix_char
;
545 if (XTYPE (c
) == Lisp_Int
)
546 XSETINT (c
, XINT (c
) & ~meta_bit
);
553 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
555 cmd
= get_keyelt (access_keymap (keymap
, c
, 0));
559 cmd
= Fmake_sparse_keymap (Qnil
);
560 store_in_keymap (keymap
, c
, cmd
);
563 keymap
= get_keymap_1 (cmd
, 0, 1);
566 /* We must use Fkey_description rather than just passing key to
567 error; key might be a vector, not a string. */
568 Lisp_Object description
= Fkey_description (key
);
570 error ("Key sequence %s uses invalid prefix characters",
571 XSTRING (description
)->data
);
576 /* Value is number if KEY is too long; NIL if valid but has no definition. */
578 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
579 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
580 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
582 A number as value means KEY is \"too long\";\n\
583 that is, characters or symbols in it except for the last one\n\
584 fail to be a valid sequence of prefix characters in KEYMAP.\n\
585 The number is how many characters at the front of KEY\n\
586 it takes to reach a non-prefix command.\n\
588 Normally, `lookup-key' ignores bindings for t, which act as default\n\
589 bindings, used when nothing else in the keymap applies; this makes it\n\
590 useable as a general function for probing keymaps. However, if the\n\
591 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
592 recognize the default bindings, just as `read-key-sequence' does.")
593 (keymap
, key
, accept_default
)
594 register Lisp_Object keymap
;
596 Lisp_Object accept_default
;
599 register Lisp_Object tem
;
600 register Lisp_Object cmd
;
601 register Lisp_Object c
;
604 int t_ok
= ! NILP (accept_default
);
607 keymap
= get_keymap (keymap
);
609 if (XTYPE (key
) != Lisp_Vector
610 && XTYPE (key
) != Lisp_String
)
611 key
= wrong_type_argument (Qarrayp
, key
);
613 length
= XFASTINT (Flength (key
));
617 if (XTYPE (key
) == Lisp_Vector
)
618 meta_bit
= meta_modifier
;
625 c
= Faref (key
, make_number (idx
));
627 if (XTYPE (c
) == Lisp_Int
628 && (XINT (c
) & meta_bit
)
631 c
= meta_prefix_char
;
636 if (XTYPE (c
) == Lisp_Int
)
637 XSETINT (c
, XINT (c
) & ~meta_bit
);
643 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
));
647 keymap
= get_keymap_1 (cmd
, 0, 0);
649 return make_number (idx
);
655 /* Append a key to the end of a key sequence. We always make a vector. */
658 append_key (key_sequence
, key
)
659 Lisp_Object key_sequence
, key
;
663 args
[0] = key_sequence
;
665 args
[1] = Fcons (key
, Qnil
);
666 return Fvconcat (2, args
);
670 /* Global, local, and minor mode keymap stuff. */
672 /* We can't put these variables inside current_minor_maps, since under
673 some systems, static gets macro-defined to be the empty string.
675 static Lisp_Object
*cmm_modes
, *cmm_maps
;
678 /* Store a pointer to an array of the keymaps of the currently active
679 minor modes in *buf, and return the number of maps it contains.
681 This function always returns a pointer to the same buffer, and may
682 free or reallocate it, so if you want to keep it for a long time or
683 hand it out to lisp code, copy it. This procedure will be called
684 for every key sequence read, so the nice lispy approach (return a
685 new assoclist, list, what have you) for each invocation would
686 result in a lot of consing over time.
688 If we used xrealloc/xmalloc and ran out of memory, they would throw
689 back to the command loop, which would try to read a key sequence,
690 which would call this function again, resulting in an infinite
691 loop. Instead, we'll use realloc/malloc and silently truncate the
692 list, let the key sequence be read, and hope some other piece of
693 code signals the error. */
695 current_minor_maps (modeptr
, mapptr
)
696 Lisp_Object
**modeptr
, **mapptr
;
699 Lisp_Object alist
, assoc
, var
, val
;
701 for (alist
= Vminor_mode_map_alist
;
703 alist
= XCONS (alist
)->cdr
)
704 if (CONSP (assoc
= XCONS (alist
)->car
)
705 && XTYPE (var
= XCONS (assoc
)->car
) == Lisp_Symbol
706 && ! EQ ((val
= find_symbol_value (var
)), Qunbound
)
711 Lisp_Object
*newmodes
, *newmaps
;
716 newmodes
= (Lisp_Object
*) realloc (cmm_modes
, cmm_size
*= 2);
717 newmaps
= (Lisp_Object
*) realloc (cmm_maps
, cmm_size
);
723 newmodes
= (Lisp_Object
*) malloc (cmm_size
= 30);
724 newmaps
= (Lisp_Object
*) malloc (cmm_size
);
728 if (newmaps
&& newmodes
)
730 cmm_modes
= newmodes
;
737 cmm_maps
[i
] = Findirect_function (XCONS (assoc
)->cdr
);
741 if (modeptr
) *modeptr
= cmm_modes
;
742 if (mapptr
) *mapptr
= cmm_maps
;
746 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
747 "Return the binding for command KEY in current keymaps.\n\
748 KEY is a string or vector, a sequence of keystrokes.\n\
749 The binding is probably a symbol with a function definition.\n\
751 Normally, `key-binding' ignores bindings for t, which act as default\n\
752 bindings, used when nothing else in the keymap applies; this makes it\n\
753 useable as a general function for probing keymaps. However, if the\n\
754 third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will\n\
755 recognize the default bindings, just as `read-key-sequence' does.")
756 (key
, accept_default
)
759 Lisp_Object
*maps
, value
;
762 nmaps
= current_minor_maps (0, &maps
);
763 for (i
= 0; i
< nmaps
; i
++)
764 if (! NILP (maps
[i
]))
766 value
= Flookup_key (maps
[i
], key
, accept_default
);
767 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
771 if (! NILP (current_buffer
->keymap
))
773 value
= Flookup_key (current_buffer
->keymap
, key
, accept_default
);
774 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
778 value
= Flookup_key (current_global_map
, key
, accept_default
);
779 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
785 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
786 "Return the binding for command KEYS in current local keymap only.\n\
787 KEYS is a string, a sequence of keystrokes.\n\
788 The binding is probably a symbol with a function definition.\n\
790 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
791 bindings; see the description of `lookup-key' for more details about this.")
792 (keys
, accept_default
)
793 Lisp_Object keys
, accept_default
;
795 register Lisp_Object map
;
796 map
= current_buffer
->keymap
;
799 return Flookup_key (map
, keys
, accept_default
);
802 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
803 "Return the binding for command KEYS in current global keymap only.\n\
804 KEYS is a string, a sequence of keystrokes.\n\
805 The binding is probably a symbol with a function definition.\n\
806 This function's return values are the same as those of lookup-key\n\
809 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
810 bindings; see the description of `lookup-key' for more details about this.")
811 (keys
, accept_default
)
812 Lisp_Object keys
, accept_default
;
814 return Flookup_key (current_global_map
, keys
, accept_default
);
817 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
818 "Find the visible minor mode bindings of KEY.\n\
819 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
820 the symbol which names the minor mode binding KEY, and BINDING is\n\
821 KEY's definition in that mode. In particular, if KEY has no\n\
822 minor-mode bindings, return nil. If the first binding is a\n\
823 non-prefix, all subsequent bindings will be omitted, since they would\n\
824 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
825 that come after prefix bindings.\n\
827 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
828 bindings; see the description of `lookup-key' for more details about this.")
829 (key
, accept_default
)
830 Lisp_Object key
, accept_default
;
832 Lisp_Object
*modes
, *maps
;
837 nmaps
= current_minor_maps (&modes
, &maps
);
839 for (i
= j
= 0; i
< nmaps
; i
++)
841 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
842 && XTYPE (binding
) != Lisp_Int
)
844 if (! NILP (get_keymap (binding
)))
845 maps
[j
++] = Fcons (modes
[i
], binding
);
847 return Fcons (Fcons (modes
[i
], binding
), Qnil
);
850 return Flist (j
, maps
);
853 DEFUN ("global-set-key", Fglobal_set_key
, Sglobal_set_key
, 2, 2,
854 "kSet key globally: \nCSet key %s to command: ",
855 "Give KEY a global binding as COMMAND.\n\
856 COMMAND is a symbol naming an interactively-callable function.\n\
857 KEY is a string representing a sequence of keystrokes.\n\
858 Note that if KEY has a local binding in the current buffer\n\
859 that local binding will continue to shadow any global binding.")
861 Lisp_Object keys
, function
;
863 if (XTYPE (keys
) != Lisp_Vector
864 && XTYPE (keys
) != Lisp_String
)
865 keys
= wrong_type_argument (Qarrayp
, keys
);
867 Fdefine_key (current_global_map
, keys
, function
);
871 DEFUN ("local-set-key", Flocal_set_key
, Slocal_set_key
, 2, 2,
872 "kSet key locally: \nCSet key %s locally to command: ",
873 "Give KEY a local binding as COMMAND.\n\
874 COMMAND is a symbol naming an interactively-callable function.\n\
875 KEY is a string representing a sequence of keystrokes.\n\
876 The binding goes in the current buffer's local map,\n\
877 which is shared with other buffers in the same major mode.")
879 Lisp_Object keys
, function
;
881 register Lisp_Object map
;
882 map
= current_buffer
->keymap
;
885 map
= Fmake_sparse_keymap (Qnil
);
886 current_buffer
->keymap
= map
;
889 if (XTYPE (keys
) != Lisp_Vector
890 && XTYPE (keys
) != Lisp_String
)
891 keys
= wrong_type_argument (Qarrayp
, keys
);
893 Fdefine_key (map
, keys
, function
);
897 DEFUN ("global-unset-key", Fglobal_unset_key
, Sglobal_unset_key
,
898 1, 1, "kUnset key globally: ",
899 "Remove global binding of KEY.\n\
900 KEY is a string representing a sequence of keystrokes.")
904 return Fglobal_set_key (keys
, Qnil
);
907 DEFUN ("local-unset-key", Flocal_unset_key
, Slocal_unset_key
, 1, 1,
908 "kUnset key locally: ",
909 "Remove local binding of KEY.\n\
910 KEY is a string representing a sequence of keystrokes.")
914 if (!NILP (current_buffer
->keymap
))
915 Flocal_set_key (keys
, Qnil
);
919 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
920 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
921 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
922 If a second optional argument MAPVAR is given, the map is stored as\n\
923 its value instead of as COMMAND's value; but COMMAND is still defined\n\
926 Lisp_Object name
, mapvar
;
929 map
= Fmake_sparse_keymap (Qnil
);
938 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
939 "Select KEYMAP as the global keymap.")
943 keymap
= get_keymap (keymap
);
944 current_global_map
= keymap
;
948 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
949 "Select KEYMAP as the local keymap.\n\
950 If KEYMAP is nil, that means no local keymap.")
955 keymap
= get_keymap (keymap
);
957 current_buffer
->keymap
= keymap
;
962 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
963 "Return current buffer's local keymap, or nil if it has none.")
966 return current_buffer
->keymap
;
969 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
970 "Return the current global keymap.")
973 return current_global_map
;
976 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
977 "Return a list of keymaps for the minor modes of the current buffer.")
981 int nmaps
= current_minor_maps (0, &maps
);
983 return Flist (nmaps
, maps
);
986 /* Help functions for describing and documenting keymaps. */
988 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
990 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
991 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
992 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
993 so that the KEYS increase in length. The first element is (\"\" . KEYMAP).")
995 Lisp_Object startmap
;
997 Lisp_Object maps
, tail
;
999 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1000 get_keymap (startmap
)),
1003 /* For each map in the list maps,
1004 look at any other maps it points to,
1005 and stick them at the end if they are not already in the list.
1007 This is a breadth-first traversal, where tail is the queue of
1008 nodes, and maps accumulates a list of all nodes visited. */
1010 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1012 register Lisp_Object thisseq
= Fcar (Fcar (tail
));
1013 register Lisp_Object thismap
= Fcdr (Fcar (tail
));
1014 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
1016 /* Does the current sequence end in the meta-prefix-char? */
1017 int is_metized
= (XINT (last
) >= 0
1018 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1020 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1022 Lisp_Object elt
= XCONS (thismap
)->car
;
1026 if (XTYPE (elt
) == Lisp_Vector
)
1030 /* Vector keymap. Scan all the elements. */
1031 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1033 register Lisp_Object tem
;
1034 register Lisp_Object cmd
;
1036 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
]);
1037 if (NILP (cmd
)) continue;
1038 tem
= Fkeymapp (cmd
);
1041 cmd
= get_keymap (cmd
);
1042 /* Ignore keymaps that are already added to maps. */
1043 tem
= Frassq (cmd
, maps
);
1046 /* If the last key in thisseq is meta-prefix-char,
1047 turn it into a meta-ized keystroke. We know
1048 that the event we're about to append is an
1049 ascii keystroke since we're processing a
1053 int meta_bit
= meta_modifier
;
1054 tem
= Fcopy_sequence (thisseq
);
1056 Faset (tem
, last
, make_number (i
| meta_bit
));
1058 /* This new sequence is the same length as
1059 thisseq, so stick it in the list right
1062 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1066 tem
= append_key (thisseq
, make_number (i
));
1067 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1073 else if (CONSP (elt
))
1075 register Lisp_Object cmd
= get_keyelt (XCONS (elt
)->cdr
);
1076 register Lisp_Object tem
;
1078 /* Ignore definitions that aren't keymaps themselves. */
1079 tem
= Fkeymapp (cmd
);
1082 /* Ignore keymaps that have been seen already. */
1083 cmd
= get_keymap (cmd
);
1084 tem
= Frassq (cmd
, maps
);
1087 /* let elt be the event defined by this map entry. */
1088 elt
= XCONS (elt
)->car
;
1090 /* If the last key in thisseq is meta-prefix-char, and
1091 this entry is a binding for an ascii keystroke,
1092 turn it into a meta-ized keystroke. */
1093 if (is_metized
&& XTYPE (elt
) == Lisp_Int
)
1095 tem
= Fcopy_sequence (thisseq
);
1097 make_number (XINT (elt
) | meta_modifier
));
1099 /* This new sequence is the same length as
1100 thisseq, so stick it in the list right
1103 Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1107 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1118 Lisp_Object Qsingle_key_description
, Qkey_description
;
1120 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1121 "Return a pretty description of key-sequence KEYS.\n\
1122 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1123 spaces are put between sequence elements, etc.")
1127 if (XTYPE (keys
) == Lisp_String
)
1131 vector
= Fmake_vector (Flength (keys
), Qnil
);
1132 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1134 if (XSTRING (keys
)->data
[i
] & 0x80)
1135 XFASTINT (XVECTOR (vector
)->contents
[i
])
1136 = meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80);
1138 XFASTINT (XVECTOR (vector
)->contents
[i
])
1139 = XSTRING (keys
)->data
[i
];
1143 return Fmapconcat (Qsingle_key_description
, keys
, build_string (" "));
1147 push_key_description (c
, p
)
1148 register unsigned int c
;
1151 /* Clear all the meaningless bits above the meta bit. */
1152 c
&= meta_modifier
| ~ - meta_modifier
;
1154 if (c
& alt_modifier
)
1160 if (c
& ctrl_modifier
)
1166 if (c
& hyper_modifier
)
1170 c
-= hyper_modifier
;
1172 if (c
& meta_modifier
)
1178 if (c
& shift_modifier
)
1182 c
-= shift_modifier
;
1184 if (c
& super_modifier
)
1188 c
-= super_modifier
;
1204 else if (c
== Ctl('J'))
1210 else if (c
== Ctl('M'))
1220 if (c
> 0 && c
<= Ctl ('Z'))
1243 *p
++ = (7 & (c
>> 15)) + '0';
1244 *p
++ = (7 & (c
>> 12)) + '0';
1245 *p
++ = (7 & (c
>> 9)) + '0';
1246 *p
++ = (7 & (c
>> 6)) + '0';
1247 *p
++ = (7 & (c
>> 3)) + '0';
1248 *p
++ = (7 & (c
>> 0)) + '0';
1254 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1255 "Return a pretty description of command character KEY.\n\
1256 Control characters turn into C-whatever, etc.")
1262 key
= EVENT_HEAD (key
);
1264 switch (XTYPE (key
))
1266 case Lisp_Int
: /* Normal character */
1267 *push_key_description (XUINT (key
), tem
) = 0;
1268 return build_string (tem
);
1270 case Lisp_Symbol
: /* Function key or event-symbol */
1271 return Fsymbol_name (key
);
1274 error ("KEY must be an integer, cons, or symbol.");
1279 push_text_char_description (c
, p
)
1280 register unsigned int c
;
1292 *p
++ = c
+ 64; /* 'A' - 1 */
1304 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1305 "Return a pretty description of file-character CHAR.\n\
1306 Control characters turn into \"^char\", etc.")
1312 CHECK_NUMBER (chr
, 0);
1314 *push_text_char_description (XINT (chr
) & 0377, tem
) = 0;
1316 return build_string (tem
);
1319 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1322 ascii_sequence_p (seq
)
1326 int len
= XINT (Flength (seq
));
1328 for (XFASTINT (i
) = 0; XFASTINT (i
) < len
; XFASTINT (i
)++)
1330 Lisp_Object elt
= Faref (seq
, i
);
1332 if (XTYPE (elt
) != Lisp_Int
1333 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1341 /* where-is - finding a command in a set of keymaps. */
1343 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
1344 "Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.\n\
1345 If KEYMAP is nil, search only KEYMAP1.\n\
1346 If KEYMAP1 is nil, use the current global map.\n\
1348 If optional 4th arg FIRSTONLY is non-nil, return a string representing\n\
1349 the first key sequence found, rather than a list of all possible key\n\
1350 sequences. If FIRSTONLY is t, avoid key sequences which use non-ASCII\n\
1351 keys and therefore may not be usable on ASCII terminals. If FIRSTONLY\n\
1352 is the symbol `non-ascii', return the first binding found, no matter\n\
1353 what its components.\n\
1355 If optional 5th arg NOINDIRECT is non-nil, don't follow indirections\n\
1356 to other keymaps or slots. This makes it possible to search for an\n\
1357 indirect definition itself.")
1358 (definition
, local_keymap
, global_keymap
, firstonly
, noindirect
)
1359 Lisp_Object definition
, local_keymap
, global_keymap
;
1360 Lisp_Object firstonly
, noindirect
;
1362 register Lisp_Object maps
;
1365 if (NILP (global_keymap
))
1366 global_keymap
= current_global_map
;
1368 if (!NILP (local_keymap
))
1369 maps
= nconc2 (Faccessible_keymaps (get_keymap (local_keymap
)),
1370 Faccessible_keymaps (get_keymap (global_keymap
)));
1372 maps
= Faccessible_keymaps (get_keymap (global_keymap
));
1376 for (; !NILP (maps
); maps
= Fcdr (maps
))
1378 /* Key sequence to reach map */
1379 register Lisp_Object
this = Fcar (Fcar (maps
));
1381 /* The map that it reaches */
1382 register Lisp_Object map
= Fcdr (Fcar (maps
));
1384 /* If Fcar (map) is a VECTOR, the current element within that vector. */
1387 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1388 [M-CHAR] sequences, check if last character of the sequence
1389 is the meta-prefix char. */
1390 Lisp_Object last
= make_number (XINT (Flength (this)) - 1);
1391 int last_is_meta
= (XINT (last
) >= 0
1392 && EQ (Faref (this, last
), meta_prefix_char
));
1398 /* Because the code we want to run on each binding is rather
1399 large, we don't want to have two separate loop bodies for
1400 sparse keymap bindings and tables; we want to iterate one
1401 loop body over both keymap and vector bindings.
1403 For this reason, if Fcar (map) is a vector, we don't
1404 advance map to the next element until i indicates that we
1405 have finished off the vector. */
1407 Lisp_Object elt
= XCONS (map
)->car
;
1408 Lisp_Object key
, binding
, sequence
;
1412 /* Set key and binding to the current key and binding, and
1413 advance map and i to the next binding. */
1414 if (XTYPE (elt
) == Lisp_Vector
)
1416 /* In a vector, look at each element. */
1417 binding
= XVECTOR (elt
)->contents
[i
];
1421 /* If we've just finished scanning a vector, advance map
1422 to the next element, and reset i in anticipation of the
1423 next vector we may find. */
1424 if (i
>= XVECTOR (elt
)->size
)
1426 map
= XCONS (map
)->cdr
;
1430 else if (CONSP (elt
))
1432 key
= Fcar (Fcar (map
));
1433 binding
= Fcdr (Fcar (map
));
1435 map
= XCONS (map
)->cdr
;
1438 /* We want to ignore keymap elements that are neither
1439 vectors nor conses. */
1441 map
= XCONS (map
)->cdr
;
1445 /* Search through indirections unless that's not wanted. */
1446 if (NILP (noindirect
))
1447 binding
= get_keyelt (binding
);
1449 /* End this iteration if this element does not match
1452 if (XTYPE (definition
) == Lisp_Cons
)
1455 tem
= Fequal (binding
, definition
);
1460 if (!EQ (binding
, definition
))
1463 /* We have found a match.
1464 Construct the key sequence where we found it. */
1465 if (XTYPE (key
) == Lisp_Int
&& last_is_meta
)
1467 sequence
= Fcopy_sequence (this);
1468 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
1471 sequence
= append_key (this, key
);
1473 /* Verify that this key binding is not shadowed by another
1474 binding for the same key, before we say it exists.
1476 Mechanism: look for local definition of this key and if
1477 it is defined and does not match what we found then
1480 Either nil or number as value from Flookup_key
1482 if (!NILP (local_keymap
))
1484 binding
= Flookup_key (local_keymap
, sequence
, Qnil
);
1485 if (!NILP (binding
) && XTYPE (binding
) != Lisp_Int
)
1487 if (XTYPE (definition
) == Lisp_Cons
)
1490 tem
= Fequal (binding
, definition
);
1495 if (!EQ (binding
, definition
))
1500 /* It is a true unshadowed match. Record it. */
1501 found
= Fcons (sequence
, found
);
1503 /* If firstonly is Qnon_ascii, then we can return the first
1504 binding we find. If firstonly is not Qnon_ascii but not
1505 nil, then we should return the first ascii-only binding
1507 if (EQ (firstonly
, Qnon_ascii
))
1509 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
1514 found
= Fnreverse (found
);
1516 /* firstonly may have been t, but we may have gone all the way through
1517 the keymaps without finding an all-ASCII key sequence. So just
1518 return the best we could find. */
1519 if (! NILP (firstonly
))
1520 return Fcar (found
);
1525 /* Return a string listing the keys and buttons that run DEFINITION. */
1528 where_is_string (definition
)
1529 Lisp_Object definition
;
1531 register Lisp_Object keys
, keys1
;
1533 keys
= Fwhere_is_internal (definition
,
1534 current_buffer
->keymap
, Qnil
, Qnil
, Qnil
);
1535 keys1
= Fmapconcat (Qkey_description
, keys
, build_string (", "));
1540 DEFUN ("where-is", Fwhere_is
, Swhere_is
, 1, 1, "CWhere is command: ",
1541 "Print message listing key sequences that invoke specified command.\n\
1542 Argument is a command definition, usually a symbol with a function definition.")
1544 Lisp_Object definition
;
1546 register Lisp_Object string
;
1548 CHECK_SYMBOL (definition
, 0);
1549 string
= where_is_string (definition
);
1551 if (XSTRING (string
)->size
)
1552 message ("%s is on %s", XSYMBOL (definition
)->name
->data
,
1553 XSTRING (string
)->data
);
1555 message ("%s is not on any key", XSYMBOL (definition
)->name
->data
);
1559 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
1561 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 0, "",
1562 "Show a list of all defined keys, and their definitions.\n\
1563 The list is put in a buffer, which is displayed.")
1566 register Lisp_Object thisbuf
;
1567 XSET (thisbuf
, Lisp_Buffer
, current_buffer
);
1568 internal_with_output_to_temp_buffer ("*Help*",
1569 describe_buffer_bindings
,
1575 describe_buffer_bindings (descbuf
)
1576 Lisp_Object descbuf
;
1578 register Lisp_Object start1
, start2
;
1584 char *alternate_heading
1586 Alternate Characters (use anywhere the nominal character is listed):\n\
1587 nominal alternate\n\
1588 ------- ---------\n";
1590 Fset_buffer (Vstandard_output
);
1592 /* Report on alternates for keys. */
1593 if (XTYPE (Vkeyboard_translate_table
) == Lisp_String
)
1596 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
1597 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
1599 for (c
= 0; c
< translate_len
; c
++)
1600 if (translate
[c
] != c
)
1605 if (alternate_heading
)
1607 insert_string (alternate_heading
);
1608 alternate_heading
= 0;
1611 bufend
= push_key_description (translate
[c
], buf
);
1612 insert (buf
, bufend
- buf
);
1613 Findent_to (make_number (16), make_number (1));
1614 bufend
= push_key_description (c
, buf
);
1615 insert (buf
, bufend
- buf
);
1625 Lisp_Object
*modes
, *maps
;
1627 /* Temporarily switch to descbuf, so that we can get that buffer's
1628 minor modes correctly. */
1629 Fset_buffer (descbuf
);
1630 nmaps
= current_minor_maps (&modes
, &maps
);
1631 Fset_buffer (Vstandard_output
);
1633 for (i
= 0; i
< nmaps
; i
++)
1635 if (XTYPE (modes
[i
]) == Lisp_Symbol
)
1638 insert_string (XSYMBOL (modes
[i
])->name
->data
);
1642 insert_string ("Strangely Named");
1643 insert_string (" Minor Mode Bindings:\n");
1644 insert_string (key_heading
);
1645 describe_map_tree (maps
[i
], 0, Qnil
);
1650 start1
= XBUFFER (descbuf
)->keymap
;
1653 insert_string ("Local Bindings:\n");
1654 insert_string (key_heading
);
1655 describe_map_tree (start1
, 0, Qnil
);
1656 insert_string ("\n");
1659 insert_string ("Global Bindings:\n");
1661 insert_string (key_heading
);
1663 describe_map_tree (current_global_map
, 0, XBUFFER (descbuf
)->keymap
);
1665 Fset_buffer (descbuf
);
1669 /* Insert a desription of the key bindings in STARTMAP,
1670 followed by those of all maps reachable through STARTMAP.
1671 If PARTIAL is nonzero, omit certain "uninteresting" commands
1672 (such as `undefined').
1673 If SHADOW is non-nil, it is another map;
1674 don't mention keys which would be shadowed by it. */
1677 describe_map_tree (startmap
, partial
, shadow
)
1678 Lisp_Object startmap
, shadow
;
1681 register Lisp_Object elt
, sh
;
1683 struct gcpro gcpro1
;
1685 maps
= Faccessible_keymaps (startmap
);
1688 for (; !NILP (maps
); maps
= Fcdr (maps
))
1693 /* If there is no shadow keymap given, don't shadow. */
1697 /* If the sequence by which we reach this keymap is zero-length,
1698 then the shadow map for this keymap is just SHADOW. */
1699 else if ((XTYPE (sh
) == Lisp_String
1700 && XSTRING (sh
)->size
== 0)
1701 || (XTYPE (sh
) == Lisp_Vector
1702 && XVECTOR (sh
)->size
== 0))
1705 /* If the sequence by which we reach this keymap actually has
1706 some elements, then the sequence's definition in SHADOW is
1707 what we should use. */
1710 sh
= Flookup_key (shadow
, Fcar (elt
), Qt
);
1711 if (XTYPE (sh
) == Lisp_Int
)
1715 /* If sh is null (meaning that the current map is not shadowed),
1716 or a keymap (meaning that bindings from the current map might
1717 show through), describe the map. Otherwise, sh is a command
1718 that completely shadows the current map, and we shouldn't
1720 if (NILP (sh
) || !NILP (Fkeymapp (sh
)))
1721 describe_map (Fcdr (elt
), Fcar (elt
), partial
, sh
);
1728 describe_command (definition
)
1729 Lisp_Object definition
;
1731 register Lisp_Object tem1
;
1733 Findent_to (make_number (16), make_number (1));
1735 if (XTYPE (definition
) == Lisp_Symbol
)
1737 XSET (tem1
, Lisp_String
, XSYMBOL (definition
)->name
);
1739 insert_string ("\n");
1743 tem1
= Fkeymapp (definition
);
1745 insert_string ("Prefix Command\n");
1747 insert_string ("??\n");
1751 /* Describe the contents of map MAP, assuming that this map itself is
1752 reached by the sequence of prefix keys KEYS (a string or vector).
1753 PARTIAL, SHADOW is as in `describe_map_tree' above. */
1756 describe_map (map
, keys
, partial
, shadow
)
1757 Lisp_Object map
, keys
;
1761 register Lisp_Object keysdesc
;
1763 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
1766 /* Call Fkey_description first, to avoid GC bug for the other string. */
1767 tem
= Fkey_description (keys
);
1768 keysdesc
= concat2 (tem
, build_string (" "));
1773 describe_map_2 (map
, keysdesc
, describe_command
, partial
, shadow
);
1776 /* Insert a description of KEYMAP into the current buffer. */
1779 describe_map_2 (keymap
, elt_prefix
, elt_describer
, partial
, shadow
)
1780 register Lisp_Object keymap
;
1781 Lisp_Object elt_prefix
;
1782 int (*elt_describer
) ();
1787 Lisp_Object tem1
, tem2
= Qnil
;
1788 Lisp_Object suppress
;
1791 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1794 suppress
= intern ("suppress-keymap");
1796 /* This vector gets used to present single keys to Flookup_key. Since
1797 that is done once per keymap element, we don't want to cons up a
1798 fresh vector every time. */
1799 kludge
= Fmake_vector (make_number (1), Qnil
);
1801 GCPRO3 (elt_prefix
, tem2
, kludge
);
1803 for (; CONSP (keymap
); keymap
= Fcdr (keymap
))
1807 if (XTYPE (XCONS (keymap
)->car
) == Lisp_Vector
)
1808 describe_vector (XCONS (keymap
)->car
,
1809 elt_prefix
, elt_describer
, partial
, shadow
);
1812 tem1
= Fcar_safe (Fcar (keymap
));
1813 tem2
= get_keyelt (Fcdr_safe (Fcar (keymap
)));
1815 /* Don't show undefined commands or suppressed commands. */
1816 if (NILP (tem2
)) continue;
1817 if (XTYPE (tem2
) == Lisp_Symbol
&& partial
)
1819 this = Fget (tem2
, suppress
);
1824 /* Don't show a command that isn't really visible
1825 because a local definition of the same key shadows it. */
1831 XVECTOR (kludge
)->contents
[0] = tem1
;
1832 tem
= Flookup_key (shadow
, kludge
, Qt
);
1833 if (!NILP (tem
)) continue;
1842 if (!NILP (elt_prefix
))
1843 insert1 (elt_prefix
);
1845 /* THIS gets the string to describe the character TEM1. */
1846 this = Fsingle_key_description (tem1
);
1849 /* Print a description of the definition of this character.
1850 elt_describer will take care of spacing out far enough
1851 for alignment purposes. */
1852 (*elt_describer
) (tem2
);
1860 describe_vector_princ (elt
)
1866 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
1867 "Print on `standard-output' a description of contents of VECTOR.\n\
1868 This is text showing the elements of vector matched against indices.")
1872 CHECK_VECTOR (vector
, 0);
1873 describe_vector (vector
, Qnil
, describe_vector_princ
, 0, Qnil
);
1876 describe_vector (vector
, elt_prefix
, elt_describer
, partial
, shadow
)
1877 register Lisp_Object vector
;
1878 Lisp_Object elt_prefix
;
1879 int (*elt_describer
) ();
1885 Lisp_Object tem1
, tem2
;
1887 Lisp_Object suppress
;
1890 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1894 /* This vector gets used to present single keys to Flookup_key. Since
1895 that is done once per vector element, we don't want to cons up a
1896 fresh vector every time. */
1897 kludge
= Fmake_vector (make_number (1), Qnil
);
1898 GCPRO3 (elt_prefix
, tem1
, kludge
);
1901 suppress
= intern ("suppress-keymap");
1903 for (i
= 0; i
< XVECTOR (vector
)->size
; i
++)
1906 tem1
= get_keyelt (XVECTOR (vector
)->contents
[i
]);
1908 if (NILP (tem1
)) continue;
1910 /* Don't mention suppressed commands. */
1911 if (XTYPE (tem1
) == Lisp_Symbol
&& partial
)
1913 this = Fget (tem1
, suppress
);
1918 /* If this command in this map is shadowed by some other map,
1924 XVECTOR (kludge
)->contents
[0] = make_number (i
);
1925 tem
= Flookup_key (shadow
, kludge
, Qt
);
1927 if (!NILP (tem
)) continue;
1936 /* Output the prefix that applies to every entry in this map. */
1937 if (!NILP (elt_prefix
))
1938 insert1 (elt_prefix
);
1940 /* Get the string to describe the character I, and print it. */
1941 XFASTINT (dummy
) = i
;
1943 /* THIS gets the string to describe the character DUMMY. */
1944 this = Fsingle_key_description (dummy
);
1947 /* Find all consecutive characters that have the same definition. */
1948 while (i
+ 1 < XVECTOR (vector
)->size
1949 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+1]),
1953 /* If we have a range of more than one character,
1954 print where the range reaches to. */
1956 if (i
!= XINT (dummy
))
1959 if (!NILP (elt_prefix
))
1960 insert1 (elt_prefix
);
1962 XFASTINT (dummy
) = i
;
1963 insert1 (Fsingle_key_description (dummy
));
1966 /* Print a description of the definition of this character.
1967 elt_describer will take care of spacing out far enough
1968 for alignment purposes. */
1969 (*elt_describer
) (tem1
);
1975 /* Apropos - finding all symbols whose names match a regexp. */
1976 Lisp_Object apropos_predicate
;
1977 Lisp_Object apropos_accumulate
;
1980 apropos_accum (symbol
, string
)
1981 Lisp_Object symbol
, string
;
1983 register Lisp_Object tem
;
1985 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
1986 if (!NILP (tem
) && !NILP (apropos_predicate
))
1987 tem
= call1 (apropos_predicate
, symbol
);
1989 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
1992 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
1993 "Show all symbols whose names contain match for REGEXP.\n\
1994 If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done\n\
1995 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
1996 Return list of symbols found.")
1998 Lisp_Object string
, pred
;
2000 struct gcpro gcpro1
, gcpro2
;
2001 CHECK_STRING (string
, 0);
2002 apropos_predicate
= pred
;
2003 GCPRO2 (apropos_predicate
, apropos_accumulate
);
2004 apropos_accumulate
= Qnil
;
2005 map_obarray (Vobarray
, apropos_accum
, string
);
2006 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
2008 return apropos_accumulate
;
2015 Qkeymap
= intern ("keymap");
2016 staticpro (&Qkeymap
);
2018 /* Initialize the keymaps standardly used.
2019 Each one is the value of a Lisp variable, and is also
2020 pointed to by a C variable */
2022 global_map
= Fcons (Qkeymap
,
2023 Fcons (Fmake_vector (make_number (0400), Qnil
), Qnil
));
2024 Fset (intern ("global-map"), global_map
);
2026 meta_map
= Fmake_keymap (Qnil
);
2027 Fset (intern ("esc-map"), meta_map
);
2028 Ffset (intern ("ESC-prefix"), meta_map
);
2030 control_x_map
= Fmake_keymap (Qnil
);
2031 Fset (intern ("ctl-x-map"), control_x_map
);
2032 Ffset (intern ("Control-X-prefix"), control_x_map
);
2034 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
2035 "Default keymap to use when reading from the minibuffer.");
2036 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
2038 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
2039 "Local keymap for the minibuffer when spaces are not allowed.");
2040 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
2042 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
2043 "Local keymap for minibuffer input with completion.");
2044 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
2046 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
2047 "Local keymap for minibuffer input with completion, for exact match.");
2048 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
2050 current_global_map
= global_map
;
2052 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
2053 "Alist of keymaps to use for minor modes.\n\
2054 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
2055 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
2056 If two active keymaps bind the same key, the keymap appearing earlier\n\
2057 in the list takes precedence.");
2058 Vminor_mode_map_alist
= Qnil
;
2060 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
2061 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
2062 This allows Emacs to recognize function keys sent from ASCII\n\
2063 terminals at any point in a key sequence.\n\
2065 The read-key-sequence function replaces subsequences bound by\n\
2066 function-key-map with their bindings. When the current local and global\n\
2067 keymaps have no binding for the current key sequence but\n\
2068 function-key-map binds a suffix of the sequence to a vector,\n\
2069 read-key-sequence replaces the matching suffix with its binding, and\n\
2070 continues with the new sequence.\n\
2072 For example, suppose function-key-map binds `ESC O P' to [pf1].\n\
2073 Typing `ESC O P' to read-key-sequence would return [pf1]. Typing\n\
2074 `C-x ESC O P' would return [?\C-x pf1]. If [pf1] were a prefix\n\
2075 key, typing `ESC O P x' would return [pf1 x].");
2076 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
2078 Qsingle_key_description
= intern ("single-key-description");
2079 staticpro (&Qsingle_key_description
);
2081 Qkey_description
= intern ("key-description");
2082 staticpro (&Qkey_description
);
2084 Qkeymapp
= intern ("keymapp");
2085 staticpro (&Qkeymapp
);
2087 Qnon_ascii
= intern ("non-ascii");
2088 staticpro (&Qnon_ascii
);
2090 defsubr (&Skeymapp
);
2091 defsubr (&Smake_keymap
);
2092 defsubr (&Smake_sparse_keymap
);
2093 defsubr (&Scopy_keymap
);
2094 defsubr (&Skey_binding
);
2095 defsubr (&Slocal_key_binding
);
2096 defsubr (&Sglobal_key_binding
);
2097 defsubr (&Sminor_mode_key_binding
);
2098 defsubr (&Sglobal_set_key
);
2099 defsubr (&Slocal_set_key
);
2100 defsubr (&Sdefine_key
);
2101 defsubr (&Slookup_key
);
2102 defsubr (&Sglobal_unset_key
);
2103 defsubr (&Slocal_unset_key
);
2104 defsubr (&Sdefine_prefix_command
);
2105 defsubr (&Suse_global_map
);
2106 defsubr (&Suse_local_map
);
2107 defsubr (&Scurrent_local_map
);
2108 defsubr (&Scurrent_global_map
);
2109 defsubr (&Scurrent_minor_mode_maps
);
2110 defsubr (&Saccessible_keymaps
);
2111 defsubr (&Skey_description
);
2112 defsubr (&Sdescribe_vector
);
2113 defsubr (&Ssingle_key_description
);
2114 defsubr (&Stext_char_description
);
2115 defsubr (&Swhere_is_internal
);
2116 defsubr (&Swhere_is
);
2117 defsubr (&Sdescribe_bindings
);
2118 defsubr (&Sapropos_internal
);
2125 initial_define_key (global_map
, 033, "ESC-prefix");
2126 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");