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. */
30 #include "termhooks.h"
31 #include "blockinput.h"
34 #define min(a, b) ((a) < (b) ? (a) : (b))
36 /* The number of elements in keymap vectors. */
37 #define DENSE_TABLE_SIZE (0200)
39 /* Actually allocate storage for these variables */
41 Lisp_Object current_global_map
; /* Current global keymap */
43 Lisp_Object global_map
; /* default global key bindings */
45 Lisp_Object meta_map
; /* The keymap used for globally bound
46 ESC-prefixed default commands */
48 Lisp_Object control_x_map
; /* The keymap used for globally bound
49 C-x-prefixed default commands */
51 /* was MinibufLocalMap */
52 Lisp_Object Vminibuffer_local_map
;
53 /* The keymap used by the minibuf for local
54 bindings when spaces are allowed in the
57 /* was MinibufLocalNSMap */
58 Lisp_Object Vminibuffer_local_ns_map
;
59 /* The keymap used by the minibuf for local
60 bindings when spaces are not encouraged
63 /* keymap used for minibuffers when doing completion */
64 /* was MinibufLocalCompletionMap */
65 Lisp_Object Vminibuffer_local_completion_map
;
67 /* keymap used for minibuffers when doing completion and require a match */
68 /* was MinibufLocalMustMatchMap */
69 Lisp_Object Vminibuffer_local_must_match_map
;
71 /* Alist of minor mode variables and keymaps. */
72 Lisp_Object Vminor_mode_map_alist
;
74 /* Keymap mapping ASCII function key sequences onto their preferred forms.
75 Initialized by the terminal-specific lisp files. See DEFVAR for more
77 Lisp_Object Vfunction_key_map
;
79 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
80 Lisp_Object Vkey_translation_map
;
82 /* A list of all commands given new bindings since a certain time
83 when nil was stored here.
84 This is used to speed up recomputation of menu key equivalents
85 when Emacs starts up. t means don't record anything here. */
86 Lisp_Object Vdefine_key_rebound_commands
;
88 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
;
90 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
91 in a string key sequence is equivalent to prefixing with this
93 extern Lisp_Object meta_prefix_char
;
95 extern Lisp_Object Voverriding_local_map
;
97 static Lisp_Object
define_as_prefix ();
98 static Lisp_Object
describe_buffer_bindings ();
99 static void describe_command (), describe_translation ();
100 static void describe_map ();
101 Lisp_Object
Fcopy_keymap ();
103 /* Keymap object support - constructors and predicates. */
105 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
106 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
107 VECTOR is a vector which holds the bindings for the ASCII\n\
108 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
109 mouse events, and any other things that appear in the input stream.\n\
110 All entries in it are initially nil, meaning \"command undefined\".\n\n\
111 The optional arg STRING supplies a menu name for the keymap\n\
112 in case you use it as a menu with `x-popup-menu'.")
118 tail
= Fcons (string
, Qnil
);
121 return Fcons (Qkeymap
,
122 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
125 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
126 "Construct and return a new sparse-keymap list.\n\
127 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
128 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
129 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
130 Initially the alist is nil.\n\n\
131 The optional arg STRING supplies a menu name for the keymap\n\
132 in case you use it as a menu with `x-popup-menu'.")
137 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
138 return Fcons (Qkeymap
, Qnil
);
141 /* This function is used for installing the standard key bindings
142 at initialization time.
146 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
149 initial_define_key (keymap
, key
, defname
)
154 store_in_keymap (keymap
, make_number (key
), intern (defname
));
158 initial_define_lispy_key (keymap
, keyname
, defname
)
163 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
166 /* Define character fromchar in map frommap as an alias for character
167 tochar in map tomap. Subsequent redefinitions of the latter WILL
168 affect the former. */
172 synkey (frommap
, fromchar
, tomap
, tochar
)
173 struct Lisp_Vector
*frommap
, *tomap
;
174 int fromchar
, tochar
;
177 XSETVECTOR (v
, tomap
);
178 XSETFASTINT (c
, tochar
);
179 frommap
->contents
[fromchar
] = Fcons (v
, c
);
183 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
184 "Return t if OBJECT is a keymap.\n\
186 A keymap is a list (keymap . ALIST),\n\
187 or a symbol whose function definition is itself a keymap.\n\
188 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
189 a vector of densely packed bindings for small character codes\n\
190 is also allowed as an element.")
194 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
197 /* Check that OBJECT is a keymap (after dereferencing through any
198 symbols). If it is, return it.
200 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
201 is an autoload form, do the autoload and try again.
202 If AUTOLOAD is nonzero, callers must assume GC is possible.
204 ERROR controls how we respond if OBJECT isn't a keymap.
205 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
207 Note that most of the time, we don't want to pursue autoloads.
208 Functions like Faccessible_keymaps which scan entire keymap trees
209 shouldn't load every autoloaded keymap. I'm not sure about this,
210 but it seems to me that only read_key_sequence, Flookup_key, and
211 Fdefine_key should cause keymaps to be autoloaded. */
214 get_keymap_1 (object
, error
, autoload
)
221 tem
= indirect_function (object
);
222 if (CONSP (tem
) && EQ (XCONS (tem
)->car
, Qkeymap
))
225 /* Should we do an autoload? Autoload forms for keymaps have
226 Qkeymap as their fifth element. */
230 && EQ (XCONS (tem
)->car
, Qautoload
))
234 tail
= Fnth (make_number (4), tem
);
235 if (EQ (tail
, Qkeymap
))
237 struct gcpro gcpro1
, gcpro2
;
239 GCPRO2 (tem
, object
);
240 do_autoload (tem
, object
);
248 wrong_type_argument (Qkeymapp
, object
);
254 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
255 If OBJECT doesn't denote a keymap at all, signal an error. */
260 return get_keymap_1 (object
, 1, 0);
263 /* Return the parent map of the keymap MAP, or nil if it has none.
264 We assume that MAP is a valid keymap. */
266 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
267 "Return the parent keymap of KEYMAP.")
273 keymap
= get_keymap_1 (keymap
, 1, 1);
275 /* Skip past the initial element `keymap'. */
276 list
= XCONS (keymap
)->cdr
;
277 for (; CONSP (list
); list
= XCONS (list
)->cdr
)
279 /* See if there is another `keymap'. */
280 if (EQ (Qkeymap
, XCONS (list
)->car
))
287 /* Set the parent keymap of MAP to PARENT. */
289 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
290 "Modify KEYMAP to set its parent map to PARENT.\n\
291 PARENT should be nil or another keymap.")
293 Lisp_Object keymap
, parent
;
295 Lisp_Object list
, prev
;
298 keymap
= get_keymap_1 (keymap
, 1, 1);
300 parent
= get_keymap_1 (parent
, 1, 1);
302 /* Skip past the initial element `keymap'. */
306 list
= XCONS (prev
)->cdr
;
307 /* If there is a parent keymap here, replace it.
308 If we came to the end, add the parent in PREV. */
309 if (! CONSP (list
) || EQ (Qkeymap
, XCONS (list
)->car
))
311 /* If we already have the right parent, return now
312 so that we avoid the loops below. */
313 if (EQ (XCONS (prev
)->cdr
, parent
))
316 XCONS (prev
)->cdr
= parent
;
322 /* Scan through for submaps, and set their parents too. */
324 for (list
= XCONS (keymap
)->cdr
; CONSP (list
); list
= XCONS (list
)->cdr
)
326 /* Stop the scan when we come to the parent. */
327 if (EQ (XCONS (list
)->car
, Qkeymap
))
330 /* If this element holds a prefix map, deal with it. */
331 if (CONSP (XCONS (list
)->car
)
332 && CONSP (XCONS (XCONS (list
)->car
)->cdr
))
333 fix_submap_inheritance (keymap
, XCONS (XCONS (list
)->car
)->car
,
334 XCONS (XCONS (list
)->car
)->cdr
);
336 if (VECTORP (XCONS (list
)->car
))
337 for (i
= 0; i
< XVECTOR (XCONS (list
)->car
)->size
; i
++)
338 if (CONSP (XVECTOR (XCONS (list
)->car
)->contents
[i
]))
339 fix_submap_inheritance (keymap
, make_number (i
),
340 XVECTOR (XCONS (list
)->car
)->contents
[i
]);
342 if (CHAR_TABLE_P (XCONS (list
)->car
))
344 Lisp_Object indices
[3];
346 map_char_table (fix_submap_inheritance
, Qnil
, XCONS (list
)->car
,
354 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
355 if EVENT is also a prefix in MAP's parent,
356 make sure that SUBMAP inherits that definition as its own parent. */
358 fix_submap_inheritance (map
, event
, submap
)
359 Lisp_Object map
, event
, submap
;
361 Lisp_Object map_parent
, parent_entry
;
363 /* SUBMAP is a cons that we found as a key binding.
364 Discard the other things found in a menu key binding. */
367 && STRINGP (XCONS (submap
)->car
))
369 submap
= XCONS (submap
)->cdr
;
370 /* Also remove a menu help string, if any,
371 following the menu item name. */
372 if (CONSP (submap
) && STRINGP (XCONS (submap
)->car
))
373 submap
= XCONS (submap
)->cdr
;
374 /* Also remove the sublist that caches key equivalences, if any. */
376 && CONSP (XCONS (submap
)->car
))
379 carcar
= XCONS (XCONS (submap
)->car
)->car
;
380 if (NILP (carcar
) || VECTORP (carcar
))
381 submap
= XCONS (submap
)->cdr
;
385 /* If it isn't a keymap now, there's no work to do. */
387 || ! EQ (XCONS (submap
)->car
, Qkeymap
))
390 map_parent
= Fkeymap_parent (map
);
391 if (! NILP (map_parent
))
392 parent_entry
= access_keymap (map_parent
, event
, 0, 0);
396 /* If MAP's parent has something other than a keymap,
397 our own submap shadows it completely, so use nil as SUBMAP's parent. */
398 if (! (CONSP (parent_entry
) && EQ (XCONS (parent_entry
)->car
, Qkeymap
)))
401 if (! EQ (parent_entry
, submap
))
402 Fset_keymap_parent (submap
, parent_entry
);
405 /* Look up IDX in MAP. IDX may be any sort of event.
406 Note that this does only one level of lookup; IDX must be a single
407 event, not a sequence.
409 If T_OK is non-zero, bindings for Qt are treated as default
410 bindings; any key left unmentioned by other tables and bindings is
411 given the binding of Qt.
413 If T_OK is zero, bindings for Qt are not treated specially.
415 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
418 access_keymap (map
, idx
, t_ok
, noinherit
)
427 /* If idx is a list (some sort of mouse click, perhaps?),
428 the index we want to use is the car of the list, which
429 ought to be a symbol. */
430 idx
= EVENT_HEAD (idx
);
432 /* If idx is a symbol, it might have modifiers, which need to
433 be put in the canonical order. */
435 idx
= reorder_modifiers (idx
);
436 else if (INTEGERP (idx
))
437 /* Clobber the high bits that can be present on a machine
438 with more than 24 bits of integer. */
439 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
443 Lisp_Object t_binding
;
446 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
450 binding
= XCONS (tail
)->car
;
451 if (SYMBOLP (binding
))
453 /* If NOINHERIT, stop finding prefix definitions
454 after we pass a second occurrence of the `keymap' symbol. */
455 if (noinherit
&& EQ (binding
, Qkeymap
) && ! EQ (tail
, map
))
458 else if (CONSP (binding
))
460 if (EQ (XCONS (binding
)->car
, idx
))
462 val
= XCONS (binding
)->cdr
;
463 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
466 fix_submap_inheritance (map
, idx
, val
);
469 if (t_ok
&& EQ (XCONS (binding
)->car
, Qt
))
470 t_binding
= XCONS (binding
)->cdr
;
472 else if (VECTORP (binding
))
474 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
476 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
477 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
480 fix_submap_inheritance (map
, idx
, val
);
484 else if (CHAR_TABLE_P (binding
))
486 /* Character codes with modifiers
487 are not included in a char-table.
488 All character codes without modifiers are included. */
491 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
492 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
494 val
= Faref (binding
, idx
);
495 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
498 fix_submap_inheritance (map
, idx
, val
);
510 /* Given OBJECT which was found in a slot in a keymap,
511 trace indirect definitions to get the actual definition of that slot.
512 An indirect definition is a list of the form
513 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
514 and INDEX is the object to look up in KEYMAP to yield the definition.
516 Also if OBJECT has a menu string as the first element,
517 remove that. Also remove a menu help string as second element.
519 If AUTOLOAD is nonzero, load autoloadable keymaps
520 that are referred to with indirection. */
523 get_keyelt (object
, autoload
)
524 register Lisp_Object object
;
529 register Lisp_Object map
, tem
;
531 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
532 map
= get_keymap_1 (Fcar_safe (object
), 0, autoload
);
533 tem
= Fkeymapp (map
);
538 if (INTEGERP (key
) && (XINT (key
) & meta_modifier
))
540 object
= access_keymap (map
, meta_prefix_char
, 0, 0);
541 map
= get_keymap_1 (object
, 0, autoload
);
542 object
= access_keymap (map
,
543 make_number (XINT (key
) & ~meta_modifier
),
547 object
= access_keymap (map
, key
, 0, 0);
550 /* If the keymap contents looks like (STRING . DEFN),
552 Keymap alist elements like (CHAR MENUSTRING . DEFN)
553 will be used by HierarKey menus. */
554 else if (CONSP (object
)
555 && STRINGP (XCONS (object
)->car
))
557 object
= XCONS (object
)->cdr
;
558 /* Also remove a menu help string, if any,
559 following the menu item name. */
560 if (CONSP (object
) && STRINGP (XCONS (object
)->car
))
561 object
= XCONS (object
)->cdr
;
562 /* Also remove the sublist that caches key equivalences, if any. */
564 && CONSP (XCONS (object
)->car
))
567 carcar
= XCONS (XCONS (object
)->car
)->car
;
568 if (NILP (carcar
) || VECTORP (carcar
))
569 object
= XCONS (object
)->cdr
;
574 /* Anything else is really the value. */
580 store_in_keymap (keymap
, idx
, def
)
582 register Lisp_Object idx
;
583 register Lisp_Object def
;
585 /* If we are preparing to dump, and DEF is a menu element
586 with a menu item string, copy it to ensure it is not pure. */
587 if (CONSP (def
) && PURE_P (def
) && STRINGP (XCONS (def
)->car
))
588 def
= Fcons (XCONS (def
)->car
, XCONS (def
)->cdr
);
590 if (!CONSP (keymap
) || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
591 error ("attempt to define a key in a non-keymap");
593 /* If idx is a list (some sort of mouse click, perhaps?),
594 the index we want to use is the car of the list, which
595 ought to be a symbol. */
596 idx
= EVENT_HEAD (idx
);
598 /* If idx is a symbol, it might have modifiers, which need to
599 be put in the canonical order. */
601 idx
= reorder_modifiers (idx
);
602 else if (INTEGERP (idx
))
603 /* Clobber the high bits that can be present on a machine
604 with more than 24 bits of integer. */
605 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
607 /* Scan the keymap for a binding of idx. */
611 /* The cons after which we should insert new bindings. If the
612 keymap has a table element, we record its position here, so new
613 bindings will go after it; this way, the table will stay
614 towards the front of the alist and character lookups in dense
615 keymaps will remain fast. Otherwise, this just points at the
616 front of the keymap. */
617 Lisp_Object insertion_point
;
619 insertion_point
= keymap
;
620 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
624 elt
= XCONS (tail
)->car
;
627 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (elt
)->size
)
629 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
632 insertion_point
= tail
;
634 else if (CHAR_TABLE_P (elt
))
636 /* Character codes with modifiers
637 are not included in a char-table.
638 All character codes without modifiers are included. */
641 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
642 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
644 Faset (elt
, idx
, def
);
647 insertion_point
= tail
;
649 else if (CONSP (elt
))
651 if (EQ (idx
, XCONS (elt
)->car
))
653 XCONS (elt
)->cdr
= def
;
657 else if (SYMBOLP (elt
))
659 /* If we find a 'keymap' symbol in the spine of KEYMAP,
660 then we must have found the start of a second keymap
661 being used as the tail of KEYMAP, and a binding for IDX
662 should be inserted before it. */
663 if (EQ (elt
, Qkeymap
))
671 /* We have scanned the entire keymap, and not found a binding for
672 IDX. Let's add one. */
673 XCONS (insertion_point
)->cdr
674 = Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
681 copy_keymap_1 (chartable
, idx
, elt
)
682 Lisp_Object chartable
, idx
, elt
;
684 if (!SYMBOLP (elt
) && ! NILP (Fkeymapp (elt
)))
685 Faset (chartable
, idx
, Fcopy_keymap (elt
));
688 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
689 "Return a copy of the keymap KEYMAP.\n\
690 The copy starts out with the same definitions of KEYMAP,\n\
691 but changing either the copy or KEYMAP does not affect the other.\n\
692 Any key definitions that are subkeymaps are recursively copied.\n\
693 However, a key definition which is a symbol whose definition is a keymap\n\
698 register Lisp_Object copy
, tail
;
700 copy
= Fcopy_alist (get_keymap (keymap
));
702 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
706 elt
= XCONS (tail
)->car
;
707 if (CHAR_TABLE_P (elt
))
709 Lisp_Object indices
[3];
711 elt
= Fcopy_sequence (elt
);
712 XCONS (tail
)->car
= elt
;
714 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
716 else if (VECTORP (elt
))
720 elt
= Fcopy_sequence (elt
);
721 XCONS (tail
)->car
= elt
;
723 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
724 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
725 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
726 XVECTOR (elt
)->contents
[i
]
727 = Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
729 else if (CONSP (elt
))
731 /* Skip the optional menu string. */
732 if (CONSP (XCONS (elt
)->cdr
)
733 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
737 /* Copy the cell, since copy-alist didn't go this deep. */
738 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
739 XCONS (XCONS (elt
)->cdr
)->cdr
);
740 elt
= XCONS (elt
)->cdr
;
742 /* Also skip the optional menu help string. */
743 if (CONSP (XCONS (elt
)->cdr
)
744 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
746 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
747 XCONS (XCONS (elt
)->cdr
)->cdr
);
748 elt
= XCONS (elt
)->cdr
;
750 /* There may also be a list that caches key equivalences.
751 Just delete it for the new keymap. */
752 if (CONSP (XCONS (elt
)->cdr
)
753 && CONSP (XCONS (XCONS (elt
)->cdr
)->car
)
754 && (NILP (tem
= XCONS (XCONS (XCONS (elt
)->cdr
)->car
)->car
)
756 XCONS (elt
)->cdr
= XCONS (XCONS (elt
)->cdr
)->cdr
;
759 && ! SYMBOLP (XCONS (elt
)->cdr
)
760 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
761 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
768 /* Simple Keymap mutators and accessors. */
770 /* GC is possible in this function if it autoloads a keymap. */
772 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
773 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
774 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
775 meaning a sequence of keystrokes and events.\n\
776 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
777 can be included if you use a vector.\n\
778 DEF is anything that can be a key's definition:\n\
779 nil (means key is undefined in this keymap),\n\
780 a command (a Lisp function suitable for interactive calling)\n\
781 a string (treated as a keyboard macro),\n\
782 a keymap (to define a prefix key),\n\
783 a symbol. When the key is looked up, the symbol will stand for its\n\
784 function definition, which should at that time be one of the above,\n\
785 or another symbol whose function definition is used, etc.\n\
786 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
787 (DEFN should be a valid definition in its own right),\n\
788 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
790 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
791 the front of KEYMAP.")
798 register Lisp_Object c
;
799 register Lisp_Object tem
;
800 register Lisp_Object cmd
;
804 struct gcpro gcpro1
, gcpro2
, gcpro3
;
806 keymap
= get_keymap_1 (keymap
, 1, 1);
808 if (!VECTORP (key
) && !STRINGP (key
))
809 key
= wrong_type_argument (Qarrayp
, key
);
811 length
= XFASTINT (Flength (key
));
815 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
816 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
818 GCPRO3 (keymap
, key
, def
);
821 meta_bit
= meta_modifier
;
828 c
= Faref (key
, make_number (idx
));
830 if (CONSP (c
) && lucid_event_type_list_p (c
))
831 c
= Fevent_convert_list (c
);
834 && (XINT (c
) & meta_bit
)
837 c
= meta_prefix_char
;
843 XSETINT (c
, XINT (c
) & ~meta_bit
);
849 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
850 error ("Key sequence contains invalid events");
853 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
855 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1), 1);
857 /* If this key is undefined, make it a prefix. */
859 cmd
= define_as_prefix (keymap
, c
);
861 keymap
= get_keymap_1 (cmd
, 0, 1);
863 /* We must use Fkey_description rather than just passing key to
864 error; key might be a vector, not a string. */
865 error ("Key sequence %s uses invalid prefix characters",
866 XSTRING (Fkey_description (key
))->data
);
870 /* Value is number if KEY is too long; NIL if valid but has no definition. */
871 /* GC is possible in this function if it autoloads a keymap. */
873 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
874 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
875 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
877 A number as value means KEY is \"too long\";\n\
878 that is, characters or symbols in it except for the last one\n\
879 fail to be a valid sequence of prefix characters in KEYMAP.\n\
880 The number is how many characters at the front of KEY\n\
881 it takes to reach a non-prefix command.\n\
883 Normally, `lookup-key' ignores bindings for t, which act as default\n\
884 bindings, used when nothing else in the keymap applies; this makes it\n\
885 usable as a general function for probing keymaps. However, if the\n\
886 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
887 recognize the default bindings, just as `read-key-sequence' does.")
888 (keymap
, key
, accept_default
)
889 register Lisp_Object keymap
;
891 Lisp_Object accept_default
;
894 register Lisp_Object tem
;
895 register Lisp_Object cmd
;
896 register Lisp_Object c
;
899 int t_ok
= ! NILP (accept_default
);
903 keymap
= get_keymap_1 (keymap
, 1, 1);
905 if (!VECTORP (key
) && !STRINGP (key
))
906 key
= wrong_type_argument (Qarrayp
, key
);
908 length
= XFASTINT (Flength (key
));
913 meta_bit
= meta_modifier
;
922 c
= Faref (key
, make_number (idx
));
924 if (CONSP (c
) && lucid_event_type_list_p (c
))
925 c
= Fevent_convert_list (c
);
928 && (XINT (c
) & meta_bit
)
931 c
= meta_prefix_char
;
937 XSETINT (c
, XINT (c
) & ~meta_bit
);
943 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0), 1);
945 RETURN_UNGCPRO (cmd
);
947 keymap
= get_keymap_1 (cmd
, 0, 1);
949 RETURN_UNGCPRO (make_number (idx
));
955 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
956 Assume that currently it does not define C at all.
957 Return the keymap. */
960 define_as_prefix (keymap
, c
)
961 Lisp_Object keymap
, c
;
963 Lisp_Object inherit
, cmd
;
965 cmd
= Fmake_sparse_keymap (Qnil
);
966 /* If this key is defined as a prefix in an inherited keymap,
967 make it a prefix in this map, and make its definition
968 inherit the other prefix definition. */
969 inherit
= access_keymap (keymap
, c
, 0, 0);
971 /* This code is needed to do the right thing in the following case:
972 keymap A inherits from B,
973 you define KEY as a prefix in A,
974 then later you define KEY as a prefix in B.
975 We want the old prefix definition in A to inherit from that in B.
976 It is hard to do that retroactively, so this code
977 creates the prefix in B right away.
979 But it turns out that this code causes problems immediately
980 when the prefix in A is defined: it causes B to define KEY
981 as a prefix with no subcommands.
983 So I took out this code. */
986 /* If there's an inherited keymap
987 and it doesn't define this key,
988 make it define this key. */
991 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
992 if (EQ (XCONS (tail
)->car
, Qkeymap
))
996 inherit
= define_as_prefix (tail
, c
);
1000 cmd
= nconc2 (cmd
, inherit
);
1001 store_in_keymap (keymap
, c
, cmd
);
1006 /* Append a key to the end of a key sequence. We always make a vector. */
1009 append_key (key_sequence
, key
)
1010 Lisp_Object key_sequence
, key
;
1012 Lisp_Object args
[2];
1014 args
[0] = key_sequence
;
1016 args
[1] = Fcons (key
, Qnil
);
1017 return Fvconcat (2, args
);
1021 /* Global, local, and minor mode keymap stuff. */
1023 /* We can't put these variables inside current_minor_maps, since under
1024 some systems, static gets macro-defined to be the empty string.
1026 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1027 static int cmm_size
;
1029 /* Error handler used in current_minor_maps. */
1031 current_minor_maps_error ()
1036 /* Store a pointer to an array of the keymaps of the currently active
1037 minor modes in *buf, and return the number of maps it contains.
1039 This function always returns a pointer to the same buffer, and may
1040 free or reallocate it, so if you want to keep it for a long time or
1041 hand it out to lisp code, copy it. This procedure will be called
1042 for every key sequence read, so the nice lispy approach (return a
1043 new assoclist, list, what have you) for each invocation would
1044 result in a lot of consing over time.
1046 If we used xrealloc/xmalloc and ran out of memory, they would throw
1047 back to the command loop, which would try to read a key sequence,
1048 which would call this function again, resulting in an infinite
1049 loop. Instead, we'll use realloc/malloc and silently truncate the
1050 list, let the key sequence be read, and hope some other piece of
1051 code signals the error. */
1053 current_minor_maps (modeptr
, mapptr
)
1054 Lisp_Object
**modeptr
, **mapptr
;
1057 Lisp_Object alist
, assoc
, var
, val
;
1059 for (alist
= Vminor_mode_map_alist
;
1061 alist
= XCONS (alist
)->cdr
)
1062 if ((assoc
= XCONS (alist
)->car
, CONSP (assoc
))
1063 && (var
= XCONS (assoc
)->car
, SYMBOLP (var
))
1064 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1071 Lisp_Object
*newmodes
, *newmaps
;
1078 = (Lisp_Object
*) realloc (cmm_modes
,
1079 cmm_size
* sizeof (Lisp_Object
));
1081 = (Lisp_Object
*) realloc (cmm_maps
,
1082 cmm_size
* sizeof (Lisp_Object
));
1090 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1092 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1096 if (newmaps
&& newmodes
)
1098 cmm_modes
= newmodes
;
1105 /* Get the keymap definition--or nil if it is not defined. */
1106 temp
= internal_condition_case_1 (Findirect_function
,
1108 Qerror
, current_minor_maps_error
);
1112 cmm_maps
[i
] = temp
;
1117 if (modeptr
) *modeptr
= cmm_modes
;
1118 if (mapptr
) *mapptr
= cmm_maps
;
1122 /* GC is possible in this function if it autoloads a keymap. */
1124 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1125 "Return the binding for command KEY in current keymaps.\n\
1126 KEY is a string or vector, a sequence of keystrokes.\n\
1127 The binding is probably a symbol with a function definition.\n\
1129 Normally, `key-binding' ignores bindings for t, which act as default\n\
1130 bindings, used when nothing else in the keymap applies; this makes it\n\
1131 usable as a general function for probing keymaps. However, if the\n\
1132 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1133 recognize the default bindings, just as `read-key-sequence' does.")
1134 (key
, accept_default
)
1135 Lisp_Object key
, accept_default
;
1137 Lisp_Object
*maps
, value
;
1139 struct gcpro gcpro1
;
1143 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1145 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1146 key
, accept_default
);
1147 if (! NILP (value
) && !INTEGERP (value
))
1148 RETURN_UNGCPRO (value
);
1150 else if (!NILP (Voverriding_local_map
))
1152 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1153 if (! NILP (value
) && !INTEGERP (value
))
1154 RETURN_UNGCPRO (value
);
1160 nmaps
= current_minor_maps (0, &maps
);
1161 /* Note that all these maps are GCPRO'd
1162 in the places where we found them. */
1164 for (i
= 0; i
< nmaps
; i
++)
1165 if (! NILP (maps
[i
]))
1167 value
= Flookup_key (maps
[i
], key
, accept_default
);
1168 if (! NILP (value
) && !INTEGERP (value
))
1169 RETURN_UNGCPRO (value
);
1172 local
= get_local_map (PT
, current_buffer
);
1176 value
= Flookup_key (local
, key
, accept_default
);
1177 if (! NILP (value
) && !INTEGERP (value
))
1178 RETURN_UNGCPRO (value
);
1182 value
= Flookup_key (current_global_map
, key
, accept_default
);
1184 if (! NILP (value
) && !INTEGERP (value
))
1190 /* GC is possible in this function if it autoloads a keymap. */
1192 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1193 "Return the binding for command KEYS in current local keymap only.\n\
1194 KEYS is a string, a sequence of keystrokes.\n\
1195 The binding is probably a symbol with a function definition.\n\
1197 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1198 bindings; see the description of `lookup-key' for more details about this.")
1199 (keys
, accept_default
)
1200 Lisp_Object keys
, accept_default
;
1202 register Lisp_Object map
;
1203 map
= current_buffer
->keymap
;
1206 return Flookup_key (map
, keys
, accept_default
);
1209 /* GC is possible in this function if it autoloads a keymap. */
1211 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1212 "Return the binding for command KEYS in current global keymap only.\n\
1213 KEYS is a string, a sequence of keystrokes.\n\
1214 The binding is probably a symbol with a function definition.\n\
1215 This function's return values are the same as those of lookup-key\n\
1218 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1219 bindings; see the description of `lookup-key' for more details about this.")
1220 (keys
, accept_default
)
1221 Lisp_Object keys
, accept_default
;
1223 return Flookup_key (current_global_map
, keys
, accept_default
);
1226 /* GC is possible in this function if it autoloads a keymap. */
1228 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1229 "Find the visible minor mode bindings of KEY.\n\
1230 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1231 the symbol which names the minor mode binding KEY, and BINDING is\n\
1232 KEY's definition in that mode. In particular, if KEY has no\n\
1233 minor-mode bindings, return nil. If the first binding is a\n\
1234 non-prefix, all subsequent bindings will be omitted, since they would\n\
1235 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1236 that come after prefix bindings.\n\
1238 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1239 bindings; see the description of `lookup-key' for more details about this.")
1240 (key
, accept_default
)
1241 Lisp_Object key
, accept_default
;
1243 Lisp_Object
*modes
, *maps
;
1245 Lisp_Object binding
;
1247 struct gcpro gcpro1
, gcpro2
;
1249 nmaps
= current_minor_maps (&modes
, &maps
);
1250 /* Note that all these maps are GCPRO'd
1251 in the places where we found them. */
1254 GCPRO2 (key
, binding
);
1256 for (i
= j
= 0; i
< nmaps
; i
++)
1257 if (! NILP (maps
[i
])
1258 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1259 && !INTEGERP (binding
))
1261 if (! NILP (get_keymap (binding
)))
1262 maps
[j
++] = Fcons (modes
[i
], binding
);
1264 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1268 return Flist (j
, maps
);
1271 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
1272 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1273 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1274 If a second optional argument MAPVAR is given, the map is stored as\n\
1275 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1278 Lisp_Object command
, mapvar
;
1281 map
= Fmake_sparse_keymap (Qnil
);
1282 Ffset (command
, map
);
1286 Fset (command
, map
);
1290 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1291 "Select KEYMAP as the global keymap.")
1295 keymap
= get_keymap (keymap
);
1296 current_global_map
= keymap
;
1301 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1302 "Select KEYMAP as the local keymap.\n\
1303 If KEYMAP is nil, that means no local keymap.")
1308 keymap
= get_keymap (keymap
);
1310 current_buffer
->keymap
= keymap
;
1315 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1316 "Return current buffer's local keymap, or nil if it has none.")
1319 return current_buffer
->keymap
;
1322 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1323 "Return the current global keymap.")
1326 return current_global_map
;
1329 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1330 "Return a list of keymaps for the minor modes of the current buffer.")
1334 int nmaps
= current_minor_maps (0, &maps
);
1336 return Flist (nmaps
, maps
);
1339 /* Help functions for describing and documenting keymaps. */
1341 static void accessible_keymaps_char_table ();
1343 /* This function cannot GC. */
1345 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1347 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1348 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1349 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1350 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1351 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1352 then the value includes only maps for prefixes that start with PREFIX.")
1354 Lisp_Object keymap
, prefix
;
1356 Lisp_Object maps
, good_maps
, tail
;
1359 /* no need for gcpro because we don't autoload any keymaps. */
1362 prefixlen
= XINT (Flength (prefix
));
1366 /* If a prefix was specified, start with the keymap (if any) for
1367 that prefix, so we don't waste time considering other prefixes. */
1369 tem
= Flookup_key (keymap
, prefix
, Qt
);
1370 /* Flookup_key may give us nil, or a number,
1371 if the prefix is not defined in this particular map.
1372 It might even give us a list that isn't a keymap. */
1373 tem
= get_keymap_1 (tem
, 0, 0);
1376 /* Convert PREFIX to a vector now, so that later on
1377 we don't have to deal with the possibility of a string. */
1378 if (STRINGP (prefix
))
1383 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1384 for (i
= 0; i
< XSTRING (prefix
)->size
; i
++)
1386 int c
= XSTRING (prefix
)->data
[i
];
1388 c
^= 0200 | meta_modifier
;
1389 XVECTOR (copy
)->contents
[i
] = make_number (c
);
1393 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1399 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1400 get_keymap (keymap
)),
1403 /* For each map in the list maps,
1404 look at any other maps it points to,
1405 and stick them at the end if they are not already in the list.
1407 This is a breadth-first traversal, where tail is the queue of
1408 nodes, and maps accumulates a list of all nodes visited. */
1410 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1412 register Lisp_Object thisseq
, thismap
;
1414 /* Does the current sequence end in the meta-prefix-char? */
1417 thisseq
= Fcar (Fcar (tail
));
1418 thismap
= Fcdr (Fcar (tail
));
1419 last
= make_number (XINT (Flength (thisseq
)) - 1);
1420 is_metized
= (XINT (last
) >= 0
1421 /* Don't metize the last char of PREFIX. */
1422 && XINT (last
) >= prefixlen
1423 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1425 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1429 elt
= XCONS (thismap
)->car
;
1433 if (CHAR_TABLE_P (elt
))
1435 Lisp_Object indices
[3];
1437 map_char_table (accessible_keymaps_char_table
, Qnil
,
1438 elt
, Fcons (maps
, Fcons (tail
, thisseq
)),
1441 else if (VECTORP (elt
))
1445 /* Vector keymap. Scan all the elements. */
1446 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1448 register Lisp_Object tem
;
1449 register Lisp_Object cmd
;
1451 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1452 if (NILP (cmd
)) continue;
1453 tem
= Fkeymapp (cmd
);
1456 cmd
= get_keymap (cmd
);
1457 /* Ignore keymaps that are already added to maps. */
1458 tem
= Frassq (cmd
, maps
);
1461 /* If the last key in thisseq is meta-prefix-char,
1462 turn it into a meta-ized keystroke. We know
1463 that the event we're about to append is an
1464 ascii keystroke since we're processing a
1468 int meta_bit
= meta_modifier
;
1469 tem
= Fcopy_sequence (thisseq
);
1471 Faset (tem
, last
, make_number (i
| meta_bit
));
1473 /* This new sequence is the same length as
1474 thisseq, so stick it in the list right
1477 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1481 tem
= append_key (thisseq
, make_number (i
));
1482 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1488 else if (CONSP (elt
))
1490 register Lisp_Object cmd
, tem
, filter
;
1492 cmd
= get_keyelt (XCONS (elt
)->cdr
, 0);
1493 /* Ignore definitions that aren't keymaps themselves. */
1494 tem
= Fkeymapp (cmd
);
1497 /* Ignore keymaps that have been seen already. */
1498 cmd
= get_keymap (cmd
);
1499 tem
= Frassq (cmd
, maps
);
1502 /* Let elt be the event defined by this map entry. */
1503 elt
= XCONS (elt
)->car
;
1505 /* If the last key in thisseq is meta-prefix-char, and
1506 this entry is a binding for an ascii keystroke,
1507 turn it into a meta-ized keystroke. */
1508 if (is_metized
&& INTEGERP (elt
))
1510 Lisp_Object element
;
1513 tem
= Fvconcat (1, &element
);
1514 XSETFASTINT (XVECTOR (tem
)->contents
[XINT (last
)],
1515 XINT (elt
) | meta_modifier
);
1517 /* This new sequence is the same length as
1518 thisseq, so stick it in the list right
1521 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1525 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1536 /* Now find just the maps whose access prefixes start with PREFIX. */
1539 for (; CONSP (maps
); maps
= XCONS (maps
)->cdr
)
1541 Lisp_Object elt
, thisseq
;
1542 elt
= XCONS (maps
)->car
;
1543 thisseq
= XCONS (elt
)->car
;
1544 /* The access prefix must be at least as long as PREFIX,
1545 and the first elements must match those of PREFIX. */
1546 if (XINT (Flength (thisseq
)) >= prefixlen
)
1549 for (i
= 0; i
< prefixlen
; i
++)
1552 XSETFASTINT (i1
, i
);
1553 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1557 good_maps
= Fcons (elt
, good_maps
);
1561 return Fnreverse (good_maps
);
1565 accessible_keymaps_char_table (args
, index
, cmd
)
1566 Lisp_Object args
, index
, cmd
;
1569 Lisp_Object maps
, tail
, thisseq
;
1574 maps
= XCONS (args
)->car
;
1575 tail
= XCONS (XCONS (args
)->cdr
)->car
;
1576 thisseq
= XCONS (XCONS (args
)->cdr
)->cdr
;
1578 tem
= Fkeymapp (cmd
);
1581 cmd
= get_keymap (cmd
);
1582 /* Ignore keymaps that are already added to maps. */
1583 tem
= Frassq (cmd
, maps
);
1586 tem
= append_key (thisseq
, index
);
1587 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1592 Lisp_Object Qsingle_key_description
, Qkey_description
;
1594 /* This function cannot GC. */
1596 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1597 "Return a pretty description of key-sequence KEYS.\n\
1598 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1599 spaces are put between sequence elements, etc.")
1611 vector
= Fmake_vector (Flength (keys
), Qnil
);
1612 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1614 if (XSTRING (keys
)->data
[i
] & 0x80)
1615 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1616 meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80));
1618 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1619 XSTRING (keys
)->data
[i
]);
1623 else if (!VECTORP (keys
))
1624 keys
= wrong_type_argument (Qarrayp
, keys
);
1626 /* In effect, this computes
1627 (mapconcat 'single-key-description keys " ")
1628 but we shouldn't use mapconcat because it can do GC. */
1630 len
= XVECTOR (keys
)->size
;
1631 sep
= build_string (" ");
1632 /* This has one extra element at the end that we don't pass to Fconcat. */
1633 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1635 for (i
= 0; i
< len
; i
++)
1637 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
]);
1638 args
[i
* 2 + 1] = sep
;
1641 return Fconcat (len
* 2 - 1, args
);
1645 push_key_description (c
, p
)
1646 register unsigned int c
;
1649 /* Clear all the meaningless bits above the meta bit. */
1650 c
&= meta_modifier
| ~ - meta_modifier
;
1652 if (c
& alt_modifier
)
1658 if (c
& ctrl_modifier
)
1664 if (c
& hyper_modifier
)
1668 c
-= hyper_modifier
;
1670 if (c
& meta_modifier
)
1676 if (c
& shift_modifier
)
1680 c
-= shift_modifier
;
1682 if (c
& super_modifier
)
1686 c
-= super_modifier
;
1702 else if (c
== Ctl ('M'))
1712 if (c
> 0 && c
<= Ctl ('Z'))
1735 *p
++ = (7 & (c
>> 6)) + '0';
1736 *p
++ = (7 & (c
>> 3)) + '0';
1737 *p
++ = (7 & (c
>> 0)) + '0';
1742 *p
++ = (7 & (c
>> 15)) + '0';
1743 *p
++ = (7 & (c
>> 12)) + '0';
1744 *p
++ = (7 & (c
>> 9)) + '0';
1745 *p
++ = (7 & (c
>> 6)) + '0';
1746 *p
++ = (7 & (c
>> 3)) + '0';
1747 *p
++ = (7 & (c
>> 0)) + '0';
1753 /* This function cannot GC. */
1755 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1756 "Return a pretty description of command character KEY.\n\
1757 Control characters turn into C-whatever, etc.")
1763 key
= EVENT_HEAD (key
);
1765 if (INTEGERP (key
)) /* Normal character */
1767 *push_key_description (XUINT (key
), tem
) = 0;
1768 return build_string (tem
);
1770 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1771 return Fsymbol_name (key
);
1772 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1773 return Fcopy_sequence (key
);
1775 error ("KEY must be an integer, cons, symbol, or string");
1779 push_text_char_description (c
, p
)
1780 register unsigned int c
;
1792 *p
++ = c
+ 64; /* 'A' - 1 */
1804 /* This function cannot GC. */
1806 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1807 "Return a pretty description of file-character CHARACTER.\n\
1808 Control characters turn into \"^char\", etc.")
1810 Lisp_Object character
;
1814 CHECK_NUMBER (character
, 0);
1816 if (!SINGLE_BYTE_CHAR_P (XFASTINT (character
)))
1819 int len
= non_ascii_char_to_string (XFASTINT (character
), tem
, &str
);
1821 return make_string (str
, len
);
1824 *push_text_char_description (XINT (character
) & 0377, tem
) = 0;
1826 return build_string (tem
);
1829 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1832 ascii_sequence_p (seq
)
1836 int len
= XINT (Flength (seq
));
1838 for (i
= 0; i
< len
; i
++)
1840 Lisp_Object ii
, elt
;
1842 XSETFASTINT (ii
, i
);
1843 elt
= Faref (seq
, ii
);
1846 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1854 /* where-is - finding a command in a set of keymaps. */
1856 static Lisp_Object
where_is_internal_1 ();
1857 static void where_is_internal_2 ();
1859 /* This function can GC if Flookup_key autoloads any keymaps. */
1861 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
1862 "Return list of keys that invoke DEFINITION.\n\
1863 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
1864 If KEYMAP is nil, search all the currently active keymaps.\n\
1866 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
1867 rather than a list of all possible key sequences.\n\
1868 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
1869 no matter what it is.\n\
1870 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
1871 and entirely reject menu bindings.\n\
1873 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
1874 to other keymaps or slots. This makes it possible to search for an\n\
1875 indirect definition itself.")
1876 (definition
, keymap
, firstonly
, noindirect
)
1877 Lisp_Object definition
, keymap
;
1878 Lisp_Object firstonly
, noindirect
;
1881 Lisp_Object found
, sequences
;
1882 Lisp_Object keymap1
;
1883 int keymap_specified
= !NILP (keymap
);
1884 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
1885 /* 1 means ignore all menu bindings entirely. */
1886 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
1888 /* Find keymaps accessible from `keymap' or the current
1889 context. But don't muck with the value of `keymap',
1890 because `where_is_internal_1' uses it to check for
1891 shadowed bindings. */
1893 if (! keymap_specified
)
1895 #ifdef USE_TEXT_PROPERTIES
1896 keymap1
= get_local_map (PT
, current_buffer
);
1898 keymap1
= current_buffer
->keymap
;
1902 if (!NILP (keymap1
))
1903 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap1
), Qnil
),
1904 Faccessible_keymaps (get_keymap (current_global_map
),
1907 maps
= Faccessible_keymaps (get_keymap (current_global_map
), Qnil
);
1909 /* Put the minor mode keymaps on the front. */
1910 if (! keymap_specified
)
1913 minors
= Fnreverse (Fcurrent_minor_mode_maps ());
1914 while (!NILP (minors
))
1916 maps
= nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors
)->car
),
1919 minors
= XCONS (minors
)->cdr
;
1923 GCPRO5 (definition
, keymap
, maps
, found
, sequences
);
1927 for (; !NILP (maps
); maps
= Fcdr (maps
))
1929 /* Key sequence to reach map, and the map that it reaches */
1930 register Lisp_Object
this, map
;
1932 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1933 [M-CHAR] sequences, check if last character of the sequence
1934 is the meta-prefix char. */
1938 this = Fcar (Fcar (maps
));
1939 map
= Fcdr (Fcar (maps
));
1940 last
= make_number (XINT (Flength (this)) - 1);
1941 last_is_meta
= (XINT (last
) >= 0
1942 && EQ (Faref (this, last
), meta_prefix_char
));
1948 /* Because the code we want to run on each binding is rather
1949 large, we don't want to have two separate loop bodies for
1950 sparse keymap bindings and tables; we want to iterate one
1951 loop body over both keymap and vector bindings.
1953 For this reason, if Fcar (map) is a vector, we don't
1954 advance map to the next element until i indicates that we
1955 have finished off the vector. */
1956 Lisp_Object elt
, key
, binding
;
1957 elt
= XCONS (map
)->car
;
1958 map
= XCONS (map
)->cdr
;
1964 /* Set key and binding to the current key and binding, and
1965 advance map and i to the next binding. */
1968 Lisp_Object sequence
;
1970 /* In a vector, look at each element. */
1971 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1973 binding
= XVECTOR (elt
)->contents
[i
];
1974 XSETFASTINT (key
, i
);
1975 sequence
= where_is_internal_1 (binding
, key
, definition
,
1976 noindirect
, keymap
, this,
1977 last
, nomenus
, last_is_meta
);
1978 if (!NILP (sequence
))
1979 sequences
= Fcons (sequence
, sequences
);
1982 else if (CHAR_TABLE_P (elt
))
1984 Lisp_Object indices
[3];
1987 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
1988 Fcons (keymap
, Qnil
)),
1989 Fcons (Fcons (this, last
),
1990 Fcons (make_number (nomenus
),
1991 make_number (last_is_meta
))));
1993 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
1995 sequences
= XCONS (XCONS (XCONS (args
)->car
)->cdr
)->cdr
;
1997 else if (CONSP (elt
))
1999 Lisp_Object sequence
;
2001 key
= XCONS (elt
)->car
;
2002 binding
= XCONS (elt
)->cdr
;
2004 sequence
= where_is_internal_1 (binding
, key
, definition
,
2005 noindirect
, keymap
, this,
2006 last
, nomenus
, last_is_meta
);
2007 if (!NILP (sequence
))
2008 sequences
= Fcons (sequence
, sequences
);
2012 for (; ! NILP (sequences
); sequences
= XCONS (sequences
)->cdr
)
2014 Lisp_Object sequence
;
2016 sequence
= XCONS (sequences
)->car
;
2018 /* It is a true unshadowed match. Record it, unless it's already
2019 been seen (as could happen when inheriting keymaps). */
2020 if (NILP (Fmember (sequence
, found
)))
2021 found
= Fcons (sequence
, found
);
2023 /* If firstonly is Qnon_ascii, then we can return the first
2024 binding we find. If firstonly is not Qnon_ascii but not
2025 nil, then we should return the first ascii-only binding
2027 if (EQ (firstonly
, Qnon_ascii
))
2028 RETURN_UNGCPRO (sequence
);
2029 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2030 RETURN_UNGCPRO (sequence
);
2037 found
= Fnreverse (found
);
2039 /* firstonly may have been t, but we may have gone all the way through
2040 the keymaps without finding an all-ASCII key sequence. So just
2041 return the best we could find. */
2042 if (! NILP (firstonly
))
2043 return Fcar (found
);
2048 /* This is the function that Fwhere_is_internal calls using map_char_table.
2050 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2052 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2053 Since map_char_table doesn't really use the return value from this function,
2054 we the result append to RESULT, the slot in ARGS. */
2057 where_is_internal_2 (args
, key
, binding
)
2058 Lisp_Object args
, key
, binding
;
2060 Lisp_Object definition
, noindirect
, keymap
, this, last
;
2061 Lisp_Object result
, sequence
;
2062 int nomenus
, last_is_meta
;
2064 result
= XCONS (XCONS (XCONS (args
)->car
)->cdr
)->cdr
;
2065 definition
= XCONS (XCONS (XCONS (args
)->car
)->car
)->car
;
2066 noindirect
= XCONS (XCONS (XCONS (args
)->car
)->car
)->cdr
;
2067 keymap
= XCONS (XCONS (XCONS (args
)->car
)->cdr
)->car
;
2068 this = XCONS (XCONS (XCONS (args
)->cdr
)->car
)->car
;
2069 last
= XCONS (XCONS (XCONS (args
)->cdr
)->car
)->cdr
;
2070 nomenus
= XFASTINT (XCONS (XCONS (XCONS (args
)->cdr
)->cdr
)->car
);
2071 last_is_meta
= XFASTINT (XCONS (XCONS (XCONS (args
)->cdr
)->cdr
)->cdr
);
2073 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
,
2074 this, last
, nomenus
, last_is_meta
);
2076 if (!NILP (sequence
))
2077 XCONS (XCONS (XCONS (args
)->car
)->cdr
)->cdr
2078 = Fcons (sequence
, result
);
2082 where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
, this, last
,
2083 nomenus
, last_is_meta
)
2084 Lisp_Object binding
, key
, definition
, noindirect
, keymap
, this, last
;
2085 int nomenus
, last_is_meta
;
2087 Lisp_Object sequence
;
2088 int keymap_specified
= !NILP (keymap
);
2090 /* Search through indirections unless that's not wanted. */
2091 if (NILP (noindirect
))
2097 Lisp_Object map
, tem
;
2098 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
2099 map
= get_keymap_1 (Fcar_safe (definition
), 0, 0);
2100 tem
= Fkeymapp (map
);
2102 definition
= access_keymap (map
, Fcdr (definition
), 0, 0);
2106 /* If the contents are (STRING ...), reject. */
2107 if (CONSP (definition
)
2108 && STRINGP (XCONS (definition
)->car
))
2112 binding
= get_keyelt (binding
, 0);
2115 /* End this iteration if this element does not match
2118 if (CONSP (definition
))
2121 tem
= Fequal (binding
, definition
);
2126 if (!EQ (binding
, definition
))
2129 /* We have found a match.
2130 Construct the key sequence where we found it. */
2131 if (INTEGERP (key
) && last_is_meta
)
2133 sequence
= Fcopy_sequence (this);
2134 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2137 sequence
= append_key (this, key
);
2139 /* Verify that this key binding is not shadowed by another
2140 binding for the same key, before we say it exists.
2142 Mechanism: look for local definition of this key and if
2143 it is defined and does not match what we found then
2146 Either nil or number as value from Flookup_key
2148 if (keymap_specified
)
2150 binding
= Flookup_key (keymap
, sequence
, Qnil
);
2151 if (!NILP (binding
) && !INTEGERP (binding
))
2153 if (CONSP (definition
))
2156 tem
= Fequal (binding
, definition
);
2161 if (!EQ (binding
, definition
))
2167 binding
= Fkey_binding (sequence
, Qnil
);
2168 if (!EQ (binding
, definition
))
2175 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2177 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 1, "",
2178 "Show a list of all defined keys, and their definitions.\n\
2179 The list is put in a buffer, which is displayed.\n\
2180 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
2181 then we display only bindings that start with that prefix.")
2185 register Lisp_Object thisbuf
;
2186 XSETBUFFER (thisbuf
, current_buffer
);
2187 internal_with_output_to_temp_buffer ("*Help*",
2188 describe_buffer_bindings
,
2189 Fcons (thisbuf
, prefix
));
2193 /* ARG is (BUFFER . PREFIX). */
2196 describe_buffer_bindings (arg
)
2199 Lisp_Object descbuf
, prefix
, shadow
;
2200 register Lisp_Object start1
;
2201 struct gcpro gcpro1
;
2203 char *alternate_heading
2205 Alternate Characters (use anywhere the nominal character is listed):\n\
2206 nominal alternate\n\
2207 ------- ---------\n";
2209 descbuf
= XCONS (arg
)->car
;
2210 prefix
= XCONS (arg
)->cdr
;
2214 Fset_buffer (Vstandard_output
);
2216 /* Report on alternates for keys. */
2217 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2220 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2221 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2223 for (c
= 0; c
< translate_len
; c
++)
2224 if (translate
[c
] != c
)
2229 if (alternate_heading
)
2231 insert_string (alternate_heading
);
2232 alternate_heading
= 0;
2235 bufend
= push_key_description (translate
[c
], buf
);
2236 insert (buf
, bufend
- buf
);
2237 Findent_to (make_number (16), make_number (1));
2238 bufend
= push_key_description (c
, buf
);
2239 insert (buf
, bufend
- buf
);
2247 if (!NILP (Vkey_translation_map
))
2248 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2249 "Key translations", 0, 1, 0);
2253 Lisp_Object
*modes
, *maps
;
2255 /* Temporarily switch to descbuf, so that we can get that buffer's
2256 minor modes correctly. */
2257 Fset_buffer (descbuf
);
2259 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2260 || !NILP (Voverriding_local_map
))
2263 nmaps
= current_minor_maps (&modes
, &maps
);
2264 Fset_buffer (Vstandard_output
);
2266 /* Print the minor mode maps. */
2267 for (i
= 0; i
< nmaps
; i
++)
2269 /* The title for a minor mode keymap
2270 is constructed at run time.
2271 We let describe_map_tree do the actual insertion
2272 because it takes care of other features when doing so. */
2275 if (!SYMBOLP (modes
[i
]))
2278 p
= title
= (char *) alloca (40 + XSYMBOL (modes
[i
])->name
->size
);
2280 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2281 XSYMBOL (modes
[i
])->name
->size
);
2282 p
+= XSYMBOL (modes
[i
])->name
->size
;
2284 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2285 p
+= sizeof (" Minor Mode Bindings") - 1;
2288 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, 0, 0, 0);
2289 shadow
= Fcons (maps
[i
], shadow
);
2293 /* Print the (major mode) local map. */
2294 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2295 start1
= current_kboard
->Voverriding_terminal_local_map
;
2296 else if (!NILP (Voverriding_local_map
))
2297 start1
= Voverriding_local_map
;
2299 start1
= XBUFFER (descbuf
)->keymap
;
2303 describe_map_tree (start1
, 1, shadow
, prefix
,
2304 "Major Mode Bindings", 0, 0, 0);
2305 shadow
= Fcons (start1
, shadow
);
2308 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2309 "Global Bindings", 0, 0, 1);
2311 /* Print the function-key-map translations under this prefix. */
2312 if (!NILP (Vfunction_key_map
))
2313 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2314 "Function key map translations", 0, 1, 0);
2316 call0 (intern ("help-mode"));
2317 Fset_buffer (descbuf
);
2322 /* Insert a description of the key bindings in STARTMAP,
2323 followed by those of all maps reachable through STARTMAP.
2324 If PARTIAL is nonzero, omit certain "uninteresting" commands
2325 (such as `undefined').
2326 If SHADOW is non-nil, it is a list of maps;
2327 don't mention keys which would be shadowed by any of them.
2328 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2329 TITLE, if not 0, is a string to insert at the beginning.
2330 TITLE should not end with a colon or a newline; we supply that.
2331 If NOMENU is not 0, then omit menu-bar commands.
2333 If TRANSL is nonzero, the definitions are actually key translations
2334 so print strings and vectors differently.
2336 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2340 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2342 Lisp_Object startmap
, shadow
, prefix
;
2349 Lisp_Object maps
, seen
, sub_shadows
;
2350 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2357 maps
= Faccessible_keymaps (startmap
, prefix
);
2360 GCPRO3 (maps
, seen
, sub_shadows
);
2366 /* Delete from MAPS each element that is for the menu bar. */
2367 for (list
= maps
; !NILP (list
); list
= XCONS (list
)->cdr
)
2369 Lisp_Object elt
, prefix
, tem
;
2372 prefix
= Fcar (elt
);
2373 if (XVECTOR (prefix
)->size
>= 1)
2375 tem
= Faref (prefix
, make_number (0));
2376 if (EQ (tem
, Qmenu_bar
))
2377 maps
= Fdelq (elt
, maps
);
2382 if (!NILP (maps
) || always_title
)
2386 insert_string (title
);
2389 insert_string (" Starting With ");
2390 insert1 (Fkey_description (prefix
));
2392 insert_string (":\n");
2394 insert_string (key_heading
);
2398 for (; !NILP (maps
); maps
= Fcdr (maps
))
2400 register Lisp_Object elt
, prefix
, tail
;
2403 prefix
= Fcar (elt
);
2407 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2411 shmap
= XCONS (tail
)->car
;
2413 /* If the sequence by which we reach this keymap is zero-length,
2414 then the shadow map for this keymap is just SHADOW. */
2415 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2416 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2418 /* If the sequence by which we reach this keymap actually has
2419 some elements, then the sequence's definition in SHADOW is
2420 what we should use. */
2423 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2424 if (INTEGERP (shmap
))
2428 /* If shmap is not nil and not a keymap,
2429 it completely shadows this map, so don't
2430 describe this map at all. */
2431 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2435 sub_shadows
= Fcons (shmap
, sub_shadows
);
2438 describe_map (Fcdr (elt
), Fcar (elt
),
2439 transl
? describe_translation
: describe_command
,
2440 partial
, sub_shadows
, &seen
, nomenu
);
2446 insert_string ("\n");
2451 static int previous_description_column
;
2454 describe_command (definition
)
2455 Lisp_Object definition
;
2457 register Lisp_Object tem1
;
2458 int column
= current_column ();
2459 int description_column
;
2461 /* If column 16 is no good, go to col 32;
2462 but don't push beyond that--go to next line instead. */
2466 description_column
= 32;
2468 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2469 description_column
= 32;
2471 description_column
= 16;
2473 Findent_to (make_number (description_column
), make_number (1));
2474 previous_description_column
= description_column
;
2476 if (SYMBOLP (definition
))
2478 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2480 insert_string ("\n");
2482 else if (STRINGP (definition
) || VECTORP (definition
))
2483 insert_string ("Keyboard Macro\n");
2486 tem1
= Fkeymapp (definition
);
2488 insert_string ("Prefix Command\n");
2490 insert_string ("??\n");
2495 describe_translation (definition
)
2496 Lisp_Object definition
;
2498 register Lisp_Object tem1
;
2500 Findent_to (make_number (16), make_number (1));
2502 if (SYMBOLP (definition
))
2504 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2506 insert_string ("\n");
2508 else if (STRINGP (definition
) || VECTORP (definition
))
2510 insert1 (Fkey_description (definition
));
2511 insert_string ("\n");
2515 tem1
= Fkeymapp (definition
);
2517 insert_string ("Prefix Command\n");
2519 insert_string ("??\n");
2523 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2524 Returns the first non-nil binding found in any of those maps. */
2527 shadow_lookup (shadow
, key
, flag
)
2528 Lisp_Object shadow
, key
, flag
;
2530 Lisp_Object tail
, value
;
2532 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2534 value
= Flookup_key (XCONS (tail
)->car
, key
, flag
);
2541 /* Describe the contents of map MAP, assuming that this map itself is
2542 reached by the sequence of prefix keys KEYS (a string or vector).
2543 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2546 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2547 register Lisp_Object map
;
2549 int (*elt_describer
) ();
2555 Lisp_Object elt_prefix
;
2556 Lisp_Object tail
, definition
, event
;
2558 Lisp_Object suppress
;
2561 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2563 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2565 /* Call Fkey_description first, to avoid GC bug for the other string. */
2566 tem
= Fkey_description (keys
);
2567 elt_prefix
= concat2 (tem
, build_string (" "));
2573 suppress
= intern ("suppress-keymap");
2575 /* This vector gets used to present single keys to Flookup_key. Since
2576 that is done once per keymap element, we don't want to cons up a
2577 fresh vector every time. */
2578 kludge
= Fmake_vector (make_number (1), Qnil
);
2581 GCPRO3 (elt_prefix
, definition
, kludge
);
2583 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2587 if (VECTORP (XCONS (tail
)->car
)
2588 || CHAR_TABLE_P (XCONS (tail
)->car
))
2589 describe_vector (XCONS (tail
)->car
,
2590 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2592 else if (CONSP (XCONS (tail
)->car
))
2594 event
= XCONS (XCONS (tail
)->car
)->car
;
2596 /* Ignore bindings whose "keys" are not really valid events.
2597 (We get these in the frames and buffers menu.) */
2598 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2601 if (nomenu
&& EQ (event
, Qmenu_bar
))
2604 definition
= get_keyelt (XCONS (XCONS (tail
)->car
)->cdr
, 0);
2606 /* Don't show undefined commands or suppressed commands. */
2607 if (NILP (definition
)) continue;
2608 if (SYMBOLP (definition
) && partial
)
2610 tem
= Fget (definition
, suppress
);
2615 /* Don't show a command that isn't really visible
2616 because a local definition of the same key shadows it. */
2618 XVECTOR (kludge
)->contents
[0] = event
;
2621 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2622 if (!NILP (tem
)) continue;
2625 tem
= Flookup_key (map
, kludge
, Qt
);
2626 if (! EQ (tem
, definition
)) continue;
2630 previous_description_column
= 0;
2635 if (!NILP (elt_prefix
))
2636 insert1 (elt_prefix
);
2638 /* THIS gets the string to describe the character EVENT. */
2639 insert1 (Fsingle_key_description (event
));
2641 /* Print a description of the definition of this character.
2642 elt_describer will take care of spacing out far enough
2643 for alignment purposes. */
2644 (*elt_describer
) (definition
);
2646 else if (EQ (XCONS (tail
)->car
, Qkeymap
))
2648 /* The same keymap might be in the structure twice, if we're
2649 using an inherited keymap. So skip anything we've already
2651 tem
= Fassq (tail
, *seen
);
2652 if (CONSP (tem
) && !NILP (Fequal (XCONS (tem
)->car
, keys
)))
2654 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2662 describe_vector_princ (elt
)
2665 Findent_to (make_number (16), make_number (1));
2670 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2671 "Insert a description of contents of VECTOR.\n\
2672 This is text showing the elements of vector matched against indices.")
2676 int count
= specpdl_ptr
- specpdl
;
2678 specbind (Qstandard_output
, Fcurrent_buffer ());
2679 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2680 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2681 Qnil
, Qnil
, (int *)0, 0);
2683 return unbind_to (count
, Qnil
);
2686 /* Insert in the current buffer a description of the contents of VECTOR.
2687 We call ELT_DESCRIBER to insert the description of one value found
2690 ELT_PREFIX describes what "comes before" the keys or indices defined
2691 by this vector. This is a human-readable string whose size
2692 is not necessarily related to the situation.
2694 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2695 leads to this keymap.
2697 If the vector is a chartable, ELT_PREFIX is the vector
2698 of bytes that lead to the character set or portion of a character
2699 set described by this chartable.
2701 If PARTIAL is nonzero, it means do not mention suppressed commands
2702 (that assumes the vector is in a keymap).
2704 SHADOW is a list of keymaps that shadow this map.
2705 If it is non-nil, then we look up the key in those maps
2706 and we don't mention it now if it is defined by any of them.
2708 ENTIRE_MAP is the keymap in which this vector appears.
2709 If the definition in effect in the whole map does not match
2710 the one in this vector, we ignore this one.
2712 When describing a sub-char-table, INDICES is a list of
2713 indices at higher levels in this char-table,
2714 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2717 describe_vector (vector
, elt_prefix
, elt_describer
,
2718 partial
, shadow
, entire_map
,
2719 indices
, char_table_depth
)
2720 register Lisp_Object vector
;
2721 Lisp_Object elt_prefix
;
2722 void (*elt_describer
) P_ ((Lisp_Object
));
2725 Lisp_Object entire_map
;
2727 int char_table_depth
;
2729 Lisp_Object definition
;
2732 Lisp_Object suppress
;
2735 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2736 /* Range of elements to be handled. */
2738 /* Flag to tell if we should handle multibyte characters. */
2739 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
2740 /* A flag to tell if a leaf in this level of char-table is not a
2741 generic character (i.e. a complete multibyte character). */
2747 indices
= (int *) alloca (3 * sizeof (int));
2751 /* This vector gets used to present single keys to Flookup_key. Since
2752 that is done once per vector element, we don't want to cons up a
2753 fresh vector every time. */
2754 kludge
= Fmake_vector (make_number (1), Qnil
);
2755 GCPRO3 (elt_prefix
, definition
, kludge
);
2758 suppress
= intern ("suppress-keymap");
2760 if (CHAR_TABLE_P (vector
))
2762 if (char_table_depth
== 0)
2764 /* VECTOR is a top level char-table. */
2767 to
= CHAR_TABLE_ORDINARY_SLOTS
;
2771 /* VECTOR is a sub char-table. */
2772 if (char_table_depth
>= 3)
2773 /* A char-table is never that deep. */
2774 error ("Too deep char table");
2777 = (CHARSET_VALID_P (indices
[0])
2778 && ((CHARSET_DIMENSION (indices
[0]) == 1
2779 && char_table_depth
== 1)
2780 || char_table_depth
== 2));
2782 /* Meaningful elements are from 32th to 127th. */
2784 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
2789 /* This does the right thing for ordinary vectors. */
2793 to
= XVECTOR (vector
)->size
;
2796 for (i
= from
; i
< to
; i
++)
2800 if (CHAR_TABLE_P (vector
))
2802 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
2805 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
2806 && !CHARSET_DEFINED_P (i
- 128))
2810 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
2813 definition
= get_keyelt (XVECTOR (vector
)->contents
[i
], 0);
2815 if (NILP (definition
)) continue;
2817 /* Don't mention suppressed commands. */
2818 if (SYMBOLP (definition
) && partial
)
2822 tem
= Fget (definition
, suppress
);
2824 if (!NILP (tem
)) continue;
2827 /* Set CHARACTER to the character this entry describes, if any.
2828 Also update *INDICES. */
2829 if (CHAR_TABLE_P (vector
))
2831 indices
[char_table_depth
] = i
;
2833 if (char_table_depth
== 0)
2836 indices
[0] = i
- 128;
2838 else if (complete_char
)
2841 = MAKE_NON_ASCII_CHAR (indices
[0], indices
[1], indices
[2]);
2849 /* If this binding is shadowed by some other map, ignore it. */
2850 if (!NILP (shadow
) && complete_char
)
2854 XVECTOR (kludge
)->contents
[0] = make_number (character
);
2855 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2857 if (!NILP (tem
)) continue;
2860 /* Ignore this definition if it is shadowed by an earlier
2861 one in the same keymap. */
2862 if (!NILP (entire_map
) && complete_char
)
2866 XVECTOR (kludge
)->contents
[0] = make_number (character
);
2867 tem
= Flookup_key (entire_map
, kludge
, Qt
);
2869 if (! EQ (tem
, definition
))
2875 if (char_table_depth
== 0)
2880 /* For a sub char-table, show the depth by indentation.
2881 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
2882 if (char_table_depth
> 0)
2883 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
2885 /* Output the prefix that applies to every entry in this map. */
2886 if (!NILP (elt_prefix
))
2887 insert1 (elt_prefix
);
2889 /* Insert or describe the character this slot is for,
2890 or a description of what it is for. */
2891 if (SUB_CHAR_TABLE_P (vector
))
2894 insert_char (character
);
2897 /* We need an octal representation for this block of
2900 sprintf (work
, "(row %d)", i
);
2901 insert (work
, strlen (work
));
2904 else if (CHAR_TABLE_P (vector
))
2907 insert1 (Fsingle_key_description (make_number (character
)));
2910 /* Print the information for this character set. */
2911 insert_string ("<");
2912 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
2914 insert_from_string (tem2
, 0 , XSTRING (tem2
)->size
, 0);
2922 insert1 (Fsingle_key_description (make_number (character
)));
2925 /* If we find a sub char-table within a char-table,
2926 scan it recursively; it defines the details for
2927 a character set or a portion of a character set. */
2928 if (multibyte
&& CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
2931 describe_vector (definition
, elt_prefix
, elt_describer
,
2932 partial
, shadow
, entire_map
,
2933 indices
, char_table_depth
+ 1);
2939 /* Find all consecutive characters or rows that have the same
2940 definition. But, for elements of a top level char table, if
2941 they are for charsets, we had better describe one by one even
2942 if they have the same definition. */
2943 if (CHAR_TABLE_P (vector
))
2947 if (char_table_depth
== 0)
2948 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
2950 while (i
+ 1 < limit
2951 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
2953 && !NILP (Fequal (tem2
, definition
)))
2958 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+ 1], 0),
2960 && !NILP (Fequal (tem2
, definition
)))
2964 /* If we have a range of more than one character,
2965 print where the range reaches to. */
2967 if (i
!= starting_i
)
2971 if (!NILP (elt_prefix
))
2972 insert1 (elt_prefix
);
2974 if (CHAR_TABLE_P (vector
))
2976 if (char_table_depth
== 0)
2978 insert1 (Fsingle_key_description (make_number (i
)));
2980 else if (complete_char
)
2982 indices
[char_table_depth
] = i
;
2984 = MAKE_NON_ASCII_CHAR (indices
[0], indices
[1], indices
[2]);
2985 insert_char (character
);
2989 /* We need an octal representation for this block of
2992 sprintf (work
, "(row %d)", i
);
2993 insert (work
, strlen (work
));
2998 insert1 (Fsingle_key_description (make_number (i
)));
3002 /* Print a description of the definition of this character.
3003 elt_describer will take care of spacing out far enough
3004 for alignment purposes. */
3005 (*elt_describer
) (definition
);
3008 /* For (sub) char-table, print `defalt' slot at last. */
3009 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3011 insert (" ", char_table_depth
* 2);
3012 insert_string ("<<default>>");
3013 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3019 /* Apropos - finding all symbols whose names match a regexp. */
3020 Lisp_Object apropos_predicate
;
3021 Lisp_Object apropos_accumulate
;
3024 apropos_accum (symbol
, string
)
3025 Lisp_Object symbol
, string
;
3027 register Lisp_Object tem
;
3029 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3030 if (!NILP (tem
) && !NILP (apropos_predicate
))
3031 tem
= call1 (apropos_predicate
, symbol
);
3033 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3036 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3037 "Show all symbols whose names contain match for REGEXP.\n\
3038 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3039 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3040 Return list of symbols found.")
3042 Lisp_Object regexp
, predicate
;
3044 struct gcpro gcpro1
, gcpro2
;
3045 CHECK_STRING (regexp
, 0);
3046 apropos_predicate
= predicate
;
3047 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3048 apropos_accumulate
= Qnil
;
3049 map_obarray (Vobarray
, apropos_accum
, regexp
);
3050 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3052 return apropos_accumulate
;
3059 Qkeymap
= intern ("keymap");
3060 staticpro (&Qkeymap
);
3062 /* Now we are ready to set up this property, so we can
3063 create char tables. */
3064 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3066 /* Initialize the keymaps standardly used.
3067 Each one is the value of a Lisp variable, and is also
3068 pointed to by a C variable */
3070 global_map
= Fmake_keymap (Qnil
);
3071 Fset (intern ("global-map"), global_map
);
3073 current_global_map
= global_map
;
3074 staticpro (&global_map
);
3075 staticpro (¤t_global_map
);
3077 meta_map
= Fmake_keymap (Qnil
);
3078 Fset (intern ("esc-map"), meta_map
);
3079 Ffset (intern ("ESC-prefix"), meta_map
);
3081 control_x_map
= Fmake_keymap (Qnil
);
3082 Fset (intern ("ctl-x-map"), control_x_map
);
3083 Ffset (intern ("Control-X-prefix"), control_x_map
);
3085 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3086 "List of commands given new key bindings recently.\n\
3087 This is used for internal purposes during Emacs startup;\n\
3088 don't alter it yourself.");
3089 Vdefine_key_rebound_commands
= Qt
;
3091 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3092 "Default keymap to use when reading from the minibuffer.");
3093 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3095 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3096 "Local keymap for the minibuffer when spaces are not allowed.");
3097 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3099 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3100 "Local keymap for minibuffer input with completion.");
3101 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3103 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3104 "Local keymap for minibuffer input with completion, for exact match.");
3105 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3107 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3108 "Alist of keymaps to use for minor modes.\n\
3109 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3110 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3111 If two active keymaps bind the same key, the keymap appearing earlier\n\
3112 in the list takes precedence.");
3113 Vminor_mode_map_alist
= Qnil
;
3115 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3116 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3117 This allows Emacs to recognize function keys sent from ASCII\n\
3118 terminals at any point in a key sequence.\n\
3120 The `read-key-sequence' function replaces any subsequence bound by\n\
3121 `function-key-map' with its binding. More precisely, when the active\n\
3122 keymaps have no binding for the current key sequence but\n\
3123 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3124 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3125 continues with the new sequence.\n\
3127 The events that come from bindings in `function-key-map' are not\n\
3128 themselves looked up in `function-key-map'.\n\
3130 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3131 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3132 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3133 key, typing `ESC O P x' would return [f1 x].");
3134 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3136 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3137 "Keymap of key translations that can override keymaps.\n\
3138 This keymap works like `function-key-map', but comes after that,\n\
3139 and applies even for keys that have ordinary bindings.");
3140 Vkey_translation_map
= Qnil
;
3142 Qsingle_key_description
= intern ("single-key-description");
3143 staticpro (&Qsingle_key_description
);
3145 Qkey_description
= intern ("key-description");
3146 staticpro (&Qkey_description
);
3148 Qkeymapp
= intern ("keymapp");
3149 staticpro (&Qkeymapp
);
3151 Qnon_ascii
= intern ("non-ascii");
3152 staticpro (&Qnon_ascii
);
3154 defsubr (&Skeymapp
);
3155 defsubr (&Skeymap_parent
);
3156 defsubr (&Sset_keymap_parent
);
3157 defsubr (&Smake_keymap
);
3158 defsubr (&Smake_sparse_keymap
);
3159 defsubr (&Scopy_keymap
);
3160 defsubr (&Skey_binding
);
3161 defsubr (&Slocal_key_binding
);
3162 defsubr (&Sglobal_key_binding
);
3163 defsubr (&Sminor_mode_key_binding
);
3164 defsubr (&Sdefine_key
);
3165 defsubr (&Slookup_key
);
3166 defsubr (&Sdefine_prefix_command
);
3167 defsubr (&Suse_global_map
);
3168 defsubr (&Suse_local_map
);
3169 defsubr (&Scurrent_local_map
);
3170 defsubr (&Scurrent_global_map
);
3171 defsubr (&Scurrent_minor_mode_maps
);
3172 defsubr (&Saccessible_keymaps
);
3173 defsubr (&Skey_description
);
3174 defsubr (&Sdescribe_vector
);
3175 defsubr (&Ssingle_key_description
);
3176 defsubr (&Stext_char_description
);
3177 defsubr (&Swhere_is_internal
);
3178 defsubr (&Sdescribe_bindings
);
3179 defsubr (&Sapropos_internal
);
3186 initial_define_key (global_map
, 033, "ESC-prefix");
3187 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");