1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95 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, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
29 #include "termhooks.h"
30 #include "blockinput.h"
33 #define min(a, b) ((a) < (b) ? (a) : (b))
35 /* The number of elements in keymap vectors. */
36 #define DENSE_TABLE_SIZE (0200)
38 /* Actually allocate storage for these variables */
40 Lisp_Object current_global_map
; /* Current global keymap */
42 Lisp_Object global_map
; /* default global key bindings */
44 Lisp_Object meta_map
; /* The keymap used for globally bound
45 ESC-prefixed default commands */
47 Lisp_Object control_x_map
; /* The keymap used for globally bound
48 C-x-prefixed default commands */
50 /* was MinibufLocalMap */
51 Lisp_Object Vminibuffer_local_map
;
52 /* The keymap used by the minibuf for local
53 bindings when spaces are allowed in the
56 /* was MinibufLocalNSMap */
57 Lisp_Object Vminibuffer_local_ns_map
;
58 /* The keymap used by the minibuf for local
59 bindings when spaces are not encouraged
62 /* keymap used for minibuffers when doing completion */
63 /* was MinibufLocalCompletionMap */
64 Lisp_Object Vminibuffer_local_completion_map
;
66 /* keymap used for minibuffers when doing completion and require a match */
67 /* was MinibufLocalMustMatchMap */
68 Lisp_Object Vminibuffer_local_must_match_map
;
70 /* Alist of minor mode variables and keymaps. */
71 Lisp_Object Vminor_mode_map_alist
;
73 /* Keymap mapping ASCII function key sequences onto their preferred forms.
74 Initialized by the terminal-specific lisp files. See DEFVAR for more
76 Lisp_Object Vfunction_key_map
;
78 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
79 Lisp_Object Vkey_translation_map
;
81 /* A list of all commands given new bindings since a certain time
82 when nil was stored here.
83 This is used to speed up recomputation of menu key equivalents
84 when Emacs starts up. t means don't record anything here. */
85 Lisp_Object Vdefine_key_rebound_commands
;
87 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
;
89 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
90 in a string key sequence is equivalent to prefixing with this
92 extern Lisp_Object meta_prefix_char
;
94 extern Lisp_Object Voverriding_local_map
;
96 static Lisp_Object
define_as_prefix ();
97 static Lisp_Object
describe_buffer_bindings ();
98 static void describe_command (), describe_translation ();
99 static void describe_map ();
101 /* Keymap object support - constructors and predicates. */
103 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
104 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
105 VECTOR is a vector which holds the bindings for the ASCII\n\
106 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
107 mouse events, and any other things that appear in the input stream.\n\
108 All entries in it are initially nil, meaning \"command undefined\".\n\n\
109 The optional arg STRING supplies a menu name for the keymap\n\
110 in case you use it as a menu with `x-popup-menu'.")
116 tail
= Fcons (string
, Qnil
);
119 return Fcons (Qkeymap
,
120 Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE
), Qnil
),
124 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
125 "Construct and return a new sparse-keymap list.\n\
126 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
127 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
128 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
129 Initially the alist is nil.\n\n\
130 The optional arg STRING supplies a menu name for the keymap\n\
131 in case you use it as a menu with `x-popup-menu'.")
136 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
137 return Fcons (Qkeymap
, Qnil
);
140 /* This function is used for installing the standard key bindings
141 at initialization time.
145 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
148 initial_define_key (keymap
, key
, defname
)
153 store_in_keymap (keymap
, make_number (key
), intern (defname
));
157 initial_define_lispy_key (keymap
, keyname
, defname
)
162 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
165 /* Define character fromchar in map frommap as an alias for character
166 tochar in map tomap. Subsequent redefinitions of the latter WILL
167 affect the former. */
171 synkey (frommap
, fromchar
, tomap
, tochar
)
172 struct Lisp_Vector
*frommap
, *tomap
;
173 int fromchar
, tochar
;
176 XSETVECTOR (v
, tomap
);
177 XSETFASTINT (c
, tochar
);
178 frommap
->contents
[fromchar
] = Fcons (v
, c
);
182 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
183 "Return t if OBJECT is a keymap.\n\
185 A keymap is a list (keymap . ALIST),\n\
186 or a symbol whose function definition is itself a keymap.\n\
187 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
188 a vector of densely packed bindings for small character codes\n\
189 is also allowed as an element.")
193 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
196 /* Check that OBJECT is a keymap (after dereferencing through any
197 symbols). If it is, return it.
199 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
200 is an autoload form, do the autoload and try again.
201 If AUTOLOAD is nonzero, callers must assume GC is possible.
203 ERROR controls how we respond if OBJECT isn't a keymap.
204 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
206 Note that most of the time, we don't want to pursue autoloads.
207 Functions like Faccessible_keymaps which scan entire keymap trees
208 shouldn't load every autoloaded keymap. I'm not sure about this,
209 but it seems to me that only read_key_sequence, Flookup_key, and
210 Fdefine_key should cause keymaps to be autoloaded. */
213 get_keymap_1 (object
, error
, autoload
)
220 tem
= indirect_function (object
);
221 if (CONSP (tem
) && EQ (XCONS (tem
)->car
, Qkeymap
))
224 /* Should we do an autoload? Autoload forms for keymaps have
225 Qkeymap as their fifth element. */
229 && EQ (XCONS (tem
)->car
, Qautoload
))
233 tail
= Fnth (make_number (4), tem
);
234 if (EQ (tail
, Qkeymap
))
236 struct gcpro gcpro1
, gcpro2
;
238 GCPRO2 (tem
, object
);
239 do_autoload (tem
, object
);
247 wrong_type_argument (Qkeymapp
, object
);
253 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
254 If OBJECT doesn't denote a keymap at all, signal an error. */
259 return get_keymap_1 (object
, 1, 0);
262 /* Return the parent map of the keymap MAP, or nil if it has none.
263 We assume that MAP is a valid keymap. */
265 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
266 "Return the parent keymap of KEYMAP.")
272 keymap
= get_keymap_1 (keymap
, 1, 1);
274 /* Skip past the initial element `keymap'. */
275 list
= XCONS (keymap
)->cdr
;
276 for (; CONSP (list
); list
= XCONS (list
)->cdr
)
278 /* See if there is another `keymap'. */
279 if (EQ (Qkeymap
, XCONS (list
)->car
))
286 /* Set the parent keymap of MAP to PARENT. */
288 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
289 "Modify KEYMAP to set its parent map to PARENT.\n\
290 PARENT should be nil or another keymap.")
292 Lisp_Object keymap
, parent
;
294 Lisp_Object list
, prev
;
297 keymap
= get_keymap_1 (keymap
, 1, 1);
299 parent
= get_keymap_1 (parent
, 1, 1);
301 /* Skip past the initial element `keymap'. */
305 list
= XCONS (prev
)->cdr
;
306 /* If there is a parent keymap here, replace it.
307 If we came to the end, add the parent in PREV. */
308 if (! CONSP (list
) || EQ (Qkeymap
, XCONS (list
)->car
))
310 /* If we already have the right parent, return now
311 so that we avoid the loops below. */
312 if (EQ (XCONS (prev
)->cdr
, parent
))
315 XCONS (prev
)->cdr
= parent
;
321 /* Scan through for submaps, and set their parents too. */
323 for (list
= XCONS (keymap
)->cdr
; CONSP (list
); list
= XCONS (list
)->cdr
)
325 /* Stop the scan when we come to the parent. */
326 if (EQ (XCONS (list
)->car
, Qkeymap
))
329 /* If this element holds a prefix map, deal with it. */
330 if (CONSP (XCONS (list
)->car
)
331 && CONSP (XCONS (XCONS (list
)->car
)->cdr
))
332 fix_submap_inheritance (keymap
, XCONS (XCONS (list
)->car
)->car
,
333 XCONS (XCONS (list
)->car
)->cdr
);
335 if (VECTORP (XCONS (list
)->car
))
336 for (i
= 0; i
< XVECTOR (XCONS (list
)->car
)->size
; i
++)
337 if (CONSP (XVECTOR (XCONS (list
)->car
)->contents
[i
]))
338 fix_submap_inheritance (keymap
, make_number (i
),
339 XVECTOR (XCONS (list
)->car
)->contents
[i
]);
345 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
346 if EVENT is also a prefix in MAP's parent,
347 make sure that SUBMAP inherits that definition as its own parent. */
349 fix_submap_inheritance (map
, event
, submap
)
350 Lisp_Object map
, event
, submap
;
352 Lisp_Object map_parent
, parent_entry
;
354 /* SUBMAP is a cons that we found as a key binding.
355 Discard the other things found in a menu key binding. */
358 && STRINGP (XCONS (submap
)->car
))
360 submap
= XCONS (submap
)->cdr
;
361 /* Also remove a menu help string, if any,
362 following the menu item name. */
363 if (CONSP (submap
) && STRINGP (XCONS (submap
)->car
))
364 submap
= XCONS (submap
)->cdr
;
365 /* Also remove the sublist that caches key equivalences, if any. */
367 && CONSP (XCONS (submap
)->car
))
370 carcar
= XCONS (XCONS (submap
)->car
)->car
;
371 if (NILP (carcar
) || VECTORP (carcar
))
372 submap
= XCONS (submap
)->cdr
;
376 /* If it isn't a keymap now, there's no work to do. */
378 || ! EQ (XCONS (submap
)->car
, Qkeymap
))
381 map_parent
= Fkeymap_parent (map
);
382 if (! NILP (map_parent
))
383 parent_entry
= access_keymap (map_parent
, event
, 0, 0);
387 /* If MAP's parent has something other than a keymap,
388 our own submap shadows it completely, so use nil as SUBMAP's parent. */
389 if (! (CONSP (parent_entry
) && EQ (XCONS (parent_entry
)->car
, Qkeymap
)))
392 if (! EQ (parent_entry
, submap
))
393 Fset_keymap_parent (submap
, parent_entry
);
396 /* Look up IDX in MAP. IDX may be any sort of event.
397 Note that this does only one level of lookup; IDX must be a single
398 event, not a sequence.
400 If T_OK is non-zero, bindings for Qt are treated as default
401 bindings; any key left unmentioned by other tables and bindings is
402 given the binding of Qt.
404 If T_OK is zero, bindings for Qt are not treated specially.
406 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
409 access_keymap (map
, idx
, t_ok
, noinherit
)
418 /* If idx is a list (some sort of mouse click, perhaps?),
419 the index we want to use is the car of the list, which
420 ought to be a symbol. */
421 idx
= EVENT_HEAD (idx
);
423 /* If idx is a symbol, it might have modifiers, which need to
424 be put in the canonical order. */
426 idx
= reorder_modifiers (idx
);
427 else if (INTEGERP (idx
))
428 /* Clobber the high bits that can be present on a machine
429 with more than 24 bits of integer. */
430 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
434 Lisp_Object t_binding
;
437 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
441 binding
= XCONS (tail
)->car
;
442 if (SYMBOLP (binding
))
444 /* If NOINHERIT, stop finding prefix definitions
445 after we pass a second occurrence of the `keymap' symbol. */
446 if (noinherit
&& EQ (binding
, Qkeymap
) && ! EQ (tail
, map
))
449 else if (CONSP (binding
))
451 if (EQ (XCONS (binding
)->car
, idx
))
453 val
= XCONS (binding
)->cdr
;
454 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
457 fix_submap_inheritance (map
, idx
, val
);
460 if (t_ok
&& EQ (XCONS (binding
)->car
, Qt
))
461 t_binding
= XCONS (binding
)->cdr
;
463 else if (VECTORP (binding
))
465 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
467 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
468 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
471 fix_submap_inheritance (map
, idx
, val
);
483 /* Given OBJECT which was found in a slot in a keymap,
484 trace indirect definitions to get the actual definition of that slot.
485 An indirect definition is a list of the form
486 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
487 and INDEX is the object to look up in KEYMAP to yield the definition.
489 Also if OBJECT has a menu string as the first element,
490 remove that. Also remove a menu help string as second element.
492 If AUTOLOAD is nonzero, load autoloadable keymaps
493 that are referred to with indirection. */
496 get_keyelt (object
, autoload
)
497 register Lisp_Object object
;
502 register Lisp_Object map
, tem
;
504 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
505 map
= get_keymap_1 (Fcar_safe (object
), 0, autoload
);
506 tem
= Fkeymapp (map
);
508 object
= access_keymap (map
, Fcdr (object
), 0, 0);
510 /* If the keymap contents looks like (STRING . DEFN),
512 Keymap alist elements like (CHAR MENUSTRING . DEFN)
513 will be used by HierarKey menus. */
514 else if (CONSP (object
)
515 && STRINGP (XCONS (object
)->car
))
517 object
= XCONS (object
)->cdr
;
518 /* Also remove a menu help string, if any,
519 following the menu item name. */
520 if (CONSP (object
) && STRINGP (XCONS (object
)->car
))
521 object
= XCONS (object
)->cdr
;
522 /* Also remove the sublist that caches key equivalences, if any. */
524 && CONSP (XCONS (object
)->car
))
527 carcar
= XCONS (XCONS (object
)->car
)->car
;
528 if (NILP (carcar
) || VECTORP (carcar
))
529 object
= XCONS (object
)->cdr
;
534 /* Anything else is really the value. */
540 store_in_keymap (keymap
, idx
, def
)
542 register Lisp_Object idx
;
543 register Lisp_Object def
;
545 /* If we are preparing to dump, and DEF is a menu element
546 with a menu item string, copy it to ensure it is not pure. */
547 if (CONSP (def
) && PURE_P (def
) && STRINGP (XCONS (def
)->car
))
548 def
= Fcons (XCONS (def
)->car
, XCONS (def
)->cdr
);
550 if (!CONSP (keymap
) || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
551 error ("attempt to define a key in a non-keymap");
553 /* If idx is a list (some sort of mouse click, perhaps?),
554 the index we want to use is the car of the list, which
555 ought to be a symbol. */
556 idx
= EVENT_HEAD (idx
);
558 /* If idx is a symbol, it might have modifiers, which need to
559 be put in the canonical order. */
561 idx
= reorder_modifiers (idx
);
562 else if (INTEGERP (idx
))
563 /* Clobber the high bits that can be present on a machine
564 with more than 24 bits of integer. */
565 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
567 /* Scan the keymap for a binding of idx. */
571 /* The cons after which we should insert new bindings. If the
572 keymap has a table element, we record its position here, so new
573 bindings will go after it; this way, the table will stay
574 towards the front of the alist and character lookups in dense
575 keymaps will remain fast. Otherwise, this just points at the
576 front of the keymap. */
577 Lisp_Object insertion_point
;
579 insertion_point
= keymap
;
580 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
584 elt
= XCONS (tail
)->car
;
587 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (elt
)->size
)
589 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
592 insertion_point
= tail
;
594 else if (CONSP (elt
))
596 if (EQ (idx
, XCONS (elt
)->car
))
598 XCONS (elt
)->cdr
= def
;
602 else if (SYMBOLP (elt
))
604 /* If we find a 'keymap' symbol in the spine of KEYMAP,
605 then we must have found the start of a second keymap
606 being used as the tail of KEYMAP, and a binding for IDX
607 should be inserted before it. */
608 if (EQ (elt
, Qkeymap
))
616 /* We have scanned the entire keymap, and not found a binding for
617 IDX. Let's add one. */
618 XCONS (insertion_point
)->cdr
619 = Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
626 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
627 "Return a copy of the keymap KEYMAP.\n\
628 The copy starts out with the same definitions of KEYMAP,\n\
629 but changing either the copy or KEYMAP does not affect the other.\n\
630 Any key definitions that are subkeymaps are recursively copied.\n\
631 However, a key definition which is a symbol whose definition is a keymap\n\
636 register Lisp_Object copy
, tail
;
638 copy
= Fcopy_alist (get_keymap (keymap
));
640 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
644 elt
= XCONS (tail
)->car
;
649 elt
= Fcopy_sequence (elt
);
650 XCONS (tail
)->car
= elt
;
652 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
653 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
654 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
655 XVECTOR (elt
)->contents
[i
] =
656 Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
658 else if (CONSP (elt
))
660 /* Skip the optional menu string. */
661 if (CONSP (XCONS (elt
)->cdr
)
662 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
666 /* Copy the cell, since copy-alist didn't go this deep. */
667 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
668 XCONS (XCONS (elt
)->cdr
)->cdr
);
669 elt
= XCONS (elt
)->cdr
;
671 /* Also skip the optional menu help string. */
672 if (CONSP (XCONS (elt
)->cdr
)
673 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
675 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
676 XCONS (XCONS (elt
)->cdr
)->cdr
);
677 elt
= XCONS (elt
)->cdr
;
679 /* There may also be a list that caches key equivalences.
680 Just delete it for the new keymap. */
681 if (CONSP (XCONS (elt
)->cdr
)
682 && CONSP (XCONS (XCONS (elt
)->cdr
)->car
)
683 && (NILP (tem
= XCONS (XCONS (XCONS (elt
)->cdr
)->car
)->car
)
685 XCONS (elt
)->cdr
= XCONS (XCONS (elt
)->cdr
)->cdr
;
688 && ! SYMBOLP (XCONS (elt
)->cdr
)
689 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
690 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
697 /* Simple Keymap mutators and accessors. */
699 /* GC is possible in this function if it autoloads a keymap. */
701 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
702 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
703 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
704 meaning a sequence of keystrokes and events.\n\
705 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
706 can be included if you use a vector.\n\
707 DEF is anything that can be a key's definition:\n\
708 nil (means key is undefined in this keymap),\n\
709 a command (a Lisp function suitable for interactive calling)\n\
710 a string (treated as a keyboard macro),\n\
711 a keymap (to define a prefix key),\n\
712 a symbol. When the key is looked up, the symbol will stand for its\n\
713 function definition, which should at that time be one of the above,\n\
714 or another symbol whose function definition is used, etc.\n\
715 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
716 (DEFN should be a valid definition in its own right),\n\
717 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
719 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
720 the front of KEYMAP.")
727 register Lisp_Object c
;
728 register Lisp_Object tem
;
729 register Lisp_Object cmd
;
733 struct gcpro gcpro1
, gcpro2
, gcpro3
;
735 keymap
= get_keymap_1 (keymap
, 1, 1);
737 if (!VECTORP (key
) && !STRINGP (key
))
738 key
= wrong_type_argument (Qarrayp
, key
);
740 length
= XFASTINT (Flength (key
));
744 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
745 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
747 GCPRO3 (keymap
, key
, def
);
750 meta_bit
= meta_modifier
;
757 c
= Faref (key
, make_number (idx
));
759 if (CONSP (c
) && lucid_event_type_list_p (c
))
760 c
= Fevent_convert_list (c
);
763 && (XINT (c
) & meta_bit
)
766 c
= meta_prefix_char
;
772 XSETINT (c
, XINT (c
) & ~meta_bit
);
778 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
779 error ("Key sequence contains invalid events");
782 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
784 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1), 1);
786 /* If this key is undefined, make it a prefix. */
788 cmd
= define_as_prefix (keymap
, c
);
790 keymap
= get_keymap_1 (cmd
, 0, 1);
792 /* We must use Fkey_description rather than just passing key to
793 error; key might be a vector, not a string. */
794 error ("Key sequence %s uses invalid prefix characters",
795 XSTRING (Fkey_description (key
))->data
);
799 /* Value is number if KEY is too long; NIL if valid but has no definition. */
800 /* GC is possible in this function if it autoloads a keymap. */
802 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
803 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
804 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
806 A number as value means KEY is \"too long\";\n\
807 that is, characters or symbols in it except for the last one\n\
808 fail to be a valid sequence of prefix characters in KEYMAP.\n\
809 The number is how many characters at the front of KEY\n\
810 it takes to reach a non-prefix command.\n\
812 Normally, `lookup-key' ignores bindings for t, which act as default\n\
813 bindings, used when nothing else in the keymap applies; this makes it\n\
814 usable as a general function for probing keymaps. However, if the\n\
815 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
816 recognize the default bindings, just as `read-key-sequence' does.")
817 (keymap
, key
, accept_default
)
818 register Lisp_Object keymap
;
820 Lisp_Object accept_default
;
823 register Lisp_Object tem
;
824 register Lisp_Object cmd
;
825 register Lisp_Object c
;
828 int t_ok
= ! NILP (accept_default
);
832 keymap
= get_keymap_1 (keymap
, 1, 1);
834 if (!VECTORP (key
) && !STRINGP (key
))
835 key
= wrong_type_argument (Qarrayp
, key
);
837 length
= XFASTINT (Flength (key
));
842 meta_bit
= meta_modifier
;
851 c
= Faref (key
, make_number (idx
));
853 if (CONSP (c
) && lucid_event_type_list_p (c
))
854 c
= Fevent_convert_list (c
);
857 && (XINT (c
) & meta_bit
)
860 c
= meta_prefix_char
;
866 XSETINT (c
, XINT (c
) & ~meta_bit
);
872 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0), 1);
874 RETURN_UNGCPRO (cmd
);
876 keymap
= get_keymap_1 (cmd
, 0, 1);
878 RETURN_UNGCPRO (make_number (idx
));
884 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
885 Assume that currently it does not define C at all.
886 Return the keymap. */
889 define_as_prefix (keymap
, c
)
890 Lisp_Object keymap
, c
;
892 Lisp_Object inherit
, cmd
;
894 cmd
= Fmake_sparse_keymap (Qnil
);
895 /* If this key is defined as a prefix in an inherited keymap,
896 make it a prefix in this map, and make its definition
897 inherit the other prefix definition. */
898 inherit
= access_keymap (keymap
, c
, 0, 0);
900 /* This code is needed to do the right thing in the following case:
901 keymap A inherits from B,
902 you define KEY as a prefix in A,
903 then later you define KEY as a prefix in B.
904 We want the old prefix definition in A to inherit from that in B.
905 It is hard to do that retroactively, so this code
906 creates the prefix in B right away.
908 But it turns out that this code causes problems immediately
909 when the prefix in A is defined: it causes B to define KEY
910 as a prefix with no subcommands.
912 So I took out this code. */
915 /* If there's an inherited keymap
916 and it doesn't define this key,
917 make it define this key. */
920 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
921 if (EQ (XCONS (tail
)->car
, Qkeymap
))
925 inherit
= define_as_prefix (tail
, c
);
929 cmd
= nconc2 (cmd
, inherit
);
930 store_in_keymap (keymap
, c
, cmd
);
935 /* Append a key to the end of a key sequence. We always make a vector. */
938 append_key (key_sequence
, key
)
939 Lisp_Object key_sequence
, key
;
943 args
[0] = key_sequence
;
945 args
[1] = Fcons (key
, Qnil
);
946 return Fvconcat (2, args
);
950 /* Global, local, and minor mode keymap stuff. */
952 /* We can't put these variables inside current_minor_maps, since under
953 some systems, static gets macro-defined to be the empty string.
955 static Lisp_Object
*cmm_modes
, *cmm_maps
;
958 /* Error handler used in current_minor_maps. */
960 current_minor_maps_error ()
965 /* Store a pointer to an array of the keymaps of the currently active
966 minor modes in *buf, and return the number of maps it contains.
968 This function always returns a pointer to the same buffer, and may
969 free or reallocate it, so if you want to keep it for a long time or
970 hand it out to lisp code, copy it. This procedure will be called
971 for every key sequence read, so the nice lispy approach (return a
972 new assoclist, list, what have you) for each invocation would
973 result in a lot of consing over time.
975 If we used xrealloc/xmalloc and ran out of memory, they would throw
976 back to the command loop, which would try to read a key sequence,
977 which would call this function again, resulting in an infinite
978 loop. Instead, we'll use realloc/malloc and silently truncate the
979 list, let the key sequence be read, and hope some other piece of
980 code signals the error. */
982 current_minor_maps (modeptr
, mapptr
)
983 Lisp_Object
**modeptr
, **mapptr
;
986 Lisp_Object alist
, assoc
, var
, val
;
988 for (alist
= Vminor_mode_map_alist
;
990 alist
= XCONS (alist
)->cdr
)
991 if ((assoc
= XCONS (alist
)->car
, CONSP (assoc
))
992 && (var
= XCONS (assoc
)->car
, SYMBOLP (var
))
993 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1000 Lisp_Object
*newmodes
, *newmaps
;
1007 = (Lisp_Object
*) realloc (cmm_modes
,
1008 cmm_size
* sizeof (Lisp_Object
));
1010 = (Lisp_Object
*) realloc (cmm_maps
,
1011 cmm_size
* sizeof (Lisp_Object
));
1019 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1021 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1025 if (newmaps
&& newmodes
)
1027 cmm_modes
= newmodes
;
1034 /* Get the keymap definition--or nil if it is not defined. */
1035 temp
= internal_condition_case_1 (Findirect_function
,
1037 Qerror
, current_minor_maps_error
);
1041 cmm_maps
[i
] = temp
;
1046 if (modeptr
) *modeptr
= cmm_modes
;
1047 if (mapptr
) *mapptr
= cmm_maps
;
1051 /* GC is possible in this function if it autoloads a keymap. */
1053 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1054 "Return the binding for command KEY in current keymaps.\n\
1055 KEY is a string or vector, a sequence of keystrokes.\n\
1056 The binding is probably a symbol with a function definition.\n\
1058 Normally, `key-binding' ignores bindings for t, which act as default\n\
1059 bindings, used when nothing else in the keymap applies; this makes it\n\
1060 usable as a general function for probing keymaps. However, if the\n\
1061 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1062 recognize the default bindings, just as `read-key-sequence' does.")
1063 (key
, accept_default
)
1064 Lisp_Object key
, accept_default
;
1066 Lisp_Object
*maps
, value
;
1068 struct gcpro gcpro1
;
1072 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1074 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1075 key
, accept_default
);
1076 if (! NILP (value
) && !INTEGERP (value
))
1077 RETURN_UNGCPRO (value
);
1079 else if (!NILP (Voverriding_local_map
))
1081 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1082 if (! NILP (value
) && !INTEGERP (value
))
1083 RETURN_UNGCPRO (value
);
1089 nmaps
= current_minor_maps (0, &maps
);
1090 /* Note that all these maps are GCPRO'd
1091 in the places where we found them. */
1093 for (i
= 0; i
< nmaps
; i
++)
1094 if (! NILP (maps
[i
]))
1096 value
= Flookup_key (maps
[i
], key
, accept_default
);
1097 if (! NILP (value
) && !INTEGERP (value
))
1098 RETURN_UNGCPRO (value
);
1101 local
= get_local_map (PT
, current_buffer
);
1105 value
= Flookup_key (local
, key
, accept_default
);
1106 if (! NILP (value
) && !INTEGERP (value
))
1107 RETURN_UNGCPRO (value
);
1111 value
= Flookup_key (current_global_map
, key
, accept_default
);
1113 if (! NILP (value
) && !INTEGERP (value
))
1119 /* GC is possible in this function if it autoloads a keymap. */
1121 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1122 "Return the binding for command KEYS in current local keymap only.\n\
1123 KEYS is a string, a sequence of keystrokes.\n\
1124 The binding is probably a symbol with a function definition.\n\
1126 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1127 bindings; see the description of `lookup-key' for more details about this.")
1128 (keys
, accept_default
)
1129 Lisp_Object keys
, accept_default
;
1131 register Lisp_Object map
;
1132 map
= current_buffer
->keymap
;
1135 return Flookup_key (map
, keys
, accept_default
);
1138 /* GC is possible in this function if it autoloads a keymap. */
1140 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1141 "Return the binding for command KEYS in current global keymap only.\n\
1142 KEYS is a string, a sequence of keystrokes.\n\
1143 The binding is probably a symbol with a function definition.\n\
1144 This function's return values are the same as those of lookup-key\n\
1147 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1148 bindings; see the description of `lookup-key' for more details about this.")
1149 (keys
, accept_default
)
1150 Lisp_Object keys
, accept_default
;
1152 return Flookup_key (current_global_map
, keys
, accept_default
);
1155 /* GC is possible in this function if it autoloads a keymap. */
1157 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1158 "Find the visible minor mode bindings of KEY.\n\
1159 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1160 the symbol which names the minor mode binding KEY, and BINDING is\n\
1161 KEY's definition in that mode. In particular, if KEY has no\n\
1162 minor-mode bindings, return nil. If the first binding is a\n\
1163 non-prefix, all subsequent bindings will be omitted, since they would\n\
1164 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1165 that come after prefix bindings.\n\
1167 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1168 bindings; see the description of `lookup-key' for more details about this.")
1169 (key
, accept_default
)
1170 Lisp_Object key
, accept_default
;
1172 Lisp_Object
*modes
, *maps
;
1174 Lisp_Object binding
;
1176 struct gcpro gcpro1
, gcpro2
;
1178 nmaps
= current_minor_maps (&modes
, &maps
);
1179 /* Note that all these maps are GCPRO'd
1180 in the places where we found them. */
1183 GCPRO2 (key
, binding
);
1185 for (i
= j
= 0; i
< nmaps
; i
++)
1186 if (! NILP (maps
[i
])
1187 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1188 && !INTEGERP (binding
))
1190 if (! NILP (get_keymap (binding
)))
1191 maps
[j
++] = Fcons (modes
[i
], binding
);
1193 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1197 return Flist (j
, maps
);
1200 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
1201 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1202 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1203 If a second optional argument MAPVAR is given, the map is stored as\n\
1204 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1207 Lisp_Object command
, mapvar
;
1210 map
= Fmake_sparse_keymap (Qnil
);
1211 Ffset (command
, map
);
1215 Fset (command
, map
);
1219 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1220 "Select KEYMAP as the global keymap.")
1224 keymap
= get_keymap (keymap
);
1225 current_global_map
= keymap
;
1230 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1231 "Select KEYMAP as the local keymap.\n\
1232 If KEYMAP is nil, that means no local keymap.")
1237 keymap
= get_keymap (keymap
);
1239 current_buffer
->keymap
= keymap
;
1244 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1245 "Return current buffer's local keymap, or nil if it has none.")
1248 return current_buffer
->keymap
;
1251 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1252 "Return the current global keymap.")
1255 return current_global_map
;
1258 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1259 "Return a list of keymaps for the minor modes of the current buffer.")
1263 int nmaps
= current_minor_maps (0, &maps
);
1265 return Flist (nmaps
, maps
);
1268 /* Help functions for describing and documenting keymaps. */
1270 /* This function cannot GC. */
1272 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1274 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1275 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1276 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1277 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1278 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1279 then the value includes only maps for prefixes that start with PREFIX.")
1281 Lisp_Object keymap
, prefix
;
1283 Lisp_Object maps
, good_maps
, tail
;
1286 /* no need for gcpro because we don't autoload any keymaps. */
1289 prefixlen
= XINT (Flength (prefix
));
1293 /* If a prefix was specified, start with the keymap (if any) for
1294 that prefix, so we don't waste time considering other prefixes. */
1296 tem
= Flookup_key (keymap
, prefix
, Qt
);
1297 /* Flookup_key may give us nil, or a number,
1298 if the prefix is not defined in this particular map.
1299 It might even give us a list that isn't a keymap. */
1300 tem
= get_keymap_1 (tem
, 0, 0);
1302 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1307 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1308 get_keymap (keymap
)),
1311 /* For each map in the list maps,
1312 look at any other maps it points to,
1313 and stick them at the end if they are not already in the list.
1315 This is a breadth-first traversal, where tail is the queue of
1316 nodes, and maps accumulates a list of all nodes visited. */
1318 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1320 register Lisp_Object thisseq
, thismap
;
1322 /* Does the current sequence end in the meta-prefix-char? */
1325 thisseq
= Fcar (Fcar (tail
));
1326 thismap
= Fcdr (Fcar (tail
));
1327 last
= make_number (XINT (Flength (thisseq
)) - 1);
1328 is_metized
= (XINT (last
) >= 0
1329 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1331 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1335 elt
= XCONS (thismap
)->car
;
1343 /* Vector keymap. Scan all the elements. */
1344 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1346 register Lisp_Object tem
;
1347 register Lisp_Object cmd
;
1349 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1350 if (NILP (cmd
)) continue;
1351 tem
= Fkeymapp (cmd
);
1354 cmd
= get_keymap (cmd
);
1355 /* Ignore keymaps that are already added to maps. */
1356 tem
= Frassq (cmd
, maps
);
1359 /* If the last key in thisseq is meta-prefix-char,
1360 turn it into a meta-ized keystroke. We know
1361 that the event we're about to append is an
1362 ascii keystroke since we're processing a
1366 int meta_bit
= meta_modifier
;
1367 tem
= Fcopy_sequence (thisseq
);
1369 Faset (tem
, last
, make_number (i
| meta_bit
));
1371 /* This new sequence is the same length as
1372 thisseq, so stick it in the list right
1375 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1379 tem
= append_key (thisseq
, make_number (i
));
1380 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1386 else if (CONSP (elt
))
1388 register Lisp_Object cmd
, tem
, filter
;
1390 cmd
= get_keyelt (XCONS (elt
)->cdr
, 0);
1391 /* Ignore definitions that aren't keymaps themselves. */
1392 tem
= Fkeymapp (cmd
);
1395 /* Ignore keymaps that have been seen already. */
1396 cmd
= get_keymap (cmd
);
1397 tem
= Frassq (cmd
, maps
);
1400 /* Let elt be the event defined by this map entry. */
1401 elt
= XCONS (elt
)->car
;
1403 /* If the last key in thisseq is meta-prefix-char, and
1404 this entry is a binding for an ascii keystroke,
1405 turn it into a meta-ized keystroke. */
1406 if (is_metized
&& INTEGERP (elt
))
1408 tem
= Fcopy_sequence (thisseq
);
1410 make_number (XINT (elt
) | meta_modifier
));
1412 /* This new sequence is the same length as
1413 thisseq, so stick it in the list right
1416 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1420 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1431 /* Now find just the maps whose access prefixes start with PREFIX. */
1434 for (; CONSP (maps
); maps
= XCONS (maps
)->cdr
)
1436 Lisp_Object elt
, thisseq
;
1437 elt
= XCONS (maps
)->car
;
1438 thisseq
= XCONS (elt
)->car
;
1439 /* The access prefix must be at least as long as PREFIX,
1440 and the first elements must match those of PREFIX. */
1441 if (XINT (Flength (thisseq
)) >= prefixlen
)
1444 for (i
= 0; i
< prefixlen
; i
++)
1447 XSETFASTINT (i1
, i
);
1448 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1452 good_maps
= Fcons (elt
, good_maps
);
1456 return Fnreverse (good_maps
);
1459 Lisp_Object Qsingle_key_description
, Qkey_description
;
1461 /* This function cannot GC. */
1463 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1464 "Return a pretty description of key-sequence KEYS.\n\
1465 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1466 spaces are put between sequence elements, etc.")
1478 vector
= Fmake_vector (Flength (keys
), Qnil
);
1479 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1481 if (XSTRING (keys
)->data
[i
] & 0x80)
1482 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1483 meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80));
1485 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1486 XSTRING (keys
)->data
[i
]);
1490 else if (!VECTORP (keys
))
1491 keys
= wrong_type_argument (Qarrayp
, keys
);
1493 /* In effect, this computes
1494 (mapconcat 'single-key-description keys " ")
1495 but we shouldn't use mapconcat because it can do GC. */
1497 len
= XVECTOR (keys
)->size
;
1498 sep
= build_string (" ");
1499 /* This has one extra element at the end that we don't pass to Fconcat. */
1500 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1502 for (i
= 0; i
< len
; i
++)
1504 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
]);
1505 args
[i
* 2 + 1] = sep
;
1508 return Fconcat (len
* 2 - 1, args
);
1512 push_key_description (c
, p
)
1513 register unsigned int c
;
1516 /* Clear all the meaningless bits above the meta bit. */
1517 c
&= meta_modifier
| ~ - meta_modifier
;
1519 if (c
& alt_modifier
)
1525 if (c
& ctrl_modifier
)
1531 if (c
& hyper_modifier
)
1535 c
-= hyper_modifier
;
1537 if (c
& meta_modifier
)
1543 if (c
& shift_modifier
)
1547 c
-= shift_modifier
;
1549 if (c
& super_modifier
)
1553 c
-= super_modifier
;
1569 else if (c
== Ctl ('M'))
1579 if (c
> 0 && c
<= Ctl ('Z'))
1602 *p
++ = (7 & (c
>> 15)) + '0';
1603 *p
++ = (7 & (c
>> 12)) + '0';
1604 *p
++ = (7 & (c
>> 9)) + '0';
1605 *p
++ = (7 & (c
>> 6)) + '0';
1606 *p
++ = (7 & (c
>> 3)) + '0';
1607 *p
++ = (7 & (c
>> 0)) + '0';
1613 /* This function cannot GC. */
1615 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1616 "Return a pretty description of command character KEY.\n\
1617 Control characters turn into C-whatever, etc.")
1623 key
= EVENT_HEAD (key
);
1625 if (INTEGERP (key
)) /* Normal character */
1627 *push_key_description (XUINT (key
), tem
) = 0;
1628 return build_string (tem
);
1630 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1631 return Fsymbol_name (key
);
1632 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1633 return Fcopy_sequence (key
);
1635 error ("KEY must be an integer, cons, symbol, or string");
1639 push_text_char_description (c
, p
)
1640 register unsigned int c
;
1652 *p
++ = c
+ 64; /* 'A' - 1 */
1664 /* This function cannot GC. */
1666 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1667 "Return a pretty description of file-character CHARACTER.\n\
1668 Control characters turn into \"^char\", etc.")
1670 Lisp_Object character
;
1674 CHECK_NUMBER (character
, 0);
1676 *push_text_char_description (XINT (character
) & 0377, tem
) = 0;
1678 return build_string (tem
);
1681 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1684 ascii_sequence_p (seq
)
1688 int len
= XINT (Flength (seq
));
1690 for (i
= 0; i
< len
; i
++)
1692 Lisp_Object ii
, elt
;
1694 XSETFASTINT (ii
, i
);
1695 elt
= Faref (seq
, ii
);
1698 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1706 /* where-is - finding a command in a set of keymaps. */
1708 /* This function can GC if Flookup_key autoloads any keymaps. */
1710 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
1711 "Return list of keys that invoke DEFINITION.\n\
1712 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
1713 If KEYMAP is nil, search all the currently active keymaps.\n\
1715 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
1716 rather than a list of all possible key sequences.\n\
1717 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
1718 no matter what it is.\n\
1719 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
1720 and entirely reject menu bindings.\n\
1722 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
1723 to other keymaps or slots. This makes it possible to search for an\n\
1724 indirect definition itself.")
1725 (definition
, keymap
, firstonly
, noindirect
)
1726 Lisp_Object definition
, keymap
;
1727 Lisp_Object firstonly
, noindirect
;
1730 Lisp_Object found
, sequence
;
1731 int keymap_specified
= !NILP (keymap
);
1732 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
1733 /* 1 means ignore all menu bindings entirely. */
1734 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
1736 if (! keymap_specified
)
1738 #ifdef USE_TEXT_PROPERTIES
1739 keymap
= get_local_map (PT
, current_buffer
);
1741 keymap
= current_buffer
->keymap
;
1746 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap
), Qnil
),
1747 Faccessible_keymaps (get_keymap (current_global_map
),
1750 maps
= Faccessible_keymaps (get_keymap (current_global_map
), Qnil
);
1752 /* Put the minor mode keymaps on the front. */
1753 if (! keymap_specified
)
1756 minors
= Fnreverse (Fcurrent_minor_mode_maps ());
1757 while (!NILP (minors
))
1759 maps
= nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors
)->car
),
1762 minors
= XCONS (minors
)->cdr
;
1766 GCPRO5 (definition
, keymap
, maps
, found
, sequence
);
1770 for (; !NILP (maps
); maps
= Fcdr (maps
))
1772 /* Key sequence to reach map, and the map that it reaches */
1773 register Lisp_Object
this, map
;
1775 /* If Fcar (map) is a VECTOR, the current element within that vector. */
1778 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1779 [M-CHAR] sequences, check if last character of the sequence
1780 is the meta-prefix char. */
1784 this = Fcar (Fcar (maps
));
1785 map
= Fcdr (Fcar (maps
));
1786 last
= make_number (XINT (Flength (this)) - 1);
1787 last_is_meta
= (XINT (last
) >= 0
1788 && EQ (Faref (this, last
), meta_prefix_char
));
1794 /* Because the code we want to run on each binding is rather
1795 large, we don't want to have two separate loop bodies for
1796 sparse keymap bindings and tables; we want to iterate one
1797 loop body over both keymap and vector bindings.
1799 For this reason, if Fcar (map) is a vector, we don't
1800 advance map to the next element until i indicates that we
1801 have finished off the vector. */
1803 Lisp_Object elt
, key
, binding
;
1804 elt
= XCONS (map
)->car
;
1808 /* Set key and binding to the current key and binding, and
1809 advance map and i to the next binding. */
1812 /* In a vector, look at each element. */
1813 binding
= XVECTOR (elt
)->contents
[i
];
1814 XSETFASTINT (key
, i
);
1817 /* If we've just finished scanning a vector, advance map
1818 to the next element, and reset i in anticipation of the
1819 next vector we may find. */
1820 if (i
>= XVECTOR (elt
)->size
)
1822 map
= XCONS (map
)->cdr
;
1826 else if (CONSP (elt
))
1828 key
= Fcar (Fcar (map
));
1829 binding
= Fcdr (Fcar (map
));
1831 map
= XCONS (map
)->cdr
;
1834 /* We want to ignore keymap elements that are neither
1835 vectors nor conses. */
1837 map
= XCONS (map
)->cdr
;
1841 /* Search through indirections unless that's not wanted. */
1842 if (NILP (noindirect
))
1848 Lisp_Object map
, tem
;
1849 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
1850 map
= get_keymap_1 (Fcar_safe (definition
), 0, 0);
1851 tem
= Fkeymapp (map
);
1853 definition
= access_keymap (map
, Fcdr (definition
), 0, 0);
1857 /* If the contents are (STRING ...), reject. */
1858 if (CONSP (definition
)
1859 && STRINGP (XCONS (definition
)->car
))
1863 binding
= get_keyelt (binding
, 0);
1866 /* End this iteration if this element does not match
1869 if (CONSP (definition
))
1872 tem
= Fequal (binding
, definition
);
1877 if (!EQ (binding
, definition
))
1880 /* We have found a match.
1881 Construct the key sequence where we found it. */
1882 if (INTEGERP (key
) && last_is_meta
)
1884 sequence
= Fcopy_sequence (this);
1885 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
1888 sequence
= append_key (this, key
);
1890 /* Verify that this key binding is not shadowed by another
1891 binding for the same key, before we say it exists.
1893 Mechanism: look for local definition of this key and if
1894 it is defined and does not match what we found then
1897 Either nil or number as value from Flookup_key
1899 if (keymap_specified
)
1901 binding
= Flookup_key (keymap
, sequence
, Qnil
);
1902 if (!NILP (binding
) && !INTEGERP (binding
))
1904 if (CONSP (definition
))
1907 tem
= Fequal (binding
, definition
);
1912 if (!EQ (binding
, definition
))
1918 binding
= Fkey_binding (sequence
, Qnil
);
1919 if (!EQ (binding
, definition
))
1923 /* It is a true unshadowed match. Record it, unless it's already
1924 been seen (as could happen when inheriting keymaps). */
1925 if (NILP (Fmember (sequence
, found
)))
1926 found
= Fcons (sequence
, found
);
1928 /* If firstonly is Qnon_ascii, then we can return the first
1929 binding we find. If firstonly is not Qnon_ascii but not
1930 nil, then we should return the first ascii-only binding
1932 if (EQ (firstonly
, Qnon_ascii
))
1933 RETURN_UNGCPRO (sequence
);
1934 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
1935 RETURN_UNGCPRO (sequence
);
1941 found
= Fnreverse (found
);
1943 /* firstonly may have been t, but we may have gone all the way through
1944 the keymaps without finding an all-ASCII key sequence. So just
1945 return the best we could find. */
1946 if (! NILP (firstonly
))
1947 return Fcar (found
);
1952 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
1954 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 1, "",
1955 "Show a list of all defined keys, and their definitions.\n\
1956 The list is put in a buffer, which is displayed.\n\
1957 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1958 then we display only bindings that start with that prefix.")
1962 register Lisp_Object thisbuf
;
1963 XSETBUFFER (thisbuf
, current_buffer
);
1964 internal_with_output_to_temp_buffer ("*Help*",
1965 describe_buffer_bindings
,
1966 Fcons (thisbuf
, prefix
));
1970 /* ARG is (BUFFER . PREFIX). */
1973 describe_buffer_bindings (arg
)
1976 Lisp_Object descbuf
, prefix
, shadow
;
1977 register Lisp_Object start1
;
1978 struct gcpro gcpro1
;
1980 char *alternate_heading
1982 Alternate Characters (use anywhere the nominal character is listed):\n\
1983 nominal alternate\n\
1984 ------- ---------\n";
1986 descbuf
= XCONS (arg
)->car
;
1987 prefix
= XCONS (arg
)->cdr
;
1991 Fset_buffer (Vstandard_output
);
1993 /* Report on alternates for keys. */
1994 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
1997 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
1998 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2000 for (c
= 0; c
< translate_len
; c
++)
2001 if (translate
[c
] != c
)
2006 if (alternate_heading
)
2008 insert_string (alternate_heading
);
2009 alternate_heading
= 0;
2012 bufend
= push_key_description (translate
[c
], buf
);
2013 insert (buf
, bufend
- buf
);
2014 Findent_to (make_number (16), make_number (1));
2015 bufend
= push_key_description (c
, buf
);
2016 insert (buf
, bufend
- buf
);
2024 if (!NILP (Vkey_translation_map
))
2025 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2026 "Key translations", 0, 1, 0);
2030 Lisp_Object
*modes
, *maps
;
2032 /* Temporarily switch to descbuf, so that we can get that buffer's
2033 minor modes correctly. */
2034 Fset_buffer (descbuf
);
2036 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2037 || !NILP (Voverriding_local_map
))
2040 nmaps
= current_minor_maps (&modes
, &maps
);
2041 Fset_buffer (Vstandard_output
);
2043 /* Print the minor mode maps. */
2044 for (i
= 0; i
< nmaps
; i
++)
2046 /* The title for a minor mode keymap
2047 is constructed at run time.
2048 We let describe_map_tree do the actual insertion
2049 because it takes care of other features when doing so. */
2052 if (!SYMBOLP (modes
[i
]))
2055 p
= title
= (char *) alloca (40 + XSYMBOL (modes
[i
])->name
->size
);
2057 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2058 XSYMBOL (modes
[i
])->name
->size
);
2059 p
+= XSYMBOL (modes
[i
])->name
->size
;
2061 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2062 p
+= sizeof (" Minor Mode Bindings") - 1;
2065 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, 0, 0, 0);
2066 shadow
= Fcons (maps
[i
], shadow
);
2070 /* Print the (major mode) local map. */
2071 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2072 start1
= current_kboard
->Voverriding_terminal_local_map
;
2073 else if (!NILP (Voverriding_local_map
))
2074 start1
= Voverriding_local_map
;
2076 start1
= XBUFFER (descbuf
)->keymap
;
2080 describe_map_tree (start1
, 1, shadow
, prefix
,
2081 "Major Mode Bindings", 0, 0, 0);
2082 shadow
= Fcons (start1
, shadow
);
2085 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2086 "Global Bindings", 0, 0, 1);
2088 /* Print the function-key-map translations under this prefix. */
2089 if (!NILP (Vfunction_key_map
))
2090 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2091 "Function key map translations", 0, 1, 0);
2093 call0 (intern ("help-mode"));
2094 Fset_buffer (descbuf
);
2099 /* Insert a description of the key bindings in STARTMAP,
2100 followed by those of all maps reachable through STARTMAP.
2101 If PARTIAL is nonzero, omit certain "uninteresting" commands
2102 (such as `undefined').
2103 If SHADOW is non-nil, it is a list of maps;
2104 don't mention keys which would be shadowed by any of them.
2105 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2106 TITLE, if not 0, is a string to insert at the beginning.
2107 TITLE should not end with a colon or a newline; we supply that.
2108 If NOMENU is not 0, then omit menu-bar commands.
2110 If TRANSL is nonzero, the definitions are actually key translations
2111 so print strings and vectors differently.
2113 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2117 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2119 Lisp_Object startmap
, shadow
, prefix
;
2126 Lisp_Object maps
, seen
, sub_shadows
;
2127 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2134 maps
= Faccessible_keymaps (startmap
, prefix
);
2137 GCPRO3 (maps
, seen
, sub_shadows
);
2143 /* Delete from MAPS each element that is for the menu bar. */
2144 for (list
= maps
; !NILP (list
); list
= XCONS (list
)->cdr
)
2146 Lisp_Object elt
, prefix
, tem
;
2149 prefix
= Fcar (elt
);
2150 if (XVECTOR (prefix
)->size
>= 1)
2152 tem
= Faref (prefix
, make_number (0));
2153 if (EQ (tem
, Qmenu_bar
))
2154 maps
= Fdelq (elt
, maps
);
2159 if (!NILP (maps
) || always_title
)
2163 insert_string (title
);
2166 insert_string (" Starting With ");
2167 insert1 (Fkey_description (prefix
));
2169 insert_string (":\n");
2171 insert_string (key_heading
);
2175 for (; !NILP (maps
); maps
= Fcdr (maps
))
2177 register Lisp_Object elt
, prefix
, tail
;
2180 prefix
= Fcar (elt
);
2184 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2188 shmap
= XCONS (tail
)->car
;
2190 /* If the sequence by which we reach this keymap is zero-length,
2191 then the shadow map for this keymap is just SHADOW. */
2192 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2193 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2195 /* If the sequence by which we reach this keymap actually has
2196 some elements, then the sequence's definition in SHADOW is
2197 what we should use. */
2200 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2201 if (INTEGERP (shmap
))
2205 /* If shmap is not nil and not a keymap,
2206 it completely shadows this map, so don't
2207 describe this map at all. */
2208 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2212 sub_shadows
= Fcons (shmap
, sub_shadows
);
2215 describe_map (Fcdr (elt
), Fcar (elt
),
2216 transl
? describe_translation
: describe_command
,
2217 partial
, sub_shadows
, &seen
, nomenu
);
2223 insert_string ("\n");
2228 static int previous_description_column
;
2231 describe_command (definition
)
2232 Lisp_Object definition
;
2234 register Lisp_Object tem1
;
2235 int column
= current_column ();
2236 int description_column
;
2238 /* If column 16 is no good, go to col 32;
2239 but don't push beyond that--go to next line instead. */
2243 description_column
= 32;
2245 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2246 description_column
= 32;
2248 description_column
= 16;
2250 Findent_to (make_number (description_column
), make_number (1));
2251 previous_description_column
= description_column
;
2253 if (SYMBOLP (definition
))
2255 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2257 insert_string ("\n");
2259 else if (STRINGP (definition
) || VECTORP (definition
))
2260 insert_string ("Keyboard Macro\n");
2263 tem1
= Fkeymapp (definition
);
2265 insert_string ("Prefix Command\n");
2267 insert_string ("??\n");
2272 describe_translation (definition
)
2273 Lisp_Object definition
;
2275 register Lisp_Object tem1
;
2277 Findent_to (make_number (16), make_number (1));
2279 if (SYMBOLP (definition
))
2281 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2283 insert_string ("\n");
2285 else if (STRINGP (definition
) || VECTORP (definition
))
2287 insert1 (Fkey_description (definition
));
2288 insert_string ("\n");
2292 tem1
= Fkeymapp (definition
);
2294 insert_string ("Prefix Command\n");
2296 insert_string ("??\n");
2300 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2301 Returns the first non-nil binding found in any of those maps. */
2304 shadow_lookup (shadow
, key
, flag
)
2305 Lisp_Object shadow
, key
, flag
;
2307 Lisp_Object tail
, value
;
2309 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2311 value
= Flookup_key (XCONS (tail
)->car
, key
, flag
);
2318 /* Describe the contents of map MAP, assuming that this map itself is
2319 reached by the sequence of prefix keys KEYS (a string or vector).
2320 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2323 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2324 register Lisp_Object map
;
2326 int (*elt_describer
) ();
2332 Lisp_Object elt_prefix
;
2333 Lisp_Object tail
, definition
, event
;
2335 Lisp_Object suppress
;
2338 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2340 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2342 /* Call Fkey_description first, to avoid GC bug for the other string. */
2343 tem
= Fkey_description (keys
);
2344 elt_prefix
= concat2 (tem
, build_string (" "));
2350 suppress
= intern ("suppress-keymap");
2352 /* This vector gets used to present single keys to Flookup_key. Since
2353 that is done once per keymap element, we don't want to cons up a
2354 fresh vector every time. */
2355 kludge
= Fmake_vector (make_number (1), Qnil
);
2358 GCPRO3 (elt_prefix
, definition
, kludge
);
2360 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2364 if (VECTORP (XCONS (tail
)->car
))
2365 describe_vector (XCONS (tail
)->car
,
2366 elt_prefix
, elt_describer
, partial
, shadow
, map
);
2367 else if (CONSP (XCONS (tail
)->car
))
2369 event
= XCONS (XCONS (tail
)->car
)->car
;
2371 /* Ignore bindings whose "keys" are not really valid events.
2372 (We get these in the frames and buffers menu.) */
2373 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2376 if (nomenu
&& EQ (event
, Qmenu_bar
))
2379 definition
= get_keyelt (XCONS (XCONS (tail
)->car
)->cdr
, 0);
2381 /* Don't show undefined commands or suppressed commands. */
2382 if (NILP (definition
)) continue;
2383 if (SYMBOLP (definition
) && partial
)
2385 tem
= Fget (definition
, suppress
);
2390 /* Don't show a command that isn't really visible
2391 because a local definition of the same key shadows it. */
2393 XVECTOR (kludge
)->contents
[0] = event
;
2396 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2397 if (!NILP (tem
)) continue;
2400 tem
= Flookup_key (map
, kludge
, Qt
);
2401 if (! EQ (tem
, definition
)) continue;
2405 previous_description_column
= 0;
2410 if (!NILP (elt_prefix
))
2411 insert1 (elt_prefix
);
2413 /* THIS gets the string to describe the character EVENT. */
2414 insert1 (Fsingle_key_description (event
));
2416 /* Print a description of the definition of this character.
2417 elt_describer will take care of spacing out far enough
2418 for alignment purposes. */
2419 (*elt_describer
) (definition
);
2421 else if (EQ (XCONS (tail
)->car
, Qkeymap
))
2423 /* The same keymap might be in the structure twice, if we're
2424 using an inherited keymap. So skip anything we've already
2426 tem
= Fassq (tail
, *seen
);
2427 if (CONSP (tem
) && !NILP (Fequal (XCONS (tem
)->car
, keys
)))
2429 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2437 describe_vector_princ (elt
)
2440 Findent_to (make_number (16), make_number (1));
2445 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2446 "Insert a description of contents of VECTOR.\n\
2447 This is text showing the elements of vector matched against indices.")
2451 int count
= specpdl_ptr
- specpdl
;
2453 specbind (Qstandard_output
, Fcurrent_buffer ());
2454 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2455 describe_vector (vector
, Qnil
, describe_vector_princ
, 0, Qnil
, Qnil
);
2457 return unbind_to (count
, Qnil
);
2460 /* Insert in the current buffer a description of the contents of VECTOR.
2461 We call ELT_DESCRIBER to insert the description of one value found
2464 ELT_PREFIX describes what "comes before" the keys or indices defined
2467 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2468 leads to this keymap.
2470 If the vector is a chartable, ELT_PREFIX is the vector
2471 of bytes that lead to the character set or portion of a character
2472 set described by this chartable.
2474 If PARTIAL is nonzero, it means do not mention suppressed commands
2475 (that assumes the vector is in a keymap).
2477 SHADOW is a list of keymaps that shadow this map.
2478 If it is non-nil, then we look up the key in those maps
2479 and we don't mention it now if it is defined by any of them.
2481 ENTIRE_MAP is the keymap in which this vector appears.
2482 If the definition in effect in the whole map does not match
2483 the one in this vector, we ignore this one. */
2485 describe_vector (vector
, elt_prefix
, elt_describer
,
2486 partial
, shadow
, entire_map
)
2487 register Lisp_Object vector
;
2488 Lisp_Object elt_prefix
;
2489 int (*elt_describer
) ();
2492 Lisp_Object entire_map
;
2496 Lisp_Object definition
;
2499 Lisp_Object suppress
;
2501 Lisp_Object chartable_kludge
;
2504 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2507 chartable_kludge
= Qnil
;
2509 /* This vector gets used to present single keys to Flookup_key. Since
2510 that is done once per vector element, we don't want to cons up a
2511 fresh vector every time. */
2512 kludge
= Fmake_vector (make_number (1), Qnil
);
2513 GCPRO4 (elt_prefix
, definition
, kludge
, chartable_kludge
);
2516 suppress
= intern ("suppress-keymap");
2518 /* This does the right thing for char-tables as well as ordinary vectors. */
2519 size
= XFASTINT (Flength (vector
));
2521 for (i
= 0; i
< size
; i
++)
2524 definition
= get_keyelt (XVECTOR (vector
)->contents
[i
], 0);
2526 if (NILP (definition
)) continue;
2528 /* Don't mention suppressed commands. */
2529 if (SYMBOLP (definition
) && partial
)
2531 this = Fget (definition
, suppress
);
2536 /* If this binding is shadowed by some other map, ignore it. */
2541 XVECTOR (kludge
)->contents
[0] = make_number (i
);
2542 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2544 if (!NILP (tem
)) continue;
2547 /* Ignore this definition if it is shadowed by an earlier
2548 one in the same keymap. */
2549 if (!NILP (entire_map
))
2553 XVECTOR (kludge
)->contents
[0] = make_number (i
);
2554 tem
= Flookup_key (entire_map
, kludge
, Qt
);
2556 if (! EQ (tem
, definition
))
2560 /* If we find a char-table within a char-table,
2561 scan it recursively; it defines the details for
2562 a character set or a portion of a character set. */
2563 if (CHAR_TABLE_P (vector
) && CHAR_TABLE_P (definition
))
2566 = !NILP (elt_prefix
) ? XVECTOR (elt_prefix
)->size
: 0;
2567 if (NILP (chartable_kludge
))
2570 = Fmake_vector (make_number (outer_level
+ 1), Qnil
);
2571 if (outer_level
!= 0)
2572 bcopy (XVECTOR (elt_prefix
)->contents
,
2573 XVECTOR (chartable_kludge
)->contents
,
2574 outer_level
* sizeof (Lisp_Object
));
2576 XVECTOR (chartable_kludge
)->contents
[outer_level
]
2578 describe_vector (definition
, chartable_kludge
, elt_describer
,
2579 partial
, shadow
, entire_map
);
2589 if (CHAR_TABLE_P (vector
))
2591 if (!NILP (elt_prefix
))
2593 /* Must combine elt_prefix with i to produce a character
2594 code, then insert that character's description. */
2598 /* Get the string to describe the character I, and print it. */
2599 XSETFASTINT (dummy
, i
);
2601 /* THIS gets the string to describe the character DUMMY. */
2602 this = Fsingle_key_description (dummy
);
2608 /* Output the prefix that applies to every entry in this map. */
2609 if (!NILP (elt_prefix
))
2610 insert1 (elt_prefix
);
2612 /* Get the string to describe the character I, and print it. */
2613 XSETFASTINT (dummy
, i
);
2615 /* THIS gets the string to describe the character DUMMY. */
2616 this = Fsingle_key_description (dummy
);
2620 /* Find all consecutive characters that have the same definition. */
2621 while (i
+ 1 < XVECTOR (vector
)->size
2622 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+1], 0),
2623 EQ (tem2
, definition
)))
2626 /* If we have a range of more than one character,
2627 print where the range reaches to. */
2629 if (i
!= XINT (dummy
))
2632 if (CHAR_TABLE_P (vector
))
2634 if (!NILP (elt_prefix
))
2636 /* Must combine elt_prefix with i to produce a character
2637 code, then insert that character's description. */
2641 XSETFASTINT (dummy
, i
);
2643 this = Fsingle_key_description (dummy
);
2649 if (!NILP (elt_prefix
))
2650 insert1 (elt_prefix
);
2652 XSETFASTINT (dummy
, i
);
2653 insert1 (Fsingle_key_description (dummy
));
2657 /* Print a description of the definition of this character.
2658 elt_describer will take care of spacing out far enough
2659 for alignment purposes. */
2660 (*elt_describer
) (definition
);
2666 /* Apropos - finding all symbols whose names match a regexp. */
2667 Lisp_Object apropos_predicate
;
2668 Lisp_Object apropos_accumulate
;
2671 apropos_accum (symbol
, string
)
2672 Lisp_Object symbol
, string
;
2674 register Lisp_Object tem
;
2676 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
2677 if (!NILP (tem
) && !NILP (apropos_predicate
))
2678 tem
= call1 (apropos_predicate
, symbol
);
2680 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
2683 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
2684 "Show all symbols whose names contain match for REGEXP.\n\
2685 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
2686 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
2687 Return list of symbols found.")
2689 Lisp_Object regexp
, predicate
;
2691 struct gcpro gcpro1
, gcpro2
;
2692 CHECK_STRING (regexp
, 0);
2693 apropos_predicate
= predicate
;
2694 GCPRO2 (apropos_predicate
, apropos_accumulate
);
2695 apropos_accumulate
= Qnil
;
2696 map_obarray (Vobarray
, apropos_accum
, regexp
);
2697 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
2699 return apropos_accumulate
;
2706 Qkeymap
= intern ("keymap");
2707 staticpro (&Qkeymap
);
2709 /* Initialize the keymaps standardly used.
2710 Each one is the value of a Lisp variable, and is also
2711 pointed to by a C variable */
2713 global_map
= Fcons (Qkeymap
,
2714 Fcons (Fmake_vector (make_number (0400), Qnil
), Qnil
));
2715 Fset (intern ("global-map"), global_map
);
2717 current_global_map
= global_map
;
2718 staticpro (&global_map
);
2719 staticpro (¤t_global_map
);
2721 meta_map
= Fmake_keymap (Qnil
);
2722 Fset (intern ("esc-map"), meta_map
);
2723 Ffset (intern ("ESC-prefix"), meta_map
);
2725 control_x_map
= Fmake_keymap (Qnil
);
2726 Fset (intern ("ctl-x-map"), control_x_map
);
2727 Ffset (intern ("Control-X-prefix"), control_x_map
);
2729 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
2730 "List of commands given new key bindings recently.\n\
2731 This is used for internal purposes during Emacs startup;\n\
2732 don't alter it yourself.");
2733 Vdefine_key_rebound_commands
= Qt
;
2735 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
2736 "Default keymap to use when reading from the minibuffer.");
2737 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
2739 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
2740 "Local keymap for the minibuffer when spaces are not allowed.");
2741 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
2743 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
2744 "Local keymap for minibuffer input with completion.");
2745 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
2747 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
2748 "Local keymap for minibuffer input with completion, for exact match.");
2749 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
2751 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
2752 "Alist of keymaps to use for minor modes.\n\
2753 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
2754 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
2755 If two active keymaps bind the same key, the keymap appearing earlier\n\
2756 in the list takes precedence.");
2757 Vminor_mode_map_alist
= Qnil
;
2759 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
2760 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
2761 This allows Emacs to recognize function keys sent from ASCII\n\
2762 terminals at any point in a key sequence.\n\
2764 The `read-key-sequence' function replaces any subsequence bound by\n\
2765 `function-key-map' with its binding. More precisely, when the active\n\
2766 keymaps have no binding for the current key sequence but\n\
2767 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
2768 `read-key-sequence' replaces the matching suffix with its binding, and\n\
2769 continues with the new sequence.\n\
2771 The events that come from bindings in `function-key-map' are not\n\
2772 themselves looked up in `function-key-map'.\n\
2774 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
2775 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
2776 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
2777 key, typing `ESC O P x' would return [f1 x].");
2778 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
2780 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
2781 "Keymap of key translations that can override keymaps.\n\
2782 This keymap works like `function-key-map', but comes after that,\n\
2783 and applies even for keys that have ordinary bindings.");
2784 Vkey_translation_map
= Qnil
;
2786 Qsingle_key_description
= intern ("single-key-description");
2787 staticpro (&Qsingle_key_description
);
2789 Qkey_description
= intern ("key-description");
2790 staticpro (&Qkey_description
);
2792 Qkeymapp
= intern ("keymapp");
2793 staticpro (&Qkeymapp
);
2795 Qnon_ascii
= intern ("non-ascii");
2796 staticpro (&Qnon_ascii
);
2798 defsubr (&Skeymapp
);
2799 defsubr (&Skeymap_parent
);
2800 defsubr (&Sset_keymap_parent
);
2801 defsubr (&Smake_keymap
);
2802 defsubr (&Smake_sparse_keymap
);
2803 defsubr (&Scopy_keymap
);
2804 defsubr (&Skey_binding
);
2805 defsubr (&Slocal_key_binding
);
2806 defsubr (&Sglobal_key_binding
);
2807 defsubr (&Sminor_mode_key_binding
);
2808 defsubr (&Sdefine_key
);
2809 defsubr (&Slookup_key
);
2810 defsubr (&Sdefine_prefix_command
);
2811 defsubr (&Suse_global_map
);
2812 defsubr (&Suse_local_map
);
2813 defsubr (&Scurrent_local_map
);
2814 defsubr (&Scurrent_global_map
);
2815 defsubr (&Scurrent_minor_mode_maps
);
2816 defsubr (&Saccessible_keymaps
);
2817 defsubr (&Skey_description
);
2818 defsubr (&Sdescribe_vector
);
2819 defsubr (&Ssingle_key_description
);
2820 defsubr (&Stext_char_description
);
2821 defsubr (&Swhere_is_internal
);
2822 defsubr (&Sdescribe_bindings
);
2823 defsubr (&Sapropos_internal
);
2830 initial_define_key (global_map
, 033, "ESC-prefix");
2831 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");