1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
29 #include "termhooks.h"
30 #include "blockinput.h"
33 #define min(a, b) ((a) < (b) ? (a) : (b))
35 /* The number of elements in keymap vectors. */
36 #define DENSE_TABLE_SIZE (0200)
38 /* Actually allocate storage for these variables */
40 Lisp_Object current_global_map
; /* Current global keymap */
42 Lisp_Object global_map
; /* default global key bindings */
44 Lisp_Object meta_map
; /* The keymap used for globally bound
45 ESC-prefixed default commands */
47 Lisp_Object control_x_map
; /* The keymap used for globally bound
48 C-x-prefixed default commands */
50 /* was MinibufLocalMap */
51 Lisp_Object Vminibuffer_local_map
;
52 /* The keymap used by the minibuf for local
53 bindings when spaces are allowed in the
56 /* was MinibufLocalNSMap */
57 Lisp_Object Vminibuffer_local_ns_map
;
58 /* The keymap used by the minibuf for local
59 bindings when spaces are not encouraged
62 /* keymap used for minibuffers when doing completion */
63 /* was MinibufLocalCompletionMap */
64 Lisp_Object Vminibuffer_local_completion_map
;
66 /* keymap used for minibuffers when doing completion and require a match */
67 /* was MinibufLocalMustMatchMap */
68 Lisp_Object Vminibuffer_local_must_match_map
;
70 /* Alist of minor mode variables and keymaps. */
71 Lisp_Object Vminor_mode_map_alist
;
73 /* Keymap mapping ASCII function key sequences onto their preferred forms.
74 Initialized by the terminal-specific lisp files. See DEFVAR for more
76 Lisp_Object Vfunction_key_map
;
78 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
79 Lisp_Object Vkey_translation_map
;
81 /* A list of all commands given new bindings since a certain time
82 when nil was stored here.
83 This is used to speed up recomputation of menu key equivalents
84 when Emacs starts up. t means don't record anything here. */
85 Lisp_Object Vdefine_key_rebound_commands
;
87 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
;
89 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
90 in a string key sequence is equivalent to prefixing with this
92 extern Lisp_Object meta_prefix_char
;
94 extern Lisp_Object Voverriding_local_map
;
96 static Lisp_Object
define_as_prefix ();
97 static Lisp_Object
describe_buffer_bindings ();
98 static void describe_command (), describe_translation ();
99 static void describe_map ();
101 /* Keymap object support - constructors and predicates. */
103 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
104 "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
105 VECTOR is a vector which holds the bindings for the ASCII\n\
106 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
107 mouse events, and any other things that appear in the input stream.\n\
108 All entries in it are initially nil, meaning \"command undefined\".\n\n\
109 The optional arg STRING supplies a menu name for the keymap\n\
110 in case you use it as a menu with `x-popup-menu'.")
116 tail
= Fcons (string
, Qnil
);
119 return Fcons (Qkeymap
,
120 Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE
), Qnil
),
124 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
125 "Construct and return a new sparse-keymap list.\n\
126 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
127 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
128 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
129 Initially the alist is nil.\n\n\
130 The optional arg STRING supplies a menu name for the keymap\n\
131 in case you use it as a menu with `x-popup-menu'.")
136 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
137 return Fcons (Qkeymap
, Qnil
);
140 /* This function is used for installing the standard key bindings
141 at initialization time.
145 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
148 initial_define_key (keymap
, key
, defname
)
153 store_in_keymap (keymap
, make_number (key
), intern (defname
));
157 initial_define_lispy_key (keymap
, keyname
, defname
)
162 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
165 /* Define character fromchar in map frommap as an alias for character
166 tochar in map tomap. Subsequent redefinitions of the latter WILL
167 affect the former. */
171 synkey (frommap
, fromchar
, tomap
, tochar
)
172 struct Lisp_Vector
*frommap
, *tomap
;
173 int fromchar
, tochar
;
176 XSETVECTOR (v
, tomap
);
177 XSETFASTINT (c
, tochar
);
178 frommap
->contents
[fromchar
] = Fcons (v
, c
);
182 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
183 "Return t if OBJECT is a keymap.\n\
185 A keymap is a list (keymap . ALIST),\n\
186 or a symbol whose function definition is itself a keymap.\n\
187 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
188 a vector of densely packed bindings for small character codes\n\
189 is also allowed as an element.")
193 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
196 /* Check that OBJECT is a keymap (after dereferencing through any
197 symbols). If it is, return it.
199 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
200 is an autoload form, do the autoload and try again.
201 If AUTOLOAD is nonzero, callers must assume GC is possible.
203 ERROR controls how we respond if OBJECT isn't a keymap.
204 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
206 Note that most of the time, we don't want to pursue autoloads.
207 Functions like Faccessible_keymaps which scan entire keymap trees
208 shouldn't load every autoloaded keymap. I'm not sure about this,
209 but it seems to me that only read_key_sequence, Flookup_key, and
210 Fdefine_key should cause keymaps to be autoloaded. */
213 get_keymap_1 (object
, error
, autoload
)
220 tem
= indirect_function (object
);
221 if (CONSP (tem
) && EQ (XCONS (tem
)->car
, Qkeymap
))
224 /* Should we do an autoload? Autoload forms for keymaps have
225 Qkeymap as their fifth element. */
229 && EQ (XCONS (tem
)->car
, Qautoload
))
233 tail
= Fnth (make_number (4), tem
);
234 if (EQ (tail
, Qkeymap
))
236 struct gcpro gcpro1
, gcpro2
;
238 GCPRO2 (tem
, object
);
239 do_autoload (tem
, object
);
247 wrong_type_argument (Qkeymapp
, object
);
253 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
254 If OBJECT doesn't denote a keymap at all, signal an error. */
259 return get_keymap_1 (object
, 1, 0);
262 /* Return the parent map of the keymap MAP, or nil if it has none.
263 We assume that MAP is a valid keymap. */
265 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
266 "Return the parent keymap of KEYMAP.")
272 keymap
= get_keymap_1 (keymap
, 1, 1);
274 /* Skip past the initial element `keymap'. */
275 list
= XCONS (keymap
)->cdr
;
276 for (; CONSP (list
); list
= XCONS (list
)->cdr
)
278 /* See if there is another `keymap'. */
279 if (EQ (Qkeymap
, XCONS (list
)->car
))
286 /* Set the parent keymap of MAP to PARENT. */
288 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
289 "Modify KEYMAP to set its parent map to PARENT.\n\
290 PARENT should be nil or another keymap.")
292 Lisp_Object keymap
, parent
;
294 Lisp_Object list
, prev
;
297 keymap
= get_keymap_1 (keymap
, 1, 1);
299 parent
= get_keymap_1 (parent
, 1, 1);
301 /* Skip past the initial element `keymap'. */
305 list
= XCONS (prev
)->cdr
;
306 /* If there is a parent keymap here, replace it.
307 If we came to the end, add the parent in PREV. */
308 if (! CONSP (list
) || EQ (Qkeymap
, XCONS (list
)->car
))
310 XCONS (prev
)->cdr
= parent
;
316 /* Scan through for submaps, and set their parents too. */
318 for (list
= XCONS (keymap
)->cdr
; CONSP (list
); list
= XCONS (list
)->cdr
)
320 /* Stop the scan when we come to the parent. */
321 if (EQ (XCONS (list
)->car
, Qkeymap
))
324 /* If this element holds a prefix map, deal with it. */
325 if (CONSP (XCONS (list
)->car
)
326 && CONSP (XCONS (XCONS (list
)->car
)->cdr
))
327 fix_submap_inheritance (keymap
, XCONS (XCONS (list
)->car
)->car
,
328 XCONS (XCONS (list
)->car
)->cdr
);
330 if (VECTORP (XCONS (list
)->car
))
331 for (i
= 0; i
< XVECTOR (XCONS (list
)->car
)->size
; i
++)
332 if (CONSP (XVECTOR (XCONS (list
)->car
)->contents
[i
]))
333 fix_submap_inheritance (keymap
, make_number (i
),
334 XVECTOR (XCONS (list
)->car
)->contents
[i
]);
340 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
341 if EVENT is also a prefix in MAP's parent,
342 make sure that SUBMAP inherits that definition as its own parent. */
344 fix_submap_inheritance (map
, event
, submap
)
345 Lisp_Object map
, event
, submap
;
347 Lisp_Object map_parent
, parent_entry
;
349 /* SUBMAP is a cons that we found as a key binding.
350 Discard the other things found in a menu key binding. */
353 && STRINGP (XCONS (submap
)->car
))
355 submap
= XCONS (submap
)->cdr
;
356 /* Also remove a menu help string, if any,
357 following the menu item name. */
358 if (CONSP (submap
) && STRINGP (XCONS (submap
)->car
))
359 submap
= XCONS (submap
)->cdr
;
360 /* Also remove the sublist that caches key equivalences, if any. */
362 && CONSP (XCONS (submap
)->car
))
365 carcar
= XCONS (XCONS (submap
)->car
)->car
;
366 if (NILP (carcar
) || VECTORP (carcar
))
367 submap
= XCONS (submap
)->cdr
;
371 /* If it isn't a keymap now, there's no work to do. */
373 || ! EQ (XCONS (submap
)->car
, Qkeymap
))
376 map_parent
= Fkeymap_parent (map
);
377 if (! NILP (map_parent
))
378 parent_entry
= access_keymap (map_parent
, event
, 0, 0);
382 if (! EQ (parent_entry
, submap
))
383 Fset_keymap_parent (submap
, parent_entry
);
386 /* Look up IDX in MAP. IDX may be any sort of event.
387 Note that this does only one level of lookup; IDX must be a single
388 event, not a sequence.
390 If T_OK is non-zero, bindings for Qt are treated as default
391 bindings; any key left unmentioned by other tables and bindings is
392 given the binding of Qt.
394 If T_OK is zero, bindings for Qt are not treated specially.
396 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
399 access_keymap (map
, idx
, t_ok
, noinherit
)
408 /* If idx is a list (some sort of mouse click, perhaps?),
409 the index we want to use is the car of the list, which
410 ought to be a symbol. */
411 idx
= EVENT_HEAD (idx
);
413 /* If idx is a symbol, it might have modifiers, which need to
414 be put in the canonical order. */
416 idx
= reorder_modifiers (idx
);
417 else if (INTEGERP (idx
))
418 /* Clobber the high bits that can be present on a machine
419 with more than 24 bits of integer. */
420 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
424 Lisp_Object t_binding
;
427 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
431 binding
= XCONS (tail
)->car
;
432 if (SYMBOLP (binding
))
434 /* If NOINHERIT, stop finding prefix definitions
435 after we pass a second occurrence of the `keymap' symbol. */
436 if (noinherit
&& EQ (binding
, Qkeymap
) && ! EQ (tail
, map
))
439 else if (CONSP (binding
))
441 if (EQ (XCONS (binding
)->car
, idx
))
443 val
= XCONS (binding
)->cdr
;
444 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
447 fix_submap_inheritance (map
, idx
, val
);
450 if (t_ok
&& EQ (XCONS (binding
)->car
, Qt
))
451 t_binding
= XCONS (binding
)->cdr
;
453 else if (VECTORP (binding
))
455 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
457 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
458 if (noprefix
&& CONSP (val
) && EQ (XCONS (val
)->car
, Qkeymap
))
461 fix_submap_inheritance (map
, idx
, val
);
473 /* Given OBJECT which was found in a slot in a keymap,
474 trace indirect definitions to get the actual definition of that slot.
475 An indirect definition is a list of the form
476 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
477 and INDEX is the object to look up in KEYMAP to yield the definition.
479 Also if OBJECT has a menu string as the first element,
480 remove that. Also remove a menu help string as second element.
482 If AUTOLOAD is nonzero, load autoloadable keymaps
483 that are referred to with indirection. */
486 get_keyelt (object
, autoload
)
487 register Lisp_Object object
;
492 register Lisp_Object map
, tem
;
494 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
495 map
= get_keymap_1 (Fcar_safe (object
), 0, autoload
);
496 tem
= Fkeymapp (map
);
498 object
= access_keymap (map
, Fcdr (object
), 0, 0);
500 /* If the keymap contents looks like (STRING . DEFN),
502 Keymap alist elements like (CHAR MENUSTRING . DEFN)
503 will be used by HierarKey menus. */
504 else if (CONSP (object
)
505 && STRINGP (XCONS (object
)->car
))
507 object
= XCONS (object
)->cdr
;
508 /* Also remove a menu help string, if any,
509 following the menu item name. */
510 if (CONSP (object
) && STRINGP (XCONS (object
)->car
))
511 object
= XCONS (object
)->cdr
;
512 /* Also remove the sublist that caches key equivalences, if any. */
514 && CONSP (XCONS (object
)->car
))
517 carcar
= XCONS (XCONS (object
)->car
)->car
;
518 if (NILP (carcar
) || VECTORP (carcar
))
519 object
= XCONS (object
)->cdr
;
524 /* Anything else is really the value. */
530 store_in_keymap (keymap
, idx
, def
)
532 register Lisp_Object idx
;
533 register Lisp_Object def
;
535 /* If we are preparing to dump, and DEF is a menu element
536 with a menu item string, copy it to ensure it is not pure. */
537 if (CONSP (def
) && PURE_P (def
) && STRINGP (XCONS (def
)->car
))
538 def
= Fcons (XCONS (def
)->car
, XCONS (def
)->cdr
);
540 if (!CONSP (keymap
) || ! EQ (XCONS (keymap
)->car
, Qkeymap
))
541 error ("attempt to define a key in a non-keymap");
543 /* If idx is a list (some sort of mouse click, perhaps?),
544 the index we want to use is the car of the list, which
545 ought to be a symbol. */
546 idx
= EVENT_HEAD (idx
);
548 /* If idx is a symbol, it might have modifiers, which need to
549 be put in the canonical order. */
551 idx
= reorder_modifiers (idx
);
552 else if (INTEGERP (idx
))
553 /* Clobber the high bits that can be present on a machine
554 with more than 24 bits of integer. */
555 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
557 /* Scan the keymap for a binding of idx. */
561 /* The cons after which we should insert new bindings. If the
562 keymap has a table element, we record its position here, so new
563 bindings will go after it; this way, the table will stay
564 towards the front of the alist and character lookups in dense
565 keymaps will remain fast. Otherwise, this just points at the
566 front of the keymap. */
567 Lisp_Object insertion_point
;
569 insertion_point
= keymap
;
570 for (tail
= XCONS (keymap
)->cdr
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
574 elt
= XCONS (tail
)->car
;
577 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (elt
)->size
)
579 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
582 insertion_point
= tail
;
584 else if (CONSP (elt
))
586 if (EQ (idx
, XCONS (elt
)->car
))
588 XCONS (elt
)->cdr
= def
;
592 else if (SYMBOLP (elt
))
594 /* If we find a 'keymap' symbol in the spine of KEYMAP,
595 then we must have found the start of a second keymap
596 being used as the tail of KEYMAP, and a binding for IDX
597 should be inserted before it. */
598 if (EQ (elt
, Qkeymap
))
606 /* We have scanned the entire keymap, and not found a binding for
607 IDX. Let's add one. */
608 XCONS (insertion_point
)->cdr
609 = Fcons (Fcons (idx
, def
), XCONS (insertion_point
)->cdr
);
616 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
617 "Return a copy of the keymap KEYMAP.\n\
618 The copy starts out with the same definitions of KEYMAP,\n\
619 but changing either the copy or KEYMAP does not affect the other.\n\
620 Any key definitions that are subkeymaps are recursively copied.\n\
621 However, a key definition which is a symbol whose definition is a keymap\n\
626 register Lisp_Object copy
, tail
;
628 copy
= Fcopy_alist (get_keymap (keymap
));
630 for (tail
= copy
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
634 elt
= XCONS (tail
)->car
;
639 elt
= Fcopy_sequence (elt
);
640 XCONS (tail
)->car
= elt
;
642 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
643 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
644 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
645 XVECTOR (elt
)->contents
[i
] =
646 Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
648 else if (CONSP (elt
))
650 /* Skip the optional menu string. */
651 if (CONSP (XCONS (elt
)->cdr
)
652 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
656 /* Copy the cell, since copy-alist didn't go this deep. */
657 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
658 XCONS (XCONS (elt
)->cdr
)->cdr
);
659 elt
= XCONS (elt
)->cdr
;
661 /* Also skip the optional menu help string. */
662 if (CONSP (XCONS (elt
)->cdr
)
663 && STRINGP (XCONS (XCONS (elt
)->cdr
)->car
))
665 XCONS (elt
)->cdr
= Fcons (XCONS (XCONS (elt
)->cdr
)->car
,
666 XCONS (XCONS (elt
)->cdr
)->cdr
);
667 elt
= XCONS (elt
)->cdr
;
669 /* There may also be a list that caches key equivalences.
670 Just delete it for the new keymap. */
671 if (CONSP (XCONS (elt
)->cdr
)
672 && CONSP (XCONS (XCONS (elt
)->cdr
)->car
)
673 && (NILP (tem
= XCONS (XCONS (XCONS (elt
)->cdr
)->car
)->car
)
675 XCONS (elt
)->cdr
= XCONS (XCONS (elt
)->cdr
)->cdr
;
678 && ! SYMBOLP (XCONS (elt
)->cdr
)
679 && ! NILP (Fkeymapp (XCONS (elt
)->cdr
)))
680 XCONS (elt
)->cdr
= Fcopy_keymap (XCONS (elt
)->cdr
);
687 /* Simple Keymap mutators and accessors. */
689 /* GC is possible in this function if it autoloads a keymap. */
691 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
692 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
693 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
694 meaning a sequence of keystrokes and events.\n\
695 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
696 can be included if you use a vector.\n\
697 DEF is anything that can be a key's definition:\n\
698 nil (means key is undefined in this keymap),\n\
699 a command (a Lisp function suitable for interactive calling)\n\
700 a string (treated as a keyboard macro),\n\
701 a keymap (to define a prefix key),\n\
702 a symbol. When the key is looked up, the symbol will stand for its\n\
703 function definition, which should at that time be one of the above,\n\
704 or another symbol whose function definition is used, etc.\n\
705 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
706 (DEFN should be a valid definition in its own right),\n\
707 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
709 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
710 the front of KEYMAP.")
717 register Lisp_Object c
;
718 register Lisp_Object tem
;
719 register Lisp_Object cmd
;
723 struct gcpro gcpro1
, gcpro2
, gcpro3
;
725 keymap
= get_keymap_1 (keymap
, 1, 1);
727 if (!VECTORP (key
) && !STRINGP (key
))
728 key
= wrong_type_argument (Qarrayp
, key
);
730 length
= XFASTINT (Flength (key
));
734 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
735 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
737 GCPRO3 (keymap
, key
, def
);
740 meta_bit
= meta_modifier
;
747 c
= Faref (key
, make_number (idx
));
749 if (CONSP (c
) && lucid_event_type_list_p (c
))
750 c
= Fevent_convert_list (c
);
753 && (XINT (c
) & meta_bit
)
756 c
= meta_prefix_char
;
762 XSETINT (c
, XINT (c
) & ~meta_bit
);
768 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
769 error ("Key sequence contains invalid events");
772 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
774 cmd
= get_keyelt (access_keymap (keymap
, c
, 0, 1), 1);
776 /* If this key is undefined, make it a prefix. */
778 cmd
= define_as_prefix (keymap
, c
);
780 keymap
= get_keymap_1 (cmd
, 0, 1);
782 /* We must use Fkey_description rather than just passing key to
783 error; key might be a vector, not a string. */
784 error ("Key sequence %s uses invalid prefix characters",
785 XSTRING (Fkey_description (key
))->data
);
789 /* Value is number if KEY is too long; NIL if valid but has no definition. */
790 /* GC is possible in this function if it autoloads a keymap. */
792 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
793 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
794 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
796 A number as value means KEY is \"too long\";\n\
797 that is, characters or symbols in it except for the last one\n\
798 fail to be a valid sequence of prefix characters in KEYMAP.\n\
799 The number is how many characters at the front of KEY\n\
800 it takes to reach a non-prefix command.\n\
802 Normally, `lookup-key' ignores bindings for t, which act as default\n\
803 bindings, used when nothing else in the keymap applies; this makes it\n\
804 usable as a general function for probing keymaps. However, if the\n\
805 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
806 recognize the default bindings, just as `read-key-sequence' does.")
807 (keymap
, key
, accept_default
)
808 register Lisp_Object keymap
;
810 Lisp_Object accept_default
;
813 register Lisp_Object tem
;
814 register Lisp_Object cmd
;
815 register Lisp_Object c
;
818 int t_ok
= ! NILP (accept_default
);
822 keymap
= get_keymap_1 (keymap
, 1, 1);
824 if (!VECTORP (key
) && !STRINGP (key
))
825 key
= wrong_type_argument (Qarrayp
, key
);
827 length
= XFASTINT (Flength (key
));
832 meta_bit
= meta_modifier
;
841 c
= Faref (key
, make_number (idx
));
843 if (CONSP (c
) && lucid_event_type_list_p (c
))
844 c
= Fevent_convert_list (c
);
847 && (XINT (c
) & meta_bit
)
850 c
= meta_prefix_char
;
856 XSETINT (c
, XINT (c
) & ~meta_bit
);
862 cmd
= get_keyelt (access_keymap (keymap
, c
, t_ok
, 0), 1);
864 RETURN_UNGCPRO (cmd
);
866 keymap
= get_keymap_1 (cmd
, 0, 1);
868 RETURN_UNGCPRO (make_number (idx
));
874 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
875 Assume that currently it does not define C at all.
876 Return the keymap. */
879 define_as_prefix (keymap
, c
)
880 Lisp_Object keymap
, c
;
882 Lisp_Object inherit
, cmd
;
884 cmd
= Fmake_sparse_keymap (Qnil
);
885 /* If this key is defined as a prefix in an inherited keymap,
886 make it a prefix in this map, and make its definition
887 inherit the other prefix definition. */
888 inherit
= access_keymap (keymap
, c
, 0, 0);
890 /* This code is needed to do the right thing in the following case:
891 keymap A inherits from B,
892 you define KEY as a prefix in A,
893 then later you define KEY as a prefix in B.
894 We want the old prefix definition in A to inherit from that in B.
895 It is hard to do that retroactively, so this code
896 creates the prefix in B right away.
898 But it turns out that this code causes problems immediately
899 when the prefix in A is defined: it causes B to define KEY
900 as a prefix with no subcommands.
902 So I took out this code. */
905 /* If there's an inherited keymap
906 and it doesn't define this key,
907 make it define this key. */
910 for (tail
= Fcdr (keymap
); CONSP (tail
); tail
= XCONS (tail
)->cdr
)
911 if (EQ (XCONS (tail
)->car
, Qkeymap
))
915 inherit
= define_as_prefix (tail
, c
);
919 cmd
= nconc2 (cmd
, inherit
);
920 store_in_keymap (keymap
, c
, cmd
);
925 /* Append a key to the end of a key sequence. We always make a vector. */
928 append_key (key_sequence
, key
)
929 Lisp_Object key_sequence
, key
;
933 args
[0] = key_sequence
;
935 args
[1] = Fcons (key
, Qnil
);
936 return Fvconcat (2, args
);
940 /* Global, local, and minor mode keymap stuff. */
942 /* We can't put these variables inside current_minor_maps, since under
943 some systems, static gets macro-defined to be the empty string.
945 static Lisp_Object
*cmm_modes
, *cmm_maps
;
948 /* Error handler used in current_minor_maps. */
950 current_minor_maps_error ()
955 /* Store a pointer to an array of the keymaps of the currently active
956 minor modes in *buf, and return the number of maps it contains.
958 This function always returns a pointer to the same buffer, and may
959 free or reallocate it, so if you want to keep it for a long time or
960 hand it out to lisp code, copy it. This procedure will be called
961 for every key sequence read, so the nice lispy approach (return a
962 new assoclist, list, what have you) for each invocation would
963 result in a lot of consing over time.
965 If we used xrealloc/xmalloc and ran out of memory, they would throw
966 back to the command loop, which would try to read a key sequence,
967 which would call this function again, resulting in an infinite
968 loop. Instead, we'll use realloc/malloc and silently truncate the
969 list, let the key sequence be read, and hope some other piece of
970 code signals the error. */
972 current_minor_maps (modeptr
, mapptr
)
973 Lisp_Object
**modeptr
, **mapptr
;
976 Lisp_Object alist
, assoc
, var
, val
;
978 for (alist
= Vminor_mode_map_alist
;
980 alist
= XCONS (alist
)->cdr
)
981 if ((assoc
= XCONS (alist
)->car
, CONSP (assoc
))
982 && (var
= XCONS (assoc
)->car
, SYMBOLP (var
))
983 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
990 Lisp_Object
*newmodes
, *newmaps
;
997 = (Lisp_Object
*) realloc (cmm_modes
,
998 cmm_size
* sizeof (Lisp_Object
));
1000 = (Lisp_Object
*) realloc (cmm_maps
,
1001 cmm_size
* sizeof (Lisp_Object
));
1009 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1011 = (Lisp_Object
*) malloc (cmm_size
* sizeof (Lisp_Object
));
1015 if (newmaps
&& newmodes
)
1017 cmm_modes
= newmodes
;
1024 /* Get the keymap definition--or nil if it is not defined. */
1025 temp
= internal_condition_case_1 (Findirect_function
,
1027 Qerror
, current_minor_maps_error
);
1031 cmm_maps
[i
] = temp
;
1036 if (modeptr
) *modeptr
= cmm_modes
;
1037 if (mapptr
) *mapptr
= cmm_maps
;
1041 /* GC is possible in this function if it autoloads a keymap. */
1043 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1044 "Return the binding for command KEY in current keymaps.\n\
1045 KEY is a string or vector, a sequence of keystrokes.\n\
1046 The binding is probably a symbol with a function definition.\n\
1048 Normally, `key-binding' ignores bindings for t, which act as default\n\
1049 bindings, used when nothing else in the keymap applies; this makes it\n\
1050 usable as a general function for probing keymaps. However, if the\n\
1051 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1052 recognize the default bindings, just as `read-key-sequence' does.")
1053 (key
, accept_default
)
1054 Lisp_Object key
, accept_default
;
1056 Lisp_Object
*maps
, value
;
1058 struct gcpro gcpro1
;
1062 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1064 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1065 key
, accept_default
);
1066 if (! NILP (value
) && !INTEGERP (value
))
1067 RETURN_UNGCPRO (value
);
1069 else if (!NILP (Voverriding_local_map
))
1071 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1072 if (! NILP (value
) && !INTEGERP (value
))
1073 RETURN_UNGCPRO (value
);
1079 nmaps
= current_minor_maps (0, &maps
);
1080 /* Note that all these maps are GCPRO'd
1081 in the places where we found them. */
1083 for (i
= 0; i
< nmaps
; i
++)
1084 if (! NILP (maps
[i
]))
1086 value
= Flookup_key (maps
[i
], key
, accept_default
);
1087 if (! NILP (value
) && !INTEGERP (value
))
1088 RETURN_UNGCPRO (value
);
1091 local
= get_local_map (PT
, current_buffer
);
1095 value
= Flookup_key (local
, key
, accept_default
);
1096 if (! NILP (value
) && !INTEGERP (value
))
1097 RETURN_UNGCPRO (value
);
1101 value
= Flookup_key (current_global_map
, key
, accept_default
);
1103 if (! NILP (value
) && !INTEGERP (value
))
1109 /* GC is possible in this function if it autoloads a keymap. */
1111 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1112 "Return the binding for command KEYS in current local keymap only.\n\
1113 KEYS is a string, a sequence of keystrokes.\n\
1114 The binding is probably a symbol with a function definition.\n\
1116 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1117 bindings; see the description of `lookup-key' for more details about this.")
1118 (keys
, accept_default
)
1119 Lisp_Object keys
, accept_default
;
1121 register Lisp_Object map
;
1122 map
= current_buffer
->keymap
;
1125 return Flookup_key (map
, keys
, accept_default
);
1128 /* GC is possible in this function if it autoloads a keymap. */
1130 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1131 "Return the binding for command KEYS in current global keymap only.\n\
1132 KEYS is a string, a sequence of keystrokes.\n\
1133 The binding is probably a symbol with a function definition.\n\
1134 This function's return values are the same as those of lookup-key\n\
1137 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1138 bindings; see the description of `lookup-key' for more details about this.")
1139 (keys
, accept_default
)
1140 Lisp_Object keys
, accept_default
;
1142 return Flookup_key (current_global_map
, keys
, accept_default
);
1145 /* GC is possible in this function if it autoloads a keymap. */
1147 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1148 "Find the visible minor mode bindings of KEY.\n\
1149 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1150 the symbol which names the minor mode binding KEY, and BINDING is\n\
1151 KEY's definition in that mode. In particular, if KEY has no\n\
1152 minor-mode bindings, return nil. If the first binding is a\n\
1153 non-prefix, all subsequent bindings will be omitted, since they would\n\
1154 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1155 that come after prefix bindings.\n\
1157 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1158 bindings; see the description of `lookup-key' for more details about this.")
1159 (key
, accept_default
)
1160 Lisp_Object key
, accept_default
;
1162 Lisp_Object
*modes
, *maps
;
1164 Lisp_Object binding
;
1166 struct gcpro gcpro1
, gcpro2
;
1168 nmaps
= current_minor_maps (&modes
, &maps
);
1169 /* Note that all these maps are GCPRO'd
1170 in the places where we found them. */
1173 GCPRO2 (key
, binding
);
1175 for (i
= j
= 0; i
< nmaps
; i
++)
1176 if (! NILP (maps
[i
])
1177 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1178 && !INTEGERP (binding
))
1180 if (! NILP (get_keymap (binding
)))
1181 maps
[j
++] = Fcons (modes
[i
], binding
);
1183 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1187 return Flist (j
, maps
);
1190 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 2, 0,
1191 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1192 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1193 If a second optional argument MAPVAR is given, the map is stored as\n\
1194 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1197 Lisp_Object command
, mapvar
;
1200 map
= Fmake_sparse_keymap (Qnil
);
1201 Ffset (command
, map
);
1205 Fset (command
, map
);
1209 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1210 "Select KEYMAP as the global keymap.")
1214 keymap
= get_keymap (keymap
);
1215 current_global_map
= keymap
;
1220 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1221 "Select KEYMAP as the local keymap.\n\
1222 If KEYMAP is nil, that means no local keymap.")
1227 keymap
= get_keymap (keymap
);
1229 current_buffer
->keymap
= keymap
;
1234 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1235 "Return current buffer's local keymap, or nil if it has none.")
1238 return current_buffer
->keymap
;
1241 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1242 "Return the current global keymap.")
1245 return current_global_map
;
1248 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1249 "Return a list of keymaps for the minor modes of the current buffer.")
1253 int nmaps
= current_minor_maps (0, &maps
);
1255 return Flist (nmaps
, maps
);
1258 /* Help functions for describing and documenting keymaps. */
1260 /* This function cannot GC. */
1262 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1264 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1265 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1266 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1267 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1268 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1269 then the value includes only maps for prefixes that start with PREFIX.")
1271 Lisp_Object keymap
, prefix
;
1273 Lisp_Object maps
, good_maps
, tail
;
1276 /* no need for gcpro because we don't autoload any keymaps. */
1279 prefixlen
= XINT (Flength (prefix
));
1283 /* If a prefix was specified, start with the keymap (if any) for
1284 that prefix, so we don't waste time considering other prefixes. */
1286 tem
= Flookup_key (keymap
, prefix
, Qt
);
1287 /* Flookup_key may give us nil, or a number,
1288 if the prefix is not defined in this particular map.
1289 It might even give us a list that isn't a keymap. */
1290 tem
= get_keymap_1 (tem
, 0, 0);
1292 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1297 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1298 get_keymap (keymap
)),
1301 /* For each map in the list maps,
1302 look at any other maps it points to,
1303 and stick them at the end if they are not already in the list.
1305 This is a breadth-first traversal, where tail is the queue of
1306 nodes, and maps accumulates a list of all nodes visited. */
1308 for (tail
= maps
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1310 register Lisp_Object thisseq
, thismap
;
1312 /* Does the current sequence end in the meta-prefix-char? */
1315 thisseq
= Fcar (Fcar (tail
));
1316 thismap
= Fcdr (Fcar (tail
));
1317 last
= make_number (XINT (Flength (thisseq
)) - 1);
1318 is_metized
= (XINT (last
) >= 0
1319 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1321 for (; CONSP (thismap
); thismap
= XCONS (thismap
)->cdr
)
1325 elt
= XCONS (thismap
)->car
;
1333 /* Vector keymap. Scan all the elements. */
1334 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1336 register Lisp_Object tem
;
1337 register Lisp_Object cmd
;
1339 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1340 if (NILP (cmd
)) continue;
1341 tem
= Fkeymapp (cmd
);
1344 cmd
= get_keymap (cmd
);
1345 /* Ignore keymaps that are already added to maps. */
1346 tem
= Frassq (cmd
, maps
);
1349 /* If the last key in thisseq is meta-prefix-char,
1350 turn it into a meta-ized keystroke. We know
1351 that the event we're about to append is an
1352 ascii keystroke since we're processing a
1356 int meta_bit
= meta_modifier
;
1357 tem
= Fcopy_sequence (thisseq
);
1359 Faset (tem
, last
, make_number (i
| meta_bit
));
1361 /* This new sequence is the same length as
1362 thisseq, so stick it in the list right
1365 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1369 tem
= append_key (thisseq
, make_number (i
));
1370 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1376 else if (CONSP (elt
))
1378 register Lisp_Object cmd
, tem
, filter
;
1380 cmd
= get_keyelt (XCONS (elt
)->cdr
, 0);
1381 /* Ignore definitions that aren't keymaps themselves. */
1382 tem
= Fkeymapp (cmd
);
1385 /* Ignore keymaps that have been seen already. */
1386 cmd
= get_keymap (cmd
);
1387 tem
= Frassq (cmd
, maps
);
1390 /* Let elt be the event defined by this map entry. */
1391 elt
= XCONS (elt
)->car
;
1393 /* If the last key in thisseq is meta-prefix-char, and
1394 this entry is a binding for an ascii keystroke,
1395 turn it into a meta-ized keystroke. */
1396 if (is_metized
&& INTEGERP (elt
))
1398 tem
= Fcopy_sequence (thisseq
);
1400 make_number (XINT (elt
) | meta_modifier
));
1402 /* This new sequence is the same length as
1403 thisseq, so stick it in the list right
1406 = Fcons (Fcons (tem
, cmd
), XCONS (tail
)->cdr
);
1410 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1421 /* Now find just the maps whose access prefixes start with PREFIX. */
1424 for (; CONSP (maps
); maps
= XCONS (maps
)->cdr
)
1426 Lisp_Object elt
, thisseq
;
1427 elt
= XCONS (maps
)->car
;
1428 thisseq
= XCONS (elt
)->car
;
1429 /* The access prefix must be at least as long as PREFIX,
1430 and the first elements must match those of PREFIX. */
1431 if (XINT (Flength (thisseq
)) >= prefixlen
)
1434 for (i
= 0; i
< prefixlen
; i
++)
1437 XSETFASTINT (i1
, i
);
1438 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1442 good_maps
= Fcons (elt
, good_maps
);
1446 return Fnreverse (good_maps
);
1449 Lisp_Object Qsingle_key_description
, Qkey_description
;
1451 /* This function cannot GC. */
1453 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1454 "Return a pretty description of key-sequence KEYS.\n\
1455 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1456 spaces are put between sequence elements, etc.")
1468 vector
= Fmake_vector (Flength (keys
), Qnil
);
1469 for (i
= 0; i
< XSTRING (keys
)->size
; i
++)
1471 if (XSTRING (keys
)->data
[i
] & 0x80)
1472 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1473 meta_modifier
| (XSTRING (keys
)->data
[i
] & ~0x80));
1475 XSETFASTINT (XVECTOR (vector
)->contents
[i
],
1476 XSTRING (keys
)->data
[i
]);
1480 else if (!VECTORP (keys
))
1481 keys
= wrong_type_argument (Qarrayp
, keys
);
1483 /* In effect, this computes
1484 (mapconcat 'single-key-description keys " ")
1485 but we shouldn't use mapconcat because it can do GC. */
1487 len
= XVECTOR (keys
)->size
;
1488 sep
= build_string (" ");
1489 /* This has one extra element at the end that we don't pass to Fconcat. */
1490 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1492 for (i
= 0; i
< len
; i
++)
1494 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
]);
1495 args
[i
* 2 + 1] = sep
;
1498 return Fconcat (len
* 2 - 1, args
);
1502 push_key_description (c
, p
)
1503 register unsigned int c
;
1506 /* Clear all the meaningless bits above the meta bit. */
1507 c
&= meta_modifier
| ~ - meta_modifier
;
1509 if (c
& alt_modifier
)
1515 if (c
& ctrl_modifier
)
1521 if (c
& hyper_modifier
)
1525 c
-= hyper_modifier
;
1527 if (c
& meta_modifier
)
1533 if (c
& shift_modifier
)
1537 c
-= shift_modifier
;
1539 if (c
& super_modifier
)
1543 c
-= super_modifier
;
1559 else if (c
== Ctl('J'))
1565 else if (c
== Ctl('M'))
1575 if (c
> 0 && c
<= Ctl ('Z'))
1598 *p
++ = (7 & (c
>> 15)) + '0';
1599 *p
++ = (7 & (c
>> 12)) + '0';
1600 *p
++ = (7 & (c
>> 9)) + '0';
1601 *p
++ = (7 & (c
>> 6)) + '0';
1602 *p
++ = (7 & (c
>> 3)) + '0';
1603 *p
++ = (7 & (c
>> 0)) + '0';
1609 /* This function cannot GC. */
1611 DEFUN ("single-key-description", Fsingle_key_description
, Ssingle_key_description
, 1, 1, 0,
1612 "Return a pretty description of command character KEY.\n\
1613 Control characters turn into C-whatever, etc.")
1619 key
= EVENT_HEAD (key
);
1621 if (INTEGERP (key
)) /* Normal character */
1623 *push_key_description (XUINT (key
), tem
) = 0;
1624 return build_string (tem
);
1626 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1627 return Fsymbol_name (key
);
1628 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1629 return Fcopy_sequence (key
);
1631 error ("KEY must be an integer, cons, symbol, or string");
1635 push_text_char_description (c
, p
)
1636 register unsigned int c
;
1648 *p
++ = c
+ 64; /* 'A' - 1 */
1660 /* This function cannot GC. */
1662 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1663 "Return a pretty description of file-character CHARACTER.\n\
1664 Control characters turn into \"^char\", etc.")
1666 Lisp_Object character
;
1670 CHECK_NUMBER (character
, 0);
1672 *push_text_char_description (XINT (character
) & 0377, tem
) = 0;
1674 return build_string (tem
);
1677 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
1680 ascii_sequence_p (seq
)
1684 int len
= XINT (Flength (seq
));
1686 for (i
= 0; i
< len
; i
++)
1688 Lisp_Object ii
, elt
;
1690 XSETFASTINT (ii
, i
);
1691 elt
= Faref (seq
, ii
);
1694 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
1702 /* where-is - finding a command in a set of keymaps. */
1704 /* This function can GC if Flookup_key autoloads any keymaps. */
1706 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
1707 "Return list of keys that invoke DEFINITION.\n\
1708 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
1709 If KEYMAP is nil, search all the currently active keymaps.\n\
1711 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
1712 rather than a list of all possible key sequences.\n\
1713 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
1714 no matter what it is.\n\
1715 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
1716 and entirely reject menu bindings.\n\
1718 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
1719 to other keymaps or slots. This makes it possible to search for an\n\
1720 indirect definition itself.")
1721 (definition
, keymap
, firstonly
, noindirect
)
1722 Lisp_Object definition
, keymap
;
1723 Lisp_Object firstonly
, noindirect
;
1726 Lisp_Object found
, sequence
;
1727 int keymap_specified
= !NILP (keymap
);
1728 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
1729 /* 1 means ignore all menu bindings entirely. */
1730 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
1732 if (! keymap_specified
)
1734 #ifdef USE_TEXT_PROPERTIES
1735 keymap
= get_local_map (PT
, current_buffer
);
1737 keymap
= current_buffer
->keymap
;
1742 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap
), Qnil
),
1743 Faccessible_keymaps (get_keymap (current_global_map
),
1746 maps
= Faccessible_keymaps (get_keymap (current_global_map
), Qnil
);
1748 /* Put the minor mode keymaps on the front. */
1749 if (! keymap_specified
)
1752 minors
= Fnreverse (Fcurrent_minor_mode_maps ());
1753 while (!NILP (minors
))
1755 maps
= nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors
)->car
),
1758 minors
= XCONS (minors
)->cdr
;
1762 GCPRO5 (definition
, keymap
, maps
, found
, sequence
);
1766 for (; !NILP (maps
); maps
= Fcdr (maps
))
1768 /* Key sequence to reach map, and the map that it reaches */
1769 register Lisp_Object
this, map
;
1771 /* If Fcar (map) is a VECTOR, the current element within that vector. */
1774 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
1775 [M-CHAR] sequences, check if last character of the sequence
1776 is the meta-prefix char. */
1780 this = Fcar (Fcar (maps
));
1781 map
= Fcdr (Fcar (maps
));
1782 last
= make_number (XINT (Flength (this)) - 1);
1783 last_is_meta
= (XINT (last
) >= 0
1784 && EQ (Faref (this, last
), meta_prefix_char
));
1790 /* Because the code we want to run on each binding is rather
1791 large, we don't want to have two separate loop bodies for
1792 sparse keymap bindings and tables; we want to iterate one
1793 loop body over both keymap and vector bindings.
1795 For this reason, if Fcar (map) is a vector, we don't
1796 advance map to the next element until i indicates that we
1797 have finished off the vector. */
1799 Lisp_Object elt
, key
, binding
;
1800 elt
= XCONS (map
)->car
;
1804 /* Set key and binding to the current key and binding, and
1805 advance map and i to the next binding. */
1808 /* In a vector, look at each element. */
1809 binding
= XVECTOR (elt
)->contents
[i
];
1810 XSETFASTINT (key
, i
);
1813 /* If we've just finished scanning a vector, advance map
1814 to the next element, and reset i in anticipation of the
1815 next vector we may find. */
1816 if (i
>= XVECTOR (elt
)->size
)
1818 map
= XCONS (map
)->cdr
;
1822 else if (CONSP (elt
))
1824 key
= Fcar (Fcar (map
));
1825 binding
= Fcdr (Fcar (map
));
1827 map
= XCONS (map
)->cdr
;
1830 /* We want to ignore keymap elements that are neither
1831 vectors nor conses. */
1833 map
= XCONS (map
)->cdr
;
1837 /* Search through indirections unless that's not wanted. */
1838 if (NILP (noindirect
))
1844 Lisp_Object map
, tem
;
1845 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
1846 map
= get_keymap_1 (Fcar_safe (definition
), 0, 0);
1847 tem
= Fkeymapp (map
);
1849 definition
= access_keymap (map
, Fcdr (definition
), 0, 0);
1853 /* If the contents are (STRING ...), reject. */
1854 if (CONSP (definition
)
1855 && STRINGP (XCONS (definition
)->car
))
1859 binding
= get_keyelt (binding
, 0);
1862 /* End this iteration if this element does not match
1865 if (CONSP (definition
))
1868 tem
= Fequal (binding
, definition
);
1873 if (!EQ (binding
, definition
))
1876 /* We have found a match.
1877 Construct the key sequence where we found it. */
1878 if (INTEGERP (key
) && last_is_meta
)
1880 sequence
= Fcopy_sequence (this);
1881 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
1884 sequence
= append_key (this, key
);
1886 /* Verify that this key binding is not shadowed by another
1887 binding for the same key, before we say it exists.
1889 Mechanism: look for local definition of this key and if
1890 it is defined and does not match what we found then
1893 Either nil or number as value from Flookup_key
1895 if (keymap_specified
)
1897 binding
= Flookup_key (keymap
, sequence
, Qnil
);
1898 if (!NILP (binding
) && !INTEGERP (binding
))
1900 if (CONSP (definition
))
1903 tem
= Fequal (binding
, definition
);
1908 if (!EQ (binding
, definition
))
1914 binding
= Fkey_binding (sequence
, Qnil
);
1915 if (!EQ (binding
, definition
))
1919 /* It is a true unshadowed match. Record it, unless it's already
1920 been seen (as could happen when inheriting keymaps). */
1921 if (NILP (Fmember (sequence
, found
)))
1922 found
= Fcons (sequence
, found
);
1924 /* If firstonly is Qnon_ascii, then we can return the first
1925 binding we find. If firstonly is not Qnon_ascii but not
1926 nil, then we should return the first ascii-only binding
1928 if (EQ (firstonly
, Qnon_ascii
))
1929 RETURN_UNGCPRO (sequence
);
1930 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
1931 RETURN_UNGCPRO (sequence
);
1937 found
= Fnreverse (found
);
1939 /* firstonly may have been t, but we may have gone all the way through
1940 the keymaps without finding an all-ASCII key sequence. So just
1941 return the best we could find. */
1942 if (! NILP (firstonly
))
1943 return Fcar (found
);
1948 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
1950 DEFUN ("describe-bindings", Fdescribe_bindings
, Sdescribe_bindings
, 0, 1, "",
1951 "Show a list of all defined keys, and their definitions.\n\
1952 The list is put in a buffer, which is displayed.\n\
1953 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1954 then we display only bindings that start with that prefix.")
1958 register Lisp_Object thisbuf
;
1959 XSETBUFFER (thisbuf
, current_buffer
);
1960 internal_with_output_to_temp_buffer ("*Help*",
1961 describe_buffer_bindings
,
1962 Fcons (thisbuf
, prefix
));
1966 /* ARG is (BUFFER . PREFIX). */
1969 describe_buffer_bindings (arg
)
1972 Lisp_Object descbuf
, prefix
, shadow
;
1973 register Lisp_Object start1
;
1974 struct gcpro gcpro1
;
1976 char *alternate_heading
1978 Alternate Characters (use anywhere the nominal character is listed):\n\
1979 nominal alternate\n\
1980 ------- ---------\n";
1982 descbuf
= XCONS (arg
)->car
;
1983 prefix
= XCONS (arg
)->cdr
;
1987 Fset_buffer (Vstandard_output
);
1989 /* Report on alternates for keys. */
1990 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
1993 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
1994 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
1996 for (c
= 0; c
< translate_len
; c
++)
1997 if (translate
[c
] != c
)
2002 if (alternate_heading
)
2004 insert_string (alternate_heading
);
2005 alternate_heading
= 0;
2008 bufend
= push_key_description (translate
[c
], buf
);
2009 insert (buf
, bufend
- buf
);
2010 Findent_to (make_number (16), make_number (1));
2011 bufend
= push_key_description (c
, buf
);
2012 insert (buf
, bufend
- buf
);
2020 if (!NILP (Vkey_translation_map
))
2021 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2022 "Key translations", 0, 1, 0);
2026 Lisp_Object
*modes
, *maps
;
2028 /* Temporarily switch to descbuf, so that we can get that buffer's
2029 minor modes correctly. */
2030 Fset_buffer (descbuf
);
2032 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2033 || !NILP (Voverriding_local_map
))
2036 nmaps
= current_minor_maps (&modes
, &maps
);
2037 Fset_buffer (Vstandard_output
);
2039 /* Print the minor mode maps. */
2040 for (i
= 0; i
< nmaps
; i
++)
2042 /* The title for a minor mode keymap
2043 is constructed at run time.
2044 We let describe_map_tree do the actual insertion
2045 because it takes care of other features when doing so. */
2048 if (!SYMBOLP (modes
[i
]))
2051 p
= title
= (char *) alloca (40 + XSYMBOL (modes
[i
])->name
->size
);
2053 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2054 XSYMBOL (modes
[i
])->name
->size
);
2055 p
+= XSYMBOL (modes
[i
])->name
->size
;
2057 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2058 p
+= sizeof (" Minor Mode Bindings") - 1;
2061 describe_map_tree (maps
[i
], 0, shadow
, prefix
, title
, 0, 0, 0);
2062 shadow
= Fcons (maps
[i
], shadow
);
2066 /* Print the (major mode) local map. */
2067 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2068 start1
= current_kboard
->Voverriding_terminal_local_map
;
2069 else if (!NILP (Voverriding_local_map
))
2070 start1
= Voverriding_local_map
;
2072 start1
= XBUFFER (descbuf
)->keymap
;
2076 describe_map_tree (start1
, 0, shadow
, prefix
,
2077 "Major Mode Bindings", 0, 0, 0);
2078 shadow
= Fcons (start1
, shadow
);
2081 describe_map_tree (current_global_map
, 0, shadow
, prefix
,
2082 "Global Bindings", 0, 0, 1);
2084 /* Print the function-key-map translations under this prefix. */
2085 if (!NILP (Vfunction_key_map
))
2086 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2087 "Function key map translations", 0, 1, 0);
2089 call0 (intern ("help-mode"));
2090 Fset_buffer (descbuf
);
2095 /* Insert a description of the key bindings in STARTMAP,
2096 followed by those of all maps reachable through STARTMAP.
2097 If PARTIAL is nonzero, omit certain "uninteresting" commands
2098 (such as `undefined').
2099 If SHADOW is non-nil, it is a list of maps;
2100 don't mention keys which would be shadowed by any of them.
2101 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2102 TITLE, if not 0, is a string to insert at the beginning.
2103 TITLE should not end with a colon or a newline; we supply that.
2104 If NOMENU is not 0, then omit menu-bar commands.
2106 If TRANSL is nonzero, the definitions are actually key translations
2107 so print strings and vectors differently.
2109 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2113 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2115 Lisp_Object startmap
, shadow
, prefix
;
2122 Lisp_Object maps
, seen
, sub_shadows
;
2123 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2130 maps
= Faccessible_keymaps (startmap
, prefix
);
2133 GCPRO3 (maps
, seen
, sub_shadows
);
2139 /* Delete from MAPS each element that is for the menu bar. */
2140 for (list
= maps
; !NILP (list
); list
= XCONS (list
)->cdr
)
2142 Lisp_Object elt
, prefix
, tem
;
2145 prefix
= Fcar (elt
);
2146 if (XVECTOR (prefix
)->size
>= 1)
2148 tem
= Faref (prefix
, make_number (0));
2149 if (EQ (tem
, Qmenu_bar
))
2150 maps
= Fdelq (elt
, maps
);
2155 if (!NILP (maps
) || always_title
)
2159 insert_string (title
);
2162 insert_string (" Starting With ");
2163 insert1 (Fkey_description (prefix
));
2165 insert_string (":\n");
2167 insert_string (key_heading
);
2171 for (; !NILP (maps
); maps
= Fcdr (maps
))
2173 register Lisp_Object elt
, prefix
, tail
;
2176 prefix
= Fcar (elt
);
2180 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2184 shmap
= XCONS (tail
)->car
;
2186 /* If the sequence by which we reach this keymap is zero-length,
2187 then the shadow map for this keymap is just SHADOW. */
2188 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2189 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2191 /* If the sequence by which we reach this keymap actually has
2192 some elements, then the sequence's definition in SHADOW is
2193 what we should use. */
2196 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2197 if (INTEGERP (shmap
))
2201 /* If shmap is not nil and not a keymap,
2202 it completely shadows this map, so don't
2203 describe this map at all. */
2204 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2208 sub_shadows
= Fcons (shmap
, sub_shadows
);
2211 describe_map (Fcdr (elt
), Fcar (elt
),
2212 transl
? describe_translation
: describe_command
,
2213 partial
, sub_shadows
, &seen
, nomenu
);
2219 insert_string ("\n");
2224 static int previous_description_column
;
2227 describe_command (definition
)
2228 Lisp_Object definition
;
2230 register Lisp_Object tem1
;
2231 int column
= current_column ();
2232 int description_column
;
2234 /* If column 16 is no good, go to col 32;
2235 but don't push beyond that--go to next line instead. */
2239 description_column
= 32;
2241 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2242 description_column
= 32;
2244 description_column
= 16;
2246 Findent_to (make_number (description_column
), make_number (1));
2247 previous_description_column
= description_column
;
2249 if (SYMBOLP (definition
))
2251 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2253 insert_string ("\n");
2255 else if (STRINGP (definition
) || VECTORP (definition
))
2256 insert_string ("Keyboard Macro\n");
2259 tem1
= Fkeymapp (definition
);
2261 insert_string ("Prefix Command\n");
2263 insert_string ("??\n");
2268 describe_translation (definition
)
2269 Lisp_Object definition
;
2271 register Lisp_Object tem1
;
2273 Findent_to (make_number (16), make_number (1));
2275 if (SYMBOLP (definition
))
2277 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2279 insert_string ("\n");
2281 else if (STRINGP (definition
) || VECTORP (definition
))
2283 insert1 (Fkey_description (definition
));
2284 insert_string ("\n");
2288 tem1
= Fkeymapp (definition
);
2290 insert_string ("Prefix Command\n");
2292 insert_string ("??\n");
2296 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2297 Returns the first non-nil binding found in any of those maps. */
2300 shadow_lookup (shadow
, key
, flag
)
2301 Lisp_Object shadow
, key
, flag
;
2303 Lisp_Object tail
, value
;
2305 for (tail
= shadow
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2307 value
= Flookup_key (XCONS (tail
)->car
, key
, flag
);
2314 /* Describe the contents of map MAP, assuming that this map itself is
2315 reached by the sequence of prefix keys KEYS (a string or vector).
2316 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2319 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2320 register Lisp_Object map
;
2322 int (*elt_describer
) ();
2328 Lisp_Object elt_prefix
;
2329 Lisp_Object tail
, definition
, event
;
2331 Lisp_Object suppress
;
2334 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2336 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2338 /* Call Fkey_description first, to avoid GC bug for the other string. */
2339 tem
= Fkey_description (keys
);
2340 elt_prefix
= concat2 (tem
, build_string (" "));
2346 suppress
= intern ("suppress-keymap");
2348 /* This vector gets used to present single keys to Flookup_key. Since
2349 that is done once per keymap element, we don't want to cons up a
2350 fresh vector every time. */
2351 kludge
= Fmake_vector (make_number (1), Qnil
);
2354 GCPRO3 (elt_prefix
, definition
, kludge
);
2356 for (tail
= map
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2360 if (VECTORP (XCONS (tail
)->car
))
2361 describe_vector (XCONS (tail
)->car
,
2362 elt_prefix
, elt_describer
, partial
, shadow
, map
);
2363 else if (CONSP (XCONS (tail
)->car
))
2365 event
= XCONS (XCONS (tail
)->car
)->car
;
2367 /* Ignore bindings whose "keys" are not really valid events.
2368 (We get these in the frames and buffers menu.) */
2369 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2372 if (nomenu
&& EQ (event
, Qmenu_bar
))
2375 definition
= get_keyelt (XCONS (XCONS (tail
)->car
)->cdr
, 0);
2377 /* Don't show undefined commands or suppressed commands. */
2378 if (NILP (definition
)) continue;
2379 if (SYMBOLP (definition
) && partial
)
2381 tem
= Fget (definition
, suppress
);
2386 /* Don't show a command that isn't really visible
2387 because a local definition of the same key shadows it. */
2389 XVECTOR (kludge
)->contents
[0] = event
;
2392 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2393 if (!NILP (tem
)) continue;
2396 tem
= Flookup_key (map
, kludge
, Qt
);
2397 if (! EQ (tem
, definition
)) continue;
2401 previous_description_column
= 0;
2406 if (!NILP (elt_prefix
))
2407 insert1 (elt_prefix
);
2409 /* THIS gets the string to describe the character EVENT. */
2410 insert1 (Fsingle_key_description (event
));
2412 /* Print a description of the definition of this character.
2413 elt_describer will take care of spacing out far enough
2414 for alignment purposes. */
2415 (*elt_describer
) (definition
);
2417 else if (EQ (XCONS (tail
)->car
, Qkeymap
))
2419 /* The same keymap might be in the structure twice, if we're
2420 using an inherited keymap. So skip anything we've already
2422 tem
= Fassq (tail
, *seen
);
2423 if (CONSP (tem
) && !NILP (Fequal (XCONS (tem
)->car
, keys
)))
2425 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2433 describe_vector_princ (elt
)
2436 Findent_to (make_number (16), make_number (1));
2441 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2442 "Insert a description of contents of VECTOR.\n\
2443 This is text showing the elements of vector matched against indices.")
2447 int count
= specpdl_ptr
- specpdl
;
2449 specbind (Qstandard_output
, Fcurrent_buffer ());
2450 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2451 describe_vector (vector
, Qnil
, describe_vector_princ
, 0, Qnil
, Qnil
);
2453 return unbind_to (count
, Qnil
);
2456 /* Insert in the current buffer a description of the contents of VECTOR.
2457 We call ELT_DESCRIBER to insert the description of one value found
2460 ELT_PREFIX describes what "comes before" the keys or indices defined
2463 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2464 leads to this keymap.
2466 If the vector is a chartable, ELT_PREFIX is the vector
2467 of bytes that lead to the character set or portion of a character
2468 set described by this chartable.
2470 If PARTIAL is nonzero, it means do not mention suppressed commands
2471 (that assumes the vector is in a keymap).
2473 SHADOW is a list of keymaps that shadow this map.
2474 If it is non-nil, then we look up the key in those maps
2475 and we don't mention it now if it is defined by any of them.
2477 ENTIRE_MAP is the keymap in which this vector appears.
2478 If the definition in effect in the whole map does not match
2479 the one in this vector, we ignore this one. */
2481 describe_vector (vector
, elt_prefix
, elt_describer
,
2482 partial
, shadow
, entire_map
)
2483 register Lisp_Object vector
;
2484 Lisp_Object elt_prefix
;
2485 int (*elt_describer
) ();
2488 Lisp_Object entire_map
;
2492 Lisp_Object definition
;
2495 Lisp_Object suppress
;
2497 Lisp_Object chartable_kludge
;
2500 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
2503 chartable_kludge
= Qnil
;
2505 /* This vector gets used to present single keys to Flookup_key. Since
2506 that is done once per vector element, we don't want to cons up a
2507 fresh vector every time. */
2508 kludge
= Fmake_vector (make_number (1), Qnil
);
2509 GCPRO4 (elt_prefix
, definition
, kludge
, chartable_kludge
);
2512 suppress
= intern ("suppress-keymap");
2514 /* This does the right thing for char-tables as well as ordinary vectors. */
2515 size
= XFASTINT (Flength (vector
));
2517 for (i
= 0; i
< size
; i
++)
2520 definition
= get_keyelt (XVECTOR (vector
)->contents
[i
], 0);
2522 if (NILP (definition
)) continue;
2524 /* Don't mention suppressed commands. */
2525 if (SYMBOLP (definition
) && partial
)
2527 this = Fget (definition
, suppress
);
2532 /* If this binding is shadowed by some other map, ignore it. */
2537 XVECTOR (kludge
)->contents
[0] = make_number (i
);
2538 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2540 if (!NILP (tem
)) continue;
2543 /* Ignore this definition if it is shadowed by an earlier
2544 one in the same keymap. */
2545 if (!NILP (entire_map
))
2549 XVECTOR (kludge
)->contents
[0] = make_number (i
);
2550 tem
= Flookup_key (entire_map
, kludge
, Qt
);
2552 if (! EQ (tem
, definition
))
2556 /* If we find a char-table within a char-table,
2557 scan it recursively; it defines the details for
2558 a character set or a portion of a character set. */
2559 if (CHAR_TABLE_P (vector
) && CHAR_TABLE_P (definition
))
2562 = !NILP (elt_prefix
) ? XVECTOR (elt_prefix
)->size
: 0;
2563 if (NILP (chartable_kludge
))
2566 = Fmake_vector (make_number (outer_level
+ 1), Qnil
);
2567 if (outer_level
!= 0)
2568 bcopy (XVECTOR (elt_prefix
)->contents
,
2569 XVECTOR (chartable_kludge
)->contents
,
2570 outer_level
* sizeof (Lisp_Object
));
2572 XVECTOR (chartable_kludge
)->contents
[outer_level
]
2574 describe_vector (definition
, chartable_kludge
, elt_describer
,
2575 partial
, shadow
, entire_map
);
2585 if (CHAR_TABLE_P (vector
))
2587 if (!NILP (elt_prefix
))
2589 /* Must combine elt_prefix with i to produce a character
2590 code, then insert that character's description. */
2594 /* Get the string to describe the character I, and print it. */
2595 XSETFASTINT (dummy
, i
);
2597 /* THIS gets the string to describe the character DUMMY. */
2598 this = Fsingle_key_description (dummy
);
2604 /* Output the prefix that applies to every entry in this map. */
2605 if (!NILP (elt_prefix
))
2606 insert1 (elt_prefix
);
2608 /* Get the string to describe the character I, and print it. */
2609 XSETFASTINT (dummy
, i
);
2611 /* THIS gets the string to describe the character DUMMY. */
2612 this = Fsingle_key_description (dummy
);
2616 /* Find all consecutive characters that have the same definition. */
2617 while (i
+ 1 < XVECTOR (vector
)->size
2618 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+1], 0),
2619 EQ (tem2
, definition
)))
2622 /* If we have a range of more than one character,
2623 print where the range reaches to. */
2625 if (i
!= XINT (dummy
))
2628 if (CHAR_TABLE_P (vector
))
2630 if (!NILP (elt_prefix
))
2632 /* Must combine elt_prefix with i to produce a character
2633 code, then insert that character's description. */
2637 XSETFASTINT (dummy
, i
);
2639 this = Fsingle_key_description (dummy
);
2645 if (!NILP (elt_prefix
))
2646 insert1 (elt_prefix
);
2648 XSETFASTINT (dummy
, i
);
2649 insert1 (Fsingle_key_description (dummy
));
2653 /* Print a description of the definition of this character.
2654 elt_describer will take care of spacing out far enough
2655 for alignment purposes. */
2656 (*elt_describer
) (definition
);
2662 /* Apropos - finding all symbols whose names match a regexp. */
2663 Lisp_Object apropos_predicate
;
2664 Lisp_Object apropos_accumulate
;
2667 apropos_accum (symbol
, string
)
2668 Lisp_Object symbol
, string
;
2670 register Lisp_Object tem
;
2672 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
2673 if (!NILP (tem
) && !NILP (apropos_predicate
))
2674 tem
= call1 (apropos_predicate
, symbol
);
2676 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
2679 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
2680 "Show all symbols whose names contain match for REGEXP.\n\
2681 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
2682 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
2683 Return list of symbols found.")
2685 Lisp_Object regexp
, predicate
;
2687 struct gcpro gcpro1
, gcpro2
;
2688 CHECK_STRING (regexp
, 0);
2689 apropos_predicate
= predicate
;
2690 GCPRO2 (apropos_predicate
, apropos_accumulate
);
2691 apropos_accumulate
= Qnil
;
2692 map_obarray (Vobarray
, apropos_accum
, regexp
);
2693 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
2695 return apropos_accumulate
;
2702 Qkeymap
= intern ("keymap");
2703 staticpro (&Qkeymap
);
2705 /* Initialize the keymaps standardly used.
2706 Each one is the value of a Lisp variable, and is also
2707 pointed to by a C variable */
2709 global_map
= Fcons (Qkeymap
,
2710 Fcons (Fmake_vector (make_number (0400), Qnil
), Qnil
));
2711 Fset (intern ("global-map"), global_map
);
2713 meta_map
= Fmake_keymap (Qnil
);
2714 Fset (intern ("esc-map"), meta_map
);
2715 Ffset (intern ("ESC-prefix"), meta_map
);
2717 control_x_map
= Fmake_keymap (Qnil
);
2718 Fset (intern ("ctl-x-map"), control_x_map
);
2719 Ffset (intern ("Control-X-prefix"), control_x_map
);
2721 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
2722 "List of commands given new key bindings recently.\n\
2723 This is used for internal purposes during Emacs startup;\n\
2724 don't alter it yourself.");
2725 Vdefine_key_rebound_commands
= Qt
;
2727 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
2728 "Default keymap to use when reading from the minibuffer.");
2729 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
2731 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
2732 "Local keymap for the minibuffer when spaces are not allowed.");
2733 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
2735 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
2736 "Local keymap for minibuffer input with completion.");
2737 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
2739 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
2740 "Local keymap for minibuffer input with completion, for exact match.");
2741 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
2743 current_global_map
= global_map
;
2745 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
2746 "Alist of keymaps to use for minor modes.\n\
2747 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
2748 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
2749 If two active keymaps bind the same key, the keymap appearing earlier\n\
2750 in the list takes precedence.");
2751 Vminor_mode_map_alist
= Qnil
;
2753 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
2754 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
2755 This allows Emacs to recognize function keys sent from ASCII\n\
2756 terminals at any point in a key sequence.\n\
2758 The `read-key-sequence' function replaces any subsequence bound by\n\
2759 `function-key-map' with its binding. More precisely, when the active\n\
2760 keymaps have no binding for the current key sequence but\n\
2761 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
2762 `read-key-sequence' replaces the matching suffix with its binding, and\n\
2763 continues with the new sequence.\n\
2765 The events that come from bindings in `function-key-map' are not\n\
2766 themselves looked up in `function-key-map'.\n\
2768 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
2769 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
2770 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
2771 key, typing `ESC O P x' would return [f1 x].");
2772 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
2774 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
2775 "Keymap of key translations that can override keymaps.\n\
2776 This keymap works like `function-key-map', but comes after that,\n\
2777 and applies even for keys that have ordinary bindings.");
2778 Vkey_translation_map
= Qnil
;
2780 Qsingle_key_description
= intern ("single-key-description");
2781 staticpro (&Qsingle_key_description
);
2783 Qkey_description
= intern ("key-description");
2784 staticpro (&Qkey_description
);
2786 Qkeymapp
= intern ("keymapp");
2787 staticpro (&Qkeymapp
);
2789 Qnon_ascii
= intern ("non-ascii");
2790 staticpro (&Qnon_ascii
);
2792 defsubr (&Skeymapp
);
2793 defsubr (&Skeymap_parent
);
2794 defsubr (&Sset_keymap_parent
);
2795 defsubr (&Smake_keymap
);
2796 defsubr (&Smake_sparse_keymap
);
2797 defsubr (&Scopy_keymap
);
2798 defsubr (&Skey_binding
);
2799 defsubr (&Slocal_key_binding
);
2800 defsubr (&Sglobal_key_binding
);
2801 defsubr (&Sminor_mode_key_binding
);
2802 defsubr (&Sdefine_key
);
2803 defsubr (&Slookup_key
);
2804 defsubr (&Sdefine_prefix_command
);
2805 defsubr (&Suse_global_map
);
2806 defsubr (&Suse_local_map
);
2807 defsubr (&Scurrent_local_map
);
2808 defsubr (&Scurrent_global_map
);
2809 defsubr (&Scurrent_minor_mode_maps
);
2810 defsubr (&Saccessible_keymaps
);
2811 defsubr (&Skey_description
);
2812 defsubr (&Sdescribe_vector
);
2813 defsubr (&Ssingle_key_description
);
2814 defsubr (&Stext_char_description
);
2815 defsubr (&Swhere_is_internal
);
2816 defsubr (&Sdescribe_bindings
);
2817 defsubr (&Sapropos_internal
);
2824 initial_define_key (global_map
, 033, "ESC-prefix");
2825 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");