1 /* Manipulation of keymaps
2 Copyright (C) 1985, 1986, 1987, 1988, 1992 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. */
29 #define min(a, b) ((a) < (b) ? (a) : (b))
31 /* The number of elements in keymap vectors. */
32 #define DENSE_TABLE_SIZE (0200)
34 /* Actually allocate storage for these variables */
36 Lisp_Object current_global_map
; /* Current global keymap */
38 Lisp_Object global_map
; /* default global key bindings */
40 Lisp_Object meta_map
; /* The keymap used for globally bound
41 ESC-prefixed default commands */
43 Lisp_Object control_x_map
; /* The keymap used for globally bound
44 C-x-prefixed default commands */
46 /* was MinibufLocalMap */
47 Lisp_Object Vminibuffer_local_map
;
48 /* The keymap used by the minibuf for local
49 bindings when spaces are allowed in the
52 /* was MinibufLocalNSMap */
53 Lisp_Object Vminibuffer_local_ns_map
;
54 /* The keymap used by the minibuf for local
55 bindings when spaces are not encouraged
58 /* keymap used for minibuffers when doing completion */
59 /* was MinibufLocalCompletionMap */
60 Lisp_Object Vminibuffer_local_completion_map
;
62 /* keymap used for minibuffers when doing completion and require a match */
63 /* was MinibufLocalMustMatchMap */
64 Lisp_Object Vminibuffer_local_must_match_map
;
66 /* Alist of minor mode variables and keymaps. */
67 Lisp_Object Vminor_mode_map_alist
;
69 /* Keymap mapping ASCII function key sequences onto their preferred forms.
70 Initialized by the terminal-specific lisp files. See DEFVAR for more
72 Lisp_Object Vfunction_key_map
;
74 Lisp_Object Qkeymapp
, Qkeymap
;
76 /* A char over 0200 in a key sequence
77 is equivalent to prefixing with this character. */
79 extern Lisp_Object meta_prefix_char
;
81 void describe_map_tree ();
82 static Lisp_Object
describe_buffer_bindings ();
83 static void describe_command ();
84 static void describe_map ();
85 static void describe_map_2 ();
87 /* Keymap object support - constructors and predicates. */
89 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
90 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
91 VECTOR is a 128-element vector which holds the bindings for the ASCII\n\
92 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
93 mouse events, and any other things that appear in the input stream.\n\
94 All entries in it are initially nil, meaning \"command undefined\".\n\n\
95 The optional arg STRING supplies a menu name for the keymap\n\
96 in case you use it as a menu with `x-popup-menu'.")
102 tail
= Fcons (string
, Qnil
);
105 return Fcons (Qkeymap
,
106 Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE
), Qnil
),
110 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
111 "Construct and return a new sparse-keymap list.\n\
112 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
113 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
114 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
115 Initially the alist is nil.\n\n\
116 The optional arg STRING supplies a menu name for the keymap\n\
117 in case you use it as a menu with `x-popup-menu'.")
122 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
123 return Fcons (Qkeymap
, Qnil
);
126 /* This function is used for installing the standard key bindings
127 at initialization time.
131 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark");
133 I haven't extended these to allow the initializing code to bind
134 function keys and mouse events; since they are called by many files,
135 I'd have to fix lots of callers, and nobody right now would be using
136 the new functionality, so it seems like a waste of time. But there's
137 no technical reason not to. -JimB */
140 initial_define_key (keymap
, key
, defname
)
145 store_in_keymap (keymap
, make_number (key
), intern (defname
));
148 /* Define character fromchar in map frommap as an alias for character
149 tochar in map tomap. Subsequent redefinitions of the latter WILL
150 affect the former. */
154 synkey (frommap
, fromchar
, tomap
, tochar
)
155 struct Lisp_Vector
*frommap
, *tomap
;
156 int fromchar
, tochar
;
159 XSET (v
, Lisp_Vector
, tomap
);
160 XFASTINT (c
) = tochar
;
161 frommap
->contents
[fromchar
] = Fcons (v
, c
);
165 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
166 "Return t if ARG is a keymap.\n\
168 A keymap is list (keymap . ALIST), a list (keymap VECTOR . ALIST),\n\
169 or a symbol whose function definition is a keymap is itself a keymap.\n\
170 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
171 VECTOR is a 128-element vector of bindings for ASCII characters.")
175 return (NILP (get_keymap_1 (object
, 0)) ? Qnil
: Qt
);
178 /* Check that OBJECT is a keymap (after dereferencing through any
179 symbols). If it is, return it; otherwise, return nil, or signal an
180 error if ERROR != 0. */
182 get_keymap_1 (object
, error
)
186 register Lisp_Object tem
;
188 tem
= indirect_function (object
);
189 if (CONSP (tem
) && EQ (XCONS (tem
)->car
, Qkeymap
))
193 wrong_type_argument (Qkeymapp
, object
);
202 return get_keymap_1 (object
, 1);
206 /* Look up IDX in MAP. IDX may be any sort of event.
207 Note that this does only one level of lookup; IDX must be a single
208 event, not a sequence. */
211 access_keymap (map
, idx
)
215 /* If idx is a list (some sort of mouse click, perhaps?),
216 the index we want to use is the car of the list, which
217 ought to be a symbol. */
218 idx
= EVENT_HEAD (idx
);
220 if (XTYPE (idx
) == Lisp_Int
221 && (XINT (idx
) < 0 || XINT (idx
) >= DENSE_TABLE_SIZE
))
222 error ("only ASCII characters may used as keymap indices");
224 /* If idx is a symbol, it might have modifiers, which need to
225 be put in the canonical order. */
226 else if (XTYPE (idx
) == Lisp_Symbol
)
227 idx
= reorder_modifiers (idx
);
232 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
234 Lisp_Object binding
= XCONS (tail
)->car
;
236 switch (XTYPE (binding
))
239 if (EQ (XCONS (binding
)->car
, idx
))
240 return XCONS (binding
)->cdr
;
244 if (XVECTOR (binding
)->size
== DENSE_TABLE_SIZE
245 && XTYPE (idx
) == Lisp_Int
)
246 return XVECTOR (binding
)->contents
[XINT (idx
)];
257 /* Given OBJECT which was found in a slot in a keymap,
258 trace indirect definitions to get the actual definition of that slot.
259 An indirect definition is a list of the form
260 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
261 and INDEX is the object to look up in KEYMAP to yield the definition.
263 Also if OBJECT has a menu string as the first element,
264 remove that. Also remove a menu help string as second element. */
268 register Lisp_Object object
;
272 register Lisp_Object map
, tem
;
274 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
275 map
= get_keymap_1 (Fcar_safe (object
), 0);
276 tem
= Fkeymapp (map
);
278 object
= access_keymap (map
, Fcdr (object
));
280 /* If the keymap contents looks like (STRING . DEFN),
282 Keymap alist elements like (CHAR MENUSTRING . DEFN)
283 will be used by HierarKey menus. */
284 else if (XTYPE (object
) == Lisp_Cons
285 && XTYPE (XCONS (object
)->car
) == Lisp_String
)
287 object
= XCONS (object
)->cdr
;
288 /* Also remove a menu help string, if any,
289 following the menu item name. */
290 if (XTYPE (object
) == Lisp_Cons
291 && XTYPE (XCONS (object
)->car
) == Lisp_String
)
292 object
= XCONS (object
)->cdr
;
296 /* Anything else is really the value. */
302 store_in_keymap (keymap
, idx
, def
)
304 register Lisp_Object idx
;
305 register Lisp_Object def
;
307 if (XTYPE (keymap
) != Lisp_Cons
308 || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
309 error ("attempt to define a key in a non-keymap");
311 /* If idx is a list (some sort of mouse click, perhaps?),
312 the index we want to use is the car of the list, which
313 ought to be a symbol. */
314 idx
= EVENT_HEAD (idx
);
316 if (XTYPE (idx
) == Lisp_Int
317 && (XINT (idx
) < 0 || XINT (idx
) >= DENSE_TABLE_SIZE
))
318 error ("only ASCII characters may be used as keymap indices");
320 /* If idx is a symbol, it might have modifiers, which need to
321 be put in the canonical order. */
322 else if (XTYPE (idx
) == Lisp_Symbol
)
323 idx
= reorder_modifiers (idx
);
326 /* Scan the keymap for a binding of idx. */
330 /* The cons after which we should insert new bindings. If the
331 keymap has a table element, we record its position here, so new
332 bindings will go after it; this way, the table will stay
333 towards the front of the alist and character lookups in dense
334 keymaps will remain fast. Otherwise, this just points at the
335 front of the keymap. */
336 Lisp_Object insertion_point
= keymap
;
338 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
340 Lisp_Object elt
= XCONS (tail
)->car
;
345 if (XTYPE (idx
) == Lisp_Int
)
347 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
350 insertion_point
= tail
;
354 if (EQ (idx
, XCONS (elt
)->car
))
356 XCONS (elt
)->cdr
= def
;
362 /* If we find a 'keymap' symbol in the spine of KEYMAP,
363 then we must have found the start of a second keymap
364 being used as the tail of KEYMAP, and a binding for IDX
365 should be inserted before it. */
366 if (EQ (elt
, Qkeymap
))
373 /* We have scanned the entire keymap, and not found a binding for
374 IDX. Let's add one. */
375 XCONS (insertion_point
)->cdr
=
376 Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
383 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
384 "Return a copy of the keymap KEYMAP.\n\
385 The copy starts out with the same definitions of KEYMAP,\n\
386 but changing either the copy or KEYMAP does not affect the other.\n\
387 Any key definitions that are subkeymaps are recursively copied.\n\
388 However, a key definition which is a symbol whose definition is a keymap\n\
393 register Lisp_Object copy
, tail
;
395 copy
= Fcopy_alist (get_keymap (keymap
));
397 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
399 Lisp_Object elt
= XCONS (tail
)->car
;
401 if (XTYPE (elt
) == Lisp_Vector
402 && XVECTOR (elt
)->size
== DENSE_TABLE_SIZE
)
406 elt
= Fcopy_sequence (elt
);
407 XCONS (tail
)->car
= elt
;
409 for (i
= 0; i
< DENSE_TABLE_SIZE
; i
++)
410 if (XTYPE (XVECTOR (elt
)->contents
[i
]) != Lisp_Symbol
411 && Fkeymapp (XVECTOR (elt
)->contents
[i
]))
412 XVECTOR (elt
)->contents
[i
] =
413 Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
416 && XTYPE (XCONS (elt
)->cdr
) != Lisp_Symbol
417 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
418 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
424 /* Simple Keymap mutators and accessors. */
426 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
427 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
428 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
429 meaning a sequence of keystrokes and events.\n\
430 DEF is anything that can be a key's definition:\n\
431 nil (means key is undefined in this keymap),\n\
432 a command (a Lisp function suitable for interactive calling)\n\
433 a string (treated as a keyboard macro),\n\
434 a keymap (to define a prefix key),\n\
435 a symbol. When the key is looked up, the symbol will stand for its\n\
436 function definition, which should at that time be one of the above,\n\
437 or another symbol whose function definition is used, etc.\n\
438 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
439 (DEFN should be a valid definition in its own right),\n\
440 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
442 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
443 the front of KEYMAP.")
445 register Lisp_Object keymap
;
450 register Lisp_Object c
;
451 register Lisp_Object tem
;
452 register Lisp_Object cmd
;
456 keymap
= get_keymap (keymap
);
458 if (XTYPE (key
) != Lisp_Vector
459 && XTYPE (key
) != Lisp_String
)
460 key
= wrong_type_argument (Qarrayp
, key
);
462 length
= Flength (key
);
469 c
= Faref (key
, make_number (idx
));
471 if (XTYPE (c
) == Lisp_Int
475 c
= meta_prefix_char
;
480 if (XTYPE (c
) == Lisp_Int
)
481 XSETINT (c
, XINT (c
) & 0177);
488 return store_in_keymap (keymap
, c
, def
);
490 cmd
= get_keyelt (access_keymap (keymap
, c
));
494 cmd
= Fmake_sparse_keymap (Qnil
);
495 store_in_keymap (keymap
, c
, cmd
);
498 tem
= Fkeymapp (cmd
);
500 error ("Key sequence %s uses invalid prefix characters",
501 XSTRING (key
)->data
);
503 keymap
= get_keymap (cmd
);
507 /* Value is number if KEY is too long; NIL if valid but has no definition. */
509 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 2, 0,
510 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
511 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
512 A number as value means KEY is \"too long\";\n\
513 that is, characters or symbols in it except for the last one\n\
514 fail to be a valid sequence of prefix characters in KEYMAP.\n\
515 The number is how many characters at the front of KEY\n\
516 it takes to reach a non-prefix command.")
518 register Lisp_Object keymap
;
522 register Lisp_Object tem
;
523 register Lisp_Object cmd
;
524 register Lisp_Object c
;
528 keymap
= get_keymap (keymap
);
530 if (XTYPE (key
) != Lisp_Vector
531 && XTYPE (key
) != Lisp_String
)
532 key
= wrong_type_argument (Qarrayp
, key
);
534 length
= Flength (key
);
541 c
= Faref (key
, make_number (idx
));
543 if (XTYPE (c
) == Lisp_Int
547 c
= meta_prefix_char
;
552 if (XTYPE (c
) == Lisp_Int
)
553 XSETINT (c
, XINT (c
) & 0177);
559 cmd
= get_keyelt (access_keymap (keymap
, c
));
563 tem
= Fkeymapp (cmd
);
565 return make_number (idx
);
567 keymap
= get_keymap (cmd
);
572 /* Append a key to the end of a key sequence. If key_sequence is a
573 string and key is a character, the result will be another string;
574 otherwise, it will be a vector. */
576 append_key (key_sequence
, key
)
577 Lisp_Object key_sequence
, key
;
581 args
[0] = key_sequence
;
583 if (XTYPE (key_sequence
) == Lisp_String
584 && XTYPE (key
) == Lisp_Int
)
586 args
[1] = Fchar_to_string (key
);
587 return Fconcat (2, args
);
591 args
[1] = Fcons (key
, Qnil
);
592 return Fvconcat (2, args
);
597 /* Global, local, and minor mode keymap stuff. */
599 /* We can't put these variables inside current_minor_maps, since under
600 some systems, static gets macro-defined to be the empty string.
602 static Lisp_Object
*cmm_modes
, *cmm_maps
;
605 /* Store a pointer to an array of the keymaps of the currently active
606 minor modes in *buf, and return the number of maps it contains.
608 This function always returns a pointer to the same buffer, and may
609 free or reallocate it, so if you want to keep it for a long time or
610 hand it out to lisp code, copy it. This procedure will be called
611 for every key sequence read, so the nice lispy approach (return a
612 new assoclist, list, what have you) for each invocation would
613 result in a lot of consing over time.
615 If we used xrealloc/xmalloc and ran out of memory, they would throw
616 back to the command loop, which would try to read a key sequence,
617 which would call this function again, resulting in an infinite
618 loop. Instead, we'll use realloc/malloc and silently truncate the
619 list, let the key sequence be read, and hope some other piece of
620 code signals the error. */
622 current_minor_maps (modeptr
, mapptr
)
623 Lisp_Object
**modeptr
, **mapptr
;
626 Lisp_Object alist
, assoc
, var
, val
;
628 for (alist
= Vminor_mode_map_alist
;
630 alist
= XCONS (alist
)->cdr
)
631 if (CONSP (assoc
= XCONS (alist
)->car
)
632 && XTYPE (var
= XCONS (assoc
)->car
) == Lisp_Symbol
633 && ! EQ ((val
= find_symbol_value (var
)), Qunbound
)
638 Lisp_Object
*newmodes
, *newmaps
;
642 newmodes
= (Lisp_Object
*) realloc (cmm_modes
, cmm_size
*= 2);
643 newmaps
= (Lisp_Object
*) realloc (cmm_maps
, cmm_size
);
647 newmodes
= (Lisp_Object
*) malloc (cmm_size
= 30);
648 newmaps
= (Lisp_Object
*) malloc (cmm_size
);
651 if (newmaps
&& newmodes
)
653 cmm_modes
= newmodes
;
660 cmm_maps
[i
] = XCONS (assoc
)->cdr
;
664 if (modeptr
) *modeptr
= cmm_modes
;
665 if (mapptr
) *mapptr
= cmm_maps
;
669 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 1, 0,
670 "Return the binding for command KEY in current keymaps.\n\
671 KEY is a string, a sequence of keystrokes.\n\
672 The binding is probably a symbol with a function definition.")
676 Lisp_Object
*maps
, value
;
679 nmaps
= current_minor_maps (0, &maps
);
680 for (i
= 0; i
< nmaps
; i
++)
681 if (! NILP (maps
[i
]))
683 value
= Flookup_key (maps
[i
], key
);
684 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
688 if (! NILP (current_buffer
->keymap
))
690 value
= Flookup_key (current_buffer
->keymap
, key
);
691 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
695 value
= Flookup_key (current_global_map
, key
);
696 if (! NILP (value
) && XTYPE (value
) != Lisp_Int
)
702 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 1, 0,
703 "Return the binding for command KEYS in current local keymap only.\n\
704 KEYS is a string, a sequence of keystrokes.\n\
705 The binding is probably a symbol with a function definition.")
709 register Lisp_Object map
;
710 map
= current_buffer
->keymap
;
713 return Flookup_key (map
, keys
);
716 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 1, 0,
717 "Return the binding for command KEYS in current global keymap only.\n\
718 KEYS is a string, a sequence of keystrokes.\n\
719 The binding is probably a symbol with a function definition.\n\
720 This function's return values are the same as those of lookup-key\n\
725 return Flookup_key (current_global_map
, keys
);
728 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 1, 0,
729 "Find the visible minor mode bindings of KEY.\n\
730 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
731 the symbol which names the minor mode binding KEY, and BINDING is\n\
732 KEY's definition in that mode. In particular, if KEY has no\n\
733 minor-mode bindings, return nil. If the first binding is a\n\
734 non-prefix, all subsequent bindings will be omitted, since they would\n\
735 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
736 that come after prefix bindings.")
739 Lisp_Object
*modes
, *maps
;
744 nmaps
= current_minor_maps (&modes
, &maps
);
746 for (i
= j
= 0; i
< nmaps
; i
++)
748 && ! NILP (binding
= Flookup_key (maps
[i
], key
))
749 && XTYPE (binding
) != Lisp_Int
)
751 if (! NILP (get_keymap_1 (binding
, 0)))
752 maps
[j
++] = Fcons (modes
[i
], binding
);
754 return Fcons (Fcons (modes
[i
], binding
), Qnil
);
757 return Flist (j
, maps
);
760 DEFUN ("global-set-key", Fglobal_set_key
, Sglobal_set_key
, 2, 2,
761 "kSet key globally: \nCSet key %s to command: ",
762 "Give KEY a global binding as COMMAND.\n\
763 COMMAND is a symbol naming an interactively-callable function.\n\
764 KEY is a string representing a sequence of keystrokes.\n\
765 Note that if KEY has a local binding in the current buffer\n\
766 that local binding will continue to shadow any global binding.")
768 Lisp_Object keys
, function
;
770 if (XTYPE (keys
) != Lisp_Vector
771 && XTYPE (keys
) != Lisp_String
)
772 keys
= wrong_type_argument (Qarrayp
, keys
);
774 Fdefine_key (current_global_map
, keys
, function
);
778 DEFUN ("local-set-key", Flocal_set_key
, Slocal_set_key
, 2, 2,
779 "kSet key locally: \nCSet key %s locally to command: ",
780 "Give KEY a local binding as COMMAND.\n\
781 COMMAND is a symbol naming an interactively-callable function.\n\
782 KEY is a string representing a sequence of keystrokes.\n\
783 The binding goes in the current buffer's local map,\n\
784 which is shared with other buffers in the same major mode.")
786 Lisp_Object keys
, function
;
788 register Lisp_Object map
;
789 map
= current_buffer
->keymap
;
792 map
= Fmake_sparse_keymap (Qnil
);
793 current_buffer
->keymap
= map
;
796 if (XTYPE (keys
) != Lisp_Vector
797 && XTYPE (keys
) != Lisp_String
)
798 keys
= wrong_type_argument (Qarrayp
, keys
);
800 Fdefine_key (map
, keys
, function
);
804 DEFUN ("global-unset-key", Fglobal_unset_key
, Sglobal_unset_key
,
805 1, 1, "kUnset key globally: ",
806 "Remove global binding of KEY.\n\
807 KEY is a string representing a sequence of keystrokes.")
811 return Fglobal_set_key (keys
, Qnil
);
814 DEFUN ("local-unset-key", Flocal_unset_key
, Slocal_unset_key
, 1, 1,
815 "kUnset key locally: ",
816 "Remove local binding of KEY.\n\
817 KEY is a string representing a sequence of keystrokes.")
821 if (!NILP (current_buffer
->keymap
))
822 Flocal_set_key (keys
, Qnil
);
826 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
827 "Define COMMAND as a prefix command.\n\
828 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
829 If a second optional argument MAPVAR is given, the map is stored as\n\
830 its value instead of as COMMAND's value; but COMMAND is still defined\n\
833 Lisp_Object name
, mapvar
;
836 map
= Fmake_sparse_keymap (Qnil
);
845 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
846 "Select KEYMAP as the global keymap.")
850 keymap
= get_keymap (keymap
);
851 current_global_map
= keymap
;
855 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
856 "Select KEYMAP as the local keymap.\n\
857 If KEYMAP is nil, that means no local keymap.")
862 keymap
= get_keymap (keymap
);
864 current_buffer
->keymap
= keymap
;
869 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
870 "Return current buffer's local keymap, or nil if it has none.")
873 return current_buffer
->keymap
;
876 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
877 "Return the current global keymap.")
880 return current_global_map
;
883 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
884 "Return a list of keymaps for the minor modes of the current buffer.")
888 int nmaps
= current_minor_maps (0, &maps
);
890 return Flist (nmaps
, maps
);
893 /* Help functions for describing and documenting keymaps. */
895 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
897 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
898 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
899 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
900 so that the KEYS increase in length. The first element is (\"\" . KEYMAP).")
902 Lisp_Object startmap
;
904 Lisp_Object maps
, tail
;
906 maps
= Fcons (Fcons (build_string (""), get_keymap (startmap
)), Qnil
);
908 /* For each map in the list maps,
909 look at any other maps it points to,
910 and stick them at the end if they are not already in the list.
912 This is a breadth-first traversal, where tail is the queue of
913 nodes, and maps accumulates a list of all nodes visited. */
915 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
917 register Lisp_Object thisseq
= Fcar (Fcar (tail
));
918 register Lisp_Object thismap
= Fcdr (Fcar (tail
));
919 Lisp_Object last
= make_number (XINT (Flength (thisseq
)) - 1);
921 /* Does the current sequence end in the meta-prefix-char? */
922 int is_metized
= (XINT (last
) >= 0
923 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
925 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
927 Lisp_Object elt
= XCONS (thismap
)->car
;
931 if (XTYPE (elt
) == Lisp_Vector
)
935 /* Vector keymap. Scan all the elements. */
936 for (i
= 0; i
< DENSE_TABLE_SIZE
; i
++)
938 register Lisp_Object tem
;
939 register Lisp_Object cmd
;
941 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
]);
942 if (NILP (cmd
)) continue;
943 tem
= Fkeymapp (cmd
);
946 cmd
= get_keymap (cmd
);
947 /* Ignore keymaps that are already added to maps. */
948 tem
= Frassq (cmd
, maps
);
951 /* If the last key in thisseq is meta-prefix-char,
952 turn it into a meta-ized keystroke. We know
953 that the event we're about to append is an
954 ascii keystroke since we're processing a
958 tem
= Fcopy_sequence (thisseq
);
959 Faset (tem
, last
, make_number (i
| 0200));
961 /* This new sequence is the same length as
962 thisseq, so stick it in the list right
965 Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
969 tem
= append_key (thisseq
, make_number (i
));
970 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
976 else if (CONSP (elt
))
978 register Lisp_Object cmd
= get_keyelt (XCONS (elt
)->cdr
);
979 register Lisp_Object tem
;
981 /* Ignore definitions that aren't keymaps themselves. */
982 tem
= Fkeymapp (cmd
);
985 /* Ignore keymaps that have been seen already. */
986 cmd
= get_keymap (cmd
);
987 tem
= Frassq (cmd
, maps
);
990 /* let elt be the event defined by this map entry. */
991 elt
= XCONS (elt
)->car
;
993 /* If the last key in thisseq is meta-prefix-char, and
994 this entry is a binding for an ascii keystroke,
995 turn it into a meta-ized keystroke. */
996 if (is_metized
&& XTYPE (elt
) == Lisp_Int
)
998 tem
= Fcopy_sequence (thisseq
);
999 Faset (tem
, last
, make_number (XINT (elt
) | 0200));
1001 /* This new sequence is the same length as
1002 thisseq, so stick it in the list right
1005 Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1009 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1020 Lisp_Object Qsingle_key_description
, Qkey_description
;
1022 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1023 "Return a pretty description of key-sequence KEYS.\n\
1024 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1025 spaces are put between sequence elements, etc.")
1029 return Fmapconcat (Qsingle_key_description
, keys
, build_string (" "));
1033 push_key_description (c
, p
)
1034 register unsigned int c
;
1051 else if (c
== Ctl('I'))
1057 else if (c
== Ctl('J'))
1063 else if (c
== Ctl('M'))
1073 if (c
> 0 && c
<= Ctl ('Z'))
1097 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1098 "Return a pretty description of command character KEY.\n\
1099 Control characters turn into C-whatever, etc.")
1103 register unsigned char c
;
1106 key
= EVENT_HEAD (key
);
1108 switch (XTYPE (key
))
1110 case Lisp_Int
: /* Normal character */
1111 c
= XINT (key
) & 0377;
1112 *push_key_description (c
, tem
) = 0;
1113 return build_string (tem
);
1115 case Lisp_Symbol
: /* Function key or event-symbol */
1116 return Fsymbol_name (key
);
1119 error ("KEY must be an integer, cons, or symbol.");
1124 push_text_char_description (c
, p
)
1125 register unsigned int c
;
1137 *p
++ = c
+ 64; /* 'A' - 1 */
1149 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1150 "Return a pretty description of file-character CHAR.\n\
1151 Control characters turn into \"^char\", etc.")
1157 CHECK_NUMBER (chr
, 0);
1159 *push_text_char_description (XINT (chr
) & 0377, tem
) = 0;
1161 return build_string (tem
);
1164 /* where-is - finding a command in a set of keymaps. */
1166 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 5, 0,
1167 "Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.\n\
1168 If KEYMAP is nil, search only KEYMAP1.\n\
1169 If KEYMAP1 is nil, use the current global map.\n\
1171 If optional 4th arg FIRSTONLY is non-nil,\n\
1172 return a string representing the first key sequence found,\n\
1173 rather than a list of all possible key sequences.\n\
1175 If optional 5th arg NOINDIRECT is non-nil, don't follow indirections\n\
1176 to other keymaps or slots. This makes it possible to search for an\n\
1177 indirect definition itself.")
1178 (definition
, local_keymap
, global_keymap
, firstonly
, noindirect
)
1179 Lisp_Object definition
, local_keymap
, global_keymap
;
1180 Lisp_Object firstonly
, noindirect
;
1182 register Lisp_Object maps
;
1185 if (NILP (global_keymap
))
1186 global_keymap
= current_global_map
;
1188 if (!NILP (local_keymap
))
1189 maps
= nconc2 (Faccessible_keymaps (get_keymap (local_keymap
)),
1190 Faccessible_keymaps (get_keymap (global_keymap
)));
1192 maps
= Faccessible_keymaps (get_keymap (global_keymap
));
1196 for (; !NILP (maps
); maps
= Fcdr (maps
))
1198 /* Key sequence to reach map */
1199 register Lisp_Object
this = Fcar (Fcar (maps
));
1201 /* The map that it reaches */
1202 register Lisp_Object map
= Fcdr (Fcar (maps
));
1204 /* If Fcar (map) is a VECTOR, the current element within that vector. */
1207 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1208 [M-CHAR] sequences, check if last character of the sequence
1209 is the meta-prefix char. */
1210 Lisp_Object last
= make_number (XINT (Flength (this)) - 1);
1211 int last_is_meta
= (XINT (last
) >= 0
1212 && EQ (Faref (this, last
), meta_prefix_char
));
1218 /* Because the code we want to run on each binding is rather
1219 large, we don't want to have two separate loop bodies for
1220 sparse keymap bindings and tables; we want to iterate one
1221 loop body over both keymap and vector bindings.
1223 For this reason, if Fcar (map) is a vector, we don't
1224 advance map to the next element until i indicates that we
1225 have finished off the vector. */
1227 Lisp_Object elt
= XCONS (map
)->car
;
1228 Lisp_Object key
, binding
, sequence
;
1232 /* Set key and binding to the current key and binding, and
1233 advance map and i to the next binding. */
1234 if (XTYPE (elt
) == Lisp_Vector
)
1236 /* In a vector, look at each element. */
1237 binding
= XVECTOR (elt
)->contents
[i
];
1241 /* If we've just finished scanning a vector, advance map
1242 to the next element, and reset i in anticipation of the
1243 next vector we may find. */
1244 if (i
>= DENSE_TABLE_SIZE
)
1246 map
= XCONS (map
)->cdr
;
1250 else if (CONSP (elt
))
1252 key
= Fcar (Fcar (map
));
1253 binding
= Fcdr (Fcar (map
));
1255 map
= XCONS (map
)->cdr
;
1258 /* We want to ignore keymap elements that are neither
1259 vectors nor conses. */
1261 map
= XCONS (map
)->cdr
;
1265 /* Search through indirections unless that's not wanted. */
1266 if (NILP (noindirect
))
1267 binding
= get_keyelt (binding
);
1269 /* End this iteration if this element does not match
1272 if (XTYPE (definition
) == Lisp_Cons
)
1275 tem
= Fequal (binding
, definition
);
1280 if (!EQ (binding
, definition
))
1283 /* We have found a match.
1284 Construct the key sequence where we found it. */
1285 if (XTYPE (key
) == Lisp_Int
&& last_is_meta
)
1287 sequence
= Fcopy_sequence (this);
1288 Faset (sequence
, last
, make_number (XINT (key
) | 0200));
1291 sequence
= append_key (this, key
);
1293 /* Verify that this key binding is not shadowed by another
1294 binding for the same key, before we say it exists.
1296 Mechanism: look for local definition of this key and if
1297 it is defined and does not match what we found then
1300 Either nil or number as value from Flookup_key
1302 if (!NILP (local_keymap
))
1304 binding
= Flookup_key (local_keymap
, sequence
);
1305 if (!NILP (binding
) && XTYPE (binding
) != Lisp_Int
)
1307 if (XTYPE (definition
) == Lisp_Cons
)
1310 tem
= Fequal (binding
, definition
);
1315 if (!EQ (binding
, definition
))
1320 /* It is a true unshadowed match. Record it. */
1322 if (!NILP (firstonly
))
1324 found
= Fcons (sequence
, found
);
1327 return Fnreverse (found
);
1330 /* Return a string listing the keys and buttons that run DEFINITION. */
1333 where_is_string (definition
)
1334 Lisp_Object definition
;
1336 register Lisp_Object keys
, keys1
;
1338 keys
= Fwhere_is_internal (definition
,
1339 current_buffer
->keymap
, Qnil
, Qnil
, Qnil
);
1340 keys1
= Fmapconcat (Qkey_description
, keys
, build_string (", "));
1345 DEFUN ("where-is", Fwhere_is
, Swhere_is
, 1, 1, "CWhere is command: ",
1346 "Print message listing key sequences that invoke specified command.\n\
1347 Argument is a command definition, usually a symbol with a function definition.")
1349 Lisp_Object definition
;
1351 register Lisp_Object string
;
1353 CHECK_SYMBOL (definition
, 0);
1354 string
= where_is_string (definition
);
1356 if (XSTRING (string
)->size
)
1357 message ("%s is on %s", XSYMBOL (definition
)->name
->data
,
1358 XSTRING (string
)->data
);
1360 message ("%s is not on any key", XSYMBOL (definition
)->name
->data
);
1364 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
1366 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 0, "",
1367 "Show a list of all defined keys, and their definitions.\n\
1368 The list is put in a buffer, which is displayed.")
1371 register Lisp_Object thisbuf
;
1372 XSET (thisbuf
, Lisp_Buffer
, current_buffer
);
1373 internal_with_output_to_temp_buffer ("*Help*",
1374 describe_buffer_bindings
,
1380 describe_buffer_bindings (descbuf
)
1381 Lisp_Object descbuf
;
1383 register Lisp_Object start1
, start2
;
1389 char *alternate_heading
1391 Alternate Characters (use anywhere the nominal character is listed):\n\
1392 nominal alternate\n\
1393 ------- ---------\n";
1395 Fset_buffer (Vstandard_output
);
1397 /* Report on alternates for keys. */
1398 if (XTYPE (Vkeyboard_translate_table
) == Lisp_String
)
1401 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
1402 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
1404 for (c
= 0; c
< translate_len
; c
++)
1405 if (translate
[c
] != c
)
1410 if (alternate_heading
)
1412 insert_string (alternate_heading
);
1413 alternate_heading
= 0;
1416 bufend
= push_key_description (translate
[c
], buf
);
1417 insert (buf
, bufend
- buf
);
1418 Findent_to (make_number (16), make_number (1));
1419 bufend
= push_key_description (c
, buf
);
1420 insert (buf
, bufend
- buf
);
1430 Lisp_Object
*modes
, *maps
;
1432 /* Temporarily switch to descbuf, so that we can get that buffer's
1433 minor modes correctly. */
1434 Fset_buffer (descbuf
);
1435 nmaps
= current_minor_maps (&modes
, &maps
);
1436 Fset_buffer (Vstandard_output
);
1438 for (i
= 0; i
< nmaps
; i
++)
1440 if (XTYPE (modes
[i
]) == Lisp_Symbol
)
1443 insert_string (XSYMBOL (modes
[i
])->name
->data
);
1447 insert_string ("Strangely Named");
1448 insert_string (" Minor Mode Bindings:\n");
1449 insert_string (key_heading
);
1450 describe_map_tree (maps
[i
], 0, Qnil
);
1455 start1
= XBUFFER (descbuf
)->keymap
;
1458 insert_string ("Local Bindings:\n");
1459 insert_string (key_heading
);
1460 describe_map_tree (start1
, 0, Qnil
);
1461 insert_string ("\n");
1464 insert_string ("Global Bindings:\n");
1466 insert_string (key_heading
);
1468 describe_map_tree (current_global_map
, 0, XBUFFER (descbuf
)->keymap
);
1470 Fset_buffer (descbuf
);
1474 /* Insert a desription of the key bindings in STARTMAP,
1475 followed by those of all maps reachable through STARTMAP.
1476 If PARTIAL is nonzero, omit certain "uninteresting" commands
1477 (such as `undefined').
1478 If SHADOW is non-nil, it is another map;
1479 don't mention keys which would be shadowed by it. */
1482 describe_map_tree (startmap
, partial
, shadow
)
1483 Lisp_Object startmap
, shadow
;
1486 register Lisp_Object elt
, sh
;
1488 struct gcpro gcpro1
;
1490 maps
= Faccessible_keymaps (startmap
);
1493 for (; !NILP (maps
); maps
= Fcdr (maps
))
1498 /* If there is no shadow keymap given, don't shadow. */
1502 /* If the sequence by which we reach this keymap is zero-length,
1503 then the shadow map for this keymap is just SHADOW. */
1504 else if ((XTYPE (sh
) == Lisp_String
1505 && XSTRING (sh
)->size
== 0)
1506 || (XTYPE (sh
) == Lisp_Vector
1507 && XVECTOR (sh
)->size
== 0))
1510 /* If the sequence by which we reach this keymap actually has
1511 some elements, then the sequence's definition in SHADOW is
1512 what we should use. */
1515 sh
= Flookup_key (shadow
, Fcar (elt
));
1516 if (XTYPE (sh
) == Lisp_Int
)
1520 /* If sh is null (meaning that the current map is not shadowed),
1521 or a keymap (meaning that bindings from the current map might
1522 show through), describe the map. Otherwise, sh is a command
1523 that completely shadows the current map, and we shouldn't
1525 if (NILP (sh
) || !NILP (Fkeymapp (sh
)))
1526 describe_map (Fcdr (elt
), Fcar (elt
), partial
, sh
);
1533 describe_command (definition
)
1534 Lisp_Object definition
;
1536 register Lisp_Object tem1
;
1538 Findent_to (make_number (16), make_number (1));
1540 if (XTYPE (definition
) == Lisp_Symbol
)
1542 XSET (tem1
, Lisp_String
, XSYMBOL (definition
)->name
);
1544 insert_string ("\n");
1548 tem1
= Fkeymapp (definition
);
1550 insert_string ("Prefix Command\n");
1552 insert_string ("??\n");
1556 /* Describe the contents of map MAP, assuming that this map itself is
1557 reached by the sequence of prefix keys KEYS (a string or vector).
1558 PARTIAL, SHADOW is as in `describe_map_tree' above. */
1561 describe_map (map
, keys
, partial
, shadow
)
1562 Lisp_Object map
, keys
;
1566 register Lisp_Object keysdesc
;
1568 if (!NILP (keys
) && Flength (keys
) > 0)
1569 keysdesc
= concat2 (Fkey_description (keys
),
1570 build_string (" "));
1574 describe_map_2 (map
, keysdesc
, describe_command
, partial
, shadow
);
1577 /* Insert a description of KEYMAP into the current buffer. */
1580 describe_map_2 (keymap
, elt_prefix
, elt_describer
, partial
, shadow
)
1581 register Lisp_Object keymap
;
1582 Lisp_Object elt_prefix
;
1583 int (*elt_describer
) ();
1588 Lisp_Object tem1
, tem2
= Qnil
;
1589 Lisp_Object suppress
;
1592 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1595 suppress
= intern ("suppress-keymap");
1597 /* This vector gets used to present single keys to Flookup_key. Since
1598 that is done once per keymap element, we don't want to cons up a
1599 fresh vector every time. */
1600 kludge
= Fmake_vector (make_number (1), Qnil
);
1602 GCPRO3 (elt_prefix
, tem2
, kludge
);
1604 for (; CONSP (keymap
); keymap
= Fcdr (keymap
))
1608 if (XTYPE (XCONS (keymap
)->car
) == Lisp_Vector
)
1609 describe_vector (XCONS (keymap
)->car
,
1610 elt_prefix
, elt_describer
, partial
, shadow
);
1613 tem1
= Fcar_safe (Fcar (keymap
));
1614 tem2
= get_keyelt (Fcdr_safe (Fcar (keymap
)));
1616 /* Don't show undefined commands or suppressed commands. */
1617 if (NILP (tem2
)) continue;
1618 if (XTYPE (tem2
) == Lisp_Symbol
&& partial
)
1620 this = Fget (tem2
, suppress
);
1625 /* Don't show a command that isn't really visible
1626 because a local definition of the same key shadows it. */
1632 XVECTOR (kludge
)->contents
[0] = tem1
;
1633 tem
= Flookup_key (shadow
, kludge
);
1634 if (!NILP (tem
)) continue;
1643 if (!NILP (elt_prefix
))
1644 insert1 (elt_prefix
);
1646 /* THIS gets the string to describe the character TEM1. */
1647 this = Fsingle_key_description (tem1
);
1650 /* Print a description of the definition of this character.
1651 elt_describer will take care of spacing out far enough
1652 for alignment purposes. */
1653 (*elt_describer
) (tem2
);
1661 describe_vector_princ (elt
)
1667 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
1668 "Print on `standard-output' a description of contents of VECTOR.\n\
1669 This is text showing the elements of vector matched against indices.")
1673 CHECK_VECTOR (vector
, 0);
1674 describe_vector (vector
, Qnil
, describe_vector_princ
, 0, Qnil
, Qnil
);
1677 describe_vector (vector
, elt_prefix
, elt_describer
, partial
, shadow
)
1678 register Lisp_Object vector
;
1679 Lisp_Object elt_prefix
;
1680 int (*elt_describer
) ();
1686 Lisp_Object tem1
, tem2
;
1688 Lisp_Object suppress
;
1691 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1695 /* This vector gets used to present single keys to Flookup_key. Since
1696 that is done once per vector element, we don't want to cons up a
1697 fresh vector every time. */
1698 kludge
= Fmake_vector (make_number (1), Qnil
);
1699 GCPRO3 (elt_prefix
, tem1
, kludge
);
1702 suppress
= intern ("suppress-keymap");
1704 for (i
= 0; i
< DENSE_TABLE_SIZE
; i
++)
1707 tem1
= get_keyelt (XVECTOR (vector
)->contents
[i
]);
1709 if (NILP (tem1
)) continue;
1711 /* Don't mention suppressed commands. */
1712 if (XTYPE (tem1
) == Lisp_Symbol
&& partial
)
1714 this = Fget (tem1
, suppress
);
1719 /* If this command in this map is shadowed by some other map,
1725 XVECTOR (kludge
)->contents
[0] = make_number (i
);
1726 tem
= Flookup_key (shadow
, kludge
);
1728 if (!NILP (tem
)) continue;
1737 /* Output the prefix that applies to every entry in this map. */
1738 if (!NILP (elt_prefix
))
1739 insert1 (elt_prefix
);
1741 /* Get the string to describe the character I, and print it. */
1742 XFASTINT (dummy
) = i
;
1744 /* THIS gets the string to describe the character DUMMY. */
1745 this = Fsingle_key_description (dummy
);
1748 /* Find all consecutive characters that have the same definition. */
1749 while (i
+ 1 < DENSE_TABLE_SIZE
1750 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+1]),
1754 /* If we have a range of more than one character,
1755 print where the range reaches to. */
1757 if (i
!= XINT (dummy
))
1760 if (!NILP (elt_prefix
))
1761 insert1 (elt_prefix
);
1763 XFASTINT (dummy
) = i
;
1764 insert1 (Fsingle_key_description (dummy
));
1767 /* Print a description of the definition of this character.
1768 elt_describer will take care of spacing out far enough
1769 for alignment purposes. */
1770 (*elt_describer
) (tem1
);
1776 /* Apropos - finding all symbols whose names match a regexp. */
1777 Lisp_Object apropos_predicate
;
1778 Lisp_Object apropos_accumulate
;
1781 apropos_accum (symbol
, string
)
1782 Lisp_Object symbol
, string
;
1784 register Lisp_Object tem
;
1786 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
1787 if (!NILP (tem
) && !NILP (apropos_predicate
))
1788 tem
= call1 (apropos_predicate
, symbol
);
1790 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
1793 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
1794 "Show all symbols whose names contain match for REGEXP.\n\
1795 If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done\n\
1796 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
1797 Return list of symbols found.")
1799 Lisp_Object string
, pred
;
1801 struct gcpro gcpro1
, gcpro2
;
1802 CHECK_STRING (string
, 0);
1803 apropos_predicate
= pred
;
1804 GCPRO2 (apropos_predicate
, apropos_accumulate
);
1805 apropos_accumulate
= Qnil
;
1806 map_obarray (Vobarray
, apropos_accum
, string
);
1807 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
1809 return apropos_accumulate
;
1816 Qkeymap
= intern ("keymap");
1817 staticpro (&Qkeymap
);
1819 /* Initialize the keymaps standardly used.
1820 Each one is the value of a Lisp variable, and is also
1821 pointed to by a C variable */
1823 global_map
= Fmake_keymap (Qnil
);
1824 Fset (intern ("global-map"), global_map
);
1826 meta_map
= Fmake_keymap (Qnil
);
1827 Fset (intern ("esc-map"), meta_map
);
1828 Ffset (intern ("ESC-prefix"), meta_map
);
1830 control_x_map
= Fmake_keymap (Qnil
);
1831 Fset (intern ("ctl-x-map"), control_x_map
);
1832 Ffset (intern ("Control-X-prefix"), control_x_map
);
1834 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
1835 "Default keymap to use when reading from the minibuffer.");
1836 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
1838 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
1839 "Local keymap for the minibuffer when spaces are not allowed.");
1840 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
1842 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
1843 "Local keymap for minibuffer input with completion.");
1844 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
1846 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
1847 "Local keymap for minibuffer input with completion, for exact match.");
1848 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
1850 current_global_map
= global_map
;
1852 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
1853 "Alist of keymaps to use for minor modes.\n\
1854 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
1855 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
1856 If two active keymaps bind the same key, the keymap appearing earlier\n\
1857 in the list takes precedence.");
1858 Vminor_mode_map_alist
= Qnil
;
1860 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
1861 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
1862 This allows Emacs to recognize function keys sent from ASCII\n\
1863 terminals at any point in a key sequence.\n\
1865 The read-key-sequence function replaces subsequences bound by\n\
1866 function-key-map with their bindings. When the current local and global\n\
1867 keymaps have no binding for the current key sequence but\n\
1868 function-key-map binds a suffix of the sequence to a vector,\n\
1869 read-key-sequence replaces the matching suffix with its binding, and\n\
1870 continues with the new sequence.\n\
1872 For example, suppose function-key-map binds `ESC O P' to [pf1].\n\
1873 Typing `ESC O P' to read-key-sequence would return [pf1]. Typing\n\
1874 `C-x ESC O P' would return [?\C-x pf1]. If [pf1] were a prefix\n\
1875 key, typing `ESC O P x' would return [pf1 x].");
1876 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
1878 Qsingle_key_description
= intern ("single-key-description");
1879 staticpro (&Qsingle_key_description
);
1881 Qkey_description
= intern ("key-description");
1882 staticpro (&Qkey_description
);
1884 Qkeymapp
= intern ("keymapp");
1885 staticpro (&Qkeymapp
);
1887 defsubr (&Skeymapp
);
1888 defsubr (&Smake_keymap
);
1889 defsubr (&Smake_sparse_keymap
);
1890 defsubr (&Scopy_keymap
);
1891 defsubr (&Skey_binding
);
1892 defsubr (&Slocal_key_binding
);
1893 defsubr (&Sglobal_key_binding
);
1894 defsubr (&Sminor_mode_key_binding
);
1895 defsubr (&Sglobal_set_key
);
1896 defsubr (&Slocal_set_key
);
1897 defsubr (&Sdefine_key
);
1898 defsubr (&Slookup_key
);
1899 defsubr (&Sglobal_unset_key
);
1900 defsubr (&Slocal_unset_key
);
1901 defsubr (&Sdefine_prefix_command
);
1902 defsubr (&Suse_global_map
);
1903 defsubr (&Suse_local_map
);
1904 defsubr (&Scurrent_local_map
);
1905 defsubr (&Scurrent_global_map
);
1906 defsubr (&Scurrent_minor_mode_maps
);
1907 defsubr (&Saccessible_keymaps
);
1908 defsubr (&Skey_description
);
1909 defsubr (&Sdescribe_vector
);
1910 defsubr (&Ssingle_key_description
);
1911 defsubr (&Stext_char_description
);
1912 defsubr (&Swhere_is_internal
);
1913 defsubr (&Swhere_is
);
1914 defsubr (&Sdescribe_bindings
);
1915 defsubr (&Sapropos_internal
);
1922 initial_define_key (global_map
, 033, "ESC-prefix");
1923 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");