X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/aaef169dc63c4b557374540756865991e1bf6305..d6897a018781164bf9e7bd4ca51c87b303170313:/src/keymap.c diff --git a/src/keymap.c b/src/keymap.c index 94cc8920f0..47e3f50786 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -1,7 +1,7 @@ /* Manipulation of keymaps Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004, - 2005, 2006 Free Software Foundation, Inc. + 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -23,16 +23,21 @@ Boston, MA 02110-1301, USA. */ #include #include +#if HAVE_ALLOCA_H +# include +#endif #include "lisp.h" #include "commands.h" #include "buffer.h" #include "charset.h" #include "keyboard.h" +#include "frame.h" #include "termhooks.h" #include "blockinput.h" #include "puresize.h" #include "intervals.h" #include "keymap.h" +#include "window.h" /* The number of elements in keymap vectors. */ #define DENSE_TABLE_SIZE (0200) @@ -68,7 +73,7 @@ Lisp_Object Vminibuffer_local_completion_map; /* keymap used for minibuffers when doing completion in filenames */ Lisp_Object Vminibuffer_local_filename_completion_map; -/* keymap used for minibuffers when doing completion in filenames +/* keymap used for minibuffers when doing completion in filenames with require-match*/ Lisp_Object Vminibuffer_local_must_match_filename_map; @@ -86,14 +91,6 @@ Lisp_Object Vminor_mode_overriding_map_alist; /* List of emulation mode keymap alists. */ Lisp_Object Vemulation_mode_map_alists; -/* Keymap mapping ASCII function key sequences onto their preferred forms. - Initialized by the terminal-specific lisp files. See DEFVAR for more - documentation. */ -Lisp_Object Vfunction_key_map; - -/* Keymap mapping ASCII function key sequences onto their preferred forms. */ -Lisp_Object Vkey_translation_map; - /* A list of all commands given new bindings since a certain time when nil was stored here. This is used to speed up recomputation of menu key equivalents @@ -699,6 +696,7 @@ map_keymap (map, fun, args, data, autoload) struct gcpro gcpro1, gcpro2, gcpro3; Lisp_Object tail; + tail = Qnil; GCPRO3 (map, args, tail); map = get_keymap (map, 1, autoload); for (tail = (CONSP (map) && EQ (Qkeymap, XCAR (map))) ? XCDR (map) : map; @@ -745,7 +743,10 @@ map_keymap_call (key, val, fun, dummy) DEFUN ("map-keymap", Fmap_keymap, Smap_keymap, 2, 3, 0, doc: /* Call FUNCTION once for each event binding in KEYMAP. FUNCTION is called with two arguments: the event that is bound, and -the definition it is bound to. +the definition it is bound to. If the event is an integer, it may be +a generic character (see Info node `(elisp)Splitting Characters'), and +that means that all actual character events belonging to that generic +character are bound to the definition. If KEYMAP has a parent, the parent's bindings are included as well. This works recursively: if the parent has itself a parent, then the @@ -757,7 +758,7 @@ usage: (map-keymap FUNCTION KEYMAP) */) if (INTEGERP (function)) /* We have to stop integers early since map_keymap gives them special significance. */ - Fsignal (Qinvalid_function, Fcons (function, Qnil)); + xsignal1 (Qinvalid_function, function); if (! NILP (sort_first)) return call3 (intern ("map-keymap-internal"), function, keymap, Qt); @@ -865,7 +866,7 @@ static Lisp_Object store_in_keymap (keymap, idx, def) Lisp_Object keymap; register Lisp_Object idx; - register Lisp_Object def; + Lisp_Object def; { /* Flush any reverse-map cache. */ where_is_cache = Qnil; @@ -1116,7 +1117,9 @@ DEF is anything that can be a key's definition: or another symbol whose function definition is used, etc.), a cons (STRING . DEFN), meaning that DEFN is the definition (DEFN should be a valid definition in its own right), - or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP. + or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP, + or an extended menu item definition. + (See info node `(elisp)Extended Menu Items'.) If KEYMAP is a sparse keymap with a binding for KEY, the existing binding is altered. If there is no binding for KEY, the new pair @@ -1137,8 +1140,7 @@ binding KEY to DEF is added at the front of KEYMAP. */) GCPRO3 (keymap, key, def); keymap = get_keymap (keymap, 1, 1); - if (!VECTORP (key) && !STRINGP (key)) - key = wrong_type_argument (Qarrayp, key); + CHECK_VECTOR_OR_STRING (key); length = XFASTINT (Flength (key)); if (length == 0) @@ -1147,7 +1149,22 @@ binding KEY to DEF is added at the front of KEYMAP. */) if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt)) Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands); - meta_bit = VECTORP (key) ? meta_modifier : 0x80; + meta_bit = (VECTORP (key) || STRINGP (key) && STRING_MULTIBYTE (key) + ? meta_modifier : 0x80); + + if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, 0))) + { /* DEF is apparently an XEmacs-style keyboard macro. */ + Lisp_Object tmp = Fmake_vector (make_number (ASIZE (def)), Qnil); + int i = ASIZE (def); + while (--i >= 0) + { + Lisp_Object c = AREF (def, i); + if (CONSP (c) && lucid_event_type_list_p (c)) + c = Fevent_convert_list (c); + ASET (tmp, i, c); + } + def = tmp; + } idx = 0; while (1) @@ -1192,24 +1209,52 @@ binding KEY to DEF is added at the front of KEYMAP. */) if (!CONSP (keymap)) /* We must use Fkey_description rather than just passing key to error; key might be a vector, not a string. */ - error ("Key sequence %s uses invalid prefix characters", - SDATA (Fkey_description (key, Qnil))); + error ("Key sequence %s starts with non-prefix key %s", + SDATA (Fkey_description (key, Qnil)), + SDATA (Fkey_description (Fsubstring (key, make_number (0), + make_number (idx)), + Qnil))); } } /* This function may GC (it calls Fkey_binding). */ -DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 1, 0, - doc: /* Return the remapping for command COMMAND in current keymaps. -Returns nil if COMMAND is not remapped (or not a symbol). */) - (command) - Lisp_Object command; +DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 3, 0, + doc: /* Return the remapping for command COMMAND. +Returns nil if COMMAND is not remapped (or not a symbol). + +If the optional argument POSITION is non-nil, it specifies a mouse +position as returned by `event-start' and `event-end', and the +remapping occurs in the keymaps associated with it. It can also be a +number or marker, in which case the keymap properties at the specified +buffer position instead of point are used. The KEYMAPS argument is +ignored if POSITION is non-nil. + +If the optional argument KEYMAPS is non-nil, it should be a list of +keymaps to search for command remapping. Otherwise, search for the +remapping in all currently active keymaps. */) + (command, position, keymaps) + Lisp_Object command, position, keymaps; { if (!SYMBOLP (command)) return Qnil; ASET (command_remapping_vector, 1, command); - return Fkey_binding (command_remapping_vector, Qnil, Qt); + + if (NILP (keymaps)) + return Fkey_binding (command_remapping_vector, Qnil, Qt, position); + else + { + Lisp_Object maps, binding; + + for (maps = keymaps; !NILP (maps); maps = Fcdr (maps)) + { + binding = Flookup_key (Fcar (maps), command_remapping_vector, Qnil); + if (!NILP (binding) && !INTEGERP (binding)) + return binding; + } + return Qnil; + } } /* Value is number if KEY is too long; nil if valid but has no definition. */ @@ -1217,7 +1262,8 @@ Returns nil if COMMAND is not remapped (or not a symbol). */) DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0, doc: /* In keymap KEYMAP, look up key sequence KEY. Return the definition. -nil means undefined. See doc of `define-key' for kinds of definitions. +A value of nil means undefined. See doc of `define-key' +for kinds of definitions. A number as value means KEY is "too long"; that is, characters or symbols in it except for the last one @@ -1245,8 +1291,7 @@ recognize the default bindings, just as `read-key-sequence' does. */) GCPRO2 (keymap, key); keymap = get_keymap (keymap, 1, 1); - if (!VECTORP (key) && !STRINGP (key)) - key = wrong_type_argument (Qarrayp, key); + CHECK_VECTOR_OR_STRING (key); length = XFASTINT (Flength (key)); if (length == 0) @@ -1261,7 +1306,7 @@ recognize the default bindings, just as `read-key-sequence' does. */) c = Fevent_convert_list (c); /* Turn the 8th bit of string chars into a meta modifier. */ - if (INTEGERP (c) && XINT (c) & 0x80 && STRINGP (key)) + if (STRINGP (key) && XINT (c) & 0x80 && !STRING_MULTIBYTE (key)) XSETINT (c, (XINT (c) | meta_modifier) & ~0x80); /* Allow string since binding for `menu-bar-select-buffer' @@ -1370,15 +1415,10 @@ silly_event_symbol_error (c) static Lisp_Object *cmm_modes = NULL, *cmm_maps = NULL; static int cmm_size = 0; -/* Error handler used in current_minor_maps. */ -static Lisp_Object -current_minor_maps_error () -{ - return Qnil; -} - -/* Store a pointer to an array of the keymaps of the currently active - minor modes in *buf, and return the number of maps it contains. +/* Store a pointer to an array of the currently active minor modes in + *modeptr, a pointer to an array of the keymaps of the currently + active minor modes in *mapptr, and return the number of maps + *mapptr contains. This function always returns a pointer to the same buffer, and may free or reallocate it, so if you want to keep it for a long time or @@ -1478,9 +1518,7 @@ current_minor_maps (modeptr, mapptr) } /* Get the keymap definition--or nil if it is not defined. */ - temp = internal_condition_case_1 (Findirect_function, - XCDR (assoc), - Qerror, current_minor_maps_error); + temp = Findirect_function (XCDR (assoc), Qt); if (!NILP (temp)) { cmm_modes[i] = var; @@ -1545,7 +1583,7 @@ OLP if non-nil indicates that we should obey `overriding-local-map' and /* GC is possible in this function if it autoloads a keymap. */ -DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 3, 0, +DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 4, 0, doc: /* Return the binding for command KEY in current keymaps. KEY is a string or vector, a sequence of keystrokes. The binding is probably a symbol with a function definition. @@ -1559,24 +1597,82 @@ recognize the default bindings, just as `read-key-sequence' does. Like the normal command loop, `key-binding' will remap the command resulting from looking up KEY by looking up the command in the current keymaps. However, if the optional third argument NO-REMAP -is non-nil, `key-binding' returns the unmapped command. */) - (key, accept_default, no_remap) - Lisp_Object key, accept_default, no_remap; +is non-nil, `key-binding' returns the unmapped command. + +If KEY is a key sequence initiated with the mouse, the used keymaps +will depend on the clicked mouse position with regard to the buffer +and possible local keymaps on strings. + +If the optional argument POSITION is non-nil, it specifies a mouse +position as returned by `event-start' and `event-end', and the lookup +occurs in the keymaps associated with it instead of KEY. It can also +be a number or marker, in which case the keymap properties at the +specified buffer position instead of point are used. + */) + (key, accept_default, no_remap, position) + Lisp_Object key, accept_default, no_remap, position; { Lisp_Object *maps, value; int nmaps, i; - struct gcpro gcpro1; + struct gcpro gcpro1, gcpro2; + int count = SPECPDL_INDEX (); - GCPRO1 (key); + GCPRO2 (key, position); - if (!NILP (current_kboard->Voverriding_terminal_local_map)) + if (NILP (position) && VECTORP (key)) + { + Lisp_Object event + /* mouse events may have a symbolic prefix indicating the + scrollbar or mode line */ + = AREF (key, SYMBOLP (AREF (key, 0)) && ASIZE (key) > 1 ? 1 : 0); + + /* We are not interested in locations without event data */ + + if (EVENT_HAS_PARAMETERS (event) && CONSP (XCDR (event))) + { + Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (event)); + if (EQ (kind, Qmouse_click)) + position = EVENT_START (event); + } + } + + /* Key sequences beginning with mouse clicks + are read using the keymaps of the buffer clicked on, not + the current buffer. So we may have to switch the buffer + here. */ + + if (CONSP (position)) + { + Lisp_Object window; + + window = POSN_WINDOW (position); + + if (WINDOWP (window) + && BUFFERP (XWINDOW (window)->buffer) + && XBUFFER (XWINDOW (window)->buffer) != current_buffer) + { + /* Arrange to go back to the original buffer once we're done + processing the key sequence. We don't use + save_excursion_{save,restore} here, in analogy to + `read-key-sequence' to avoid saving point. Maybe this + would not be a problem here, but it is easier to keep + things the same. + */ + + record_unwind_protect (Fset_buffer, Fcurrent_buffer ()); + + set_buffer_internal (XBUFFER (XWINDOW (window)->buffer)); + } + } + + if (! NILP (current_kboard->Voverriding_terminal_local_map)) { value = Flookup_key (current_kboard->Voverriding_terminal_local_map, key, accept_default); if (! NILP (value) && !INTEGERP (value)) goto done; } - else if (!NILP (Voverriding_local_map)) + else if (! NILP (Voverriding_local_map)) { value = Flookup_key (Voverriding_local_map, key, accept_default); if (! NILP (value) && !INTEGERP (value)) @@ -1584,12 +1680,71 @@ is non-nil, `key-binding' returns the unmapped command. */) } else { - Lisp_Object local; + Lisp_Object keymap, local_map; + EMACS_INT pt; - local = get_local_map (PT, current_buffer, Qkeymap); - if (! NILP (local)) + pt = INTEGERP (position) ? XINT (position) + : MARKERP (position) ? marker_position (position) + : PT; + + local_map = get_local_map (pt, current_buffer, Qlocal_map); + keymap = get_local_map (pt, current_buffer, Qkeymap); + + if (CONSP (position)) + { + Lisp_Object string; + + /* For a mouse click, get the local text-property keymap + of the place clicked on, rather than point. */ + + if (POSN_INBUFFER_P (position)) + { + Lisp_Object pos; + + pos = POSN_BUFFER_POSN (position); + if (INTEGERP (pos) + && XINT (pos) >= BEG && XINT (pos) <= Z) + { + local_map = get_local_map (XINT (pos), + current_buffer, Qlocal_map); + + keymap = get_local_map (XINT (pos), + current_buffer, Qkeymap); + } + } + + /* If on a mode line string with a local keymap, + or for a click on a string, i.e. overlay string or a + string displayed via the `display' property, + consider `local-map' and `keymap' properties of + that string. */ + + if (string = POSN_STRING (position), + (CONSP (string) && STRINGP (XCAR (string)))) + { + Lisp_Object pos, map; + + pos = XCDR (string); + string = XCAR (string); + if (INTEGERP (pos) + && XINT (pos) >= 0 + && XINT (pos) < SCHARS (string)) + { + map = Fget_text_property (pos, Qlocal_map, string); + if (!NILP (map)) + local_map = map; + + map = Fget_text_property (pos, Qkeymap, string); + if (!NILP (map)) + keymap = map; + } + } + + } + + if (! NILP (keymap)) { - value = Flookup_key (local, key, accept_default); + value = Flookup_key (keymap, key, accept_default); if (! NILP (value) && !INTEGERP (value)) goto done; } @@ -1606,10 +1761,9 @@ is non-nil, `key-binding' returns the unmapped command. */) goto done; } - local = get_local_map (PT, current_buffer, Qlocal_map); - if (! NILP (local)) + if (! NILP (local_map)) { - value = Flookup_key (local, key, accept_default); + value = Flookup_key (local_map, key, accept_default); if (! NILP (value) && !INTEGERP (value)) goto done; } @@ -1618,6 +1772,8 @@ is non-nil, `key-binding' returns the unmapped command. */) value = Flookup_key (current_global_map, key, accept_default); done: + unbind_to (count, Qnil); + UNGCPRO; if (NILP (value) || INTEGERP (value)) return Qnil; @@ -1628,7 +1784,7 @@ is non-nil, `key-binding' returns the unmapped command. */) if (NILP (no_remap) && SYMBOLP (value)) { Lisp_Object value1; - if (value1 = Fcommand_remapping (value), !NILP (value1)) + if (value1 = Fcommand_remapping (value, position, Qnil), !NILP (value1)) value = value1; } @@ -2095,12 +2251,21 @@ push_key_description (c, p, force_multibyte) int force_multibyte; { unsigned c2; + int valid_p; /* Clear all the meaningless bits above the meta bit. */ c &= meta_modifier | ~ - meta_modifier; c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier | meta_modifier | shift_modifier | super_modifier); + valid_p = SINGLE_BYTE_CHAR_P (c2) || char_valid_p (c2, 0); + if (! valid_p) + { + /* KEY_DESCRIPTION_SIZE is large enough for this. */ + p += sprintf (p, "[%d]", c); + return p; + } + if (c & alt_modifier) { *p++ = 'A'; @@ -2188,16 +2353,13 @@ push_key_description (c, p, force_multibyte) } else { - int valid_p = SINGLE_BYTE_CHAR_P (c) || char_valid_p (c, 0); - - if (force_multibyte && valid_p) + if (force_multibyte) { if (SINGLE_BYTE_CHAR_P (c)) c = unibyte_char_to_multibyte (c); p += CHAR_STRING (c, p); } - else if (NILP (current_buffer->enable_multibyte_characters) - || valid_p) + else if (NILP (current_buffer->enable_multibyte_characters)) { int bit_offset; *p++ = '\\'; @@ -2241,16 +2403,29 @@ around function keys and event symbols. */) else SPLIT_CHAR (without_bits, charset, c1, c2); - if (charset - && CHARSET_DEFINED_P (charset) - && ((c1 >= 0 && c1 < 32) - || (c2 >= 0 && c2 < 32))) + if (! CHAR_VALID_P (without_bits, 1)) + { + char buf[256]; + + sprintf (buf, "Invalid char code %d", XINT (key)); + return build_string (buf); + } + else if (charset + && ((c1 == 0 && c2 == -1) || c2 == 0)) { /* Handle a generic character. */ Lisp_Object name; - name = CHARSET_TABLE_INFO (charset, CHARSET_LONG_NAME_IDX); + char buf[256]; + + name = CHARSET_TABLE_INFO (charset, CHARSET_SHORT_NAME_IDX); CHECK_STRING (name); - return concat2 (build_string ("Character set "), name); + if (c1 == 0) + /* Only a charset is specified. */ + sprintf (buf, "Generic char %d: all of ", without_bits); + else + /* 1st code-point of 2-dimensional charset is specified. */ + sprintf (buf, "Generic char %d: row %d of ", without_bits, c1); + return concat2 (build_string (buf), name); } else { @@ -2418,15 +2593,6 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap) /* 1 means ignore all menu bindings entirely. */ int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii); - /* If this command is remapped, then it has no key bindings - of its own. */ - if (NILP (no_remap) && SYMBOLP (definition)) - { - Lisp_Object tem; - if (tem = Fcommand_remapping (definition), !NILP (tem)) - return Qnil; - } - found = keymaps; while (CONSP (found)) { @@ -2440,6 +2606,13 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap) found = Qnil; sequences = Qnil; + /* If this command is remapped, then it has no key bindings + of its own. */ + if (NILP (no_remap) + && SYMBOLP (definition) + && !NILP (Fcommand_remapping (definition, Qnil, keymaps))) + RETURN_UNGCPRO (Qnil); + for (; !NILP (maps); maps = Fcdr (maps)) { /* Key sequence to reach map, and the map that it reaches */ @@ -2833,17 +3006,19 @@ Keyboard translations:\n\n\ You type Translation\n\ -------- -----------\n"; + CHECK_BUFFER (buffer); + shadow = Qnil; GCPRO1 (shadow); outbuf = Fcurrent_buffer (); /* Report on alternates for keys. */ - if (STRINGP (Vkeyboard_translate_table) && !NILP (prefix)) + if (STRINGP (current_kboard->Vkeyboard_translate_table) && !NILP (prefix)) { int c; - const unsigned char *translate = SDATA (Vkeyboard_translate_table); - int translate_len = SCHARS (Vkeyboard_translate_table); + const unsigned char *translate = SDATA (current_kboard->Vkeyboard_translate_table); + int translate_len = SCHARS (current_kboard->Vkeyboard_translate_table); for (c = 0; c < translate_len; c++) if (translate[c] != c) @@ -2866,14 +3041,14 @@ You type Translation\n\ insert ("\n", 1); /* Insert calls signal_after_change which may GC. */ - translate = SDATA (Vkeyboard_translate_table); + translate = SDATA (current_kboard->Vkeyboard_translate_table); } insert ("\n", 1); } - if (!NILP (Vkey_translation_map)) - describe_map_tree (Vkey_translation_map, 0, Qnil, prefix, + if (!NILP (current_kboard->Vlocal_key_translation_map)) + describe_map_tree (current_kboard->Vlocal_key_translation_map, 0, Qnil, prefix, "Key translations", nomenu, 1, 0, 0); @@ -2962,8 +3137,8 @@ You type Translation\n\ "\f\nGlobal Bindings", nomenu, 0, 1, 0); /* Print the function-key-map translations under this prefix. */ - if (!NILP (Vfunction_key_map)) - describe_map_tree (Vfunction_key_map, 0, Qnil, prefix, + if (!NILP (current_kboard->Vlocal_function_key_map)) + describe_map_tree (current_kboard->Vlocal_function_key_map, 0, Qnil, prefix, "\f\nFunction key map translations", nomenu, 1, 0, 0); UNGCPRO; @@ -3296,7 +3471,13 @@ describe_map (map, prefix, elt_describer, partial, shadow, tem = shadow_lookup (shadow, kludge, Qt); if (!NILP (tem)) { - if (mention_shadow) + /* If both bindings are keymaps, this key is a prefix key, + so don't say it is shadowed. */ + if (KEYMAPP (definition) && KEYMAPP (tem)) + ; + /* Avoid generating duplicate entries if the + shadowed binding has the same definition. */ + else if (mention_shadow && !EQ (tem, definition)) this_shadowed = 1; else continue; @@ -3351,7 +3532,7 @@ describe_map (map, prefix, elt_describer, partial, shadow, if (INTEGERP (vect[i].event)) { while (i + 1 < slots_used - && XINT (vect[i + 1].event) == XINT (vect[i].event) + 1 + && EQ (vect[i+1].event, make_number (XINT (vect[i].event) + 1)) && !NILP (Fequal (vect[i + 1].definition, definition)) && vect[i].shadowed == vect[i + 1].shadowed) i++; @@ -3380,7 +3561,7 @@ describe_map (map, prefix, elt_describer, partial, shadow, if (vect[i].shadowed) { SET_PT (PT - 1); - insert_string (" (binding currently shadowed)"); + insert_string ("\n (that binding is currently shadowed by another mode)"); SET_PT (PT + 1); } } @@ -3882,11 +4063,11 @@ don't alter it yourself. */); Vminibuffer_local_completion_map = Fmake_sparse_keymap (Qnil); Fset_keymap_parent (Vminibuffer_local_completion_map, Vminibuffer_local_map); - DEFVAR_LISP ("minibuffer-local-filename-completion-map", + DEFVAR_LISP ("minibuffer-local-filename-completion-map", &Vminibuffer_local_filename_completion_map, doc: /* Local keymap for minibuffer input with completion for filenames. */); Vminibuffer_local_filename_completion_map = Fmake_sparse_keymap (Qnil); - Fset_keymap_parent (Vminibuffer_local_filename_completion_map, + Fset_keymap_parent (Vminibuffer_local_filename_completion_map, Vminibuffer_local_completion_map); @@ -3896,11 +4077,11 @@ don't alter it yourself. */); Fset_keymap_parent (Vminibuffer_local_must_match_map, Vminibuffer_local_completion_map); - DEFVAR_LISP ("minibuffer-local-must-match-filename-map", + DEFVAR_LISP ("minibuffer-local-must-match-filename-map", &Vminibuffer_local_must_match_filename_map, doc: /* Local keymap for minibuffer input with completion for filenames with exact match. */); Vminibuffer_local_must_match_filename_map = Fmake_sparse_keymap (Qnil); - Fset_keymap_parent (Vminibuffer_local_must_match_filename_map, + Fset_keymap_parent (Vminibuffer_local_must_match_filename_map, Vminibuffer_local_must_match_map); DEFVAR_LISP ("minor-mode-map-alist", &Vminor_mode_map_alist, @@ -3927,37 +4108,6 @@ the same way. The "active" keymaps in each alist are used before `minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */); Vemulation_mode_map_alists = Qnil; - - DEFVAR_LISP ("function-key-map", &Vfunction_key_map, - doc: /* Keymap that translates key sequences to key sequences during input. -This is used mainly for mapping ASCII function key sequences into -real Emacs function key events (symbols). - -The `read-key-sequence' function replaces any subsequence bound by -`function-key-map' with its binding. More precisely, when the active -keymaps have no binding for the current key sequence but -`function-key-map' binds a suffix of the sequence to a vector or string, -`read-key-sequence' replaces the matching suffix with its binding, and -continues with the new sequence. - -If the binding is a function, it is called with one argument (the prompt) -and its return value (a key sequence) is used. - -The events that come from bindings in `function-key-map' are not -themselves looked up in `function-key-map'. - -For example, suppose `function-key-map' binds `ESC O P' to [f1]. -Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing -`C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix -key, typing `ESC O P x' would return [f1 x]. */); - Vfunction_key_map = Fmake_sparse_keymap (Qnil); - - DEFVAR_LISP ("key-translation-map", &Vkey_translation_map, - doc: /* Keymap of key translations that can override keymaps. -This keymap works like `function-key-map', but comes after that, -and its non-prefix bindings override ordinary bindings. */); - Vkey_translation_map = Qnil; - staticpro (&Vmouse_events); Vmouse_events = Fcons (intern ("menu-bar"), Fcons (intern ("tool-bar"),