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
))
345 = (Lisp_Object
*) alloca (3 * sizeof (Lisp_Object
));
347 map_char_table (fix_submap_inheritance
, Qnil
, XCONS (list
)->car
,
355 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
356 if EVENT is also a prefix in MAP's parent,
357 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
))
711 = (Lisp_Object
*) alloca (3 * sizeof (Lisp_Object
));
713 elt
= Fcopy_sequence (elt
);
714 XCONS (tail
)->car
= elt
;
716 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
718 else if (VECTORP (elt
))
722 elt
= Fcopy_sequence (elt
);
723 XCONS (tail
)->car
= elt
;
725 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
726 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
727 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
728 XVECTOR (elt
)->contents
[i
]
729 = Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
731 else if (CONSP (elt
))
733 /* Skip the optional menu string. */
734 if (CONSP (XCONS (elt
)->cdr
)
735 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
739 /* Copy the cell, since copy-alist didn't go this deep. */
740 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
741 XCONS (XCONS (elt
)->cdr
)->cdr
);
742 elt
= XCONS (elt
)->cdr
;
744 /* Also skip the optional menu help string. */
745 if (CONSP (XCONS (elt
)->cdr
)
746 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
748 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
749 XCONS (XCONS (elt
)->cdr
)->cdr
);
750 elt
= XCONS (elt
)->cdr
;
752 /* There may also be a list that caches key equivalences.
753 Just delete it for the new keymap. */
754 if (CONSP (XCONS (elt
)->cdr
)
755 && CONSP (XCONS (XCONS (elt
)->cdr
)->car
)
756 && (NILP (tem
= XCONS (XCONS (XCONS (elt
)->cdr
)->car
)->car
)
758 XCONS (elt
)->cdr
= XCONS (XCONS (elt
)->cdr
)->cdr
;
761 && ! SYMBOLP (XCONS (elt
)->cdr
)
762 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
763 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
770 /* Simple Keymap mutators and accessors. */
772 /* GC is possible in this function if it autoloads a keymap. */
774 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
775 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
776 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
777 meaning a sequence of keystrokes and events.\n\
778 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
779 can be included if you use a vector.\n\
780 DEF is anything that can be a key's definition:\n\
781 nil (means key is undefined in this keymap),\n\
782 a command (a Lisp function suitable for interactive calling)\n\
783 a string (treated as a keyboard macro),\n\
784 a keymap (to define a prefix key),\n\
785 a symbol. When the key is looked up, the symbol will stand for its\n\
786 function definition, which should at that time be one of the above,\n\
787 or another symbol whose function definition is used, etc.\n\
788 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
789 (DEFN should be a valid definition in its own right),\n\
790 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
792 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
793 the front of KEYMAP.")
800 register Lisp_Object c
;
801 register Lisp_Object tem
;
802 register Lisp_Object cmd
;
806 struct gcpro gcpro1
, gcpro2
, gcpro3
;
808 keymap
= get_keymap_1 (keymap
, 1, 1);
810 if (!VECTORP (key
) && !STRINGP (key
))
811 key
= wrong_type_argument (Qarrayp
, key
);
813 length
= XFASTINT (Flength (key
));
817 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
818 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
820 GCPRO3 (keymap
, key
, def
);
823 meta_bit
= meta_modifier
;
830 c
= Faref (key
, make_number (idx
));
832 if (CONSP (c
) && lucid_event_type_list_p (c
))
833 c
= Fevent_convert_list (c
);
836 && (XINT (c
) & meta_bit
)
839 c
= meta_prefix_char
;
845 XSETINT (c
, XINT (c
) & ~meta_bit
);
851 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
852 error ("Key sequence contains invalid events");
855 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
857 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1), 1);
859 /* If this key is undefined, make it a prefix. */
861 cmd
= define_as_prefix (keymap
, c
);
863 keymap
= get_keymap_1 (cmd
, 0, 1);
865 /* We must use Fkey_description rather than just passing key to
866 error; key might be a vector, not a string. */
867 error ("Key sequence %s uses invalid prefix characters",
868 XSTRING (Fkey_description (key
))->data
);
872 /* Value is number if KEY is too long; NIL if valid but has no definition. */
873 /* GC is possible in this function if it autoloads a keymap. */
875 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
876 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
877 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
879 A number as value means KEY is \"too long\";\n\
880 that is, characters or symbols in it except for the last one\n\
881 fail to be a valid sequence of prefix characters in KEYMAP.\n\
882 The number is how many characters at the front of KEY\n\
883 it takes to reach a non-prefix command.\n\
885 Normally, `lookup-key' ignores bindings for t, which act as default\n\
886 bindings, used when nothing else in the keymap applies; this makes it\n\
887 usable as a general function for probing keymaps. However, if the\n\
888 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
889 recognize the default bindings, just as `read-key-sequence' does.")
890 (keymap
, key
, accept_default
)
891 register Lisp_Object keymap
;
893 Lisp_Object accept_default
;
896 register Lisp_Object tem
;
897 register Lisp_Object cmd
;
898 register Lisp_Object c
;
901 int t_ok
= ! NILP (accept_default
);
905 keymap
= get_keymap_1 (keymap
, 1, 1);
907 if (!VECTORP (key
) && !STRINGP (key
))
908 key
= wrong_type_argument (Qarrayp
, key
);
910 length
= XFASTINT (Flength (key
));
915 meta_bit
= meta_modifier
;
924 c
= Faref (key
, make_number (idx
));
926 if (CONSP (c
) && lucid_event_type_list_p (c
))
927 c
= Fevent_convert_list (c
);
930 && (XINT (c
) & meta_bit
)
933 c
= meta_prefix_char
;
939 XSETINT (c
, XINT (c
) & ~meta_bit
);
945 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0), 1);
947 RETURN_UNGCPRO (cmd
);
949 keymap
= get_keymap_1 (cmd
, 0, 1);
951 RETURN_UNGCPRO (make_number (idx
));
957 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
958 Assume that currently it does not define C at all.
959 Return the keymap. */
962 define_as_prefix (keymap
, c
)
963 Lisp_Object keymap
, c
;
965 Lisp_Object inherit
, cmd
;
967 cmd
= Fmake_sparse_keymap (Qnil
);
968 /* If this key is defined as a prefix in an inherited keymap,
969 make it a prefix in this map, and make its definition
970 inherit the other prefix definition. */
971 inherit
= access_keymap (keymap
, c
, 0, 0);
973 /* This code is needed to do the right thing in the following case:
974 keymap A inherits from B,
975 you define KEY as a prefix in A,
976 then later you define KEY as a prefix in B.
977 We want the old prefix definition in A to inherit from that in B.
978 It is hard to do that retroactively, so this code
979 creates the prefix in B right away.
981 But it turns out that this code causes problems immediately
982 when the prefix in A is defined: it causes B to define KEY
983 as a prefix with no subcommands.
985 So I took out this code. */
988 /* If there's an inherited keymap
989 and it doesn't define this key,
990 make it define this key. */
993 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
994 if (EQ (XCONS (tail
)->car
, Qkeymap
))
998 inherit
= define_as_prefix (tail
, c
);
1002 cmd
= nconc2 (cmd
, inherit
);
1003 store_in_keymap (keymap
, c
, cmd
);
1008 /* Append a key to the end of a key sequence. We always make a vector. */
1011 append_key (key_sequence
, key
)
1012 Lisp_Object key_sequence
, key
;
1014 Lisp_Object args
[2];
1016 args
[0] = key_sequence
;
1018 args
[1] = Fcons (key
, Qnil
);
1019 return Fvconcat (2, args
);
1023 /* Global, local, and minor mode keymap stuff. */
1025 /* We can't put these variables inside current_minor_maps, since under
1026 some systems, static gets macro-defined to be the empty string.
1028 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1029 static int cmm_size
;
1031 /* Error handler used in current_minor_maps. */
1033 current_minor_maps_error ()
1038 /* Store a pointer to an array of the keymaps of the currently active
1039 minor modes in *buf, and return the number of maps it contains.
1041 This function always returns a pointer to the same buffer, and may
1042 free or reallocate it, so if you want to keep it for a long time or
1043 hand it out to lisp code, copy it. This procedure will be called
1044 for every key sequence read, so the nice lispy approach (return a
1045 new assoclist, list, what have you) for each invocation would
1046 result in a lot of consing over time.
1048 If we used xrealloc/xmalloc and ran out of memory, they would throw
1049 back to the command loop, which would try to read a key sequence,
1050 which would call this function again, resulting in an infinite
1051 loop. Instead, we'll use realloc/malloc and silently truncate the
1052 list, let the key sequence be read, and hope some other piece of
1053 code signals the error. */
1055 current_minor_maps (modeptr
, mapptr
)
1056 Lisp_Object
**modeptr
, **mapptr
;
1059 Lisp_Object alist
, assoc
, var
, val
;
1061 for (alist
= Vminor_mode_map_alist
;
1063 alist
= XCONS (alist
)->cdr
)
1064 if ((assoc
= XCONS (alist
)->car
, CONSP (assoc
))
1065 && (var
= XCONS (assoc
)->car
, SYMBOLP (var
))
1066 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1073 Lisp_Object
*newmodes
, *newmaps
;
1080 = (Lisp_Object
*) realloc (cmm_modes
,
1081 cmm_size
* sizeof (Lisp_Object
));
1083 = (Lisp_Object
*) realloc (cmm_maps
,
1084 cmm_size
* sizeof (Lisp_Object
));
1092 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1094 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1098 if (newmaps
&& newmodes
)
1100 cmm_modes
= newmodes
;
1107 /* Get the keymap definition--or nil if it is not defined. */
1108 temp
= internal_condition_case_1 (Findirect_function
,
1110 Qerror
, current_minor_maps_error
);
1114 cmm_maps
[i
] = temp
;
1119 if (modeptr
) *modeptr
= cmm_modes
;
1120 if (mapptr
) *mapptr
= cmm_maps
;
1124 /* GC is possible in this function if it autoloads a keymap. */
1126 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1127 "Return the binding for command KEY in current keymaps.\n\
1128 KEY is a string or vector, a sequence of keystrokes.\n\
1129 The binding is probably a symbol with a function definition.\n\
1131 Normally, `key-binding' ignores bindings for t, which act as default\n\
1132 bindings, used when nothing else in the keymap applies; this makes it\n\
1133 usable as a general function for probing keymaps. However, if the\n\
1134 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1135 recognize the default bindings, just as `read-key-sequence' does.")
1136 (key
, accept_default
)
1137 Lisp_Object key
, accept_default
;
1139 Lisp_Object
*maps
, value
;
1141 struct gcpro gcpro1
;
1145 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1147 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1148 key
, accept_default
);
1149 if (! NILP (value
) && !INTEGERP (value
))
1150 RETURN_UNGCPRO (value
);
1152 else if (!NILP (Voverriding_local_map
))
1154 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1155 if (! NILP (value
) && !INTEGERP (value
))
1156 RETURN_UNGCPRO (value
);
1162 nmaps
= current_minor_maps (0, &maps
);
1163 /* Note that all these maps are GCPRO'd
1164 in the places where we found them. */
1166 for (i
= 0; i
< nmaps
; i
++)
1167 if (! NILP (maps
[i
]))
1169 value
= Flookup_key (maps
[i
], key
, accept_default
);
1170 if (! NILP (value
) && !INTEGERP (value
))
1171 RETURN_UNGCPRO (value
);
1174 local
= get_local_map (PT
, current_buffer
);
1178 value
= Flookup_key (local
, key
, accept_default
);
1179 if (! NILP (value
) && !INTEGERP (value
))
1180 RETURN_UNGCPRO (value
);
1184 value
= Flookup_key (current_global_map
, key
, accept_default
);
1186 if (! NILP (value
) && !INTEGERP (value
))
1192 /* GC is possible in this function if it autoloads a keymap. */
1194 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1195 "Return the binding for command KEYS in current local keymap only.\n\
1196 KEYS is a string, a sequence of keystrokes.\n\
1197 The binding is probably a symbol with a function definition.\n\
1199 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1200 bindings; see the description of `lookup-key' for more details about this.")
1201 (keys
, accept_default
)
1202 Lisp_Object keys
, accept_default
;
1204 register Lisp_Object map
;
1205 map
= current_buffer
->keymap
;
1208 return Flookup_key (map
, keys
, accept_default
);
1211 /* GC is possible in this function if it autoloads a keymap. */
1213 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1214 "Return the binding for command KEYS in current global keymap only.\n\
1215 KEYS is a string, a sequence of keystrokes.\n\
1216 The binding is probably a symbol with a function definition.\n\
1217 This function's return values are the same as those of lookup-key\n\
1220 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1221 bindings; see the description of `lookup-key' for more details about this.")
1222 (keys
, accept_default
)
1223 Lisp_Object keys
, accept_default
;
1225 return Flookup_key (current_global_map
, keys
, accept_default
);
1228 /* GC is possible in this function if it autoloads a keymap. */
1230 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1231 "Find the visible minor mode bindings of KEY.\n\
1232 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1233 the symbol which names the minor mode binding KEY, and BINDING is\n\
1234 KEY's definition in that mode. In particular, if KEY has no\n\
1235 minor-mode bindings, return nil. If the first binding is a\n\
1236 non-prefix, all subsequent bindings will be omitted, since they would\n\
1237 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1238 that come after prefix bindings.\n\
1240 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1241 bindings; see the description of `lookup-key' for more details about this.")
1242 (key
, accept_default
)
1243 Lisp_Object key
, accept_default
;
1245 Lisp_Object
*modes
, *maps
;
1247 Lisp_Object binding
;
1249 struct gcpro gcpro1
, gcpro2
;
1251 nmaps
= current_minor_maps (&modes
, &maps
);
1252 /* Note that all these maps are GCPRO'd
1253 in the places where we found them. */
1256 GCPRO2 (key
, binding
);
1258 for (i
= j
= 0; i
< nmaps
; i
++)
1259 if (! NILP (maps
[i
])
1260 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1261 && !INTEGERP (binding
))
1263 if (! NILP (get_keymap (binding
)))
1264 maps
[j
++] = Fcons (modes
[i
], binding
);
1266 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1270 return Flist (j
, maps
);
1273 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
1274 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1275 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1276 If a second optional argument MAPVAR is given, the map is stored as\n\
1277 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1280 Lisp_Object command
, mapvar
;
1283 map
= Fmake_sparse_keymap (Qnil
);
1284 Ffset (command
, map
);
1288 Fset (command
, map
);
1292 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1293 "Select KEYMAP as the global keymap.")
1297 keymap
= get_keymap (keymap
);
1298 current_global_map
= keymap
;
1303 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1304 "Select KEYMAP as the local keymap.\n\
1305 If KEYMAP is nil, that means no local keymap.")
1310 keymap
= get_keymap (keymap
);
1312 current_buffer
->keymap
= keymap
;
1317 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1318 "Return current buffer's local keymap, or nil if it has none.")
1321 return current_buffer
->keymap
;
1324 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1325 "Return the current global keymap.")
1328 return current_global_map
;
1331 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1332 "Return a list of keymaps for the minor modes of the current buffer.")
1336 int nmaps
= current_minor_maps (0, &maps
);
1338 return Flist (nmaps
, maps
);
1341 /* Help functions for describing and documenting keymaps. */
1343 static Lisp_Object
accessible_keymaps_char_table ();
1345 /* This function cannot GC. */
1347 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1349 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1350 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1351 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1352 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1353 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1354 then the value includes only maps for prefixes that start with PREFIX.")
1356 Lisp_Object keymap
, prefix
;
1358 Lisp_Object maps
, good_maps
, tail
;
1361 /* no need for gcpro because we don't autoload any keymaps. */
1364 prefixlen
= XINT (Flength (prefix
));
1368 /* If a prefix was specified, start with the keymap (if any) for
1369 that prefix, so we don't waste time considering other prefixes. */
1371 tem
= Flookup_key (keymap
, prefix
, Qt
);
1372 /* Flookup_key may give us nil, or a number,
1373 if the prefix is not defined in this particular map.
1374 It might even give us a list that isn't a keymap. */
1375 tem
= get_keymap_1 (tem
, 0, 0);
1378 /* Convert PREFIX to a vector now, so that later on
1379 we don't have to deal with the possibility of a string. */
1380 if (STRINGP (prefix
))
1385 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1386 for (i
= 0; i
< XSTRING (prefix
)->size
; i
++)
1388 int c
= XSTRING (prefix
)->data
[i
];
1390 c
^= 0200 | meta_modifier
;
1391 XVECTOR (copy
)->contents
[i
] = make_number (c
);
1395 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1401 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1402 get_keymap (keymap
)),
1405 /* For each map in the list maps,
1406 look at any other maps it points to,
1407 and stick them at the end if they are not already in the list.
1409 This is a breadth-first traversal, where tail is the queue of
1410 nodes, and maps accumulates a list of all nodes visited. */
1412 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1414 register Lisp_Object thisseq
, thismap
;
1416 /* Does the current sequence end in the meta-prefix-char? */
1419 thisseq
= Fcar (Fcar (tail
));
1420 thismap
= Fcdr (Fcar (tail
));
1421 last
= make_number (XINT (Flength (thisseq
)) - 1);
1422 is_metized
= (XINT (last
) >= 0
1423 /* Don't metize the last char of PREFIX. */
1424 && XINT (last
) >= prefixlen
1425 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1427 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1431 elt
= XCONS (thismap
)->car
;
1435 if (CHAR_TABLE_P (elt
))
1437 Lisp_Object
*indices
1438 = (Lisp_Object
*) alloca (3 * sizeof (Lisp_Object
));
1440 map_char_table (accessible_keymaps_char_table
, Qnil
,
1441 elt
, Fcons (maps
, Fcons (tail
, thisseq
)),
1444 else if (VECTORP (elt
))
1448 /* Vector keymap. Scan all the elements. */
1449 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1451 register Lisp_Object tem
;
1452 register Lisp_Object cmd
;
1454 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1455 if (NILP (cmd
)) continue;
1456 tem
= Fkeymapp (cmd
);
1459 cmd
= get_keymap (cmd
);
1460 /* Ignore keymaps that are already added to maps. */
1461 tem
= Frassq (cmd
, maps
);
1464 /* If the last key in thisseq is meta-prefix-char,
1465 turn it into a meta-ized keystroke. We know
1466 that the event we're about to append is an
1467 ascii keystroke since we're processing a
1471 int meta_bit
= meta_modifier
;
1472 tem
= Fcopy_sequence (thisseq
);
1474 Faset (tem
, last
, make_number (i
| meta_bit
));
1476 /* This new sequence is the same length as
1477 thisseq, so stick it in the list right
1480 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1484 tem
= append_key (thisseq
, make_number (i
));
1485 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1491 else if (CONSP (elt
))
1493 register Lisp_Object cmd
, tem
, filter
;
1495 cmd
= get_keyelt (XCONS (elt
)->cdr
, 0);
1496 /* Ignore definitions that aren't keymaps themselves. */
1497 tem
= Fkeymapp (cmd
);
1500 /* Ignore keymaps that have been seen already. */
1501 cmd
= get_keymap (cmd
);
1502 tem
= Frassq (cmd
, maps
);
1505 /* Let elt be the event defined by this map entry. */
1506 elt
= XCONS (elt
)->car
;
1508 /* If the last key in thisseq is meta-prefix-char, and
1509 this entry is a binding for an ascii keystroke,
1510 turn it into a meta-ized keystroke. */
1511 if (is_metized
&& INTEGERP (elt
))
1513 Lisp_Object element
;
1516 tem
= Fvconcat (1, &element
);
1517 XSETFASTINT (XVECTOR (tem
)->contents
[XINT (last
)],
1518 XINT (elt
) | meta_modifier
);
1520 /* This new sequence is the same length as
1521 thisseq, so stick it in the list right
1524 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1528 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1539 /* Now find just the maps whose access prefixes start with PREFIX. */
1542 for (; CONSP (maps
); maps
= XCONS (maps
)->cdr
)
1544 Lisp_Object elt
, thisseq
;
1545 elt
= XCONS (maps
)->car
;
1546 thisseq
= XCONS (elt
)->car
;
1547 /* The access prefix must be at least as long as PREFIX,
1548 and the first elements must match those of PREFIX. */
1549 if (XINT (Flength (thisseq
)) >= prefixlen
)
1552 for (i
= 0; i
< prefixlen
; i
++)
1555 XSETFASTINT (i1
, i
);
1556 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1560 good_maps
= Fcons (elt
, good_maps
);
1564 return Fnreverse (good_maps
);
1568 accessible_keymaps_char_table (args
, index
, cmd
)
1569 Lisp_Object args
, index
, cmd
;
1572 Lisp_Object maps
, tail
, thisseq
;
1577 maps
= XCONS (args
)->car
;
1578 tail
= XCONS (XCONS (args
)->cdr
)->car
;
1579 thisseq
= XCONS (XCONS (args
)->cdr
)->cdr
;
1581 tem
= Fkeymapp (cmd
);
1584 cmd
= get_keymap (cmd
);
1585 /* Ignore keymaps that are already added to maps. */
1586 tem
= Frassq (cmd
, maps
);
1589 tem
= append_key (thisseq
, index
);
1590 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1596 Lisp_Object Qsingle_key_description
, Qkey_description
;
1598 /* This function cannot GC. */
1600 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1601 "Return a pretty description of key-sequence KEYS.\n\
1602 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1603 spaces are put between sequence elements, etc.")
1615 vector
= Fmake_vector (Flength (keys
), Qnil
);
1616 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1618 if (XSTRING (keys
)->data
[i
] & 0x80)
1619 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1620 meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80));
1622 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1623 XSTRING (keys
)->data
[i
]);
1627 else if (!VECTORP (keys
))
1628 keys
= wrong_type_argument (Qarrayp
, keys
);
1630 /* In effect, this computes
1631 (mapconcat 'single-key-description keys " ")
1632 but we shouldn't use mapconcat because it can do GC. */
1634 len
= XVECTOR (keys
)->size
;
1635 sep
= build_string (" ");
1636 /* This has one extra element at the end that we don't pass to Fconcat. */
1637 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1639 for (i
= 0; i
< len
; i
++)
1641 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
]);
1642 args
[i
* 2 + 1] = sep
;
1645 return Fconcat (len
* 2 - 1, args
);
1649 push_key_description (c
, p
)
1650 register unsigned int c
;
1653 /* Clear all the meaningless bits above the meta bit. */
1654 c
&= meta_modifier
| ~ - meta_modifier
;
1656 if (c
& alt_modifier
)
1662 if (c
& ctrl_modifier
)
1668 if (c
& hyper_modifier
)
1672 c
-= hyper_modifier
;
1674 if (c
& meta_modifier
)
1680 if (c
& shift_modifier
)
1684 c
-= shift_modifier
;
1686 if (c
& super_modifier
)
1690 c
-= super_modifier
;
1706 else if (c
== Ctl ('M'))
1716 if (c
> 0 && c
<= Ctl ('Z'))
1741 *p
++ = (7 & (c
>> 6)) + '0';
1742 *p
++ = (7 & (c
>> 3)) + '0';
1743 *p
++ = (7 & (c
>> 0)) + '0';
1748 *p
++ = (7 & (c
>> 15)) + '0';
1749 *p
++ = (7 & (c
>> 12)) + '0';
1750 *p
++ = (7 & (c
>> 9)) + '0';
1751 *p
++ = (7 & (c
>> 6)) + '0';
1752 *p
++ = (7 & (c
>> 3)) + '0';
1753 *p
++ = (7 & (c
>> 0)) + '0';
1759 /* This function cannot GC. */
1761 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1762 "Return a pretty description of command character KEY.\n\
1763 Control characters turn into C-whatever, etc.")
1769 key
= EVENT_HEAD (key
);
1771 if (INTEGERP (key
)) /* Normal character */
1773 *push_key_description (XUINT (key
), tem
) = 0;
1774 return build_string (tem
);
1776 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1777 return Fsymbol_name (key
);
1778 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1779 return Fcopy_sequence (key
);
1781 error ("KEY must be an integer, cons, symbol, or string");
1785 push_text_char_description (c
, p
)
1786 register unsigned int c
;
1798 *p
++ = c
+ 64; /* 'A' - 1 */
1810 /* This function cannot GC. */
1812 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1813 "Return a pretty description of file-character CHARACTER.\n\
1814 Control characters turn into \"^char\", etc.")
1816 Lisp_Object character
;
1820 CHECK_NUMBER (character
, 0);
1822 if (!SINGLE_BYTE_CHAR_P (XFASTINT (character
)))
1825 int len
= non_ascii_char_to_string (XFASTINT (character
), tem
, &str
);
1827 return make_string (str
, len
);
1830 *push_text_char_description (XINT (character
) & 0377, tem
) = 0;
1832 return build_string (tem
);
1835 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1838 ascii_sequence_p (seq
)
1842 int len
= XINT (Flength (seq
));
1844 for (i
= 0; i
< len
; i
++)
1846 Lisp_Object ii
, elt
;
1848 XSETFASTINT (ii
, i
);
1849 elt
= Faref (seq
, ii
);
1852 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1860 /* where-is - finding a command in a set of keymaps. */
1862 static Lisp_Object
where_is_internal_1 ();
1863 static Lisp_Object
where_is_internal_2 ();
1865 /* This function can GC if Flookup_key autoloads any keymaps. */
1867 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
1868 "Return list of keys that invoke DEFINITION.\n\
1869 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
1870 If KEYMAP is nil, search all the currently active keymaps.\n\
1872 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
1873 rather than a list of all possible key sequences.\n\
1874 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
1875 no matter what it is.\n\
1876 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
1877 and entirely reject menu bindings.\n\
1879 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
1880 to other keymaps or slots. This makes it possible to search for an\n\
1881 indirect definition itself.")
1882 (definition
, keymap
, firstonly
, noindirect
)
1883 Lisp_Object definition
, keymap
;
1884 Lisp_Object firstonly
, noindirect
;
1887 Lisp_Object found
, sequences
;
1888 int keymap_specified
= !NILP (keymap
);
1889 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
1890 /* 1 means ignore all menu bindings entirely. */
1891 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
1893 if (! keymap_specified
)
1895 #ifdef USE_TEXT_PROPERTIES
1896 keymap
= get_local_map (PT
, current_buffer
);
1898 keymap
= current_buffer
->keymap
;
1903 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap
), 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
1985 = (Lisp_Object
*) alloca (3 * sizeof (Lisp_Object
));
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
);
2084 where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
, this, last
,
2085 nomenus
, last_is_meta
)
2086 Lisp_Object binding
, key
, definition
, noindirect
, keymap
, this, last
;
2087 int nomenus
, last_is_meta
;
2089 Lisp_Object sequence
;
2090 int keymap_specified
= !NILP (keymap
);
2092 /* Search through indirections unless that's not wanted. */
2093 if (NILP (noindirect
))
2099 Lisp_Object map
, tem
;
2100 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
2101 map
= get_keymap_1 (Fcar_safe (definition
), 0, 0);
2102 tem
= Fkeymapp (map
);
2104 definition
= access_keymap (map
, Fcdr (definition
), 0, 0);
2108 /* If the contents are (STRING ...), reject. */
2109 if (CONSP (definition
)
2110 && STRINGP (XCONS (definition
)->car
))
2114 binding
= get_keyelt (binding
, 0);
2117 /* End this iteration if this element does not match
2120 if (CONSP (definition
))
2123 tem
= Fequal (binding
, definition
);
2128 if (!EQ (binding
, definition
))
2131 /* We have found a match.
2132 Construct the key sequence where we found it. */
2133 if (INTEGERP (key
) && last_is_meta
)
2135 sequence
= Fcopy_sequence (this);
2136 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2139 sequence
= append_key (this, key
);
2141 /* Verify that this key binding is not shadowed by another
2142 binding for the same key, before we say it exists.
2144 Mechanism: look for local definition of this key and if
2145 it is defined and does not match what we found then
2148 Either nil or number as value from Flookup_key
2150 if (keymap_specified
)
2152 binding
= Flookup_key (keymap
, sequence
, Qnil
);
2153 if (!NILP (binding
) && !INTEGERP (binding
))
2155 if (CONSP (definition
))
2158 tem
= Fequal (binding
, definition
);
2163 if (!EQ (binding
, definition
))
2169 binding
= Fkey_binding (sequence
, Qnil
);
2170 if (!EQ (binding
, definition
))
2177 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2179 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 1, "",
2180 "Show a list of all defined keys, and their definitions.\n\
2181 The list is put in a buffer, which is displayed.\n\
2182 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
2183 then we display only bindings that start with that prefix.")
2187 register Lisp_Object thisbuf
;
2188 XSETBUFFER (thisbuf
, current_buffer
);
2189 internal_with_output_to_temp_buffer ("*Help*",
2190 describe_buffer_bindings
,
2191 Fcons (thisbuf
, prefix
));
2195 /* ARG is (BUFFER . PREFIX). */
2198 describe_buffer_bindings (arg
)
2201 Lisp_Object descbuf
, prefix
, shadow
;
2202 register Lisp_Object start1
;
2203 struct gcpro gcpro1
;
2205 char *alternate_heading
2207 Alternate Characters (use anywhere the nominal character is listed):\n\
2208 nominal alternate\n\
2209 ------- ---------\n";
2211 descbuf
= XCONS (arg
)->car
;
2212 prefix
= XCONS (arg
)->cdr
;
2216 Fset_buffer (Vstandard_output
);
2218 /* Report on alternates for keys. */
2219 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2222 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2223 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2225 for (c
= 0; c
< translate_len
; c
++)
2226 if (translate
[c
] != c
)
2231 if (alternate_heading
)
2233 insert_string (alternate_heading
);
2234 alternate_heading
= 0;
2237 bufend
= push_key_description (translate
[c
], buf
);
2238 insert (buf
, bufend
- buf
);
2239 Findent_to (make_number (16), make_number (1));
2240 bufend
= push_key_description (c
, buf
);
2241 insert (buf
, bufend
- buf
);
2249 if (!NILP (Vkey_translation_map
))
2250 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2251 "Key translations", 0, 1, 0);
2255 Lisp_Object
*modes
, *maps
;
2257 /* Temporarily switch to descbuf, so that we can get that buffer's
2258 minor modes correctly. */
2259 Fset_buffer (descbuf
);
2261 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2262 || !NILP (Voverriding_local_map
))
2265 nmaps
= current_minor_maps (&modes
, &maps
);
2266 Fset_buffer (Vstandard_output
);
2268 /* Print the minor mode maps. */
2269 for (i
= 0; i
< nmaps
; i
++)
2271 /* The title for a minor mode keymap
2272 is constructed at run time.
2273 We let describe_map_tree do the actual insertion
2274 because it takes care of other features when doing so. */
2277 if (!SYMBOLP (modes
[i
]))
2280 p
= title
= (char *) alloca (40 + XSYMBOL (modes
[i
])->name
->size
);
2282 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2283 XSYMBOL (modes
[i
])->name
->size
);
2284 p
+= XSYMBOL (modes
[i
])->name
->size
;
2286 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2287 p
+= sizeof (" Minor Mode Bindings") - 1;
2290 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, 0, 0, 0);
2291 shadow
= Fcons (maps
[i
], shadow
);
2295 /* Print the (major mode) local map. */
2296 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2297 start1
= current_kboard
->Voverriding_terminal_local_map
;
2298 else if (!NILP (Voverriding_local_map
))
2299 start1
= Voverriding_local_map
;
2301 start1
= XBUFFER (descbuf
)->keymap
;
2305 describe_map_tree (start1
, 1, shadow
, prefix
,
2306 "Major Mode Bindings", 0, 0, 0);
2307 shadow
= Fcons (start1
, shadow
);
2310 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2311 "Global Bindings", 0, 0, 1);
2313 /* Print the function-key-map translations under this prefix. */
2314 if (!NILP (Vfunction_key_map
))
2315 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2316 "Function key map translations", 0, 1, 0);
2318 call0 (intern ("help-mode"));
2319 Fset_buffer (descbuf
);
2324 /* Insert a description of the key bindings in STARTMAP,
2325 followed by those of all maps reachable through STARTMAP.
2326 If PARTIAL is nonzero, omit certain "uninteresting" commands
2327 (such as `undefined').
2328 If SHADOW is non-nil, it is a list of maps;
2329 don't mention keys which would be shadowed by any of them.
2330 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2331 TITLE, if not 0, is a string to insert at the beginning.
2332 TITLE should not end with a colon or a newline; we supply that.
2333 If NOMENU is not 0, then omit menu-bar commands.
2335 If TRANSL is nonzero, the definitions are actually key translations
2336 so print strings and vectors differently.
2338 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2342 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2344 Lisp_Object startmap
, shadow
, prefix
;
2351 Lisp_Object maps
, seen
, sub_shadows
;
2352 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2359 maps
= Faccessible_keymaps (startmap
, prefix
);
2362 GCPRO3 (maps
, seen
, sub_shadows
);
2368 /* Delete from MAPS each element that is for the menu bar. */
2369 for (list
= maps
; !NILP (list
); list
= XCONS (list
)->cdr
)
2371 Lisp_Object elt
, prefix
, tem
;
2374 prefix
= Fcar (elt
);
2375 if (XVECTOR (prefix
)->size
>= 1)
2377 tem
= Faref (prefix
, make_number (0));
2378 if (EQ (tem
, Qmenu_bar
))
2379 maps
= Fdelq (elt
, maps
);
2384 if (!NILP (maps
) || always_title
)
2388 insert_string (title
);
2391 insert_string (" Starting With ");
2392 insert1 (Fkey_description (prefix
));
2394 insert_string (":\n");
2396 insert_string (key_heading
);
2400 for (; !NILP (maps
); maps
= Fcdr (maps
))
2402 register Lisp_Object elt
, prefix
, tail
;
2405 prefix
= Fcar (elt
);
2409 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2413 shmap
= XCONS (tail
)->car
;
2415 /* If the sequence by which we reach this keymap is zero-length,
2416 then the shadow map for this keymap is just SHADOW. */
2417 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2418 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2420 /* If the sequence by which we reach this keymap actually has
2421 some elements, then the sequence's definition in SHADOW is
2422 what we should use. */
2425 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2426 if (INTEGERP (shmap
))
2430 /* If shmap is not nil and not a keymap,
2431 it completely shadows this map, so don't
2432 describe this map at all. */
2433 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2437 sub_shadows
= Fcons (shmap
, sub_shadows
);
2440 describe_map (Fcdr (elt
), Fcar (elt
),
2441 transl
? describe_translation
: describe_command
,
2442 partial
, sub_shadows
, &seen
, nomenu
);
2448 insert_string ("\n");
2453 static int previous_description_column
;
2456 describe_command (definition
)
2457 Lisp_Object definition
;
2459 register Lisp_Object tem1
;
2460 int column
= current_column ();
2461 int description_column
;
2463 /* If column 16 is no good, go to col 32;
2464 but don't push beyond that--go to next line instead. */
2468 description_column
= 32;
2470 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2471 description_column
= 32;
2473 description_column
= 16;
2475 Findent_to (make_number (description_column
), make_number (1));
2476 previous_description_column
= description_column
;
2478 if (SYMBOLP (definition
))
2480 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2482 insert_string ("\n");
2484 else if (STRINGP (definition
) || VECTORP (definition
))
2485 insert_string ("Keyboard Macro\n");
2488 tem1
= Fkeymapp (definition
);
2490 insert_string ("Prefix Command\n");
2492 insert_string ("??\n");
2497 describe_translation (definition
)
2498 Lisp_Object definition
;
2500 register Lisp_Object tem1
;
2502 Findent_to (make_number (16), make_number (1));
2504 if (SYMBOLP (definition
))
2506 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2508 insert_string ("\n");
2510 else if (STRINGP (definition
) || VECTORP (definition
))
2512 insert1 (Fkey_description (definition
));
2513 insert_string ("\n");
2517 tem1
= Fkeymapp (definition
);
2519 insert_string ("Prefix Command\n");
2521 insert_string ("??\n");
2525 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2526 Returns the first non-nil binding found in any of those maps. */
2529 shadow_lookup (shadow
, key
, flag
)
2530 Lisp_Object shadow
, key
, flag
;
2532 Lisp_Object tail
, value
;
2534 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2536 value
= Flookup_key (XCONS (tail
)->car
, key
, flag
);
2543 /* Describe the contents of map MAP, assuming that this map itself is
2544 reached by the sequence of prefix keys KEYS (a string or vector).
2545 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2548 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2549 register Lisp_Object map
;
2551 int (*elt_describer
) ();
2557 Lisp_Object elt_prefix
;
2558 Lisp_Object tail
, definition
, event
;
2560 Lisp_Object suppress
;
2563 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2565 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2567 /* Call Fkey_description first, to avoid GC bug for the other string. */
2568 tem
= Fkey_description (keys
);
2569 elt_prefix
= concat2 (tem
, build_string (" "));
2575 suppress
= intern ("suppress-keymap");
2577 /* This vector gets used to present single keys to Flookup_key. Since
2578 that is done once per keymap element, we don't want to cons up a
2579 fresh vector every time. */
2580 kludge
= Fmake_vector (make_number (1), Qnil
);
2583 GCPRO3 (elt_prefix
, definition
, kludge
);
2585 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2589 if (VECTORP (XCONS (tail
)->car
)
2590 || CHAR_TABLE_P (XCONS (tail
)->car
))
2591 describe_vector (XCONS (tail
)->car
,
2592 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2594 else if (CONSP (XCONS (tail
)->car
))
2596 event
= XCONS (XCONS (tail
)->car
)->car
;
2598 /* Ignore bindings whose "keys" are not really valid events.
2599 (We get these in the frames and buffers menu.) */
2600 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2603 if (nomenu
&& EQ (event
, Qmenu_bar
))
2606 definition
= get_keyelt (XCONS (XCONS (tail
)->car
)->cdr
, 0);
2608 /* Don't show undefined commands or suppressed commands. */
2609 if (NILP (definition
)) continue;
2610 if (SYMBOLP (definition
) && partial
)
2612 tem
= Fget (definition
, suppress
);
2617 /* Don't show a command that isn't really visible
2618 because a local definition of the same key shadows it. */
2620 XVECTOR (kludge
)->contents
[0] = event
;
2623 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2624 if (!NILP (tem
)) continue;
2627 tem
= Flookup_key (map
, kludge
, Qt
);
2628 if (! EQ (tem
, definition
)) continue;
2632 previous_description_column
= 0;
2637 if (!NILP (elt_prefix
))
2638 insert1 (elt_prefix
);
2640 /* THIS gets the string to describe the character EVENT. */
2641 insert1 (Fsingle_key_description (event
));
2643 /* Print a description of the definition of this character.
2644 elt_describer will take care of spacing out far enough
2645 for alignment purposes. */
2646 (*elt_describer
) (definition
);
2648 else if (EQ (XCONS (tail
)->car
, Qkeymap
))
2650 /* The same keymap might be in the structure twice, if we're
2651 using an inherited keymap. So skip anything we've already
2653 tem
= Fassq (tail
, *seen
);
2654 if (CONSP (tem
) && !NILP (Fequal (XCONS (tem
)->car
, keys
)))
2656 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2664 describe_vector_princ (elt
)
2667 Findent_to (make_number (16), make_number (1));
2672 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2673 "Insert a description of contents of VECTOR.\n\
2674 This is text showing the elements of vector matched against indices.")
2678 int count
= specpdl_ptr
- specpdl
;
2680 specbind (Qstandard_output
, Fcurrent_buffer ());
2681 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2682 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2683 Qnil
, Qnil
, (int *)0, 0);
2685 return unbind_to (count
, Qnil
);
2688 /* Insert in the current buffer a description of the contents of VECTOR.
2689 We call ELT_DESCRIBER to insert the description of one value found
2692 ELT_PREFIX describes what "comes before" the keys or indices defined
2693 by this vector. This is a human-readable string whose size
2694 is not necessarily related to the situation.
2696 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2697 leads to this keymap.
2699 If the vector is a chartable, ELT_PREFIX is the vector
2700 of bytes that lead to the character set or portion of a character
2701 set described by this chartable.
2703 If PARTIAL is nonzero, it means do not mention suppressed commands
2704 (that assumes the vector is in a keymap).
2706 SHADOW is a list of keymaps that shadow this map.
2707 If it is non-nil, then we look up the key in those maps
2708 and we don't mention it now if it is defined by any of them.
2710 ENTIRE_MAP is the keymap in which this vector appears.
2711 If the definition in effect in the whole map does not match
2712 the one in this vector, we ignore this one.
2714 When describing a sub-char-table, INDICES is a list of
2715 indices at higher levels in this char-table,
2716 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 int (*elt_describer
) ();
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");