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. */
359 fix_submap_inheritance (map
, event
, submap
)
360 Lisp_Object map
, event
, submap
;
362 Lisp_Object map_parent
, parent_entry
;
364 /* SUBMAP is a cons that we found as a key binding.
365 Discard the other things found in a menu key binding. */
368 && STRINGP (XCONS (submap
)->car
))
370 submap
= XCONS (submap
)->cdr
;
371 /* Also remove a menu help string, if any,
372 following the menu item name. */
373 if (CONSP (submap
) && STRINGP (XCONS (submap
)->car
))
374 submap
= XCONS (submap
)->cdr
;
375 /* Also remove the sublist that caches key equivalences, if any. */
377 && CONSP (XCONS (submap
)->car
))
380 carcar
= XCONS (XCONS (submap
)->car
)->car
;
381 if (NILP (carcar
) || VECTORP (carcar
))
382 submap
= XCONS (submap
)->cdr
;
386 /* If it isn't a keymap now, there's no work to do. */
388 || ! EQ (XCONS (submap
)->car
, Qkeymap
))
391 map_parent
= Fkeymap_parent (map
);
392 if (! NILP (map_parent
))
393 parent_entry
= access_keymap (map_parent
, event
, 0, 0);
397 /* If MAP's parent has something other than a keymap,
398 our own submap shadows it completely, so use nil as SUBMAP's parent. */
399 if (! (CONSP (parent_entry
) && EQ (XCONS (parent_entry
)->car
, Qkeymap
)))
402 if (! EQ (parent_entry
, submap
))
403 Fset_keymap_parent (submap
, parent_entry
);
406 /* Look up IDX in MAP. IDX may be any sort of event.
407 Note that this does only one level of lookup; IDX must be a single
408 event, not a sequence.
410 If T_OK is non-zero, bindings for Qt are treated as default
411 bindings; any key left unmentioned by other tables and bindings is
412 given the binding of Qt.
414 If T_OK is zero, bindings for Qt are not treated specially.
416 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
419 access_keymap (map
, idx
, t_ok
, noinherit
)
428 /* If idx is a list (some sort of mouse click, perhaps?),
429 the index we want to use is the car of the list, which
430 ought to be a symbol. */
431 idx
= EVENT_HEAD (idx
);
433 /* If idx is a symbol, it might have modifiers, which need to
434 be put in the canonical order. */
436 idx
= reorder_modifiers (idx
);
437 else if (INTEGERP (idx
))
438 /* Clobber the high bits that can be present on a machine
439 with more than 24 bits of integer. */
440 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
444 Lisp_Object t_binding
;
447 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
451 binding
= XCONS (tail
)->car
;
452 if (SYMBOLP (binding
))
454 /* If NOINHERIT, stop finding prefix definitions
455 after we pass a second occurrence of the `keymap' symbol. */
456 if (noinherit
&& EQ (binding
, Qkeymap
) && ! EQ (tail
, map
))
459 else if (CONSP (binding
))
461 if (EQ (XCONS (binding
)->car
, idx
))
463 val
= XCONS (binding
)->cdr
;
464 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
467 fix_submap_inheritance (map
, idx
, val
);
470 if (t_ok
&& EQ (XCONS (binding
)->car
, Qt
))
471 t_binding
= XCONS (binding
)->cdr
;
473 else if (VECTORP (binding
))
475 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
477 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
478 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
481 fix_submap_inheritance (map
, idx
, val
);
485 else if (CHAR_TABLE_P (binding
))
487 /* Character codes with modifiers
488 are not included in a char-table.
489 All character codes without modifiers are included. */
492 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
493 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
495 val
= Faref (binding
, idx
);
496 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
499 fix_submap_inheritance (map
, idx
, val
);
511 /* Given OBJECT which was found in a slot in a keymap,
512 trace indirect definitions to get the actual definition of that slot.
513 An indirect definition is a list of the form
514 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
515 and INDEX is the object to look up in KEYMAP to yield the definition.
517 Also if OBJECT has a menu string as the first element,
518 remove that. Also remove a menu help string as second element.
520 If AUTOLOAD is nonzero, load autoloadable keymaps
521 that are referred to with indirection. */
524 get_keyelt (object
, autoload
)
525 register Lisp_Object object
;
530 register Lisp_Object map
, tem
;
532 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
533 map
= get_keymap_1 (Fcar_safe (object
), 0, autoload
);
534 tem
= Fkeymapp (map
);
539 if (INTEGERP (key
) && (XINT (key
) & meta_modifier
))
541 object
= access_keymap (map
, meta_prefix_char
, 0, 0);
542 map
= get_keymap_1 (object
, 0, autoload
);
543 object
= access_keymap (map
,
544 make_number (XINT (key
) & ~meta_modifier
),
548 object
= access_keymap (map
, key
, 0, 0);
551 /* If the keymap contents looks like (STRING . DEFN),
553 Keymap alist elements like (CHAR MENUSTRING . DEFN)
554 will be used by HierarKey menus. */
555 else if (CONSP (object
)
556 && STRINGP (XCONS (object
)->car
))
558 object
= XCONS (object
)->cdr
;
559 /* Also remove a menu help string, if any,
560 following the menu item name. */
561 if (CONSP (object
) && STRINGP (XCONS (object
)->car
))
562 object
= XCONS (object
)->cdr
;
563 /* Also remove the sublist that caches key equivalences, if any. */
565 && CONSP (XCONS (object
)->car
))
568 carcar
= XCONS (XCONS (object
)->car
)->car
;
569 if (NILP (carcar
) || VECTORP (carcar
))
570 object
= XCONS (object
)->cdr
;
575 /* Anything else is really the value. */
581 store_in_keymap (keymap
, idx
, def
)
583 register Lisp_Object idx
;
584 register Lisp_Object def
;
586 /* If we are preparing to dump, and DEF is a menu element
587 with a menu item string, copy it to ensure it is not pure. */
588 if (CONSP (def
) && PURE_P (def
) && STRINGP (XCONS (def
)->car
))
589 def
= Fcons (XCONS (def
)->car
, XCONS (def
)->cdr
);
591 if (!CONSP (keymap
) || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
592 error ("attempt to define a key in a non-keymap");
594 /* If idx is a list (some sort of mouse click, perhaps?),
595 the index we want to use is the car of the list, which
596 ought to be a symbol. */
597 idx
= EVENT_HEAD (idx
);
599 /* If idx is a symbol, it might have modifiers, which need to
600 be put in the canonical order. */
602 idx
= reorder_modifiers (idx
);
603 else if (INTEGERP (idx
))
604 /* Clobber the high bits that can be present on a machine
605 with more than 24 bits of integer. */
606 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
608 /* Scan the keymap for a binding of idx. */
612 /* The cons after which we should insert new bindings. If the
613 keymap has a table element, we record its position here, so new
614 bindings will go after it; this way, the table will stay
615 towards the front of the alist and character lookups in dense
616 keymaps will remain fast. Otherwise, this just points at the
617 front of the keymap. */
618 Lisp_Object insertion_point
;
620 insertion_point
= keymap
;
621 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
625 elt
= XCONS (tail
)->car
;
628 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (elt
)->size
)
630 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
633 insertion_point
= tail
;
635 else if (CHAR_TABLE_P (elt
))
637 /* Character codes with modifiers
638 are not included in a char-table.
639 All character codes without modifiers are included. */
642 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
643 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
645 Faset (elt
, idx
, def
);
648 insertion_point
= tail
;
650 else if (CONSP (elt
))
652 if (EQ (idx
, XCONS (elt
)->car
))
654 XCONS (elt
)->cdr
= def
;
658 else if (SYMBOLP (elt
))
660 /* If we find a 'keymap' symbol in the spine of KEYMAP,
661 then we must have found the start of a second keymap
662 being used as the tail of KEYMAP, and a binding for IDX
663 should be inserted before it. */
664 if (EQ (elt
, Qkeymap
))
672 /* We have scanned the entire keymap, and not found a binding for
673 IDX. Let's add one. */
674 XCONS (insertion_point
)->cdr
675 = Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
682 copy_keymap_1 (chartable
, idx
, elt
)
683 Lisp_Object chartable
, idx
, elt
;
685 if (!SYMBOLP (elt
) && ! NILP (Fkeymapp (elt
)))
686 Faset (chartable
, idx
, Fcopy_keymap (elt
));
689 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
690 "Return a copy of the keymap KEYMAP.\n\
691 The copy starts out with the same definitions of KEYMAP,\n\
692 but changing either the copy or KEYMAP does not affect the other.\n\
693 Any key definitions that are subkeymaps are recursively copied.\n\
694 However, a key definition which is a symbol whose definition is a keymap\n\
699 register Lisp_Object copy
, tail
;
701 copy
= Fcopy_alist (get_keymap (keymap
));
703 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
707 elt
= XCONS (tail
)->car
;
708 if (CHAR_TABLE_P (elt
))
710 Lisp_Object indices
[3];
712 elt
= Fcopy_sequence (elt
);
713 XCONS (tail
)->car
= elt
;
715 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
717 else if (VECTORP (elt
))
721 elt
= Fcopy_sequence (elt
);
722 XCONS (tail
)->car
= elt
;
724 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
725 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
726 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
727 XVECTOR (elt
)->contents
[i
]
728 = Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
730 else if (CONSP (elt
))
732 /* Skip the optional menu string. */
733 if (CONSP (XCONS (elt
)->cdr
)
734 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
738 /* Copy the cell, since copy-alist didn't go this deep. */
739 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
740 XCONS (XCONS (elt
)->cdr
)->cdr
);
741 elt
= XCONS (elt
)->cdr
;
743 /* Also skip the optional menu help string. */
744 if (CONSP (XCONS (elt
)->cdr
)
745 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
747 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
748 XCONS (XCONS (elt
)->cdr
)->cdr
);
749 elt
= XCONS (elt
)->cdr
;
751 /* There may also be a list that caches key equivalences.
752 Just delete it for the new keymap. */
753 if (CONSP (XCONS (elt
)->cdr
)
754 && CONSP (XCONS (XCONS (elt
)->cdr
)->car
)
755 && (NILP (tem
= XCONS (XCONS (XCONS (elt
)->cdr
)->car
)->car
)
757 XCONS (elt
)->cdr
= XCONS (XCONS (elt
)->cdr
)->cdr
;
760 && ! SYMBOLP (XCONS (elt
)->cdr
)
761 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
762 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
769 /* Simple Keymap mutators and accessors. */
771 /* GC is possible in this function if it autoloads a keymap. */
773 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
774 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
775 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
776 meaning a sequence of keystrokes and events.\n\
777 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
778 can be included if you use a vector.\n\
779 DEF is anything that can be a key's definition:\n\
780 nil (means key is undefined in this keymap),\n\
781 a command (a Lisp function suitable for interactive calling)\n\
782 a string (treated as a keyboard macro),\n\
783 a keymap (to define a prefix key),\n\
784 a symbol. When the key is looked up, the symbol will stand for its\n\
785 function definition, which should at that time be one of the above,\n\
786 or another symbol whose function definition is used, etc.\n\
787 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
788 (DEFN should be a valid definition in its own right),\n\
789 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
791 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
792 the front of KEYMAP.")
799 register Lisp_Object c
;
800 register Lisp_Object tem
;
801 register Lisp_Object cmd
;
805 struct gcpro gcpro1
, gcpro2
, gcpro3
;
807 keymap
= get_keymap_1 (keymap
, 1, 1);
809 if (!VECTORP (key
) && !STRINGP (key
))
810 key
= wrong_type_argument (Qarrayp
, key
);
812 length
= XFASTINT (Flength (key
));
816 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
817 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
819 GCPRO3 (keymap
, key
, def
);
822 meta_bit
= meta_modifier
;
829 c
= Faref (key
, make_number (idx
));
831 if (CONSP (c
) && lucid_event_type_list_p (c
))
832 c
= Fevent_convert_list (c
);
835 && (XINT (c
) & meta_bit
)
838 c
= meta_prefix_char
;
844 XSETINT (c
, XINT (c
) & ~meta_bit
);
850 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
851 error ("Key sequence contains invalid events");
854 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
856 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1), 1);
858 /* If this key is undefined, make it a prefix. */
860 cmd
= define_as_prefix (keymap
, c
);
862 keymap
= get_keymap_1 (cmd
, 0, 1);
864 /* We must use Fkey_description rather than just passing key to
865 error; key might be a vector, not a string. */
866 error ("Key sequence %s uses invalid prefix characters",
867 XSTRING (Fkey_description (key
))->data
);
871 /* Value is number if KEY is too long; NIL if valid but has no definition. */
872 /* GC is possible in this function if it autoloads a keymap. */
874 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
875 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
876 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
878 A number as value means KEY is \"too long\";\n\
879 that is, characters or symbols in it except for the last one\n\
880 fail to be a valid sequence of prefix characters in KEYMAP.\n\
881 The number is how many characters at the front of KEY\n\
882 it takes to reach a non-prefix command.\n\
884 Normally, `lookup-key' ignores bindings for t, which act as default\n\
885 bindings, used when nothing else in the keymap applies; this makes it\n\
886 usable as a general function for probing keymaps. However, if the\n\
887 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
888 recognize the default bindings, just as `read-key-sequence' does.")
889 (keymap
, key
, accept_default
)
890 register Lisp_Object keymap
;
892 Lisp_Object accept_default
;
895 register Lisp_Object tem
;
896 register Lisp_Object cmd
;
897 register Lisp_Object c
;
900 int t_ok
= ! NILP (accept_default
);
904 keymap
= get_keymap_1 (keymap
, 1, 1);
906 if (!VECTORP (key
) && !STRINGP (key
))
907 key
= wrong_type_argument (Qarrayp
, key
);
909 length
= XFASTINT (Flength (key
));
914 meta_bit
= meta_modifier
;
923 c
= Faref (key
, make_number (idx
));
925 if (CONSP (c
) && lucid_event_type_list_p (c
))
926 c
= Fevent_convert_list (c
);
929 && (XINT (c
) & meta_bit
)
932 c
= meta_prefix_char
;
938 XSETINT (c
, XINT (c
) & ~meta_bit
);
944 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0), 1);
946 RETURN_UNGCPRO (cmd
);
948 keymap
= get_keymap_1 (cmd
, 0, 1);
950 RETURN_UNGCPRO (make_number (idx
));
956 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
957 Assume that currently it does not define C at all.
958 Return the keymap. */
961 define_as_prefix (keymap
, c
)
962 Lisp_Object keymap
, c
;
964 Lisp_Object inherit
, cmd
;
966 cmd
= Fmake_sparse_keymap (Qnil
);
967 /* If this key is defined as a prefix in an inherited keymap,
968 make it a prefix in this map, and make its definition
969 inherit the other prefix definition. */
970 inherit
= access_keymap (keymap
, c
, 0, 0);
972 /* This code is needed to do the right thing in the following case:
973 keymap A inherits from B,
974 you define KEY as a prefix in A,
975 then later you define KEY as a prefix in B.
976 We want the old prefix definition in A to inherit from that in B.
977 It is hard to do that retroactively, so this code
978 creates the prefix in B right away.
980 But it turns out that this code causes problems immediately
981 when the prefix in A is defined: it causes B to define KEY
982 as a prefix with no subcommands.
984 So I took out this code. */
987 /* If there's an inherited keymap
988 and it doesn't define this key,
989 make it define this key. */
992 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
993 if (EQ (XCONS (tail
)->car
, Qkeymap
))
997 inherit
= define_as_prefix (tail
, c
);
1001 cmd
= nconc2 (cmd
, inherit
);
1002 store_in_keymap (keymap
, c
, cmd
);
1007 /* Append a key to the end of a key sequence. We always make a vector. */
1010 append_key (key_sequence
, key
)
1011 Lisp_Object key_sequence
, key
;
1013 Lisp_Object args
[2];
1015 args
[0] = key_sequence
;
1017 args
[1] = Fcons (key
, Qnil
);
1018 return Fvconcat (2, args
);
1022 /* Global, local, and minor mode keymap stuff. */
1024 /* We can't put these variables inside current_minor_maps, since under
1025 some systems, static gets macro-defined to be the empty string.
1027 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1028 static int cmm_size
;
1030 /* Error handler used in current_minor_maps. */
1032 current_minor_maps_error ()
1037 /* Store a pointer to an array of the keymaps of the currently active
1038 minor modes in *buf, and return the number of maps it contains.
1040 This function always returns a pointer to the same buffer, and may
1041 free or reallocate it, so if you want to keep it for a long time or
1042 hand it out to lisp code, copy it. This procedure will be called
1043 for every key sequence read, so the nice lispy approach (return a
1044 new assoclist, list, what have you) for each invocation would
1045 result in a lot of consing over time.
1047 If we used xrealloc/xmalloc and ran out of memory, they would throw
1048 back to the command loop, which would try to read a key sequence,
1049 which would call this function again, resulting in an infinite
1050 loop. Instead, we'll use realloc/malloc and silently truncate the
1051 list, let the key sequence be read, and hope some other piece of
1052 code signals the error. */
1054 current_minor_maps (modeptr
, mapptr
)
1055 Lisp_Object
**modeptr
, **mapptr
;
1058 Lisp_Object alist
, assoc
, var
, val
;
1060 for (alist
= Vminor_mode_map_alist
;
1062 alist
= XCONS (alist
)->cdr
)
1063 if ((assoc
= XCONS (alist
)->car
, CONSP (assoc
))
1064 && (var
= XCONS (assoc
)->car
, SYMBOLP (var
))
1065 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1072 Lisp_Object
*newmodes
, *newmaps
;
1079 = (Lisp_Object
*) realloc (cmm_modes
,
1080 cmm_size
* sizeof (Lisp_Object
));
1082 = (Lisp_Object
*) realloc (cmm_maps
,
1083 cmm_size
* sizeof (Lisp_Object
));
1091 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1093 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1097 if (newmaps
&& newmodes
)
1099 cmm_modes
= newmodes
;
1106 /* Get the keymap definition--or nil if it is not defined. */
1107 temp
= internal_condition_case_1 (Findirect_function
,
1109 Qerror
, current_minor_maps_error
);
1113 cmm_maps
[i
] = temp
;
1118 if (modeptr
) *modeptr
= cmm_modes
;
1119 if (mapptr
) *mapptr
= cmm_maps
;
1123 /* GC is possible in this function if it autoloads a keymap. */
1125 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1126 "Return the binding for command KEY in current keymaps.\n\
1127 KEY is a string or vector, a sequence of keystrokes.\n\
1128 The binding is probably a symbol with a function definition.\n\
1130 Normally, `key-binding' ignores bindings for t, which act as default\n\
1131 bindings, used when nothing else in the keymap applies; this makes it\n\
1132 usable as a general function for probing keymaps. However, if the\n\
1133 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1134 recognize the default bindings, just as `read-key-sequence' does.")
1135 (key
, accept_default
)
1136 Lisp_Object key
, accept_default
;
1138 Lisp_Object
*maps
, value
;
1140 struct gcpro gcpro1
;
1144 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1146 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1147 key
, accept_default
);
1148 if (! NILP (value
) && !INTEGERP (value
))
1149 RETURN_UNGCPRO (value
);
1151 else if (!NILP (Voverriding_local_map
))
1153 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1154 if (! NILP (value
) && !INTEGERP (value
))
1155 RETURN_UNGCPRO (value
);
1161 nmaps
= current_minor_maps (0, &maps
);
1162 /* Note that all these maps are GCPRO'd
1163 in the places where we found them. */
1165 for (i
= 0; i
< nmaps
; i
++)
1166 if (! NILP (maps
[i
]))
1168 value
= Flookup_key (maps
[i
], key
, accept_default
);
1169 if (! NILP (value
) && !INTEGERP (value
))
1170 RETURN_UNGCPRO (value
);
1173 local
= get_local_map (PT
, current_buffer
);
1177 value
= Flookup_key (local
, key
, accept_default
);
1178 if (! NILP (value
) && !INTEGERP (value
))
1179 RETURN_UNGCPRO (value
);
1183 value
= Flookup_key (current_global_map
, key
, accept_default
);
1185 if (! NILP (value
) && !INTEGERP (value
))
1191 /* GC is possible in this function if it autoloads a keymap. */
1193 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1194 "Return the binding for command KEYS in current local keymap only.\n\
1195 KEYS is a string, a sequence of keystrokes.\n\
1196 The binding is probably a symbol with a function definition.\n\
1198 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1199 bindings; see the description of `lookup-key' for more details about this.")
1200 (keys
, accept_default
)
1201 Lisp_Object keys
, accept_default
;
1203 register Lisp_Object map
;
1204 map
= current_buffer
->keymap
;
1207 return Flookup_key (map
, keys
, accept_default
);
1210 /* GC is possible in this function if it autoloads a keymap. */
1212 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1213 "Return the binding for command KEYS in current global keymap only.\n\
1214 KEYS is a string, a sequence of keystrokes.\n\
1215 The binding is probably a symbol with a function definition.\n\
1216 This function's return values are the same as those of lookup-key\n\
1219 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1220 bindings; see the description of `lookup-key' for more details about this.")
1221 (keys
, accept_default
)
1222 Lisp_Object keys
, accept_default
;
1224 return Flookup_key (current_global_map
, keys
, accept_default
);
1227 /* GC is possible in this function if it autoloads a keymap. */
1229 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1230 "Find the visible minor mode bindings of KEY.\n\
1231 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1232 the symbol which names the minor mode binding KEY, and BINDING is\n\
1233 KEY's definition in that mode. In particular, if KEY has no\n\
1234 minor-mode bindings, return nil. If the first binding is a\n\
1235 non-prefix, all subsequent bindings will be omitted, since they would\n\
1236 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1237 that come after prefix bindings.\n\
1239 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1240 bindings; see the description of `lookup-key' for more details about this.")
1241 (key
, accept_default
)
1242 Lisp_Object key
, accept_default
;
1244 Lisp_Object
*modes
, *maps
;
1246 Lisp_Object binding
;
1248 struct gcpro gcpro1
, gcpro2
;
1250 nmaps
= current_minor_maps (&modes
, &maps
);
1251 /* Note that all these maps are GCPRO'd
1252 in the places where we found them. */
1255 GCPRO2 (key
, binding
);
1257 for (i
= j
= 0; i
< nmaps
; i
++)
1258 if (! NILP (maps
[i
])
1259 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1260 && !INTEGERP (binding
))
1262 if (! NILP (get_keymap (binding
)))
1263 maps
[j
++] = Fcons (modes
[i
], binding
);
1265 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1269 return Flist (j
, maps
);
1272 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
1273 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1274 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1275 If a second optional argument MAPVAR is given, the map is stored as\n\
1276 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1279 Lisp_Object command
, mapvar
;
1282 map
= Fmake_sparse_keymap (Qnil
);
1283 Ffset (command
, map
);
1287 Fset (command
, map
);
1291 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1292 "Select KEYMAP as the global keymap.")
1296 keymap
= get_keymap (keymap
);
1297 current_global_map
= keymap
;
1302 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1303 "Select KEYMAP as the local keymap.\n\
1304 If KEYMAP is nil, that means no local keymap.")
1309 keymap
= get_keymap (keymap
);
1311 current_buffer
->keymap
= keymap
;
1316 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1317 "Return current buffer's local keymap, or nil if it has none.")
1320 return current_buffer
->keymap
;
1323 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1324 "Return the current global keymap.")
1327 return current_global_map
;
1330 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1331 "Return a list of keymaps for the minor modes of the current buffer.")
1335 int nmaps
= current_minor_maps (0, &maps
);
1337 return Flist (nmaps
, maps
);
1340 /* Help functions for describing and documenting keymaps. */
1342 static void accessible_keymaps_char_table ();
1344 /* This function cannot GC. */
1346 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1348 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1349 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1350 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1351 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1352 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1353 then the value includes only maps for prefixes that start with PREFIX.")
1355 Lisp_Object keymap
, prefix
;
1357 Lisp_Object maps
, good_maps
, tail
;
1360 /* no need for gcpro because we don't autoload any keymaps. */
1363 prefixlen
= XINT (Flength (prefix
));
1367 /* If a prefix was specified, start with the keymap (if any) for
1368 that prefix, so we don't waste time considering other prefixes. */
1370 tem
= Flookup_key (keymap
, prefix
, Qt
);
1371 /* Flookup_key may give us nil, or a number,
1372 if the prefix is not defined in this particular map.
1373 It might even give us a list that isn't a keymap. */
1374 tem
= get_keymap_1 (tem
, 0, 0);
1377 /* Convert PREFIX to a vector now, so that later on
1378 we don't have to deal with the possibility of a string. */
1379 if (STRINGP (prefix
))
1384 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1385 for (i
= 0; i
< XSTRING (prefix
)->size
; i
++)
1387 int c
= XSTRING (prefix
)->data
[i
];
1389 c
^= 0200 | meta_modifier
;
1390 XVECTOR (copy
)->contents
[i
] = make_number (c
);
1394 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1400 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1401 get_keymap (keymap
)),
1404 /* For each map in the list maps,
1405 look at any other maps it points to,
1406 and stick them at the end if they are not already in the list.
1408 This is a breadth-first traversal, where tail is the queue of
1409 nodes, and maps accumulates a list of all nodes visited. */
1411 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1413 register Lisp_Object thisseq
, thismap
;
1415 /* Does the current sequence end in the meta-prefix-char? */
1418 thisseq
= Fcar (Fcar (tail
));
1419 thismap
= Fcdr (Fcar (tail
));
1420 last
= make_number (XINT (Flength (thisseq
)) - 1);
1421 is_metized
= (XINT (last
) >= 0
1422 /* Don't metize the last char of PREFIX. */
1423 && XINT (last
) >= prefixlen
1424 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1426 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1430 elt
= XCONS (thismap
)->car
;
1434 if (CHAR_TABLE_P (elt
))
1436 Lisp_Object indices
[3];
1438 map_char_table (accessible_keymaps_char_table
, Qnil
,
1439 elt
, Fcons (maps
, Fcons (tail
, thisseq
)),
1442 else if (VECTORP (elt
))
1446 /* Vector keymap. Scan all the elements. */
1447 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1449 register Lisp_Object tem
;
1450 register Lisp_Object cmd
;
1452 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1453 if (NILP (cmd
)) continue;
1454 tem
= Fkeymapp (cmd
);
1457 cmd
= get_keymap (cmd
);
1458 /* Ignore keymaps that are already added to maps. */
1459 tem
= Frassq (cmd
, maps
);
1462 /* If the last key in thisseq is meta-prefix-char,
1463 turn it into a meta-ized keystroke. We know
1464 that the event we're about to append is an
1465 ascii keystroke since we're processing a
1469 int meta_bit
= meta_modifier
;
1470 tem
= Fcopy_sequence (thisseq
);
1472 Faset (tem
, last
, make_number (i
| meta_bit
));
1474 /* This new sequence is the same length as
1475 thisseq, so stick it in the list right
1478 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1482 tem
= append_key (thisseq
, make_number (i
));
1483 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1489 else if (CONSP (elt
))
1491 register Lisp_Object cmd
, tem
, filter
;
1493 cmd
= get_keyelt (XCONS (elt
)->cdr
, 0);
1494 /* Ignore definitions that aren't keymaps themselves. */
1495 tem
= Fkeymapp (cmd
);
1498 /* Ignore keymaps that have been seen already. */
1499 cmd
= get_keymap (cmd
);
1500 tem
= Frassq (cmd
, maps
);
1503 /* Let elt be the event defined by this map entry. */
1504 elt
= XCONS (elt
)->car
;
1506 /* If the last key in thisseq is meta-prefix-char, and
1507 this entry is a binding for an ascii keystroke,
1508 turn it into a meta-ized keystroke. */
1509 if (is_metized
&& INTEGERP (elt
))
1511 Lisp_Object element
;
1514 tem
= Fvconcat (1, &element
);
1515 XSETFASTINT (XVECTOR (tem
)->contents
[XINT (last
)],
1516 XINT (elt
) | meta_modifier
);
1518 /* This new sequence is the same length as
1519 thisseq, so stick it in the list right
1522 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1526 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1537 /* Now find just the maps whose access prefixes start with PREFIX. */
1540 for (; CONSP (maps
); maps
= XCONS (maps
)->cdr
)
1542 Lisp_Object elt
, thisseq
;
1543 elt
= XCONS (maps
)->car
;
1544 thisseq
= XCONS (elt
)->car
;
1545 /* The access prefix must be at least as long as PREFIX,
1546 and the first elements must match those of PREFIX. */
1547 if (XINT (Flength (thisseq
)) >= prefixlen
)
1550 for (i
= 0; i
< prefixlen
; i
++)
1553 XSETFASTINT (i1
, i
);
1554 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1558 good_maps
= Fcons (elt
, good_maps
);
1562 return Fnreverse (good_maps
);
1566 accessible_keymaps_char_table (args
, index
, cmd
)
1567 Lisp_Object args
, index
, cmd
;
1570 Lisp_Object maps
, tail
, thisseq
;
1575 maps
= XCONS (args
)->car
;
1576 tail
= XCONS (XCONS (args
)->cdr
)->car
;
1577 thisseq
= XCONS (XCONS (args
)->cdr
)->cdr
;
1579 tem
= Fkeymapp (cmd
);
1582 cmd
= get_keymap (cmd
);
1583 /* Ignore keymaps that are already added to maps. */
1584 tem
= Frassq (cmd
, maps
);
1587 tem
= append_key (thisseq
, index
);
1588 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1593 Lisp_Object Qsingle_key_description
, Qkey_description
;
1595 /* This function cannot GC. */
1597 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1598 "Return a pretty description of key-sequence KEYS.\n\
1599 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1600 spaces are put between sequence elements, etc.")
1612 vector
= Fmake_vector (Flength (keys
), Qnil
);
1613 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1615 if (XSTRING (keys
)->data
[i
] & 0x80)
1616 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1617 meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80));
1619 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1620 XSTRING (keys
)->data
[i
]);
1624 else if (!VECTORP (keys
))
1625 keys
= wrong_type_argument (Qarrayp
, keys
);
1627 /* In effect, this computes
1628 (mapconcat 'single-key-description keys " ")
1629 but we shouldn't use mapconcat because it can do GC. */
1631 len
= XVECTOR (keys
)->size
;
1632 sep
= build_string (" ");
1633 /* This has one extra element at the end that we don't pass to Fconcat. */
1634 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1636 for (i
= 0; i
< len
; i
++)
1638 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
]);
1639 args
[i
* 2 + 1] = sep
;
1642 return Fconcat (len
* 2 - 1, args
);
1646 push_key_description (c
, p
)
1647 register unsigned int c
;
1650 /* Clear all the meaningless bits above the meta bit. */
1651 c
&= meta_modifier
| ~ - meta_modifier
;
1653 if (c
& alt_modifier
)
1659 if (c
& ctrl_modifier
)
1665 if (c
& hyper_modifier
)
1669 c
-= hyper_modifier
;
1671 if (c
& meta_modifier
)
1677 if (c
& shift_modifier
)
1681 c
-= shift_modifier
;
1683 if (c
& super_modifier
)
1687 c
-= super_modifier
;
1703 else if (c
== Ctl ('M'))
1713 if (c
> 0 && c
<= Ctl ('Z'))
1736 *p
++ = (7 & (c
>> 6)) + '0';
1737 *p
++ = (7 & (c
>> 3)) + '0';
1738 *p
++ = (7 & (c
>> 0)) + '0';
1743 *p
++ = (7 & (c
>> 15)) + '0';
1744 *p
++ = (7 & (c
>> 12)) + '0';
1745 *p
++ = (7 & (c
>> 9)) + '0';
1746 *p
++ = (7 & (c
>> 6)) + '0';
1747 *p
++ = (7 & (c
>> 3)) + '0';
1748 *p
++ = (7 & (c
>> 0)) + '0';
1754 /* This function cannot GC. */
1756 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1757 "Return a pretty description of command character KEY.\n\
1758 Control characters turn into C-whatever, etc.")
1764 key
= EVENT_HEAD (key
);
1766 if (INTEGERP (key
)) /* Normal character */
1768 *push_key_description (XUINT (key
), tem
) = 0;
1769 return build_string (tem
);
1771 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1772 return Fsymbol_name (key
);
1773 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1774 return Fcopy_sequence (key
);
1776 error ("KEY must be an integer, cons, symbol, or string");
1780 push_text_char_description (c
, p
)
1781 register unsigned int c
;
1793 *p
++ = c
+ 64; /* 'A' - 1 */
1805 /* This function cannot GC. */
1807 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1808 "Return a pretty description of file-character CHARACTER.\n\
1809 Control characters turn into \"^char\", etc.")
1811 Lisp_Object character
;
1815 CHECK_NUMBER (character
, 0);
1817 if (!SINGLE_BYTE_CHAR_P (XFASTINT (character
)))
1820 int len
= non_ascii_char_to_string (XFASTINT (character
), tem
, &str
);
1822 return make_string (str
, len
);
1825 *push_text_char_description (XINT (character
) & 0377, tem
) = 0;
1827 return build_string (tem
);
1830 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1833 ascii_sequence_p (seq
)
1837 int len
= XINT (Flength (seq
));
1839 for (i
= 0; i
< len
; i
++)
1841 Lisp_Object ii
, elt
;
1843 XSETFASTINT (ii
, i
);
1844 elt
= Faref (seq
, ii
);
1847 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1855 /* where-is - finding a command in a set of keymaps. */
1857 static Lisp_Object
where_is_internal_1 ();
1858 static void where_is_internal_2 ();
1860 /* This function can GC if Flookup_key autoloads any keymaps. */
1862 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
1863 "Return list of keys that invoke DEFINITION.\n\
1864 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
1865 If KEYMAP is nil, search all the currently active keymaps.\n\
1867 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
1868 rather than a list of all possible key sequences.\n\
1869 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
1870 no matter what it is.\n\
1871 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
1872 and entirely reject menu bindings.\n\
1874 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
1875 to other keymaps or slots. This makes it possible to search for an\n\
1876 indirect definition itself.")
1877 (definition
, keymap
, firstonly
, noindirect
)
1878 Lisp_Object definition
, keymap
;
1879 Lisp_Object firstonly
, noindirect
;
1882 Lisp_Object found
, sequences
;
1883 Lisp_Object keymap1
;
1884 int keymap_specified
= !NILP (keymap
);
1885 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
1886 /* 1 means ignore all menu bindings entirely. */
1887 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
1889 /* Find keymaps accessible from `keymap' or the current
1890 context. But don't muck with the value of `keymap',
1891 because `where_is_internal_1' uses it to check for
1892 shadowed bindings. */
1894 if (! keymap_specified
)
1896 #ifdef USE_TEXT_PROPERTIES
1897 keymap1
= get_local_map (PT
, current_buffer
);
1899 keymap1
= current_buffer
->keymap
;
1903 if (!NILP (keymap1
))
1904 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap1
), Qnil
),
1905 Faccessible_keymaps (get_keymap (current_global_map
),
1908 maps
= Faccessible_keymaps (get_keymap (current_global_map
), Qnil
);
1910 /* Put the minor mode keymaps on the front. */
1911 if (! keymap_specified
)
1914 minors
= Fnreverse (Fcurrent_minor_mode_maps ());
1915 while (!NILP (minors
))
1917 maps
= nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors
)->car
),
1920 minors
= XCONS (minors
)->cdr
;
1924 GCPRO5 (definition
, keymap
, maps
, found
, sequences
);
1928 for (; !NILP (maps
); maps
= Fcdr (maps
))
1930 /* Key sequence to reach map, and the map that it reaches */
1931 register Lisp_Object
this, map
;
1933 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1934 [M-CHAR] sequences, check if last character of the sequence
1935 is the meta-prefix char. */
1939 this = Fcar (Fcar (maps
));
1940 map
= Fcdr (Fcar (maps
));
1941 last
= make_number (XINT (Flength (this)) - 1);
1942 last_is_meta
= (XINT (last
) >= 0
1943 && EQ (Faref (this, last
), meta_prefix_char
));
1949 /* Because the code we want to run on each binding is rather
1950 large, we don't want to have two separate loop bodies for
1951 sparse keymap bindings and tables; we want to iterate one
1952 loop body over both keymap and vector bindings.
1954 For this reason, if Fcar (map) is a vector, we don't
1955 advance map to the next element until i indicates that we
1956 have finished off the vector. */
1957 Lisp_Object elt
, key
, binding
;
1958 elt
= XCONS (map
)->car
;
1959 map
= XCONS (map
)->cdr
;
1965 /* Set key and binding to the current key and binding, and
1966 advance map and i to the next binding. */
1969 Lisp_Object sequence
;
1971 /* In a vector, look at each element. */
1972 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1974 binding
= XVECTOR (elt
)->contents
[i
];
1975 XSETFASTINT (key
, i
);
1976 sequence
= where_is_internal_1 (binding
, key
, definition
,
1977 noindirect
, keymap
, this,
1978 last
, nomenus
, last_is_meta
);
1979 if (!NILP (sequence
))
1980 sequences
= Fcons (sequence
, sequences
);
1983 else if (CHAR_TABLE_P (elt
))
1985 Lisp_Object indices
[3];
1988 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
1989 Fcons (keymap
, Qnil
)),
1990 Fcons (Fcons (this, last
),
1991 Fcons (make_number (nomenus
),
1992 make_number (last_is_meta
))));
1994 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
1996 sequences
= XCONS (XCONS (XCONS (args
)->car
)->cdr
)->cdr
;
1998 else if (CONSP (elt
))
2000 Lisp_Object sequence
;
2002 key
= XCONS (elt
)->car
;
2003 binding
= XCONS (elt
)->cdr
;
2005 sequence
= where_is_internal_1 (binding
, key
, definition
,
2006 noindirect
, keymap
, this,
2007 last
, nomenus
, last_is_meta
);
2008 if (!NILP (sequence
))
2009 sequences
= Fcons (sequence
, sequences
);
2013 for (; ! NILP (sequences
); sequences
= XCONS (sequences
)->cdr
)
2015 Lisp_Object sequence
;
2017 sequence
= XCONS (sequences
)->car
;
2019 /* It is a true unshadowed match. Record it, unless it's already
2020 been seen (as could happen when inheriting keymaps). */
2021 if (NILP (Fmember (sequence
, found
)))
2022 found
= Fcons (sequence
, found
);
2024 /* If firstonly is Qnon_ascii, then we can return the first
2025 binding we find. If firstonly is not Qnon_ascii but not
2026 nil, then we should return the first ascii-only binding
2028 if (EQ (firstonly
, Qnon_ascii
))
2029 RETURN_UNGCPRO (sequence
);
2030 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2031 RETURN_UNGCPRO (sequence
);
2038 found
= Fnreverse (found
);
2040 /* firstonly may have been t, but we may have gone all the way through
2041 the keymaps without finding an all-ASCII key sequence. So just
2042 return the best we could find. */
2043 if (! NILP (firstonly
))
2044 return Fcar (found
);
2049 /* This is the function that Fwhere_is_internal calls using map_char_table.
2051 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2053 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2054 Since map_char_table doesn't really use the return value from this function,
2055 we the result append to RESULT, the slot in ARGS. */
2058 where_is_internal_2 (args
, key
, binding
)
2059 Lisp_Object args
, key
, binding
;
2061 Lisp_Object definition
, noindirect
, keymap
, this, last
;
2062 Lisp_Object result
, sequence
;
2063 int nomenus
, last_is_meta
;
2065 result
= XCONS (XCONS (XCONS (args
)->car
)->cdr
)->cdr
;
2066 definition
= XCONS (XCONS (XCONS (args
)->car
)->car
)->car
;
2067 noindirect
= XCONS (XCONS (XCONS (args
)->car
)->car
)->cdr
;
2068 keymap
= XCONS (XCONS (XCONS (args
)->car
)->cdr
)->car
;
2069 this = XCONS (XCONS (XCONS (args
)->cdr
)->car
)->car
;
2070 last
= XCONS (XCONS (XCONS (args
)->cdr
)->car
)->cdr
;
2071 nomenus
= XFASTINT (XCONS (XCONS (XCONS (args
)->cdr
)->cdr
)->car
);
2072 last_is_meta
= XFASTINT (XCONS (XCONS (XCONS (args
)->cdr
)->cdr
)->cdr
);
2074 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
,
2075 this, last
, nomenus
, last_is_meta
);
2077 if (!NILP (sequence
))
2078 XCONS (XCONS (XCONS (args
)->car
)->cdr
)->cdr
2079 = Fcons (sequence
, result
);
2083 where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
, this, last
,
2084 nomenus
, last_is_meta
)
2085 Lisp_Object binding
, key
, definition
, noindirect
, keymap
, this, last
;
2086 int nomenus
, last_is_meta
;
2088 Lisp_Object sequence
;
2089 int keymap_specified
= !NILP (keymap
);
2091 /* Search through indirections unless that's not wanted. */
2092 if (NILP (noindirect
))
2098 Lisp_Object map
, tem
;
2099 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
2100 map
= get_keymap_1 (Fcar_safe (definition
), 0, 0);
2101 tem
= Fkeymapp (map
);
2103 definition
= access_keymap (map
, Fcdr (definition
), 0, 0);
2107 /* If the contents are (STRING ...), reject. */
2108 if (CONSP (definition
)
2109 && STRINGP (XCONS (definition
)->car
))
2113 binding
= get_keyelt (binding
, 0);
2116 /* End this iteration if this element does not match
2119 if (CONSP (definition
))
2122 tem
= Fequal (binding
, definition
);
2127 if (!EQ (binding
, definition
))
2130 /* We have found a match.
2131 Construct the key sequence where we found it. */
2132 if (INTEGERP (key
) && last_is_meta
)
2134 sequence
= Fcopy_sequence (this);
2135 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2138 sequence
= append_key (this, key
);
2140 /* Verify that this key binding is not shadowed by another
2141 binding for the same key, before we say it exists.
2143 Mechanism: look for local definition of this key and if
2144 it is defined and does not match what we found then
2147 Either nil or number as value from Flookup_key
2149 if (keymap_specified
)
2151 binding
= Flookup_key (keymap
, sequence
, Qnil
);
2152 if (!NILP (binding
) && !INTEGERP (binding
))
2154 if (CONSP (definition
))
2157 tem
= Fequal (binding
, definition
);
2162 if (!EQ (binding
, definition
))
2168 binding
= Fkey_binding (sequence
, Qnil
);
2169 if (!EQ (binding
, definition
))
2176 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2178 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 1, "",
2179 "Show a list of all defined keys, and their definitions.\n\
2180 The list is put in a buffer, which is displayed.\n\
2181 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
2182 then we display only bindings that start with that prefix.")
2186 register Lisp_Object thisbuf
;
2187 XSETBUFFER (thisbuf
, current_buffer
);
2188 internal_with_output_to_temp_buffer ("*Help*",
2189 describe_buffer_bindings
,
2190 Fcons (thisbuf
, prefix
));
2194 /* ARG is (BUFFER . PREFIX). */
2197 describe_buffer_bindings (arg
)
2200 Lisp_Object descbuf
, prefix
, shadow
;
2201 register Lisp_Object start1
;
2202 struct gcpro gcpro1
;
2204 char *alternate_heading
2206 Alternate Characters (use anywhere the nominal character is listed):\n\
2207 nominal alternate\n\
2208 ------- ---------\n";
2210 descbuf
= XCONS (arg
)->car
;
2211 prefix
= XCONS (arg
)->cdr
;
2215 Fset_buffer (Vstandard_output
);
2217 /* Report on alternates for keys. */
2218 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2221 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2222 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2224 for (c
= 0; c
< translate_len
; c
++)
2225 if (translate
[c
] != c
)
2230 if (alternate_heading
)
2232 insert_string (alternate_heading
);
2233 alternate_heading
= 0;
2236 bufend
= push_key_description (translate
[c
], buf
);
2237 insert (buf
, bufend
- buf
);
2238 Findent_to (make_number (16), make_number (1));
2239 bufend
= push_key_description (c
, buf
);
2240 insert (buf
, bufend
- buf
);
2248 if (!NILP (Vkey_translation_map
))
2249 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2250 "Key translations", 0, 1, 0);
2254 Lisp_Object
*modes
, *maps
;
2256 /* Temporarily switch to descbuf, so that we can get that buffer's
2257 minor modes correctly. */
2258 Fset_buffer (descbuf
);
2260 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2261 || !NILP (Voverriding_local_map
))
2264 nmaps
= current_minor_maps (&modes
, &maps
);
2265 Fset_buffer (Vstandard_output
);
2267 /* Print the minor mode maps. */
2268 for (i
= 0; i
< nmaps
; i
++)
2270 /* The title for a minor mode keymap
2271 is constructed at run time.
2272 We let describe_map_tree do the actual insertion
2273 because it takes care of other features when doing so. */
2276 if (!SYMBOLP (modes
[i
]))
2279 p
= title
= (char *) alloca (40 + XSYMBOL (modes
[i
])->name
->size
);
2281 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2282 XSYMBOL (modes
[i
])->name
->size
);
2283 p
+= XSYMBOL (modes
[i
])->name
->size
;
2285 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2286 p
+= sizeof (" Minor Mode Bindings") - 1;
2289 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, 0, 0, 0);
2290 shadow
= Fcons (maps
[i
], shadow
);
2294 /* Print the (major mode) local map. */
2295 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2296 start1
= current_kboard
->Voverriding_terminal_local_map
;
2297 else if (!NILP (Voverriding_local_map
))
2298 start1
= Voverriding_local_map
;
2300 start1
= XBUFFER (descbuf
)->keymap
;
2304 describe_map_tree (start1
, 1, shadow
, prefix
,
2305 "Major Mode Bindings", 0, 0, 0);
2306 shadow
= Fcons (start1
, shadow
);
2309 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2310 "Global Bindings", 0, 0, 1);
2312 /* Print the function-key-map translations under this prefix. */
2313 if (!NILP (Vfunction_key_map
))
2314 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2315 "Function key map translations", 0, 1, 0);
2317 call0 (intern ("help-mode"));
2318 Fset_buffer (descbuf
);
2323 /* Insert a description of the key bindings in STARTMAP,
2324 followed by those of all maps reachable through STARTMAP.
2325 If PARTIAL is nonzero, omit certain "uninteresting" commands
2326 (such as `undefined').
2327 If SHADOW is non-nil, it is a list of maps;
2328 don't mention keys which would be shadowed by any of them.
2329 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2330 TITLE, if not 0, is a string to insert at the beginning.
2331 TITLE should not end with a colon or a newline; we supply that.
2332 If NOMENU is not 0, then omit menu-bar commands.
2334 If TRANSL is nonzero, the definitions are actually key translations
2335 so print strings and vectors differently.
2337 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2341 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2343 Lisp_Object startmap
, shadow
, prefix
;
2350 Lisp_Object maps
, seen
, sub_shadows
;
2351 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2358 maps
= Faccessible_keymaps (startmap
, prefix
);
2361 GCPRO3 (maps
, seen
, sub_shadows
);
2367 /* Delete from MAPS each element that is for the menu bar. */
2368 for (list
= maps
; !NILP (list
); list
= XCONS (list
)->cdr
)
2370 Lisp_Object elt
, prefix
, tem
;
2373 prefix
= Fcar (elt
);
2374 if (XVECTOR (prefix
)->size
>= 1)
2376 tem
= Faref (prefix
, make_number (0));
2377 if (EQ (tem
, Qmenu_bar
))
2378 maps
= Fdelq (elt
, maps
);
2383 if (!NILP (maps
) || always_title
)
2387 insert_string (title
);
2390 insert_string (" Starting With ");
2391 insert1 (Fkey_description (prefix
));
2393 insert_string (":\n");
2395 insert_string (key_heading
);
2399 for (; !NILP (maps
); maps
= Fcdr (maps
))
2401 register Lisp_Object elt
, prefix
, tail
;
2404 prefix
= Fcar (elt
);
2408 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2412 shmap
= XCONS (tail
)->car
;
2414 /* If the sequence by which we reach this keymap is zero-length,
2415 then the shadow map for this keymap is just SHADOW. */
2416 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2417 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2419 /* If the sequence by which we reach this keymap actually has
2420 some elements, then the sequence's definition in SHADOW is
2421 what we should use. */
2424 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2425 if (INTEGERP (shmap
))
2429 /* If shmap is not nil and not a keymap,
2430 it completely shadows this map, so don't
2431 describe this map at all. */
2432 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2436 sub_shadows
= Fcons (shmap
, sub_shadows
);
2439 describe_map (Fcdr (elt
), Fcar (elt
),
2440 transl
? describe_translation
: describe_command
,
2441 partial
, sub_shadows
, &seen
, nomenu
);
2447 insert_string ("\n");
2452 static int previous_description_column
;
2455 describe_command (definition
)
2456 Lisp_Object definition
;
2458 register Lisp_Object tem1
;
2459 int column
= current_column ();
2460 int description_column
;
2462 /* If column 16 is no good, go to col 32;
2463 but don't push beyond that--go to next line instead. */
2467 description_column
= 32;
2469 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2470 description_column
= 32;
2472 description_column
= 16;
2474 Findent_to (make_number (description_column
), make_number (1));
2475 previous_description_column
= description_column
;
2477 if (SYMBOLP (definition
))
2479 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2481 insert_string ("\n");
2483 else if (STRINGP (definition
) || VECTORP (definition
))
2484 insert_string ("Keyboard Macro\n");
2487 tem1
= Fkeymapp (definition
);
2489 insert_string ("Prefix Command\n");
2491 insert_string ("??\n");
2496 describe_translation (definition
)
2497 Lisp_Object definition
;
2499 register Lisp_Object tem1
;
2501 Findent_to (make_number (16), make_number (1));
2503 if (SYMBOLP (definition
))
2505 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2507 insert_string ("\n");
2509 else if (STRINGP (definition
) || VECTORP (definition
))
2511 insert1 (Fkey_description (definition
));
2512 insert_string ("\n");
2516 tem1
= Fkeymapp (definition
);
2518 insert_string ("Prefix Command\n");
2520 insert_string ("??\n");
2524 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2525 Returns the first non-nil binding found in any of those maps. */
2528 shadow_lookup (shadow
, key
, flag
)
2529 Lisp_Object shadow
, key
, flag
;
2531 Lisp_Object tail
, value
;
2533 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2535 value
= Flookup_key (XCONS (tail
)->car
, key
, flag
);
2542 /* Describe the contents of map MAP, assuming that this map itself is
2543 reached by the sequence of prefix keys KEYS (a string or vector).
2544 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2547 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2548 register Lisp_Object map
;
2550 int (*elt_describer
) ();
2556 Lisp_Object elt_prefix
;
2557 Lisp_Object tail
, definition
, event
;
2559 Lisp_Object suppress
;
2562 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2564 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2566 /* Call Fkey_description first, to avoid GC bug for the other string. */
2567 tem
= Fkey_description (keys
);
2568 elt_prefix
= concat2 (tem
, build_string (" "));
2574 suppress
= intern ("suppress-keymap");
2576 /* This vector gets used to present single keys to Flookup_key. Since
2577 that is done once per keymap element, we don't want to cons up a
2578 fresh vector every time. */
2579 kludge
= Fmake_vector (make_number (1), Qnil
);
2582 GCPRO3 (elt_prefix
, definition
, kludge
);
2584 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2588 if (VECTORP (XCONS (tail
)->car
)
2589 || CHAR_TABLE_P (XCONS (tail
)->car
))
2590 describe_vector (XCONS (tail
)->car
,
2591 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2593 else if (CONSP (XCONS (tail
)->car
))
2595 event
= XCONS (XCONS (tail
)->car
)->car
;
2597 /* Ignore bindings whose "keys" are not really valid events.
2598 (We get these in the frames and buffers menu.) */
2599 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2602 if (nomenu
&& EQ (event
, Qmenu_bar
))
2605 definition
= get_keyelt (XCONS (XCONS (tail
)->car
)->cdr
, 0);
2607 /* Don't show undefined commands or suppressed commands. */
2608 if (NILP (definition
)) continue;
2609 if (SYMBOLP (definition
) && partial
)
2611 tem
= Fget (definition
, suppress
);
2616 /* Don't show a command that isn't really visible
2617 because a local definition of the same key shadows it. */
2619 XVECTOR (kludge
)->contents
[0] = event
;
2622 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2623 if (!NILP (tem
)) continue;
2626 tem
= Flookup_key (map
, kludge
, Qt
);
2627 if (! EQ (tem
, definition
)) continue;
2631 previous_description_column
= 0;
2636 if (!NILP (elt_prefix
))
2637 insert1 (elt_prefix
);
2639 /* THIS gets the string to describe the character EVENT. */
2640 insert1 (Fsingle_key_description (event
));
2642 /* Print a description of the definition of this character.
2643 elt_describer will take care of spacing out far enough
2644 for alignment purposes. */
2645 (*elt_describer
) (definition
);
2647 else if (EQ (XCONS (tail
)->car
, Qkeymap
))
2649 /* The same keymap might be in the structure twice, if we're
2650 using an inherited keymap. So skip anything we've already
2652 tem
= Fassq (tail
, *seen
);
2653 if (CONSP (tem
) && !NILP (Fequal (XCONS (tem
)->car
, keys
)))
2655 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2663 describe_vector_princ (elt
)
2666 Findent_to (make_number (16), make_number (1));
2671 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2672 "Insert a description of contents of VECTOR.\n\
2673 This is text showing the elements of vector matched against indices.")
2677 int count
= specpdl_ptr
- specpdl
;
2679 specbind (Qstandard_output
, Fcurrent_buffer ());
2680 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2681 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2682 Qnil
, Qnil
, (int *)0, 0);
2684 return unbind_to (count
, Qnil
);
2687 /* Insert in the current buffer a description of the contents of VECTOR.
2688 We call ELT_DESCRIBER to insert the description of one value found
2691 ELT_PREFIX describes what "comes before" the keys or indices defined
2692 by this vector. This is a human-readable string whose size
2693 is not necessarily related to the situation.
2695 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2696 leads to this keymap.
2698 If the vector is a chartable, ELT_PREFIX is the vector
2699 of bytes that lead to the character set or portion of a character
2700 set described by this chartable.
2702 If PARTIAL is nonzero, it means do not mention suppressed commands
2703 (that assumes the vector is in a keymap).
2705 SHADOW is a list of keymaps that shadow this map.
2706 If it is non-nil, then we look up the key in those maps
2707 and we don't mention it now if it is defined by any of them.
2709 ENTIRE_MAP is the keymap in which this vector appears.
2710 If the definition in effect in the whole map does not match
2711 the one in this vector, we ignore this one.
2713 When describing a sub-char-table, INDICES is a list of
2714 indices at higher levels in this char-table,
2715 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2718 describe_vector (vector
, elt_prefix
, elt_describer
,
2719 partial
, shadow
, entire_map
,
2720 indices
, char_table_depth
)
2721 register Lisp_Object vector
;
2722 Lisp_Object elt_prefix
;
2723 void (*elt_describer
) P_ ((Lisp_Object
));
2726 Lisp_Object entire_map
;
2728 int char_table_depth
;
2730 Lisp_Object definition
;
2733 Lisp_Object suppress
;
2736 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2737 /* Range of elements to be handled. */
2739 /* Flag to tell if we should handle multibyte characters. */
2740 int multibyte
= !NILP (current_buffer
->enable_multibyte_characters
);
2741 /* A flag to tell if a leaf in this level of char-table is not a
2742 generic character (i.e. a complete multibyte character). */
2748 indices
= (int *) alloca (3 * sizeof (int));
2752 /* This vector gets used to present single keys to Flookup_key. Since
2753 that is done once per vector element, we don't want to cons up a
2754 fresh vector every time. */
2755 kludge
= Fmake_vector (make_number (1), Qnil
);
2756 GCPRO3 (elt_prefix
, definition
, kludge
);
2759 suppress
= intern ("suppress-keymap");
2761 if (CHAR_TABLE_P (vector
))
2763 if (char_table_depth
== 0)
2765 /* VECTOR is a top level char-table. */
2768 to
= CHAR_TABLE_ORDINARY_SLOTS
;
2772 /* VECTOR is a sub char-table. */
2773 if (char_table_depth
>= 3)
2774 /* A char-table is never that deep. */
2775 error ("Too deep char table");
2778 = (CHARSET_VALID_P (indices
[0])
2779 && ((CHARSET_DIMENSION (indices
[0]) == 1
2780 && char_table_depth
== 1)
2781 || char_table_depth
== 2));
2783 /* Meaningful elements are from 32th to 127th. */
2785 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
2790 /* This does the right thing for ordinary vectors. */
2794 to
= XVECTOR (vector
)->size
;
2797 for (i
= from
; i
< to
; i
++)
2801 if (CHAR_TABLE_P (vector
))
2803 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
2806 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
2807 && !CHARSET_DEFINED_P (i
- 128))
2811 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
2814 definition
= get_keyelt (XVECTOR (vector
)->contents
[i
], 0);
2816 if (NILP (definition
)) continue;
2818 /* Don't mention suppressed commands. */
2819 if (SYMBOLP (definition
) && partial
)
2823 tem
= Fget (definition
, suppress
);
2825 if (!NILP (tem
)) continue;
2828 /* Set CHARACTER to the character this entry describes, if any.
2829 Also update *INDICES. */
2830 if (CHAR_TABLE_P (vector
))
2832 indices
[char_table_depth
] = i
;
2834 if (char_table_depth
== 0)
2837 indices
[0] = i
- 128;
2839 else if (complete_char
)
2842 = MAKE_NON_ASCII_CHAR (indices
[0], indices
[1], indices
[2]);
2850 /* If this binding is shadowed by some other map, ignore it. */
2851 if (!NILP (shadow
) && complete_char
)
2855 XVECTOR (kludge
)->contents
[0] = make_number (character
);
2856 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2858 if (!NILP (tem
)) continue;
2861 /* Ignore this definition if it is shadowed by an earlier
2862 one in the same keymap. */
2863 if (!NILP (entire_map
) && complete_char
)
2867 XVECTOR (kludge
)->contents
[0] = make_number (character
);
2868 tem
= Flookup_key (entire_map
, kludge
, Qt
);
2870 if (! EQ (tem
, definition
))
2876 if (char_table_depth
== 0)
2881 /* For a sub char-table, show the depth by indentation.
2882 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
2883 if (char_table_depth
> 0)
2884 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
2886 /* Output the prefix that applies to every entry in this map. */
2887 if (!NILP (elt_prefix
))
2888 insert1 (elt_prefix
);
2890 /* Insert or describe the character this slot is for,
2891 or a description of what it is for. */
2892 if (SUB_CHAR_TABLE_P (vector
))
2895 insert_char (character
);
2898 /* We need an octal representation for this block of
2901 sprintf (work
, "(row %d)", i
);
2902 insert (work
, strlen (work
));
2905 else if (CHAR_TABLE_P (vector
))
2908 insert1 (Fsingle_key_description (make_number (character
)));
2911 /* Print the information for this character set. */
2912 insert_string ("<");
2913 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
2915 insert_from_string (tem2
, 0 , XSTRING (tem2
)->size
, 0);
2923 insert1 (Fsingle_key_description (make_number (character
)));
2926 /* If we find a sub char-table within a char-table,
2927 scan it recursively; it defines the details for
2928 a character set or a portion of a character set. */
2929 if (multibyte
&& CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
2932 describe_vector (definition
, elt_prefix
, elt_describer
,
2933 partial
, shadow
, entire_map
,
2934 indices
, char_table_depth
+ 1);
2940 /* Find all consecutive characters or rows that have the same
2941 definition. But, for elements of a top level char table, if
2942 they are for charsets, we had better describe one by one even
2943 if they have the same definition. */
2944 if (CHAR_TABLE_P (vector
))
2948 if (char_table_depth
== 0)
2949 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
2951 while (i
+ 1 < limit
2952 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
2954 && !NILP (Fequal (tem2
, definition
)))
2959 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+ 1], 0),
2961 && !NILP (Fequal (tem2
, definition
)))
2965 /* If we have a range of more than one character,
2966 print where the range reaches to. */
2968 if (i
!= starting_i
)
2972 if (!NILP (elt_prefix
))
2973 insert1 (elt_prefix
);
2975 if (CHAR_TABLE_P (vector
))
2977 if (char_table_depth
== 0)
2979 insert1 (Fsingle_key_description (make_number (i
)));
2981 else if (complete_char
)
2983 indices
[char_table_depth
] = i
;
2985 = MAKE_NON_ASCII_CHAR (indices
[0], indices
[1], indices
[2]);
2986 insert_char (character
);
2990 /* We need an octal representation for this block of
2993 sprintf (work
, "(row %d)", i
);
2994 insert (work
, strlen (work
));
2999 insert1 (Fsingle_key_description (make_number (i
)));
3003 /* Print a description of the definition of this character.
3004 elt_describer will take care of spacing out far enough
3005 for alignment purposes. */
3006 (*elt_describer
) (definition
);
3009 /* For (sub) char-table, print `defalt' slot at last. */
3010 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3012 insert (" ", char_table_depth
* 2);
3013 insert_string ("<<default>>");
3014 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3020 /* Apropos - finding all symbols whose names match a regexp. */
3021 Lisp_Object apropos_predicate
;
3022 Lisp_Object apropos_accumulate
;
3025 apropos_accum (symbol
, string
)
3026 Lisp_Object symbol
, string
;
3028 register Lisp_Object tem
;
3030 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3031 if (!NILP (tem
) && !NILP (apropos_predicate
))
3032 tem
= call1 (apropos_predicate
, symbol
);
3034 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3037 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3038 "Show all symbols whose names contain match for REGEXP.\n\
3039 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3040 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3041 Return list of symbols found.")
3043 Lisp_Object regexp
, predicate
;
3045 struct gcpro gcpro1
, gcpro2
;
3046 CHECK_STRING (regexp
, 0);
3047 apropos_predicate
= predicate
;
3048 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3049 apropos_accumulate
= Qnil
;
3050 map_obarray (Vobarray
, apropos_accum
, regexp
);
3051 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3053 return apropos_accumulate
;
3060 Qkeymap
= intern ("keymap");
3061 staticpro (&Qkeymap
);
3063 /* Now we are ready to set up this property, so we can
3064 create char tables. */
3065 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3067 /* Initialize the keymaps standardly used.
3068 Each one is the value of a Lisp variable, and is also
3069 pointed to by a C variable */
3071 global_map
= Fmake_keymap (Qnil
);
3072 Fset (intern ("global-map"), global_map
);
3074 current_global_map
= global_map
;
3075 staticpro (&global_map
);
3076 staticpro (¤t_global_map
);
3078 meta_map
= Fmake_keymap (Qnil
);
3079 Fset (intern ("esc-map"), meta_map
);
3080 Ffset (intern ("ESC-prefix"), meta_map
);
3082 control_x_map
= Fmake_keymap (Qnil
);
3083 Fset (intern ("ctl-x-map"), control_x_map
);
3084 Ffset (intern ("Control-X-prefix"), control_x_map
);
3086 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3087 "List of commands given new key bindings recently.\n\
3088 This is used for internal purposes during Emacs startup;\n\
3089 don't alter it yourself.");
3090 Vdefine_key_rebound_commands
= Qt
;
3092 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3093 "Default keymap to use when reading from the minibuffer.");
3094 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3096 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3097 "Local keymap for the minibuffer when spaces are not allowed.");
3098 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3100 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3101 "Local keymap for minibuffer input with completion.");
3102 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3104 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3105 "Local keymap for minibuffer input with completion, for exact match.");
3106 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3108 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3109 "Alist of keymaps to use for minor modes.\n\
3110 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3111 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3112 If two active keymaps bind the same key, the keymap appearing earlier\n\
3113 in the list takes precedence.");
3114 Vminor_mode_map_alist
= Qnil
;
3116 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3117 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3118 This allows Emacs to recognize function keys sent from ASCII\n\
3119 terminals at any point in a key sequence.\n\
3121 The `read-key-sequence' function replaces any subsequence bound by\n\
3122 `function-key-map' with its binding. More precisely, when the active\n\
3123 keymaps have no binding for the current key sequence but\n\
3124 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3125 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3126 continues with the new sequence.\n\
3128 The events that come from bindings in `function-key-map' are not\n\
3129 themselves looked up in `function-key-map'.\n\
3131 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3132 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3133 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3134 key, typing `ESC O P x' would return [f1 x].");
3135 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3137 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3138 "Keymap of key translations that can override keymaps.\n\
3139 This keymap works like `function-key-map', but comes after that,\n\
3140 and applies even for keys that have ordinary bindings.");
3141 Vkey_translation_map
= Qnil
;
3143 Qsingle_key_description
= intern ("single-key-description");
3144 staticpro (&Qsingle_key_description
);
3146 Qkey_description
= intern ("key-description");
3147 staticpro (&Qkey_description
);
3149 Qkeymapp
= intern ("keymapp");
3150 staticpro (&Qkeymapp
);
3152 Qnon_ascii
= intern ("non-ascii");
3153 staticpro (&Qnon_ascii
);
3155 defsubr (&Skeymapp
);
3156 defsubr (&Skeymap_parent
);
3157 defsubr (&Sset_keymap_parent
);
3158 defsubr (&Smake_keymap
);
3159 defsubr (&Smake_sparse_keymap
);
3160 defsubr (&Scopy_keymap
);
3161 defsubr (&Skey_binding
);
3162 defsubr (&Slocal_key_binding
);
3163 defsubr (&Sglobal_key_binding
);
3164 defsubr (&Sminor_mode_key_binding
);
3165 defsubr (&Sdefine_key
);
3166 defsubr (&Slookup_key
);
3167 defsubr (&Sdefine_prefix_command
);
3168 defsubr (&Suse_global_map
);
3169 defsubr (&Suse_local_map
);
3170 defsubr (&Scurrent_local_map
);
3171 defsubr (&Scurrent_global_map
);
3172 defsubr (&Scurrent_minor_mode_maps
);
3173 defsubr (&Saccessible_keymaps
);
3174 defsubr (&Skey_description
);
3175 defsubr (&Sdescribe_vector
);
3176 defsubr (&Ssingle_key_description
);
3177 defsubr (&Stext_char_description
);
3178 defsubr (&Swhere_is_internal
);
3179 defsubr (&Sdescribe_bindings
);
3180 defsubr (&Sapropos_internal
);
3187 initial_define_key (global_map
, 033, "ESC-prefix");
3188 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");