X-Git-Url: http://git.hcoop.net/bpt/emacs.git/blobdiff_plain/f65f7603312547e51230192daf34349b8ac569a0..2ca773ca40d2c1896757e6382aefff6d9de1c5cc:/src/keymap.c diff --git a/src/keymap.c b/src/keymap.c index c85c37aae1..b4f74885e9 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -7,7 +7,7 @@ This file is part of GNU Emacs. GNU Emacs is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) +the Free Software Foundation; either version 3, or (at your option) any later version. GNU Emacs is distributed in the hope that it will be useful, @@ -422,7 +422,7 @@ Return PARENT. PARENT should be nil or another keymap. */) if (CHAR_TABLE_P (XCAR (list))) { - Lisp_Object indices[3]; + int indices[3]; map_char_table (fix_submap_inheritance, Qnil, XCAR (list), XCAR (list), @@ -721,7 +721,7 @@ map_keymap (map, fun, args, data, autoload) } else if (CHAR_TABLE_P (binding)) { - Lisp_Object indices[3]; + int indices[3]; map_char_table (map_keymap_char_table_item, Qnil, binding, binding, Fcons (make_save_value (fun, 0), Fcons (make_save_value (data, 0), @@ -1072,7 +1072,7 @@ is not copied. */) Lisp_Object elt = XCAR (keymap); if (CHAR_TABLE_P (elt)) { - Lisp_Object indices[3]; + int indices[3]; elt = Fcopy_sequence (elt); map_char_table (copy_keymap_1, Qnil, elt, elt, elt, 0, indices); } @@ -1118,7 +1118,8 @@ DEF is anything that can be a key's definition: 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 an extended menu item definition. (See info node `Extended Menu Items'.) + 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 @@ -1148,7 +1149,8 @@ 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. */ @@ -1217,23 +1219,42 @@ binding KEY to DEF is added at the front of KEYMAP. */) /* This function may GC (it calls Fkey_binding). */ -DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 2, 0, - doc: /* Return the remapping for command COMMAND in current keymaps. +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. */) - (command, position) - Lisp_Object command, position; +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, position); + + 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. */ @@ -1285,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' @@ -1394,8 +1415,10 @@ silly_event_symbol_error (c) static Lisp_Object *cmm_modes = NULL, *cmm_maps = NULL; static int cmm_size = 0; -/* 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 @@ -1511,14 +1534,47 @@ current_minor_maps (modeptr, mapptr) } DEFUN ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps, - 0, 1, 0, + 0, 2, 0, doc: /* Return a list of the currently active keymaps. OLP if non-nil indicates that we should obey `overriding-local-map' and -`overriding-terminal-local-map'. */) - (olp) - Lisp_Object olp; +`overriding-terminal-local-map'. POSITION can specify a click position +like in the respective argument of `key-binding'. */) + (olp, position) + Lisp_Object olp, position; { - Lisp_Object keymaps = Fcons (current_global_map, Qnil); + int count = SPECPDL_INDEX (); + + Lisp_Object keymaps; + + /* If a mouse click position is given, our variables are based on + 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)); + } + } + + keymaps = Fcons (current_global_map, Qnil); if (!NILP (olp)) { @@ -1532,15 +1588,76 @@ OLP if non-nil indicates that we should obey `overriding-local-map' and } if (NILP (XCDR (keymaps))) { - Lisp_Object local; Lisp_Object *maps; int nmaps, i; - /* This usually returns the buffer's local map, - but that can be overridden by a `local-map' property. */ - local = get_local_map (PT, current_buffer, Qlocal_map); - if (!NILP (local)) - keymaps = Fcons (local, keymaps); + Lisp_Object keymap, local_map; + EMACS_INT pt; + + pt = INTEGERP (position) ? XINT (position) + : MARKERP (position) ? marker_position (position) + : PT; + + /* Get the buffer local maps, possibly overriden by text or + overlay properties */ + + 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 (local_map)) + keymaps = Fcons (local_map, keymaps); /* Now put all the minor mode keymaps on the list. */ nmaps = current_minor_maps (0, &maps); @@ -1549,12 +1666,12 @@ OLP if non-nil indicates that we should obey `overriding-local-map' and if (!NILP (maps[i])) keymaps = Fcons (maps[i], keymaps); - /* This returns nil unless there is a `keymap' property. */ - local = get_local_map (PT, current_buffer, Qkeymap); - if (!NILP (local)) - keymaps = Fcons (local, keymaps); + if (!NILP (keymap)) + keymaps = Fcons (keymap, keymaps); } + unbind_to (count, Qnil); + return keymaps; } @@ -1605,10 +1722,10 @@ specified buffer position instead of point are used. /* We are not interested in locations without event data */ - if (EVENT_HAS_PARAMETERS (event)) + if (EVENT_HAS_PARAMETERS (event) && CONSP (XCDR (event))) { Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (event)); - if (CONSP (XCDR (event)) && EQ (kind, Qmouse_click)) + if (EQ (kind, Qmouse_click)) position = EVENT_START (event); } } @@ -1761,7 +1878,7 @@ specified buffer position instead of point are used. if (NILP (no_remap) && SYMBOLP (value)) { Lisp_Object value1; - if (value1 = Fcommand_remapping (value, position), !NILP (value1)) + if (value1 = Fcommand_remapping (value, position, Qnil), !NILP (value1)) value = value1; } @@ -1922,12 +2039,23 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_ /* Help functions for describing and documenting keymaps. */ +struct accessible_keymaps_data { + Lisp_Object maps, tail, thisseq; + /* Does the current sequence end in the meta-prefix-char? */ + int is_metized; +}; static void -accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized) - Lisp_Object maps, tail, thisseq, key, cmd; - int is_metized; /* If 1, `key' is assumed to be INTEGERP. */ +accessible_keymaps_1 (key, cmd, args, data) + Lisp_Object key, cmd, args; + /* Use void* to be compatible with map_keymap_function_t. */ + void *data; { + struct accessible_keymaps_data *d = data; /* Cast! */ + Lisp_Object maps = d->maps; + Lisp_Object tail = d->tail; + Lisp_Object thisseq = d->thisseq; + int is_metized = d->is_metized && INTEGERP (key); Lisp_Object tem; cmd = get_keymap (get_keyelt (cmd, 0), 0, 0); @@ -1981,17 +2109,6 @@ accessible_keymaps_1 (key, cmd, maps, tail, thisseq, is_metized) } } -static void -accessible_keymaps_char_table (args, index, cmd) - Lisp_Object args, index, cmd; -{ - accessible_keymaps_1 (index, cmd, - XCAR (XCAR (args)), - XCAR (XCDR (args)), - XCDR (XCDR (args)), - XINT (XCDR (XCAR (args)))); -} - /* This function cannot GC. */ DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps, @@ -2006,13 +2123,10 @@ then the value includes only maps for prefixes that start with PREFIX. */) Lisp_Object keymap, prefix; { Lisp_Object maps, tail; - int prefixlen = 0; + int prefixlen = XINT (Flength (prefix)); /* no need for gcpro because we don't autoload any keymaps. */ - if (!NILP (prefix)) - prefixlen = XINT (Flength (prefix)); - if (!NILP (prefix)) { /* If a prefix was specified, start with the keymap (if any) for @@ -2023,7 +2137,9 @@ then the value includes only maps for prefixes that start with PREFIX. */) if the prefix is not defined in this particular map. It might even give us a list that isn't a keymap. */ tem = get_keymap (tem, 0, 0); - if (CONSP (tem)) + /* If the keymap is autoloaded `tem' is not a cons-cell, but we still + want to return it. */ + if (!NILP (tem)) { /* Convert PREFIX to a vector now, so that later on we don't have to deal with the possibility of a string. */ @@ -2063,57 +2179,26 @@ then the value includes only maps for prefixes that start with PREFIX. */) for (tail = maps; CONSP (tail); tail = XCDR (tail)) { - register Lisp_Object thisseq, thismap; + struct accessible_keymaps_data data; + register Lisp_Object thismap = Fcdr (XCAR (tail)); Lisp_Object last; - /* Does the current sequence end in the meta-prefix-char? */ - int is_metized; - thisseq = Fcar (Fcar (tail)); - thismap = Fcdr (Fcar (tail)); - last = make_number (XINT (Flength (thisseq)) - 1); - is_metized = (XINT (last) >= 0 + data.thisseq = Fcar (XCAR (tail)); + data.maps = maps; + data.tail = tail; + last = make_number (XINT (Flength (data.thisseq)) - 1); + /* Does the current sequence end in the meta-prefix-char? */ + data.is_metized = (XINT (last) >= 0 /* Don't metize the last char of PREFIX. */ && XINT (last) >= prefixlen - && EQ (Faref (thisseq, last), meta_prefix_char)); - - for (; CONSP (thismap); thismap = XCDR (thismap)) - { - Lisp_Object elt; - - elt = XCAR (thismap); - - QUIT; - - if (CHAR_TABLE_P (elt)) - { - Lisp_Object indices[3]; - - map_char_table (accessible_keymaps_char_table, Qnil, elt, - elt, Fcons (Fcons (maps, make_number (is_metized)), - Fcons (tail, thisseq)), - 0, indices); - } - else if (VECTORP (elt)) - { - register int i; - - /* Vector keymap. Scan all the elements. */ - for (i = 0; i < ASIZE (elt); i++) - accessible_keymaps_1 (make_number (i), AREF (elt, i), - maps, tail, thisseq, is_metized); + && EQ (Faref (data.thisseq, last), meta_prefix_char)); - } - else if (CONSP (elt)) - accessible_keymaps_1 (XCAR (elt), XCDR (elt), - maps, tail, thisseq, - is_metized && INTEGERP (XCAR (elt))); - - } + /* Since we can't run lisp code, we can't scan autoloaded maps. */ + if (CONSP (thismap)) + map_keymap (thismap, accessible_keymaps_1, Qnil, &data, 0); } - return maps; } - Lisp_Object Qsingle_key_description, Qkey_description; /* This function cannot GC. */ @@ -2158,7 +2243,7 @@ spaces are put between sequence elements, etc. */) len += 2; } else if (len == 0) - return empty_string; + return empty_unibyte_string; return Fconcat (len - 1, args); } @@ -2384,7 +2469,7 @@ around function keys and event symbols. */) { char buf[256]; - sprintf (buf, "Invalid char code %d", XINT (key)); + sprintf (buf, "Invalid char code %ld", XINT (key)); return build_string (buf); } else if (charset @@ -2527,8 +2612,8 @@ ascii_sequence_p (seq) /* where-is - finding a command in a set of keymaps. */ static Lisp_Object where_is_internal (); -static Lisp_Object where_is_internal_1 (); -static void where_is_internal_2 (); +static void where_is_internal_1 P_ ((Lisp_Object key, Lisp_Object binding, + Lisp_Object args, void *data)); /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map. Returns the first non-nil binding found in any of those maps. */ @@ -2557,6 +2642,12 @@ shadow_lookup (shadow, key, flag) static Lisp_Object Vmouse_events; +struct where_is_internal_data { + Lisp_Object definition, noindirect, this, last; + int last_is_meta; + Lisp_Object sequences; +}; + /* This function can GC if Flookup_key autoloads any keymaps. */ static Lisp_Object @@ -2570,15 +2661,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, Qnil), !NILP (tem)) - return Qnil; - } - found = keymaps; while (CONSP (found)) { @@ -2592,10 +2674,18 @@ 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 */ register Lisp_Object this, map, tem; + struct where_is_internal_data data; /* In order to fold [META-PREFIX-CHAR CHAR] sequences into [M-CHAR] sequences, check if last character of the sequence @@ -2620,148 +2710,94 @@ where_is_internal (definition, keymaps, firstonly, noindirect, no_remap) QUIT; - while (CONSP (map)) - { - /* Because the code we want to run on each binding is rather - large, we don't want to have two separate loop bodies for - sparse keymap bindings and tables; we want to iterate one - loop body over both keymap and vector bindings. + data.definition = definition; + data.noindirect = noindirect; + data.this = this; + data.last = last; + data.last_is_meta = last_is_meta; + data.sequences = Qnil; - For this reason, if Fcar (map) is a vector, we don't - advance map to the next element until i indicates that we - have finished off the vector. */ - Lisp_Object elt, key, binding; - elt = XCAR (map); - map = XCDR (map); + if (CONSP (map)) + map_keymap (map, where_is_internal_1, Qnil, &data, 0); - sequences = Qnil; + sequences = data.sequences; - QUIT; - - /* Set key and binding to the current key and binding, and - advance map and i to the next binding. */ - if (VECTORP (elt)) + while (CONSP (sequences)) + { + Lisp_Object sequence, remapped, function; + + sequence = XCAR (sequences); + sequences = XCDR (sequences); + + /* If the current sequence is a command remapping with + format [remap COMMAND], find the key sequences + which run COMMAND, and use those sequences instead. */ + remapped = Qnil; + if (NILP (no_remap) + && VECTORP (sequence) && XVECTOR (sequence)->size == 2 + && EQ (AREF (sequence, 0), Qremap) + && (function = AREF (sequence, 1), SYMBOLP (function))) { - Lisp_Object sequence; - int i; - /* In a vector, look at each element. */ - for (i = 0; i < XVECTOR (elt)->size; i++) + Lisp_Object remapped1; + + remapped1 = where_is_internal (function, keymaps, firstonly, noindirect, Qt); + if (CONSP (remapped1)) { - binding = AREF (elt, i); - XSETFASTINT (key, i); - sequence = where_is_internal_1 (binding, key, definition, - noindirect, this, - last, nomenus, last_is_meta); - if (!NILP (sequence)) - sequences = Fcons (sequence, sequences); + /* Verify that this key binding actually maps to the + remapped command (see below). */ + if (!EQ (shadow_lookup (keymaps, XCAR (remapped1), Qnil), function)) + continue; + sequence = XCAR (remapped1); + remapped = XCDR (remapped1); + goto record_sequence; } } - else if (CHAR_TABLE_P (elt)) - { - Lisp_Object indices[3]; - Lisp_Object args; - - args = Fcons (Fcons (Fcons (definition, noindirect), - Qnil), /* Result accumulator. */ - Fcons (Fcons (this, last), - Fcons (make_number (nomenus), - make_number (last_is_meta)))); - map_char_table (where_is_internal_2, Qnil, elt, elt, args, - 0, indices); - sequences = XCDR (XCAR (args)); - } - else if (CONSP (elt)) - { - Lisp_Object sequence; - key = XCAR (elt); - binding = XCDR (elt); + /* Verify that this key binding is not shadowed by another + binding for the same key, before we say it exists. - sequence = where_is_internal_1 (binding, key, definition, - noindirect, this, - last, nomenus, last_is_meta); - if (!NILP (sequence)) - sequences = Fcons (sequence, sequences); - } + Mechanism: look for local definition of this key and if + it is defined and does not match what we found then + ignore this key. + Either nil or number as value from Flookup_key + means undefined. */ + if (!EQ (shadow_lookup (keymaps, sequence, Qnil), definition)) + continue; - while (!NILP (sequences)) + record_sequence: + /* Don't annoy user with strings from a menu such as + Select Paste. Change them all to "(any string)", + so that there seems to be only one menu item + to report. */ + if (! NILP (sequence)) { - Lisp_Object sequence, remapped, function; - - sequence = XCAR (sequences); - sequences = XCDR (sequences); - - /* If the current sequence is a command remapping with - format [remap COMMAND], find the key sequences - which run COMMAND, and use those sequences instead. */ - remapped = Qnil; - if (NILP (no_remap) - && VECTORP (sequence) && XVECTOR (sequence)->size == 2 - && EQ (AREF (sequence, 0), Qremap) - && (function = AREF (sequence, 1), SYMBOLP (function))) - { - Lisp_Object remapped1; - - remapped1 = where_is_internal (function, keymaps, firstonly, noindirect, Qt); - if (CONSP (remapped1)) - { - /* Verify that this key binding actually maps to the - remapped command (see below). */ - if (!EQ (shadow_lookup (keymaps, XCAR (remapped1), Qnil), function)) - continue; - sequence = XCAR (remapped1); - remapped = XCDR (remapped1); - goto record_sequence; - } - } - - /* Verify that this key binding is not shadowed by another - binding for the same key, before we say it exists. - - Mechanism: look for local definition of this key and if - it is defined and does not match what we found then - ignore this key. - - Either nil or number as value from Flookup_key - means undefined. */ - if (!EQ (shadow_lookup (keymaps, sequence, Qnil), definition)) - continue; - - record_sequence: - /* Don't annoy user with strings from a menu such as - Select Paste. Change them all to "(any string)", - so that there seems to be only one menu item - to report. */ - if (! NILP (sequence)) - { - Lisp_Object tem; - tem = Faref (sequence, make_number (XVECTOR (sequence)->size - 1)); - if (STRINGP (tem)) - Faset (sequence, make_number (XVECTOR (sequence)->size - 1), - build_string ("(any string)")); - } + Lisp_Object tem; + tem = Faref (sequence, make_number (XVECTOR (sequence)->size - 1)); + if (STRINGP (tem)) + Faset (sequence, make_number (XVECTOR (sequence)->size - 1), + build_string ("(any string)")); + } - /* It is a true unshadowed match. Record it, unless it's already - been seen (as could happen when inheriting keymaps). */ - if (NILP (Fmember (sequence, found))) - found = Fcons (sequence, found); - - /* If firstonly is Qnon_ascii, then we can return the first - binding we find. If firstonly is not Qnon_ascii but not - nil, then we should return the first ascii-only binding - we find. */ - if (EQ (firstonly, Qnon_ascii)) - RETURN_UNGCPRO (sequence); - else if (!NILP (firstonly) && ascii_sequence_p (sequence)) - RETURN_UNGCPRO (sequence); - - if (CONSP (remapped)) - { - sequence = XCAR (remapped); - remapped = XCDR (remapped); - goto record_sequence; - } + /* It is a true unshadowed match. Record it, unless it's already + been seen (as could happen when inheriting keymaps). */ + if (NILP (Fmember (sequence, found))) + found = Fcons (sequence, found); + + /* If firstonly is Qnon_ascii, then we can return the first + binding we find. If firstonly is not Qnon_ascii but not + nil, then we should return the first ascii-only binding + we find. */ + if (EQ (firstonly, Qnon_ascii)) + RETURN_UNGCPRO (sequence); + else if (!NILP (firstonly) && ascii_sequence_p (sequence)) + RETURN_UNGCPRO (sequence); + + if (CONSP (remapped)) + { + sequence = XCAR (remapped); + remapped = XCDR (remapped); + goto record_sequence; } } } @@ -2814,7 +2850,7 @@ remapped command in the returned list. */) else if (!NILP (keymap)) keymaps = Fcons (keymap, Fcons (current_global_map, Qnil)); else - keymaps = Fcurrent_active_maps (Qnil); + keymaps = Fcurrent_active_maps (Qnil, Qnil); /* Only use caching for the menubar (i.e. called with (def nil t nil). We don't really need to check `keymap'. */ @@ -2880,53 +2916,19 @@ remapped command in the returned list. */) return result; } -/* This is the function that Fwhere_is_internal calls using map_char_table. - ARGS has the form - (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT)) - . - ((THIS . LAST) . (NOMENUS . LAST_IS_META))) - Since map_char_table doesn't really use the return value from this function, - we the result append to RESULT, the slot in ARGS. - - This function can GC because it calls where_is_internal_1 which can - GC. */ - -static void -where_is_internal_2 (args, key, binding) - Lisp_Object args, key, binding; -{ - Lisp_Object definition, noindirect, this, last; - Lisp_Object result, sequence; - int nomenus, last_is_meta; - struct gcpro gcpro1, gcpro2, gcpro3; - - GCPRO3 (args, key, binding); - result = XCDR (XCAR (args)); - definition = XCAR (XCAR (XCAR (args))); - noindirect = XCDR (XCAR (XCAR (args))); - this = XCAR (XCAR (XCDR (args))); - last = XCDR (XCAR (XCDR (args))); - nomenus = XFASTINT (XCAR (XCDR (XCDR (args)))); - last_is_meta = XFASTINT (XCDR (XCDR (XCDR (args)))); - - sequence = where_is_internal_1 (binding, key, definition, noindirect, - this, last, nomenus, last_is_meta); - - if (!NILP (sequence)) - XSETCDR (XCAR (args), Fcons (sequence, result)); - - UNGCPRO; -} - - /* This function can GC because get_keyelt can. */ -static Lisp_Object -where_is_internal_1 (binding, key, definition, noindirect, this, last, - nomenus, last_is_meta) - Lisp_Object binding, key, definition, noindirect, this, last; - int nomenus, last_is_meta; +static void +where_is_internal_1 (key, binding, args, data) + Lisp_Object key, binding, args; + void *data; { + struct where_is_internal_data *d = data; /* Cast! */ + Lisp_Object definition = d->definition; + Lisp_Object noindirect = d->noindirect; + Lisp_Object this = d->this; + Lisp_Object last = d->last; + int last_is_meta = d->last_is_meta; Lisp_Object sequence; /* Search through indirections unless that's not wanted. */ @@ -2940,7 +2942,7 @@ where_is_internal_1 (binding, key, definition, noindirect, this, last, || EQ (binding, definition) || (CONSP (definition) && !NILP (Fequal (binding, definition))))) /* Doesn't match. */ - return Qnil; + return; /* We have found a match. Construct the key sequence where we found it. */ if (INTEGERP (key) && last_is_meta) @@ -2955,10 +2957,9 @@ where_is_internal_1 (binding, key, definition, noindirect, this, last, { Lisp_Object sequences = Fgethash (binding, where_is_cache, Qnil); Fputhash (binding, Fcons (sequence, sequences), where_is_cache); - return Qnil; } else - return sequence; + d->sequences = Fcons (sequence, d->sequences); } /* describe-bindings - summarizing all the bindings in a set of keymaps. */ @@ -2985,6 +2986,8 @@ Keyboard translations:\n\n\ You type Translation\n\ -------- -----------\n"; + CHECK_BUFFER (buffer); + shadow = Qnil; GCPRO1 (shadow);