1 /* Manipulation of keymaps
2 Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "termhooks.h"
31 #include "blockinput.h"
33 #include "intervals.h"
35 #define min(a, b) ((a) < (b) ? (a) : (b))
36 #define KEYMAPP(m) (!NILP (Fkeymapp (m)))
38 /* The number of elements in keymap vectors. */
39 #define DENSE_TABLE_SIZE (0200)
41 /* Actually allocate storage for these variables */
43 Lisp_Object current_global_map
; /* Current global keymap */
45 Lisp_Object global_map
; /* default global key bindings */
47 Lisp_Object meta_map
; /* The keymap used for globally bound
48 ESC-prefixed default commands */
50 Lisp_Object control_x_map
; /* The keymap used for globally bound
51 C-x-prefixed default commands */
53 /* was MinibufLocalMap */
54 Lisp_Object Vminibuffer_local_map
;
55 /* The keymap used by the minibuf for local
56 bindings when spaces are allowed in the
59 /* was MinibufLocalNSMap */
60 Lisp_Object Vminibuffer_local_ns_map
;
61 /* The keymap used by the minibuf for local
62 bindings when spaces are not encouraged
65 /* keymap used for minibuffers when doing completion */
66 /* was MinibufLocalCompletionMap */
67 Lisp_Object Vminibuffer_local_completion_map
;
69 /* keymap used for minibuffers when doing completion and require a match */
70 /* was MinibufLocalMustMatchMap */
71 Lisp_Object Vminibuffer_local_must_match_map
;
73 /* Alist of minor mode variables and keymaps. */
74 Lisp_Object Vminor_mode_map_alist
;
76 /* Alist of major-mode-specific overrides for
77 minor mode variables and keymaps. */
78 Lisp_Object Vminor_mode_overriding_map_alist
;
80 /* Keymap mapping ASCII function key sequences onto their preferred forms.
81 Initialized by the terminal-specific lisp files. See DEFVAR for more
83 Lisp_Object Vfunction_key_map
;
85 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
86 Lisp_Object Vkey_translation_map
;
88 /* A list of all commands given new bindings since a certain time
89 when nil was stored here.
90 This is used to speed up recomputation of menu key equivalents
91 when Emacs starts up. t means don't record anything here. */
92 Lisp_Object Vdefine_key_rebound_commands
;
94 Lisp_Object Qkeymapp
, Qkeymap
, Qnon_ascii
, Qmenu_item
;
96 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
97 in a string key sequence is equivalent to prefixing with this
99 extern Lisp_Object meta_prefix_char
;
101 extern Lisp_Object Voverriding_local_map
;
103 static Lisp_Object store_in_keymap
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
104 static void fix_submap_inheritance
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
106 static Lisp_Object define_as_prefix
P_ ((Lisp_Object
, Lisp_Object
));
107 static Lisp_Object describe_buffer_bindings
P_ ((Lisp_Object
));
108 static void describe_command
P_ ((Lisp_Object
));
109 static void describe_translation
P_ ((Lisp_Object
));
110 static void describe_map
P_ ((Lisp_Object
, Lisp_Object
,
111 void (*) P_ ((Lisp_Object
)),
112 int, Lisp_Object
, Lisp_Object
*, int));
114 /* Keymap object support - constructors and predicates. */
116 DEFUN ("make-keymap", Fmake_keymap
, Smake_keymap
, 0, 1, 0,
117 "Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).\n\
118 CHARTABLE is a char-table that holds the bindings for the ASCII\n\
119 characters. ALIST is an assoc-list which holds bindings for function keys,\n\
120 mouse events, and any other things that appear in the input stream.\n\
121 All entries in it are initially nil, meaning \"command undefined\".\n\n\
122 The optional arg STRING supplies a menu name for the keymap\n\
123 in case you use it as a menu with `x-popup-menu'.")
129 tail
= Fcons (string
, Qnil
);
132 return Fcons (Qkeymap
,
133 Fcons (Fmake_char_table (Qkeymap
, Qnil
), tail
));
136 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap
, Smake_sparse_keymap
, 0, 1, 0,
137 "Construct and return a new sparse-keymap list.\n\
138 Its car is `keymap' and its cdr is an alist of (CHAR . DEFINITION),\n\
139 which binds the character CHAR to DEFINITION, or (SYMBOL . DEFINITION),\n\
140 which binds the function key or mouse event SYMBOL to DEFINITION.\n\
141 Initially the alist is nil.\n\n\
142 The optional arg STRING supplies a menu name for the keymap\n\
143 in case you use it as a menu with `x-popup-menu'.")
148 return Fcons (Qkeymap
, Fcons (string
, Qnil
));
149 return Fcons (Qkeymap
, Qnil
);
152 /* This function is used for installing the standard key bindings
153 at initialization time.
157 initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
160 initial_define_key (keymap
, key
, defname
)
165 store_in_keymap (keymap
, make_number (key
), intern (defname
));
169 initial_define_lispy_key (keymap
, keyname
, defname
)
174 store_in_keymap (keymap
, intern (keyname
), intern (defname
));
177 /* Define character fromchar in map frommap as an alias for character
178 tochar in map tomap. Subsequent redefinitions of the latter WILL
179 affect the former. */
183 synkey (frommap
, fromchar
, tomap
, tochar
)
184 struct Lisp_Vector
*frommap
, *tomap
;
185 int fromchar
, tochar
;
188 XSETVECTOR (v
, tomap
);
189 XSETFASTINT (c
, tochar
);
190 frommap
->contents
[fromchar
] = Fcons (v
, c
);
194 DEFUN ("keymapp", Fkeymapp
, Skeymapp
, 1, 1, 0,
195 "Return t if OBJECT is a keymap.\n\
197 A keymap is a list (keymap . ALIST),\n\
198 or a symbol whose function definition is itself a keymap.\n\
199 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
200 a vector of densely packed bindings for small character codes\n\
201 is also allowed as an element.")
205 /* FIXME: Maybe this should return t for autoloaded keymaps? -sm */
206 return (NILP (get_keymap_1 (object
, 0, 0)) ? Qnil
: Qt
);
209 /* Check that OBJECT is a keymap (after dereferencing through any
210 symbols). If it is, return it.
212 If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
213 is an autoload form, do the autoload and try again.
214 If AUTOLOAD is nonzero, callers must assume GC is possible.
216 ERROR controls how we respond if OBJECT isn't a keymap.
217 If ERROR is non-zero, signal an error; otherwise, just return Qnil.
219 Note that most of the time, we don't want to pursue autoloads.
220 Functions like Faccessible_keymaps which scan entire keymap trees
221 shouldn't load every autoloaded keymap. I'm not sure about this,
222 but it seems to me that only read_key_sequence, Flookup_key, and
223 Fdefine_key should cause keymaps to be autoloaded.
225 This function can GC when AUTOLOAD is non-zero, because it calls
226 do_autoload which can GC. */
229 get_keymap_1 (object
, error
, autoload
)
238 if (CONSP (object
) && EQ (XCAR (object
), Qkeymap
))
242 tem
= indirect_function (object
);
243 if (CONSP (tem
) && EQ (XCAR (tem
), Qkeymap
))
247 /* Should we do an autoload? Autoload forms for keymaps have
248 Qkeymap as their fifth element. */
252 && EQ (XCAR (tem
), Qautoload
))
256 tail
= Fnth (make_number (4), tem
);
257 if (EQ (tail
, Qkeymap
))
259 struct gcpro gcpro1
, gcpro2
;
261 GCPRO2 (tem
, object
);
262 do_autoload (tem
, object
);
271 wrong_type_argument (Qkeymapp
, object
);
276 /* Follow any symbol chaining, and return the keymap denoted by OBJECT.
277 If OBJECT doesn't denote a keymap at all, signal an error. */
282 return get_keymap_1 (object
, 1, 0);
285 /* Return the parent map of the keymap MAP, or nil if it has none.
286 We assume that MAP is a valid keymap. */
288 DEFUN ("keymap-parent", Fkeymap_parent
, Skeymap_parent
, 1, 1, 0,
289 "Return the parent keymap of KEYMAP.")
295 keymap
= get_keymap_1 (keymap
, 1, 1);
297 /* Skip past the initial element `keymap'. */
298 list
= XCDR (keymap
);
299 for (; CONSP (list
); list
= XCDR (list
))
301 /* See if there is another `keymap'. */
306 return get_keymap_1(list
, 0, 1);
310 /* Check whether MAP is one of MAPS parents. */
312 keymap_memberp (map
, maps
)
313 Lisp_Object map
, maps
;
315 if (NILP (map
)) return 0;
316 while (KEYMAPP (maps
) && !EQ (map
, maps
))
317 maps
= Fkeymap_parent (maps
);
318 return (EQ (map
, maps
));
321 /* Set the parent keymap of MAP to PARENT. */
323 DEFUN ("set-keymap-parent", Fset_keymap_parent
, Sset_keymap_parent
, 2, 2, 0,
324 "Modify KEYMAP to set its parent map to PARENT.\n\
325 PARENT should be nil or another keymap.")
327 Lisp_Object keymap
, parent
;
329 Lisp_Object list
, prev
;
333 keymap
= get_keymap_1 (keymap
, 1, 1);
338 parent
= get_keymap_1 (parent
, 1, 1);
340 /* Check for cycles. */
341 if (keymap_memberp (keymap
, parent
))
342 error ("Cyclic keymap inheritance");
345 /* Skip past the initial element `keymap'. */
350 /* If there is a parent keymap here, replace it.
351 If we came to the end, add the parent in PREV. */
352 if (! CONSP (list
) || KEYMAPP (list
))
354 /* If we already have the right parent, return now
355 so that we avoid the loops below. */
356 if (EQ (XCDR (prev
), parent
))
357 RETURN_UNGCPRO (parent
);
359 XCDR (prev
) = parent
;
365 /* Scan through for submaps, and set their parents too. */
367 for (list
= XCDR (keymap
); CONSP (list
); list
= XCDR (list
))
369 /* Stop the scan when we come to the parent. */
370 if (EQ (XCAR (list
), Qkeymap
))
373 /* If this element holds a prefix map, deal with it. */
374 if (CONSP (XCAR (list
))
375 && CONSP (XCDR (XCAR (list
))))
376 fix_submap_inheritance (keymap
, XCAR (XCAR (list
)),
379 if (VECTORP (XCAR (list
)))
380 for (i
= 0; i
< XVECTOR (XCAR (list
))->size
; i
++)
381 if (CONSP (XVECTOR (XCAR (list
))->contents
[i
]))
382 fix_submap_inheritance (keymap
, make_number (i
),
383 XVECTOR (XCAR (list
))->contents
[i
]);
385 if (CHAR_TABLE_P (XCAR (list
)))
387 Lisp_Object indices
[3];
389 map_char_table (fix_submap_inheritance
, Qnil
, XCAR (list
),
394 RETURN_UNGCPRO (parent
);
397 /* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
398 if EVENT is also a prefix in MAP's parent,
399 make sure that SUBMAP inherits that definition as its own parent. */
402 fix_submap_inheritance (map
, event
, submap
)
403 Lisp_Object map
, event
, submap
;
405 Lisp_Object map_parent
, parent_entry
;
407 /* SUBMAP is a cons that we found as a key binding.
408 Discard the other things found in a menu key binding. */
410 submap
= get_keymap_1 (get_keyelt (submap
, 0), 0, 0);
412 /* If it isn't a keymap now, there's no work to do. */
416 map_parent
= Fkeymap_parent (map
);
417 if (! NILP (map_parent
))
418 parent_entry
= access_keymap (map_parent
, event
, 0, 0, 0);
422 /* If MAP's parent has something other than a keymap,
423 our own submap shadows it completely. */
424 if (! KEYMAPP (parent_entry
))
427 if (! EQ (parent_entry
, submap
))
429 Lisp_Object submap_parent
;
430 submap_parent
= submap
;
435 tem
= Fkeymap_parent (submap_parent
);
439 if (keymap_memberp (tem
, parent_entry
))
440 /* Fset_keymap_parent could create a cycle. */
447 Fset_keymap_parent (submap_parent
, parent_entry
);
451 /* Look up IDX in MAP. IDX may be any sort of event.
452 Note that this does only one level of lookup; IDX must be a single
453 event, not a sequence.
455 If T_OK is non-zero, bindings for Qt are treated as default
456 bindings; any key left unmentioned by other tables and bindings is
457 given the binding of Qt.
459 If T_OK is zero, bindings for Qt are not treated specially.
461 If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
464 access_keymap (map
, idx
, t_ok
, noinherit
, autoload
)
474 /* If idx is a list (some sort of mouse click, perhaps?),
475 the index we want to use is the car of the list, which
476 ought to be a symbol. */
477 idx
= EVENT_HEAD (idx
);
479 /* If idx is a symbol, it might have modifiers, which need to
480 be put in the canonical order. */
482 idx
= reorder_modifiers (idx
);
483 else if (INTEGERP (idx
))
484 /* Clobber the high bits that can be present on a machine
485 with more than 24 bits of integer. */
486 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
488 /* Handle the special meta -> esc mapping. */
489 if (INTEGERP (idx
) && XUINT (idx
) & meta_modifier
)
491 /* See if there is a meta-map. If there's none, there is
492 no binding for IDX, unless a default binding exists in MAP. */
493 Lisp_Object meta_map
=
494 get_keymap_1 (access_keymap (map
, meta_prefix_char
,
495 t_ok
, noinherit
, autoload
),
497 if (!NILP (meta_map
))
500 idx
= make_number (XUINT (idx
) & ~meta_modifier
);
503 /* Set IDX to t, so that we only find a default binding. */
506 /* We know there is no binding. */
512 Lisp_Object t_binding
;
515 for (tail
= XCDR (map
);
517 || (tail
= get_keymap_1 (tail
, 0, autoload
),
523 binding
= XCAR (tail
);
524 if (SYMBOLP (binding
))
526 /* If NOINHERIT, stop finding prefix definitions
527 after we pass a second occurrence of the `keymap' symbol. */
528 if (noinherit
&& EQ (binding
, Qkeymap
))
531 else if (CONSP (binding
))
533 if (EQ (XCAR (binding
), idx
))
535 val
= XCDR (binding
);
536 if (noprefix
&& KEYMAPP (val
))
539 fix_submap_inheritance (map
, idx
, val
);
540 return get_keyelt (val
, autoload
);
542 if (t_ok
&& EQ (XCAR (binding
), Qt
))
543 t_binding
= XCDR (binding
);
545 else if (VECTORP (binding
))
547 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (binding
)->size
)
549 val
= XVECTOR (binding
)->contents
[XFASTINT (idx
)];
550 if (noprefix
&& KEYMAPP (val
))
553 fix_submap_inheritance (map
, idx
, val
);
554 return get_keyelt (val
, autoload
);
557 else if (CHAR_TABLE_P (binding
))
559 /* Character codes with modifiers
560 are not included in a char-table.
561 All character codes without modifiers are included. */
564 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
565 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
567 val
= Faref (binding
, idx
);
568 if (noprefix
&& KEYMAPP (val
))
571 fix_submap_inheritance (map
, idx
, val
);
572 return get_keyelt (val
, autoload
);
579 return get_keyelt (t_binding
, autoload
);
583 /* Given OBJECT which was found in a slot in a keymap,
584 trace indirect definitions to get the actual definition of that slot.
585 An indirect definition is a list of the form
586 (KEYMAP . INDEX), where KEYMAP is a keymap or a symbol defined as one
587 and INDEX is the object to look up in KEYMAP to yield the definition.
589 Also if OBJECT has a menu string as the first element,
590 remove that. Also remove a menu help string as second element.
592 If AUTOLOAD is nonzero, load autoloadable keymaps
593 that are referred to with indirection. */
596 get_keyelt (object
, autoload
)
597 register Lisp_Object object
;
602 if (!(CONSP (object
)))
603 /* This is really the value. */
606 /* If the keymap contents looks like (keymap ...) or (lambda ...)
608 else if (EQ (XCAR (object
), Qkeymap
) || EQ (XCAR (object
), Qlambda
))
611 /* If the keymap contents looks like (menu-item name . DEFN)
612 or (menu-item name DEFN ...) then use DEFN.
613 This is a new format menu item. */
614 else if (EQ (XCAR (object
), Qmenu_item
))
616 if (CONSP (XCDR (object
)))
620 object
= XCDR (XCDR (object
));
623 object
= XCAR (object
);
625 /* If there's a `:filter FILTER', apply FILTER to the
626 menu-item's definition to get the real definition to
627 use. Temporarily inhibit GC while evaluating FILTER,
628 because not functions calling get_keyelt are prepared
630 for (; CONSP (tem
) && CONSP (XCDR (tem
)); tem
= XCDR (tem
))
631 if (EQ (XCAR (tem
), QCfilter
))
633 int count
= inhibit_garbage_collection ();
635 filter
= XCAR (XCDR (tem
));
636 filter
= list2 (filter
, list2 (Qquote
, object
));
637 object
= menu_item_eval_property (filter
);
638 unbind_to (count
, Qnil
);
647 /* If the keymap contents looks like (STRING . DEFN), use DEFN.
648 Keymap alist elements like (CHAR MENUSTRING . DEFN)
649 will be used by HierarKey menus. */
650 else if (STRINGP (XCAR (object
)))
652 object
= XCDR (object
);
653 /* Also remove a menu help string, if any,
654 following the menu item name. */
655 if (CONSP (object
) && STRINGP (XCAR (object
)))
656 object
= XCDR (object
);
657 /* Also remove the sublist that caches key equivalences, if any. */
658 if (CONSP (object
) && CONSP (XCAR (object
)))
661 carcar
= XCAR (XCAR (object
));
662 if (NILP (carcar
) || VECTORP (carcar
))
663 object
= XCDR (object
);
667 /* If the contents are (KEYMAP . ELEMENT), go indirect. */
671 map
= get_keymap_1 (Fcar_safe (object
), 0, autoload
);
672 return (NILP (map
) ? object
/* Invalid keymap */
673 : access_keymap (map
, Fcdr (object
), 0, 0, autoload
));
679 store_in_keymap (keymap
, idx
, def
)
681 register Lisp_Object idx
;
682 register Lisp_Object def
;
684 /* If we are preparing to dump, and DEF is a menu element
685 with a menu item indicator, copy it to ensure it is not pure. */
686 if (CONSP (def
) && PURE_P (def
)
687 && (EQ (XCAR (def
), Qmenu_item
) || STRINGP (XCAR (def
))))
688 def
= Fcons (XCAR (def
), XCDR (def
));
690 if (!CONSP (keymap
) || ! EQ (XCAR (keymap
), Qkeymap
))
691 error ("attempt to define a key in a non-keymap");
693 /* If idx is a list (some sort of mouse click, perhaps?),
694 the index we want to use is the car of the list, which
695 ought to be a symbol. */
696 idx
= EVENT_HEAD (idx
);
698 /* If idx is a symbol, it might have modifiers, which need to
699 be put in the canonical order. */
701 idx
= reorder_modifiers (idx
);
702 else if (INTEGERP (idx
))
703 /* Clobber the high bits that can be present on a machine
704 with more than 24 bits of integer. */
705 XSETFASTINT (idx
, XINT (idx
) & (CHAR_META
| (CHAR_META
- 1)));
707 /* Scan the keymap for a binding of idx. */
711 /* The cons after which we should insert new bindings. If the
712 keymap has a table element, we record its position here, so new
713 bindings will go after it; this way, the table will stay
714 towards the front of the alist and character lookups in dense
715 keymaps will remain fast. Otherwise, this just points at the
716 front of the keymap. */
717 Lisp_Object insertion_point
;
719 insertion_point
= keymap
;
720 for (tail
= XCDR (keymap
); CONSP (tail
); tail
= XCDR (tail
))
727 if (NATNUMP (idx
) && XFASTINT (idx
) < XVECTOR (elt
)->size
)
729 XVECTOR (elt
)->contents
[XFASTINT (idx
)] = def
;
732 insertion_point
= tail
;
734 else if (CHAR_TABLE_P (elt
))
736 /* Character codes with modifiers
737 are not included in a char-table.
738 All character codes without modifiers are included. */
741 & (CHAR_ALT
| CHAR_SUPER
| CHAR_HYPER
742 | CHAR_SHIFT
| CHAR_CTL
| CHAR_META
)))
744 Faset (elt
, idx
, def
);
747 insertion_point
= tail
;
749 else if (CONSP (elt
))
751 if (EQ (idx
, XCAR (elt
)))
757 else if (SYMBOLP (elt
))
759 /* If we find a 'keymap' symbol in the spine of KEYMAP,
760 then we must have found the start of a second keymap
761 being used as the tail of KEYMAP, and a binding for IDX
762 should be inserted before it. */
763 if (EQ (elt
, Qkeymap
))
771 /* We have scanned the entire keymap, and not found a binding for
772 IDX. Let's add one. */
773 XCDR (insertion_point
)
774 = Fcons (Fcons (idx
, def
), XCDR (insertion_point
));
781 copy_keymap_1 (chartable
, idx
, elt
)
782 Lisp_Object chartable
, idx
, elt
;
784 if (!SYMBOLP (elt
) && ! NILP (Fkeymapp (elt
)))
785 Faset (chartable
, idx
, Fcopy_keymap (elt
));
788 DEFUN ("copy-keymap", Fcopy_keymap
, Scopy_keymap
, 1, 1, 0,
789 "Return a copy of the keymap KEYMAP.\n\
790 The copy starts out with the same definitions of KEYMAP,\n\
791 but changing either the copy or KEYMAP does not affect the other.\n\
792 Any key definitions that are subkeymaps are recursively copied.\n\
793 However, a key definition which is a symbol whose definition is a keymap\n\
798 register Lisp_Object copy
, tail
;
800 copy
= Fcopy_alist (get_keymap (keymap
));
802 for (tail
= copy
; CONSP (tail
); tail
= XCDR (tail
))
807 if (CHAR_TABLE_P (elt
))
809 Lisp_Object indices
[3];
811 elt
= Fcopy_sequence (elt
);
814 map_char_table (copy_keymap_1
, Qnil
, elt
, elt
, 0, indices
);
816 else if (VECTORP (elt
))
820 elt
= Fcopy_sequence (elt
);
823 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
824 if (!SYMBOLP (XVECTOR (elt
)->contents
[i
])
825 && ! NILP (Fkeymapp (XVECTOR (elt
)->contents
[i
])))
826 XVECTOR (elt
)->contents
[i
]
827 = Fcopy_keymap (XVECTOR (elt
)->contents
[i
]);
829 else if (CONSP (elt
) && CONSP (XCDR (elt
)))
834 /* Is this a new format menu item. */
835 if (EQ (XCAR (tem
),Qmenu_item
))
837 /* Copy cell with menu-item marker. */
839 = Fcons (XCAR (tem
), XCDR (tem
));
844 /* Copy cell with menu-item name. */
846 = Fcons (XCAR (tem
), XCDR (tem
));
852 /* Copy cell with binding and if the binding is a keymap,
855 = Fcons (XCAR (tem
), XCDR (tem
));
858 if (!(SYMBOLP (tem
) || NILP (Fkeymapp (tem
))))
859 XCAR (elt
) = Fcopy_keymap (tem
);
861 if (CONSP (tem
) && CONSP (XCAR (tem
)))
862 /* Delete cache for key equivalences. */
863 XCDR (elt
) = XCDR (tem
);
868 /* It may be an old fomat menu item.
869 Skip the optional menu string.
871 if (STRINGP (XCAR (tem
)))
873 /* Copy the cell, since copy-alist didn't go this deep. */
875 = Fcons (XCAR (tem
), XCDR (tem
));
878 /* Also skip the optional menu help string. */
879 if (CONSP (tem
) && STRINGP (XCAR (tem
)))
882 = Fcons (XCAR (tem
), XCDR (tem
));
886 /* There may also be a list that caches key equivalences.
887 Just delete it for the new keymap. */
889 && CONSP (XCAR (tem
))
890 && (NILP (XCAR (XCAR (tem
)))
891 || VECTORP (XCAR (XCAR (tem
)))))
892 XCDR (elt
) = XCDR (tem
);
895 && ! SYMBOLP (XCDR (elt
))
896 && ! NILP (Fkeymapp (XCDR (elt
))))
897 XCDR (elt
) = Fcopy_keymap (XCDR (elt
));
906 /* Simple Keymap mutators and accessors. */
908 /* GC is possible in this function if it autoloads a keymap. */
910 DEFUN ("define-key", Fdefine_key
, Sdefine_key
, 3, 3, 0,
911 "Args KEYMAP, KEY, DEF. Define key sequence KEY, in KEYMAP, as DEF.\n\
912 KEYMAP is a keymap. KEY is a string or a vector of symbols and characters\n\
913 meaning a sequence of keystrokes and events.\n\
914 Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
915 can be included if you use a vector.\n\
916 DEF is anything that can be a key's definition:\n\
917 nil (means key is undefined in this keymap),\n\
918 a command (a Lisp function suitable for interactive calling)\n\
919 a string (treated as a keyboard macro),\n\
920 a keymap (to define a prefix key),\n\
921 a symbol. When the key is looked up, the symbol will stand for its\n\
922 function definition, which should at that time be one of the above,\n\
923 or another symbol whose function definition is used, etc.\n\
924 a cons (STRING . DEFN), meaning that DEFN is the definition\n\
925 (DEFN should be a valid definition in its own right),\n\
926 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.\n\
928 If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
929 the front of KEYMAP.")
936 register Lisp_Object c
;
937 register Lisp_Object cmd
;
941 struct gcpro gcpro1
, gcpro2
, gcpro3
;
943 keymap
= get_keymap_1 (keymap
, 1, 1);
945 if (!VECTORP (key
) && !STRINGP (key
))
946 key
= wrong_type_argument (Qarrayp
, key
);
948 length
= XFASTINT (Flength (key
));
952 if (SYMBOLP (def
) && !EQ (Vdefine_key_rebound_commands
, Qt
))
953 Vdefine_key_rebound_commands
= Fcons (def
, Vdefine_key_rebound_commands
);
955 GCPRO3 (keymap
, key
, def
);
958 meta_bit
= meta_modifier
;
965 c
= Faref (key
, make_number (idx
));
967 if (CONSP (c
) && lucid_event_type_list_p (c
))
968 c
= Fevent_convert_list (c
);
971 && (XINT (c
) & meta_bit
)
974 c
= meta_prefix_char
;
980 XSETINT (c
, XINT (c
) & ~meta_bit
);
986 if (! INTEGERP (c
) && ! SYMBOLP (c
) && ! CONSP (c
))
987 error ("Key sequence contains invalid events");
990 RETURN_UNGCPRO (store_in_keymap (keymap
, c
, def
));
992 cmd
= access_keymap (keymap
, c
, 0, 1, 1);
994 /* If this key is undefined, make it a prefix. */
996 cmd
= define_as_prefix (keymap
, c
);
998 keymap
= get_keymap_1 (cmd
, 0, 1);
1000 /* We must use Fkey_description rather than just passing key to
1001 error; key might be a vector, not a string. */
1002 error ("Key sequence %s uses invalid prefix characters",
1003 XSTRING (Fkey_description (key
))->data
);
1007 /* Value is number if KEY is too long; NIL if valid but has no definition. */
1008 /* GC is possible in this function if it autoloads a keymap. */
1010 DEFUN ("lookup-key", Flookup_key
, Slookup_key
, 2, 3, 0,
1011 "In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
1012 nil means undefined. See doc of `define-key' for kinds of definitions.\n\
1014 A number as value means KEY is \"too long\";\n\
1015 that is, characters or symbols in it except for the last one\n\
1016 fail to be a valid sequence of prefix characters in KEYMAP.\n\
1017 The number is how many characters at the front of KEY\n\
1018 it takes to reach a non-prefix command.\n\
1020 Normally, `lookup-key' ignores bindings for t, which act as default\n\
1021 bindings, used when nothing else in the keymap applies; this makes it\n\
1022 usable as a general function for probing keymaps. However, if the\n\
1023 third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
1024 recognize the default bindings, just as `read-key-sequence' does.")
1025 (keymap
, key
, accept_default
)
1026 register Lisp_Object keymap
;
1028 Lisp_Object accept_default
;
1031 register Lisp_Object cmd
;
1032 register Lisp_Object c
;
1034 int t_ok
= ! NILP (accept_default
);
1035 struct gcpro gcpro1
;
1037 keymap
= get_keymap_1 (keymap
, 1, 1);
1039 if (!VECTORP (key
) && !STRINGP (key
))
1040 key
= wrong_type_argument (Qarrayp
, key
);
1042 length
= XFASTINT (Flength (key
));
1051 c
= Faref (key
, make_number (idx
++));
1053 if (CONSP (c
) && lucid_event_type_list_p (c
))
1054 c
= Fevent_convert_list (c
);
1056 /* Turn the 8th bit of string chars into a meta modifier. */
1057 if (XINT (c
) & 0x80 && STRINGP (key
))
1058 XSETINT (c
, (XINT (c
) | meta_modifier
) & ~0x80);
1060 cmd
= access_keymap (keymap
, c
, t_ok
, 0, 1);
1062 RETURN_UNGCPRO (cmd
);
1064 keymap
= get_keymap_1 (cmd
, 0, 1);
1066 RETURN_UNGCPRO (make_number (idx
));
1072 /* Make KEYMAP define event C as a keymap (i.e., as a prefix).
1073 Assume that currently it does not define C at all.
1074 Return the keymap. */
1077 define_as_prefix (keymap
, c
)
1078 Lisp_Object keymap
, c
;
1082 cmd
= Fmake_sparse_keymap (Qnil
);
1083 /* If this key is defined as a prefix in an inherited keymap,
1084 make it a prefix in this map, and make its definition
1085 inherit the other prefix definition. */
1086 cmd
= nconc2 (cmd
, access_keymap (keymap
, c
, 0, 0, 0));
1087 store_in_keymap (keymap
, c
, cmd
);
1092 /* Append a key to the end of a key sequence. We always make a vector. */
1095 append_key (key_sequence
, key
)
1096 Lisp_Object key_sequence
, key
;
1098 Lisp_Object args
[2];
1100 args
[0] = key_sequence
;
1102 args
[1] = Fcons (key
, Qnil
);
1103 return Fvconcat (2, args
);
1107 /* Global, local, and minor mode keymap stuff. */
1109 /* We can't put these variables inside current_minor_maps, since under
1110 some systems, static gets macro-defined to be the empty string.
1112 static Lisp_Object
*cmm_modes
, *cmm_maps
;
1113 static int cmm_size
;
1115 /* Error handler used in current_minor_maps. */
1117 current_minor_maps_error ()
1122 /* Store a pointer to an array of the keymaps of the currently active
1123 minor modes in *buf, and return the number of maps it contains.
1125 This function always returns a pointer to the same buffer, and may
1126 free or reallocate it, so if you want to keep it for a long time or
1127 hand it out to lisp code, copy it. This procedure will be called
1128 for every key sequence read, so the nice lispy approach (return a
1129 new assoclist, list, what have you) for each invocation would
1130 result in a lot of consing over time.
1132 If we used xrealloc/xmalloc and ran out of memory, they would throw
1133 back to the command loop, which would try to read a key sequence,
1134 which would call this function again, resulting in an infinite
1135 loop. Instead, we'll use realloc/malloc and silently truncate the
1136 list, let the key sequence be read, and hope some other piece of
1137 code signals the error. */
1139 current_minor_maps (modeptr
, mapptr
)
1140 Lisp_Object
**modeptr
, **mapptr
;
1143 int list_number
= 0;
1144 Lisp_Object alist
, assoc
, var
, val
;
1145 Lisp_Object lists
[2];
1147 lists
[0] = Vminor_mode_overriding_map_alist
;
1148 lists
[1] = Vminor_mode_map_alist
;
1150 for (list_number
= 0; list_number
< 2; list_number
++)
1151 for (alist
= lists
[list_number
];
1153 alist
= XCDR (alist
))
1154 if ((assoc
= XCAR (alist
), CONSP (assoc
))
1155 && (var
= XCAR (assoc
), SYMBOLP (var
))
1156 && (val
= find_symbol_value (var
), ! EQ (val
, Qunbound
))
1161 /* If a variable has an entry in Vminor_mode_overriding_map_alist,
1162 and also an entry in Vminor_mode_map_alist,
1163 ignore the latter. */
1164 if (list_number
== 1)
1166 val
= assq_no_quit (var
, lists
[0]);
1173 Lisp_Object
*newmodes
, *newmaps
;
1180 = (Lisp_Object
*) realloc (cmm_modes
,
1181 cmm_size
* sizeof (Lisp_Object
));
1183 = (Lisp_Object
*) realloc (cmm_maps
,
1184 cmm_size
* sizeof (Lisp_Object
));
1192 = (Lisp_Object
*) xmalloc (cmm_size
* sizeof (Lisp_Object
));
1194 = (Lisp_Object
*) xmalloc (cmm_size
* sizeof (Lisp_Object
));
1198 if (newmaps
&& newmodes
)
1200 cmm_modes
= newmodes
;
1207 /* Get the keymap definition--or nil if it is not defined. */
1208 temp
= internal_condition_case_1 (Findirect_function
,
1210 Qerror
, current_minor_maps_error
);
1214 cmm_maps
[i
] = temp
;
1219 if (modeptr
) *modeptr
= cmm_modes
;
1220 if (mapptr
) *mapptr
= cmm_maps
;
1224 /* GC is possible in this function if it autoloads a keymap. */
1226 DEFUN ("key-binding", Fkey_binding
, Skey_binding
, 1, 2, 0,
1227 "Return the binding for command KEY in current keymaps.\n\
1228 KEY is a string or vector, a sequence of keystrokes.\n\
1229 The binding is probably a symbol with a function definition.\n\
1231 Normally, `key-binding' ignores bindings for t, which act as default\n\
1232 bindings, used when nothing else in the keymap applies; this makes it\n\
1233 usable as a general function for probing keymaps. However, if the\n\
1234 optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\
1235 recognize the default bindings, just as `read-key-sequence' does.")
1236 (key
, accept_default
)
1237 Lisp_Object key
, accept_default
;
1239 Lisp_Object
*maps
, value
;
1241 struct gcpro gcpro1
;
1245 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
1247 value
= Flookup_key (current_kboard
->Voverriding_terminal_local_map
,
1248 key
, accept_default
);
1249 if (! NILP (value
) && !INTEGERP (value
))
1250 RETURN_UNGCPRO (value
);
1252 else if (!NILP (Voverriding_local_map
))
1254 value
= Flookup_key (Voverriding_local_map
, key
, accept_default
);
1255 if (! NILP (value
) && !INTEGERP (value
))
1256 RETURN_UNGCPRO (value
);
1262 nmaps
= current_minor_maps (0, &maps
);
1263 /* Note that all these maps are GCPRO'd
1264 in the places where we found them. */
1266 for (i
= 0; i
< nmaps
; i
++)
1267 if (! NILP (maps
[i
]))
1269 value
= Flookup_key (maps
[i
], key
, accept_default
);
1270 if (! NILP (value
) && !INTEGERP (value
))
1271 RETURN_UNGCPRO (value
);
1274 local
= get_local_map (PT
, current_buffer
, keymap
);
1277 value
= Flookup_key (local
, key
, accept_default
);
1278 if (! NILP (value
) && !INTEGERP (value
))
1279 RETURN_UNGCPRO (value
);
1282 local
= get_local_map (PT
, current_buffer
, local_map
);
1286 value
= Flookup_key (local
, key
, accept_default
);
1287 if (! NILP (value
) && !INTEGERP (value
))
1288 RETURN_UNGCPRO (value
);
1292 value
= Flookup_key (current_global_map
, key
, accept_default
);
1294 if (! NILP (value
) && !INTEGERP (value
))
1300 /* GC is possible in this function if it autoloads a keymap. */
1302 DEFUN ("local-key-binding", Flocal_key_binding
, Slocal_key_binding
, 1, 2, 0,
1303 "Return the binding for command KEYS in current local keymap only.\n\
1304 KEYS is a string, a sequence of keystrokes.\n\
1305 The binding is probably a symbol with a function definition.\n\
1307 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1308 bindings; see the description of `lookup-key' for more details about this.")
1309 (keys
, accept_default
)
1310 Lisp_Object keys
, accept_default
;
1312 register Lisp_Object map
;
1313 map
= current_buffer
->keymap
;
1316 return Flookup_key (map
, keys
, accept_default
);
1319 /* GC is possible in this function if it autoloads a keymap. */
1321 DEFUN ("global-key-binding", Fglobal_key_binding
, Sglobal_key_binding
, 1, 2, 0,
1322 "Return the binding for command KEYS in current global keymap only.\n\
1323 KEYS is a string, a sequence of keystrokes.\n\
1324 The binding is probably a symbol with a function definition.\n\
1325 This function's return values are the same as those of lookup-key\n\
1328 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1329 bindings; see the description of `lookup-key' for more details about this.")
1330 (keys
, accept_default
)
1331 Lisp_Object keys
, accept_default
;
1333 return Flookup_key (current_global_map
, keys
, accept_default
);
1336 /* GC is possible in this function if it autoloads a keymap. */
1338 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding
, Sminor_mode_key_binding
, 1, 2, 0,
1339 "Find the visible minor mode bindings of KEY.\n\
1340 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
1341 the symbol which names the minor mode binding KEY, and BINDING is\n\
1342 KEY's definition in that mode. In particular, if KEY has no\n\
1343 minor-mode bindings, return nil. If the first binding is a\n\
1344 non-prefix, all subsequent bindings will be omitted, since they would\n\
1345 be ignored. Similarly, the list doesn't include non-prefix bindings\n\
1346 that come after prefix bindings.\n\
1348 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
1349 bindings; see the description of `lookup-key' for more details about this.")
1350 (key
, accept_default
)
1351 Lisp_Object key
, accept_default
;
1353 Lisp_Object
*modes
, *maps
;
1355 Lisp_Object binding
;
1357 struct gcpro gcpro1
, gcpro2
;
1359 nmaps
= current_minor_maps (&modes
, &maps
);
1360 /* Note that all these maps are GCPRO'd
1361 in the places where we found them. */
1364 GCPRO2 (key
, binding
);
1366 for (i
= j
= 0; i
< nmaps
; i
++)
1367 if (! NILP (maps
[i
])
1368 && ! NILP (binding
= Flookup_key (maps
[i
], key
, accept_default
))
1369 && !INTEGERP (binding
))
1371 if (! NILP (get_keymap (binding
)))
1372 maps
[j
++] = Fcons (modes
[i
], binding
);
1374 RETURN_UNGCPRO (Fcons (Fcons (modes
[i
], binding
), Qnil
));
1378 return Flist (j
, maps
);
1381 DEFUN ("define-prefix-command", Fdefine_prefix_command
, Sdefine_prefix_command
, 1, 3, 0,
1382 "Define COMMAND as a prefix command. COMMAND should be a symbol.\n\
1383 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
1384 If a second optional argument MAPVAR is given, the map is stored as\n\
1385 its value instead of as COMMAND's value; but COMMAND is still defined\n\
1387 The third optional argument NAME, if given, supplies a menu name\n\
1388 string for the map. This is required to use the keymap as a menu.")
1389 (command
, mapvar
, name
)
1390 Lisp_Object command
, mapvar
, name
;
1393 map
= Fmake_sparse_keymap (name
);
1394 Ffset (command
, map
);
1398 Fset (command
, map
);
1402 DEFUN ("use-global-map", Fuse_global_map
, Suse_global_map
, 1, 1, 0,
1403 "Select KEYMAP as the global keymap.")
1407 keymap
= get_keymap (keymap
);
1408 current_global_map
= keymap
;
1413 DEFUN ("use-local-map", Fuse_local_map
, Suse_local_map
, 1, 1, 0,
1414 "Select KEYMAP as the local keymap.\n\
1415 If KEYMAP is nil, that means no local keymap.")
1420 keymap
= get_keymap (keymap
);
1422 current_buffer
->keymap
= keymap
;
1427 DEFUN ("current-local-map", Fcurrent_local_map
, Scurrent_local_map
, 0, 0, 0,
1428 "Return current buffer's local keymap, or nil if it has none.")
1431 return current_buffer
->keymap
;
1434 DEFUN ("current-global-map", Fcurrent_global_map
, Scurrent_global_map
, 0, 0, 0,
1435 "Return the current global keymap.")
1438 return current_global_map
;
1441 DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps
, Scurrent_minor_mode_maps
, 0, 0, 0,
1442 "Return a list of keymaps for the minor modes of the current buffer.")
1446 int nmaps
= current_minor_maps (0, &maps
);
1448 return Flist (nmaps
, maps
);
1451 /* Help functions for describing and documenting keymaps. */
1453 static void accessible_keymaps_char_table ();
1455 /* This function cannot GC. */
1457 DEFUN ("accessible-keymaps", Faccessible_keymaps
, Saccessible_keymaps
,
1459 "Find all keymaps accessible via prefix characters from KEYMAP.\n\
1460 Returns a list of elements of the form (KEYS . MAP), where the sequence\n\
1461 KEYS starting from KEYMAP gets you to MAP. These elements are ordered\n\
1462 so that the KEYS increase in length. The first element is ([] . KEYMAP).\n\
1463 An optional argument PREFIX, if non-nil, should be a key sequence;\n\
1464 then the value includes only maps for prefixes that start with PREFIX.")
1466 Lisp_Object keymap
, prefix
;
1468 Lisp_Object maps
, good_maps
, tail
;
1471 /* no need for gcpro because we don't autoload any keymaps. */
1474 prefixlen
= XINT (Flength (prefix
));
1478 /* If a prefix was specified, start with the keymap (if any) for
1479 that prefix, so we don't waste time considering other prefixes. */
1481 tem
= Flookup_key (keymap
, prefix
, Qt
);
1482 /* Flookup_key may give us nil, or a number,
1483 if the prefix is not defined in this particular map.
1484 It might even give us a list that isn't a keymap. */
1485 tem
= get_keymap_1 (tem
, 0, 0);
1488 /* Convert PREFIX to a vector now, so that later on
1489 we don't have to deal with the possibility of a string. */
1490 if (STRINGP (prefix
))
1495 copy
= Fmake_vector (make_number (XSTRING (prefix
)->size
), Qnil
);
1496 for (i
= 0, i_byte
= 0; i
< XSTRING (prefix
)->size
;)
1500 FETCH_STRING_CHAR_ADVANCE (c
, prefix
, i
, i_byte
);
1501 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1502 c
^= 0200 | meta_modifier
;
1503 XVECTOR (copy
)->contents
[i_before
] = make_number (c
);
1507 maps
= Fcons (Fcons (prefix
, tem
), Qnil
);
1513 maps
= Fcons (Fcons (Fmake_vector (make_number (0), Qnil
),
1514 get_keymap (keymap
)),
1517 /* For each map in the list maps,
1518 look at any other maps it points to,
1519 and stick them at the end if they are not already in the list.
1521 This is a breadth-first traversal, where tail is the queue of
1522 nodes, and maps accumulates a list of all nodes visited. */
1524 for (tail
= maps
; CONSP (tail
); tail
= XCDR (tail
))
1526 register Lisp_Object thisseq
, thismap
;
1528 /* Does the current sequence end in the meta-prefix-char? */
1531 thisseq
= Fcar (Fcar (tail
));
1532 thismap
= Fcdr (Fcar (tail
));
1533 last
= make_number (XINT (Flength (thisseq
)) - 1);
1534 is_metized
= (XINT (last
) >= 0
1535 /* Don't metize the last char of PREFIX. */
1536 && XINT (last
) >= prefixlen
1537 && EQ (Faref (thisseq
, last
), meta_prefix_char
));
1539 for (; CONSP (thismap
); thismap
= XCDR (thismap
))
1543 elt
= XCAR (thismap
);
1547 if (CHAR_TABLE_P (elt
))
1549 Lisp_Object indices
[3];
1551 map_char_table (accessible_keymaps_char_table
, Qnil
,
1552 elt
, Fcons (maps
, Fcons (tail
, thisseq
)),
1555 else if (VECTORP (elt
))
1559 /* Vector keymap. Scan all the elements. */
1560 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
1562 register Lisp_Object tem
;
1563 register Lisp_Object cmd
;
1565 cmd
= get_keyelt (XVECTOR (elt
)->contents
[i
], 0);
1566 if (NILP (cmd
)) continue;
1567 tem
= Fkeymapp (cmd
);
1570 cmd
= get_keymap (cmd
);
1571 /* Ignore keymaps that are already added to maps. */
1572 tem
= Frassq (cmd
, maps
);
1575 /* If the last key in thisseq is meta-prefix-char,
1576 turn it into a meta-ized keystroke. We know
1577 that the event we're about to append is an
1578 ascii keystroke since we're processing a
1582 int meta_bit
= meta_modifier
;
1583 tem
= Fcopy_sequence (thisseq
);
1585 Faset (tem
, last
, make_number (i
| meta_bit
));
1587 /* This new sequence is the same length as
1588 thisseq, so stick it in the list right
1591 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1595 tem
= append_key (thisseq
, make_number (i
));
1596 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1602 else if (CONSP (elt
))
1604 register Lisp_Object cmd
, tem
;
1606 cmd
= get_keyelt (XCDR (elt
), 0);
1607 /* Ignore definitions that aren't keymaps themselves. */
1608 tem
= Fkeymapp (cmd
);
1611 /* Ignore keymaps that have been seen already. */
1612 cmd
= get_keymap (cmd
);
1613 tem
= Frassq (cmd
, maps
);
1616 /* Let elt be the event defined by this map entry. */
1619 /* If the last key in thisseq is meta-prefix-char, and
1620 this entry is a binding for an ascii keystroke,
1621 turn it into a meta-ized keystroke. */
1622 if (is_metized
&& INTEGERP (elt
))
1624 Lisp_Object element
;
1627 tem
= Fvconcat (1, &element
);
1628 XSETFASTINT (XVECTOR (tem
)->contents
[XINT (last
)],
1629 XINT (elt
) | meta_modifier
);
1631 /* This new sequence is the same length as
1632 thisseq, so stick it in the list right
1635 = Fcons (Fcons (tem
, cmd
), XCDR (tail
));
1639 Fcons (Fcons (append_key (thisseq
, elt
), cmd
),
1650 /* Now find just the maps whose access prefixes start with PREFIX. */
1653 for (; CONSP (maps
); maps
= XCDR (maps
))
1655 Lisp_Object elt
, thisseq
;
1657 thisseq
= XCAR (elt
);
1658 /* The access prefix must be at least as long as PREFIX,
1659 and the first elements must match those of PREFIX. */
1660 if (XINT (Flength (thisseq
)) >= prefixlen
)
1663 for (i
= 0; i
< prefixlen
; i
++)
1666 XSETFASTINT (i1
, i
);
1667 if (!EQ (Faref (thisseq
, i1
), Faref (prefix
, i1
)))
1671 good_maps
= Fcons (elt
, good_maps
);
1675 return Fnreverse (good_maps
);
1679 accessible_keymaps_char_table (args
, index
, cmd
)
1680 Lisp_Object args
, index
, cmd
;
1683 Lisp_Object maps
, tail
, thisseq
;
1689 tail
= XCAR (XCDR (args
));
1690 thisseq
= XCDR (XCDR (args
));
1692 tem
= Fkeymapp (cmd
);
1695 cmd
= get_keymap (cmd
);
1696 /* Ignore keymaps that are already added to maps. */
1697 tem
= Frassq (cmd
, maps
);
1700 tem
= append_key (thisseq
, index
);
1701 nconc2 (tail
, Fcons (Fcons (tem
, cmd
), Qnil
));
1706 Lisp_Object Qsingle_key_description
, Qkey_description
;
1708 /* This function cannot GC. */
1710 DEFUN ("key-description", Fkey_description
, Skey_description
, 1, 1, 0,
1711 "Return a pretty description of key-sequence KEYS.\n\
1712 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
1713 spaces are put between sequence elements, etc.")
1720 Lisp_Object
*args
= NULL
;
1725 vector
= Fmake_vector (Flength (keys
), Qnil
);
1726 for (i
= 0, i_byte
= 0; i
< XSTRING (keys
)->size
; )
1731 FETCH_STRING_CHAR_ADVANCE (c
, keys
, i
, i_byte
);
1732 if (SINGLE_BYTE_CHAR_P (c
) && (c
& 0200))
1733 c
^= 0200 | meta_modifier
;
1734 XSETFASTINT (XVECTOR (vector
)->contents
[i_before
], c
);
1741 /* In effect, this computes
1742 (mapconcat 'single-key-description keys " ")
1743 but we shouldn't use mapconcat because it can do GC. */
1745 len
= XVECTOR (keys
)->size
;
1746 sep
= build_string (" ");
1747 /* This has one extra element at the end that we don't pass to Fconcat. */
1748 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1750 for (i
= 0; i
< len
; i
++)
1752 args
[i
* 2] = Fsingle_key_description (XVECTOR (keys
)->contents
[i
],
1754 args
[i
* 2 + 1] = sep
;
1757 else if (CONSP (keys
))
1759 /* In effect, this computes
1760 (mapconcat 'single-key-description keys " ")
1761 but we shouldn't use mapconcat because it can do GC. */
1763 len
= XFASTINT (Flength (keys
));
1764 sep
= build_string (" ");
1765 /* This has one extra element at the end that we don't pass to Fconcat. */
1766 args
= (Lisp_Object
*) alloca (len
* 2 * sizeof (Lisp_Object
));
1768 for (i
= 0; i
< len
; i
++)
1770 args
[i
* 2] = Fsingle_key_description (XCAR (keys
), Qnil
);
1771 args
[i
* 2 + 1] = sep
;
1776 keys
= wrong_type_argument (Qarrayp
, keys
);
1778 return Fconcat (len
* 2 - 1, args
);
1782 push_key_description (c
, p
)
1783 register unsigned int c
;
1788 /* Clear all the meaningless bits above the meta bit. */
1789 c
&= meta_modifier
| ~ - meta_modifier
;
1790 c2
= c
& ~(alt_modifier
| ctrl_modifier
| hyper_modifier
1791 | meta_modifier
| shift_modifier
| super_modifier
);
1793 if (c
& alt_modifier
)
1799 if ((c
& ctrl_modifier
) != 0
1800 || (c2
< ' ' && c2
!= 27 && c2
!= '\t' && c2
!= Ctl ('M')))
1804 c
&= ~ctrl_modifier
;
1806 if (c
& hyper_modifier
)
1810 c
-= hyper_modifier
;
1812 if (c
& meta_modifier
)
1818 if (c
& shift_modifier
)
1822 c
-= shift_modifier
;
1824 if (c
& super_modifier
)
1828 c
-= super_modifier
;
1844 else if (c
== Ctl ('M'))
1852 /* `C-' already added above. */
1853 if (c
> 0 && c
<= Ctl ('Z'))
1872 || (NILP (current_buffer
->enable_multibyte_characters
)
1873 && SINGLE_BYTE_CHAR_P (c
)))
1877 if (! NILP (current_buffer
->enable_multibyte_characters
))
1878 c
= unibyte_char_to_multibyte (c
);
1880 if (NILP (current_buffer
->enable_multibyte_characters
)
1881 || SINGLE_BYTE_CHAR_P (c
)
1882 || ! char_valid_p (c
, 0))
1886 /* The biggest character code uses 19 bits. */
1887 for (bit_offset
= 18; bit_offset
>= 0; bit_offset
-= 3)
1889 if (c
>= (1 << bit_offset
))
1890 *p
++ = ((c
& (7 << bit_offset
)) >> bit_offset
) + '0';
1895 p
+= CHAR_STRING (c
, p
);
1902 /* This function cannot GC. */
1904 DEFUN ("single-key-description", Fsingle_key_description
,
1905 Ssingle_key_description
, 1, 2, 0,
1906 "Return a pretty description of command character KEY.\n\
1907 Control characters turn into C-whatever, etc.\n\
1908 Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
1909 around function keys and event symbols.")
1911 Lisp_Object key
, no_angles
;
1913 if (CONSP (key
) && lucid_event_type_list_p (key
))
1914 key
= Fevent_convert_list (key
);
1916 key
= EVENT_HEAD (key
);
1918 if (INTEGERP (key
)) /* Normal character */
1920 unsigned int charset
, c1
, c2
;
1921 int without_bits
= XINT (key
) & ~((-1) << CHARACTERBITS
);
1923 if (SINGLE_BYTE_CHAR_P (without_bits
))
1926 SPLIT_CHAR (without_bits
, charset
, c1
, c2
);
1929 && CHARSET_DEFINED_P (charset
)
1930 && ((c1
>= 0 && c1
< 32)
1931 || (c2
>= 0 && c2
< 32)))
1933 /* Handle a generic character. */
1935 name
= CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
);
1936 CHECK_STRING (name
, 0);
1937 return concat2 (build_string ("Character set "), name
);
1941 char tem
[KEY_DESCRIPTION_SIZE
];
1943 *push_key_description (XUINT (key
), tem
) = 0;
1944 return build_string (tem
);
1947 else if (SYMBOLP (key
)) /* Function key or event-symbol */
1949 if (NILP (no_angles
))
1952 = (char *) alloca (STRING_BYTES (XSYMBOL (key
)->name
) + 5);
1953 sprintf (buffer
, "<%s>", XSYMBOL (key
)->name
->data
);
1954 return build_string (buffer
);
1957 return Fsymbol_name (key
);
1959 else if (STRINGP (key
)) /* Buffer names in the menubar. */
1960 return Fcopy_sequence (key
);
1962 error ("KEY must be an integer, cons, symbol, or string");
1967 push_text_char_description (c
, p
)
1968 register unsigned int c
;
1980 *p
++ = c
+ 64; /* 'A' - 1 */
1992 /* This function cannot GC. */
1994 DEFUN ("text-char-description", Ftext_char_description
, Stext_char_description
, 1, 1, 0,
1995 "Return a pretty description of file-character CHARACTER.\n\
1996 Control characters turn into \"^char\", etc.")
1998 Lisp_Object character
;
2000 /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
2001 unsigned char str
[6];
2004 CHECK_NUMBER (character
, 0);
2006 c
= XINT (character
);
2007 if (!SINGLE_BYTE_CHAR_P (c
))
2009 int len
= CHAR_STRING (c
, str
);
2011 return make_multibyte_string (str
, 1, len
);
2014 *push_text_char_description (c
& 0377, str
) = 0;
2016 return build_string (str
);
2019 /* Return non-zero if SEQ contains only ASCII characters, perhaps with
2022 ascii_sequence_p (seq
)
2026 int len
= XINT (Flength (seq
));
2028 for (i
= 0; i
< len
; i
++)
2030 Lisp_Object ii
, elt
;
2032 XSETFASTINT (ii
, i
);
2033 elt
= Faref (seq
, ii
);
2036 || (XUINT (elt
) & ~CHAR_META
) >= 0x80)
2044 /* where-is - finding a command in a set of keymaps. */
2046 static Lisp_Object
where_is_internal_1 ();
2047 static void where_is_internal_2 ();
2049 /* This function can GC if Flookup_key autoloads any keymaps. */
2055 return (CONSP (item
)
2056 && (EQ (XCAR (item
),Qmenu_item
)
2057 || STRINGP (XCAR (item
))));
2060 DEFUN ("where-is-internal", Fwhere_is_internal
, Swhere_is_internal
, 1, 4, 0,
2061 "Return list of keys that invoke DEFINITION.\n\
2062 If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
2063 If KEYMAP is nil, search all the currently active keymaps.\n\
2065 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
2066 rather than a list of all possible key sequences.\n\
2067 If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
2068 no matter what it is.\n\
2069 If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
2070 and entirely reject menu bindings.\n\
2072 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
2073 to other keymaps or slots. This makes it possible to search for an\n\
2074 indirect definition itself.")
2075 (definition
, xkeymap
, firstonly
, noindirect
)
2076 Lisp_Object definition
, xkeymap
;
2077 Lisp_Object firstonly
, noindirect
;
2080 Lisp_Object found
, sequences
;
2081 Lisp_Object keymap1
;
2082 int keymap_specified
= !NILP (xkeymap
);
2083 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
2084 /* 1 means ignore all menu bindings entirely. */
2085 int nomenus
= !NILP (firstonly
) && !EQ (firstonly
, Qnon_ascii
);
2087 /* Find keymaps accessible from `keymap' or the current
2088 context. But don't muck with the value of `keymap',
2089 because `where_is_internal_1' uses it to check for
2090 shadowed bindings. */
2092 if (! keymap_specified
)
2093 keymap1
= get_local_map (PT
, current_buffer
, keymap
);
2095 if (!NILP (keymap1
))
2096 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap1
), Qnil
),
2097 Faccessible_keymaps (get_keymap (current_global_map
),
2102 if (! keymap_specified
)
2103 keymap1
= get_local_map (PT
, current_buffer
, local_map
);
2105 if (!NILP (keymap1
))
2106 maps
= nconc2 (Faccessible_keymaps (get_keymap (keymap1
), Qnil
),
2107 Faccessible_keymaps (get_keymap (current_global_map
),
2110 maps
= Faccessible_keymaps (get_keymap (current_global_map
), Qnil
);
2113 /* Put the minor mode keymaps on the front. */
2114 if (! keymap_specified
)
2117 minors
= Fnreverse (Fcurrent_minor_mode_maps ());
2118 while (!NILP (minors
))
2120 maps
= nconc2 (Faccessible_keymaps (get_keymap (XCAR (minors
)),
2123 minors
= XCDR (minors
);
2127 GCPRO5 (definition
, xkeymap
, maps
, found
, sequences
);
2131 for (; !NILP (maps
); maps
= Fcdr (maps
))
2133 /* Key sequence to reach map, and the map that it reaches */
2134 register Lisp_Object
this, map
;
2136 /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
2137 [M-CHAR] sequences, check if last character of the sequence
2138 is the meta-prefix char. */
2142 this = Fcar (Fcar (maps
));
2143 map
= Fcdr (Fcar (maps
));
2144 last
= make_number (XINT (Flength (this)) - 1);
2145 last_is_meta
= (XINT (last
) >= 0
2146 && EQ (Faref (this, last
), meta_prefix_char
));
2148 if (nomenus
&& XINT (last
) >= 0)
2149 { /* If no menu entries should be returned, skip over the
2150 keymaps bound to `menu-bar' and `tool-bar'. */
2151 Lisp_Object tem
= Faref (this, 0);
2152 if (EQ (tem
, Qmenu_bar
) || EQ (tem
, Qtool_bar
))
2160 /* Because the code we want to run on each binding is rather
2161 large, we don't want to have two separate loop bodies for
2162 sparse keymap bindings and tables; we want to iterate one
2163 loop body over both keymap and vector bindings.
2165 For this reason, if Fcar (map) is a vector, we don't
2166 advance map to the next element until i indicates that we
2167 have finished off the vector. */
2168 Lisp_Object elt
, key
, binding
;
2176 /* Set key and binding to the current key and binding, and
2177 advance map and i to the next binding. */
2180 Lisp_Object sequence
;
2182 /* In a vector, look at each element. */
2183 for (i
= 0; i
< XVECTOR (elt
)->size
; i
++)
2185 binding
= XVECTOR (elt
)->contents
[i
];
2186 XSETFASTINT (key
, i
);
2187 sequence
= where_is_internal_1 (binding
, key
, definition
,
2188 noindirect
, xkeymap
, this,
2189 last
, nomenus
, last_is_meta
);
2190 if (!NILP (sequence
))
2191 sequences
= Fcons (sequence
, sequences
);
2194 else if (CHAR_TABLE_P (elt
))
2196 Lisp_Object indices
[3];
2199 args
= Fcons (Fcons (Fcons (definition
, noindirect
),
2200 Fcons (xkeymap
, Qnil
)),
2201 Fcons (Fcons (this, last
),
2202 Fcons (make_number (nomenus
),
2203 make_number (last_is_meta
))));
2204 map_char_table (where_is_internal_2
, Qnil
, elt
, args
,
2206 sequences
= XCDR (XCDR (XCAR (args
)));
2208 else if (CONSP (elt
))
2210 Lisp_Object sequence
;
2213 binding
= XCDR (elt
);
2215 sequence
= where_is_internal_1 (binding
, key
, definition
,
2216 noindirect
, xkeymap
, this,
2217 last
, nomenus
, last_is_meta
);
2218 if (!NILP (sequence
))
2219 sequences
= Fcons (sequence
, sequences
);
2223 for (; ! NILP (sequences
); sequences
= XCDR (sequences
))
2225 Lisp_Object sequence
;
2227 sequence
= XCAR (sequences
);
2229 /* It is a true unshadowed match. Record it, unless it's already
2230 been seen (as could happen when inheriting keymaps). */
2231 if (NILP (Fmember (sequence
, found
)))
2232 found
= Fcons (sequence
, found
);
2234 /* If firstonly is Qnon_ascii, then we can return the first
2235 binding we find. If firstonly is not Qnon_ascii but not
2236 nil, then we should return the first ascii-only binding
2238 if (EQ (firstonly
, Qnon_ascii
))
2239 RETURN_UNGCPRO (sequence
);
2240 else if (! NILP (firstonly
) && ascii_sequence_p (sequence
))
2241 RETURN_UNGCPRO (sequence
);
2248 found
= Fnreverse (found
);
2250 /* firstonly may have been t, but we may have gone all the way through
2251 the keymaps without finding an all-ASCII key sequence. So just
2252 return the best we could find. */
2253 if (! NILP (firstonly
))
2254 return Fcar (found
);
2259 /* This is the function that Fwhere_is_internal calls using map_char_table.
2261 (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
2263 ((THIS . LAST) . (NOMENUS . LAST_IS_META)))
2264 Since map_char_table doesn't really use the return value from this function,
2265 we the result append to RESULT, the slot in ARGS.
2267 This function can GC because it calls where_is_internal_1 which can
2271 where_is_internal_2 (args
, key
, binding
)
2272 Lisp_Object args
, key
, binding
;
2274 Lisp_Object definition
, noindirect
, keymap
, this, last
;
2275 Lisp_Object result
, sequence
;
2276 int nomenus
, last_is_meta
;
2277 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2279 GCPRO3 (args
, key
, binding
);
2280 result
= XCDR (XCDR (XCAR (args
)));
2281 definition
= XCAR (XCAR (XCAR (args
)));
2282 noindirect
= XCDR (XCAR (XCAR (args
)));
2283 keymap
= XCAR (XCDR (XCAR (args
)));
2284 this = XCAR (XCAR (XCDR (args
)));
2285 last
= XCDR (XCAR (XCDR (args
)));
2286 nomenus
= XFASTINT (XCAR (XCDR (XCDR (args
))));
2287 last_is_meta
= XFASTINT (XCDR (XCDR (XCDR (args
))));
2289 sequence
= where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
,
2290 this, last
, nomenus
, last_is_meta
);
2292 if (!NILP (sequence
))
2293 XCDR (XCDR (XCAR (args
))) = Fcons (sequence
, result
);
2299 /* This function can GC.because Flookup_key calls get_keymap_1 with
2300 non-zero argument AUTOLOAD. */
2303 where_is_internal_1 (binding
, key
, definition
, noindirect
, keymap
, this, last
,
2304 nomenus
, last_is_meta
)
2305 Lisp_Object binding
, key
, definition
, noindirect
, keymap
, this, last
;
2306 int nomenus
, last_is_meta
;
2308 Lisp_Object sequence
;
2309 int keymap_specified
= !NILP (keymap
);
2310 struct gcpro gcpro1
, gcpro2
;
2312 /* Skip left-over menu-items.
2313 These can appear in a keymap bound to a mouse click, for example. */
2314 if (nomenus
&& menu_item_p (binding
))
2316 /* Search through indirections unless that's not wanted. */
2317 if (NILP (noindirect
))
2318 binding
= get_keyelt (binding
, 0);
2320 /* End this iteration if this element does not match
2323 if (CONSP (definition
))
2326 tem
= Fequal (binding
, definition
);
2331 if (!EQ (binding
, definition
))
2334 /* We have found a match.
2335 Construct the key sequence where we found it. */
2336 if (INTEGERP (key
) && last_is_meta
)
2338 sequence
= Fcopy_sequence (this);
2339 Faset (sequence
, last
, make_number (XINT (key
) | meta_modifier
));
2342 sequence
= append_key (this, key
);
2344 /* Verify that this key binding is not shadowed by another
2345 binding for the same key, before we say it exists.
2347 Mechanism: look for local definition of this key and if
2348 it is defined and does not match what we found then
2351 Either nil or number as value from Flookup_key
2353 GCPRO2 (sequence
, binding
);
2354 if (keymap_specified
)
2356 binding
= Flookup_key (keymap
, sequence
, Qnil
);
2357 if (!NILP (binding
) && !INTEGERP (binding
))
2359 if (CONSP (definition
))
2362 tem
= Fequal (binding
, definition
);
2364 RETURN_UNGCPRO (Qnil
);
2367 if (!EQ (binding
, definition
))
2368 RETURN_UNGCPRO (Qnil
);
2373 binding
= Fkey_binding (sequence
, Qnil
);
2374 if (!EQ (binding
, definition
))
2375 RETURN_UNGCPRO (Qnil
);
2378 RETURN_UNGCPRO (sequence
);
2381 /* describe-bindings - summarizing all the bindings in a set of keymaps. */
2383 DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal
, Sdescribe_bindings_internal
, 0, 2, "",
2384 "Show a list of all defined keys, and their definitions.\n\
2385 We put that list in a buffer, and display the buffer.\n\
2387 The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
2388 \(Ordinarily these are omitted from the output.)\n\
2389 The optional argument PREFIX, if non-nil, should be a key sequence;\n\
2390 then we display only bindings that start with that prefix.")
2392 Lisp_Object menus
, prefix
;
2394 register Lisp_Object thisbuf
;
2395 XSETBUFFER (thisbuf
, current_buffer
);
2396 internal_with_output_to_temp_buffer ("*Help*",
2397 describe_buffer_bindings
,
2398 list3 (thisbuf
, prefix
, menus
));
2402 /* ARG is (BUFFER PREFIX MENU-FLAG). */
2405 describe_buffer_bindings (arg
)
2408 Lisp_Object descbuf
, prefix
, shadow
;
2410 register Lisp_Object start1
;
2411 struct gcpro gcpro1
;
2413 char *alternate_heading
2415 Keyboard translations:\n\n\
2416 You type Translation\n\
2417 -------- -----------\n";
2419 descbuf
= XCAR (arg
);
2421 prefix
= XCAR (arg
);
2423 nomenu
= NILP (XCAR (arg
));
2428 Fset_buffer (Vstandard_output
);
2430 /* Report on alternates for keys. */
2431 if (STRINGP (Vkeyboard_translate_table
) && !NILP (prefix
))
2434 unsigned char *translate
= XSTRING (Vkeyboard_translate_table
)->data
;
2435 int translate_len
= XSTRING (Vkeyboard_translate_table
)->size
;
2437 for (c
= 0; c
< translate_len
; c
++)
2438 if (translate
[c
] != c
)
2440 char buf
[KEY_DESCRIPTION_SIZE
];
2443 if (alternate_heading
)
2445 insert_string (alternate_heading
);
2446 alternate_heading
= 0;
2449 bufend
= push_key_description (translate
[c
], buf
);
2450 insert (buf
, bufend
- buf
);
2451 Findent_to (make_number (16), make_number (1));
2452 bufend
= push_key_description (c
, buf
);
2453 insert (buf
, bufend
- buf
);
2461 if (!NILP (Vkey_translation_map
))
2462 describe_map_tree (Vkey_translation_map
, 0, Qnil
, prefix
,
2463 "Key translations", nomenu
, 1, 0);
2467 Lisp_Object
*modes
, *maps
;
2469 /* Temporarily switch to descbuf, so that we can get that buffer's
2470 minor modes correctly. */
2471 Fset_buffer (descbuf
);
2473 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
2474 || !NILP (Voverriding_local_map
))
2477 nmaps
= current_minor_maps (&modes
, &maps
);
2478 Fset_buffer (Vstandard_output
);
2480 /* Print the minor mode maps. */
2481 for (i
= 0; i
< nmaps
; i
++)
2483 /* The title for a minor mode keymap
2484 is constructed at run time.
2485 We let describe_map_tree do the actual insertion
2486 because it takes care of other features when doing so. */
2489 if (!SYMBOLP (modes
[i
]))
2492 p
= title
= (char *) alloca (42 + XSYMBOL (modes
[i
])->name
->size
);
2496 bcopy (XSYMBOL (modes
[i
])->name
->data
, p
,
2497 XSYMBOL (modes
[i
])->name
->size
);
2498 p
+= XSYMBOL (modes
[i
])->name
->size
;
2500 bcopy (" Minor Mode Bindings", p
, sizeof (" Minor Mode Bindings") - 1);
2501 p
+= sizeof (" Minor Mode Bindings") - 1;
2504 describe_map_tree (maps
[i
], 1, shadow
, prefix
, title
, nomenu
, 0, 0);
2505 shadow
= Fcons (maps
[i
], shadow
);
2509 /* Print the (major mode) local map. */
2510 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
2511 start1
= current_kboard
->Voverriding_terminal_local_map
;
2512 else if (!NILP (Voverriding_local_map
))
2513 start1
= Voverriding_local_map
;
2515 start1
= XBUFFER (descbuf
)->keymap
;
2519 describe_map_tree (start1
, 1, shadow
, prefix
,
2520 "\f\nMajor Mode Bindings", nomenu
, 0, 0);
2521 shadow
= Fcons (start1
, shadow
);
2524 describe_map_tree (current_global_map
, 1, shadow
, prefix
,
2525 "\f\nGlobal Bindings", nomenu
, 0, 1);
2527 /* Print the function-key-map translations under this prefix. */
2528 if (!NILP (Vfunction_key_map
))
2529 describe_map_tree (Vfunction_key_map
, 0, Qnil
, prefix
,
2530 "\f\nFunction key map translations", nomenu
, 1, 0);
2532 call0 (intern ("help-mode"));
2533 Fset_buffer (descbuf
);
2538 /* Insert a description of the key bindings in STARTMAP,
2539 followed by those of all maps reachable through STARTMAP.
2540 If PARTIAL is nonzero, omit certain "uninteresting" commands
2541 (such as `undefined').
2542 If SHADOW is non-nil, it is a list of maps;
2543 don't mention keys which would be shadowed by any of them.
2544 PREFIX, if non-nil, says mention only keys that start with PREFIX.
2545 TITLE, if not 0, is a string to insert at the beginning.
2546 TITLE should not end with a colon or a newline; we supply that.
2547 If NOMENU is not 0, then omit menu-bar commands.
2549 If TRANSL is nonzero, the definitions are actually key translations
2550 so print strings and vectors differently.
2552 If ALWAYS_TITLE is nonzero, print the title even if there are no maps
2556 describe_map_tree (startmap
, partial
, shadow
, prefix
, title
, nomenu
, transl
,
2558 Lisp_Object startmap
, shadow
, prefix
;
2565 Lisp_Object maps
, orig_maps
, seen
, sub_shadows
;
2566 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2573 orig_maps
= maps
= Faccessible_keymaps (startmap
, prefix
);
2576 GCPRO3 (maps
, seen
, sub_shadows
);
2582 /* Delete from MAPS each element that is for the menu bar. */
2583 for (list
= maps
; !NILP (list
); list
= XCDR (list
))
2585 Lisp_Object elt
, prefix
, tem
;
2588 prefix
= Fcar (elt
);
2589 if (XVECTOR (prefix
)->size
>= 1)
2591 tem
= Faref (prefix
, make_number (0));
2592 if (EQ (tem
, Qmenu_bar
))
2593 maps
= Fdelq (elt
, maps
);
2598 if (!NILP (maps
) || always_title
)
2602 insert_string (title
);
2605 insert_string (" Starting With ");
2606 insert1 (Fkey_description (prefix
));
2608 insert_string (":\n");
2610 insert_string (key_heading
);
2614 for (; !NILP (maps
); maps
= Fcdr (maps
))
2616 register Lisp_Object elt
, prefix
, tail
;
2619 prefix
= Fcar (elt
);
2623 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2627 shmap
= XCAR (tail
);
2629 /* If the sequence by which we reach this keymap is zero-length,
2630 then the shadow map for this keymap is just SHADOW. */
2631 if ((STRINGP (prefix
) && XSTRING (prefix
)->size
== 0)
2632 || (VECTORP (prefix
) && XVECTOR (prefix
)->size
== 0))
2634 /* If the sequence by which we reach this keymap actually has
2635 some elements, then the sequence's definition in SHADOW is
2636 what we should use. */
2639 shmap
= Flookup_key (shmap
, Fcar (elt
), Qt
);
2640 if (INTEGERP (shmap
))
2644 /* If shmap is not nil and not a keymap,
2645 it completely shadows this map, so don't
2646 describe this map at all. */
2647 if (!NILP (shmap
) && NILP (Fkeymapp (shmap
)))
2651 sub_shadows
= Fcons (shmap
, sub_shadows
);
2654 /* Maps we have already listed in this loop shadow this map. */
2655 for (tail
= orig_maps
; ! EQ (tail
, maps
); tail
= XCDR (tail
))
2658 tem
= Fequal (Fcar (XCAR (tail
)), prefix
);
2660 sub_shadows
= Fcons (XCDR (XCAR (tail
)), sub_shadows
);
2663 describe_map (Fcdr (elt
), prefix
,
2664 transl
? describe_translation
: describe_command
,
2665 partial
, sub_shadows
, &seen
, nomenu
);
2671 insert_string ("\n");
2676 static int previous_description_column
;
2679 describe_command (definition
)
2680 Lisp_Object definition
;
2682 register Lisp_Object tem1
;
2683 int column
= current_column ();
2684 int description_column
;
2686 /* If column 16 is no good, go to col 32;
2687 but don't push beyond that--go to next line instead. */
2691 description_column
= 32;
2693 else if (column
> 14 || (column
> 10 && previous_description_column
== 32))
2694 description_column
= 32;
2696 description_column
= 16;
2698 Findent_to (make_number (description_column
), make_number (1));
2699 previous_description_column
= description_column
;
2701 if (SYMBOLP (definition
))
2703 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2705 insert_string ("\n");
2707 else if (STRINGP (definition
) || VECTORP (definition
))
2708 insert_string ("Keyboard Macro\n");
2711 tem1
= Fkeymapp (definition
);
2713 insert_string ("Prefix Command\n");
2715 insert_string ("??\n");
2720 describe_translation (definition
)
2721 Lisp_Object definition
;
2723 register Lisp_Object tem1
;
2725 Findent_to (make_number (16), make_number (1));
2727 if (SYMBOLP (definition
))
2729 XSETSTRING (tem1
, XSYMBOL (definition
)->name
);
2731 insert_string ("\n");
2733 else if (STRINGP (definition
) || VECTORP (definition
))
2735 insert1 (Fkey_description (definition
));
2736 insert_string ("\n");
2740 tem1
= Fkeymapp (definition
);
2742 insert_string ("Prefix Command\n");
2744 insert_string ("??\n");
2748 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
2749 Returns the first non-nil binding found in any of those maps. */
2752 shadow_lookup (shadow
, key
, flag
)
2753 Lisp_Object shadow
, key
, flag
;
2755 Lisp_Object tail
, value
;
2757 for (tail
= shadow
; CONSP (tail
); tail
= XCDR (tail
))
2759 value
= Flookup_key (XCAR (tail
), key
, flag
);
2766 /* Describe the contents of map MAP, assuming that this map itself is
2767 reached by the sequence of prefix keys KEYS (a string or vector).
2768 PARTIAL, SHADOW, NOMENU are as in `describe_map_tree' above. */
2771 describe_map (map
, keys
, elt_describer
, partial
, shadow
, seen
, nomenu
)
2772 register Lisp_Object map
;
2774 void (*elt_describer
) P_ ((Lisp_Object
));
2780 Lisp_Object elt_prefix
;
2781 Lisp_Object tail
, definition
, event
;
2783 Lisp_Object suppress
;
2786 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2790 if (!NILP (keys
) && XFASTINT (Flength (keys
)) > 0)
2792 /* Call Fkey_description first, to avoid GC bug for the other string. */
2793 tem
= Fkey_description (keys
);
2794 elt_prefix
= concat2 (tem
, build_string (" "));
2800 suppress
= intern ("suppress-keymap");
2802 /* This vector gets used to present single keys to Flookup_key. Since
2803 that is done once per keymap element, we don't want to cons up a
2804 fresh vector every time. */
2805 kludge
= Fmake_vector (make_number (1), Qnil
);
2808 GCPRO3 (elt_prefix
, definition
, kludge
);
2810 for (tail
= map
; CONSP (tail
); tail
= XCDR (tail
))
2814 if (VECTORP (XCAR (tail
))
2815 || CHAR_TABLE_P (XCAR (tail
)))
2816 describe_vector (XCAR (tail
),
2817 elt_prefix
, elt_describer
, partial
, shadow
, map
,
2819 else if (CONSP (XCAR (tail
)))
2821 event
= XCAR (XCAR (tail
));
2823 /* Ignore bindings whose "keys" are not really valid events.
2824 (We get these in the frames and buffers menu.) */
2825 if (! (SYMBOLP (event
) || INTEGERP (event
)))
2828 if (nomenu
&& EQ (event
, Qmenu_bar
))
2831 definition
= get_keyelt (XCDR (XCAR (tail
)), 0);
2833 /* Don't show undefined commands or suppressed commands. */
2834 if (NILP (definition
)) continue;
2835 if (SYMBOLP (definition
) && partial
)
2837 tem
= Fget (definition
, suppress
);
2842 /* Don't show a command that isn't really visible
2843 because a local definition of the same key shadows it. */
2845 XVECTOR (kludge
)->contents
[0] = event
;
2848 tem
= shadow_lookup (shadow
, kludge
, Qt
);
2849 if (!NILP (tem
)) continue;
2852 tem
= Flookup_key (map
, kludge
, Qt
);
2853 if (! EQ (tem
, definition
)) continue;
2857 previous_description_column
= 0;
2862 if (!NILP (elt_prefix
))
2863 insert1 (elt_prefix
);
2865 /* THIS gets the string to describe the character EVENT. */
2866 insert1 (Fsingle_key_description (event
, Qnil
));
2868 /* Print a description of the definition of this character.
2869 elt_describer will take care of spacing out far enough
2870 for alignment purposes. */
2871 (*elt_describer
) (definition
);
2873 else if (EQ (XCAR (tail
), Qkeymap
))
2875 /* The same keymap might be in the structure twice, if we're
2876 using an inherited keymap. So skip anything we've already
2878 tem
= Fassq (tail
, *seen
);
2879 if (CONSP (tem
) && !NILP (Fequal (XCAR (tem
), keys
)))
2881 *seen
= Fcons (Fcons (tail
, keys
), *seen
);
2889 describe_vector_princ (elt
)
2892 Findent_to (make_number (16), make_number (1));
2897 DEFUN ("describe-vector", Fdescribe_vector
, Sdescribe_vector
, 1, 1, 0,
2898 "Insert a description of contents of VECTOR.\n\
2899 This is text showing the elements of vector matched against indices.")
2903 int count
= specpdl_ptr
- specpdl
;
2905 specbind (Qstandard_output
, Fcurrent_buffer ());
2906 CHECK_VECTOR_OR_CHAR_TABLE (vector
, 0);
2907 describe_vector (vector
, Qnil
, describe_vector_princ
, 0,
2908 Qnil
, Qnil
, (int *)0, 0);
2910 return unbind_to (count
, Qnil
);
2913 /* Insert in the current buffer a description of the contents of VECTOR.
2914 We call ELT_DESCRIBER to insert the description of one value found
2917 ELT_PREFIX describes what "comes before" the keys or indices defined
2918 by this vector. This is a human-readable string whose size
2919 is not necessarily related to the situation.
2921 If the vector is in a keymap, ELT_PREFIX is a prefix key which
2922 leads to this keymap.
2924 If the vector is a chartable, ELT_PREFIX is the vector
2925 of bytes that lead to the character set or portion of a character
2926 set described by this chartable.
2928 If PARTIAL is nonzero, it means do not mention suppressed commands
2929 (that assumes the vector is in a keymap).
2931 SHADOW is a list of keymaps that shadow this map.
2932 If it is non-nil, then we look up the key in those maps
2933 and we don't mention it now if it is defined by any of them.
2935 ENTIRE_MAP is the keymap in which this vector appears.
2936 If the definition in effect in the whole map does not match
2937 the one in this vector, we ignore this one.
2939 When describing a sub-char-table, INDICES is a list of
2940 indices at higher levels in this char-table,
2941 and CHAR_TABLE_DEPTH says how many levels down we have gone. */
2944 describe_vector (vector
, elt_prefix
, elt_describer
,
2945 partial
, shadow
, entire_map
,
2946 indices
, char_table_depth
)
2947 register Lisp_Object vector
;
2948 Lisp_Object elt_prefix
;
2949 void (*elt_describer
) P_ ((Lisp_Object
));
2952 Lisp_Object entire_map
;
2954 int char_table_depth
;
2956 Lisp_Object definition
;
2959 Lisp_Object suppress
;
2962 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2963 /* Range of elements to be handled. */
2965 /* A flag to tell if a leaf in this level of char-table is not a
2966 generic character (i.e. a complete multibyte character). */
2974 indices
= (int *) alloca (3 * sizeof (int));
2978 /* This vector gets used to present single keys to Flookup_key. Since
2979 that is done once per vector element, we don't want to cons up a
2980 fresh vector every time. */
2981 kludge
= Fmake_vector (make_number (1), Qnil
);
2982 GCPRO3 (elt_prefix
, definition
, kludge
);
2985 suppress
= intern ("suppress-keymap");
2987 if (CHAR_TABLE_P (vector
))
2989 if (char_table_depth
== 0)
2991 /* VECTOR is a top level char-table. */
2994 to
= CHAR_TABLE_ORDINARY_SLOTS
;
2998 /* VECTOR is a sub char-table. */
2999 if (char_table_depth
>= 3)
3000 /* A char-table is never that deep. */
3001 error ("Too deep char table");
3004 = (CHARSET_VALID_P (indices
[0])
3005 && ((CHARSET_DIMENSION (indices
[0]) == 1
3006 && char_table_depth
== 1)
3007 || char_table_depth
== 2));
3009 /* Meaningful elements are from 32th to 127th. */
3011 to
= SUB_CHAR_TABLE_ORDINARY_SLOTS
;
3016 /* This does the right thing for ordinary vectors. */
3020 to
= XVECTOR (vector
)->size
;
3023 for (i
= from
; i
< to
; i
++)
3027 if (CHAR_TABLE_P (vector
))
3029 if (char_table_depth
== 0 && i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
)
3032 if (i
>= CHAR_TABLE_SINGLE_BYTE_SLOTS
3033 && !CHARSET_DEFINED_P (i
- 128))
3037 = get_keyelt (XCHAR_TABLE (vector
)->contents
[i
], 0);
3040 definition
= get_keyelt (XVECTOR (vector
)->contents
[i
], 0);
3042 if (NILP (definition
)) continue;
3044 /* Don't mention suppressed commands. */
3045 if (SYMBOLP (definition
) && partial
)
3049 tem
= Fget (definition
, suppress
);
3051 if (!NILP (tem
)) continue;
3054 /* Set CHARACTER to the character this entry describes, if any.
3055 Also update *INDICES. */
3056 if (CHAR_TABLE_P (vector
))
3058 indices
[char_table_depth
] = i
;
3060 if (char_table_depth
== 0)
3063 indices
[0] = i
- 128;
3065 else if (complete_char
)
3067 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3075 /* If this binding is shadowed by some other map, ignore it. */
3076 if (!NILP (shadow
) && complete_char
)
3080 XVECTOR (kludge
)->contents
[0] = make_number (character
);
3081 tem
= shadow_lookup (shadow
, kludge
, Qt
);
3083 if (!NILP (tem
)) continue;
3086 /* Ignore this definition if it is shadowed by an earlier
3087 one in the same keymap. */
3088 if (!NILP (entire_map
) && complete_char
)
3092 XVECTOR (kludge
)->contents
[0] = make_number (character
);
3093 tem
= Flookup_key (entire_map
, kludge
, Qt
);
3095 if (! EQ (tem
, definition
))
3101 if (char_table_depth
== 0)
3106 /* For a sub char-table, show the depth by indentation.
3107 CHAR_TABLE_DEPTH can be greater than 0 only for a char-table. */
3108 if (char_table_depth
> 0)
3109 insert (" ", char_table_depth
* 2); /* depth is 1 or 2. */
3111 /* Output the prefix that applies to every entry in this map. */
3112 if (!NILP (elt_prefix
))
3113 insert1 (elt_prefix
);
3115 /* Insert or describe the character this slot is for,
3116 or a description of what it is for. */
3117 if (SUB_CHAR_TABLE_P (vector
))
3120 insert_char (character
);
3123 /* We need an octal representation for this block of
3126 sprintf (work
, "(row %d)", i
);
3127 insert (work
, strlen (work
));
3130 else if (CHAR_TABLE_P (vector
))
3133 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3136 /* Print the information for this character set. */
3137 insert_string ("<");
3138 tem2
= CHARSET_TABLE_INFO (i
- 128, CHARSET_SHORT_NAME_IDX
);
3140 insert_from_string (tem2
, 0, 0, XSTRING (tem2
)->size
,
3141 STRING_BYTES (XSTRING (tem2
)), 0);
3149 insert1 (Fsingle_key_description (make_number (character
), Qnil
));
3152 /* If we find a sub char-table within a char-table,
3153 scan it recursively; it defines the details for
3154 a character set or a portion of a character set. */
3155 if (CHAR_TABLE_P (vector
) && SUB_CHAR_TABLE_P (definition
))
3158 describe_vector (definition
, elt_prefix
, elt_describer
,
3159 partial
, shadow
, entire_map
,
3160 indices
, char_table_depth
+ 1);
3166 /* Find all consecutive characters or rows that have the same
3167 definition. But, for elements of a top level char table, if
3168 they are for charsets, we had better describe one by one even
3169 if they have the same definition. */
3170 if (CHAR_TABLE_P (vector
))
3174 if (char_table_depth
== 0)
3175 limit
= CHAR_TABLE_SINGLE_BYTE_SLOTS
;
3177 while (i
+ 1 < limit
3178 && (tem2
= get_keyelt (XCHAR_TABLE (vector
)->contents
[i
+ 1], 0),
3180 && !NILP (Fequal (tem2
, definition
)))
3185 && (tem2
= get_keyelt (XVECTOR (vector
)->contents
[i
+ 1], 0),
3187 && !NILP (Fequal (tem2
, definition
)))
3191 /* If we have a range of more than one character,
3192 print where the range reaches to. */
3194 if (i
!= starting_i
)
3198 if (!NILP (elt_prefix
))
3199 insert1 (elt_prefix
);
3201 if (CHAR_TABLE_P (vector
))
3203 if (char_table_depth
== 0)
3205 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3207 else if (complete_char
)
3209 indices
[char_table_depth
] = i
;
3210 character
= MAKE_CHAR (indices
[0], indices
[1], indices
[2]);
3211 insert_char (character
);
3215 /* We need an octal representation for this block of
3218 sprintf (work
, "(row %d)", i
);
3219 insert (work
, strlen (work
));
3224 insert1 (Fsingle_key_description (make_number (i
), Qnil
));
3228 /* Print a description of the definition of this character.
3229 elt_describer will take care of spacing out far enough
3230 for alignment purposes. */
3231 (*elt_describer
) (definition
);
3234 /* For (sub) char-table, print `defalt' slot at last. */
3235 if (CHAR_TABLE_P (vector
) && !NILP (XCHAR_TABLE (vector
)->defalt
))
3237 insert (" ", char_table_depth
* 2);
3238 insert_string ("<<default>>");
3239 (*elt_describer
) (XCHAR_TABLE (vector
)->defalt
);
3245 /* Apropos - finding all symbols whose names match a regexp. */
3246 Lisp_Object apropos_predicate
;
3247 Lisp_Object apropos_accumulate
;
3250 apropos_accum (symbol
, string
)
3251 Lisp_Object symbol
, string
;
3253 register Lisp_Object tem
;
3255 tem
= Fstring_match (string
, Fsymbol_name (symbol
), Qnil
);
3256 if (!NILP (tem
) && !NILP (apropos_predicate
))
3257 tem
= call1 (apropos_predicate
, symbol
);
3259 apropos_accumulate
= Fcons (symbol
, apropos_accumulate
);
3262 DEFUN ("apropos-internal", Fapropos_internal
, Sapropos_internal
, 1, 2, 0,
3263 "Show all symbols whose names contain match for REGEXP.\n\
3264 If optional 2nd arg PREDICATE is non-nil, (funcall PREDICATE SYMBOL) is done\n\
3265 for each symbol and a symbol is mentioned only if that returns non-nil.\n\
3266 Return list of symbols found.")
3268 Lisp_Object regexp
, predicate
;
3270 struct gcpro gcpro1
, gcpro2
;
3271 CHECK_STRING (regexp
, 0);
3272 apropos_predicate
= predicate
;
3273 GCPRO2 (apropos_predicate
, apropos_accumulate
);
3274 apropos_accumulate
= Qnil
;
3275 map_obarray (Vobarray
, apropos_accum
, regexp
);
3276 apropos_accumulate
= Fsort (apropos_accumulate
, Qstring_lessp
);
3278 return apropos_accumulate
;
3284 Qkeymap
= intern ("keymap");
3285 staticpro (&Qkeymap
);
3287 /* Now we are ready to set up this property, so we can
3288 create char tables. */
3289 Fput (Qkeymap
, Qchar_table_extra_slots
, make_number (0));
3291 /* Initialize the keymaps standardly used.
3292 Each one is the value of a Lisp variable, and is also
3293 pointed to by a C variable */
3295 global_map
= Fmake_keymap (Qnil
);
3296 Fset (intern ("global-map"), global_map
);
3298 current_global_map
= global_map
;
3299 staticpro (&global_map
);
3300 staticpro (¤t_global_map
);
3302 meta_map
= Fmake_keymap (Qnil
);
3303 Fset (intern ("esc-map"), meta_map
);
3304 Ffset (intern ("ESC-prefix"), meta_map
);
3306 control_x_map
= Fmake_keymap (Qnil
);
3307 Fset (intern ("ctl-x-map"), control_x_map
);
3308 Ffset (intern ("Control-X-prefix"), control_x_map
);
3310 DEFVAR_LISP ("define-key-rebound-commands", &Vdefine_key_rebound_commands
,
3311 "List of commands given new key bindings recently.\n\
3312 This is used for internal purposes during Emacs startup;\n\
3313 don't alter it yourself.");
3314 Vdefine_key_rebound_commands
= Qt
;
3316 DEFVAR_LISP ("minibuffer-local-map", &Vminibuffer_local_map
,
3317 "Default keymap to use when reading from the minibuffer.");
3318 Vminibuffer_local_map
= Fmake_sparse_keymap (Qnil
);
3320 DEFVAR_LISP ("minibuffer-local-ns-map", &Vminibuffer_local_ns_map
,
3321 "Local keymap for the minibuffer when spaces are not allowed.");
3322 Vminibuffer_local_ns_map
= Fmake_sparse_keymap (Qnil
);
3324 DEFVAR_LISP ("minibuffer-local-completion-map", &Vminibuffer_local_completion_map
,
3325 "Local keymap for minibuffer input with completion.");
3326 Vminibuffer_local_completion_map
= Fmake_sparse_keymap (Qnil
);
3328 DEFVAR_LISP ("minibuffer-local-must-match-map", &Vminibuffer_local_must_match_map
,
3329 "Local keymap for minibuffer input with completion, for exact match.");
3330 Vminibuffer_local_must_match_map
= Fmake_sparse_keymap (Qnil
);
3332 DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist
,
3333 "Alist of keymaps to use for minor modes.\n\
3334 Each element looks like (VARIABLE . KEYMAP); KEYMAP is used to read\n\
3335 key sequences and look up bindings iff VARIABLE's value is non-nil.\n\
3336 If two active keymaps bind the same key, the keymap appearing earlier\n\
3337 in the list takes precedence.");
3338 Vminor_mode_map_alist
= Qnil
;
3340 DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist
,
3341 "Alist of keymaps to use for minor modes, in current major mode.\n\
3342 This variable is a alist just like `minor-mode-map-alist', and it is\n\
3343 used the same way (and before `minor-mode-map-alist'); however,\n\
3344 it is provided for major modes to bind locally.");
3345 Vminor_mode_overriding_map_alist
= Qnil
;
3347 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
3348 "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
3349 This allows Emacs to recognize function keys sent from ASCII\n\
3350 terminals at any point in a key sequence.\n\
3352 The `read-key-sequence' function replaces any subsequence bound by\n\
3353 `function-key-map' with its binding. More precisely, when the active\n\
3354 keymaps have no binding for the current key sequence but\n\
3355 `function-key-map' binds a suffix of the sequence to a vector or string,\n\
3356 `read-key-sequence' replaces the matching suffix with its binding, and\n\
3357 continues with the new sequence.\n\
3359 The events that come from bindings in `function-key-map' are not\n\
3360 themselves looked up in `function-key-map'.\n\
3362 For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
3363 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing\n\
3364 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix\n\
3365 key, typing `ESC O P x' would return [f1 x].");
3366 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
3368 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
3369 "Keymap of key translations that can override keymaps.\n\
3370 This keymap works like `function-key-map', but comes after that,\n\
3371 and applies even for keys that have ordinary bindings.");
3372 Vkey_translation_map
= Qnil
;
3374 Qsingle_key_description
= intern ("single-key-description");
3375 staticpro (&Qsingle_key_description
);
3377 Qkey_description
= intern ("key-description");
3378 staticpro (&Qkey_description
);
3380 Qkeymapp
= intern ("keymapp");
3381 staticpro (&Qkeymapp
);
3383 Qnon_ascii
= intern ("non-ascii");
3384 staticpro (&Qnon_ascii
);
3386 Qmenu_item
= intern ("menu-item");
3387 staticpro (&Qmenu_item
);
3389 defsubr (&Skeymapp
);
3390 defsubr (&Skeymap_parent
);
3391 defsubr (&Sset_keymap_parent
);
3392 defsubr (&Smake_keymap
);
3393 defsubr (&Smake_sparse_keymap
);
3394 defsubr (&Scopy_keymap
);
3395 defsubr (&Skey_binding
);
3396 defsubr (&Slocal_key_binding
);
3397 defsubr (&Sglobal_key_binding
);
3398 defsubr (&Sminor_mode_key_binding
);
3399 defsubr (&Sdefine_key
);
3400 defsubr (&Slookup_key
);
3401 defsubr (&Sdefine_prefix_command
);
3402 defsubr (&Suse_global_map
);
3403 defsubr (&Suse_local_map
);
3404 defsubr (&Scurrent_local_map
);
3405 defsubr (&Scurrent_global_map
);
3406 defsubr (&Scurrent_minor_mode_maps
);
3407 defsubr (&Saccessible_keymaps
);
3408 defsubr (&Skey_description
);
3409 defsubr (&Sdescribe_vector
);
3410 defsubr (&Ssingle_key_description
);
3411 defsubr (&Stext_char_description
);
3412 defsubr (&Swhere_is_internal
);
3413 defsubr (&Sdescribe_bindings_internal
);
3414 defsubr (&Sapropos_internal
);
3420 initial_define_key (global_map
, 033, "ESC-prefix");
3421 initial_define_key (global_map
, Ctl('X'), "Control-X-prefix");