* keyboard.c: #include dispextern.h.

	(recursive_edit_unwind, command_loop, Fthis_command_keys): Declare
	these to return Lisp_Objects at the very top of the file, to avoid
	having them implicitly declared as ints.
	(echo_char): Use EQ to compare C to help_char.
	(read_char): Remember to apply XFASTINT to the return value of
	Flength before using it.  Apply XINT to c when clearing its high
	bits and meta bits, and when writing it to the dribble file.
	(read_char_menu_prompt): Use EQ to compare obj with
	menu_prompt_more_char and its control-character analog.
	(read_key_sequence): Declare PROMPT to be char *, not a
	Lisp_Object.  Use the appropriate accessors on keybuf when looking
	for ASCII function key sequences.

	* keyboard.c (echobuf): Make this 300 characters, not 100.  This
	isn't a real fix, but it's quick.

	* keyboard.c (read_char): When returning an unread switch-frame
	event, jump to reread_first to return it, rather than reread; this
	makes sure the event gets echoed (if appropriate) and goes into
	this_command_keys.

	* keyboard.c (read_key_sequence): If the key sequence starts with
	a mouse click, read the key sequence using the keymaps of the
	buffer clicked on, not the current buffer.

	* keyboard.c (unread_switch_frame): Make this static, to indicate
	that nobody outside of this file uses it.

	* keyboard.c (follow_key): Ask get_keymap_1 to perform autoloads.
	(read_key_sequence): When pursuing potential bindings in the
	function key map, ask get_keymap_1 to perform autoloading.  This
	is hardly important, but it's consistent.

1 files changed, 202 insertions, 151 deletions

diff --git a/src/keyboard.c b/src/keyboard.c
index 7d377ea679e..b107c1cc3c8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -33,6 +33,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "commands.h"
 #include "buffer.h"
 #include "disptab.h"
+#include "dispextern.h"
 #include "keyboard.h"
 #include <setjmp.h>
 #include <errno.h>
@@ -156,8 +157,10 @@ Lisp_Object unread_command_char;
 
 /* If not Qnil, this is a switch-frame event which we decided to put
    off until the end of a key sequence.  This should be read as the
-   next command input, after any unread_command_char.  */
-Lisp_Object unread_switch_frame;
+   next command input, after any unread_command_char.  Only
+   read_key_sequence sets this; it uses it to delay switch-frame
+   events until the end of the key sequence.  */
+static Lisp_Object unread_switch_frame;
 
 /* Char to use as prefix when a meta character is typed in.
    This is bound on entry to minibuffer in case ESC is changed there.  */
@@ -323,6 +326,8 @@ Lisp_Object Qmodifier_cache;
 Lisp_Object Qmode_line;
 Lisp_Object Qvertical_line;
 
+Lisp_Object recursive_edit_unwind (), command_loop ();
+Lisp_Object Fthis_command_keys ();
 
 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
    happens.  */
@@ -374,8 +379,8 @@ static int echo_keystrokes;
 static int immediate_echo;
 
 /* The text we're echoing in the modeline - partial key sequences,
-   usually.  '\0'-terminated.  */
-static char echobuf[100];
+   usually.  '\0'-terminated.  This really shouldn't have a fixed size.  */
+static char echobuf[300];
 
 /* Where to append more text to echobuf if we want to.  */
 static char *echoptr;
@@ -435,7 +440,7 @@ echo_char (c)
           ptr += name->size;
         }
 
-      if (echoptr == echobuf && c == help_char)
+      if (echoptr == echobuf && EQ (c, help_char))
         {
           strcpy (ptr, " (Type ? for further options)");
           ptr += strlen (ptr);
@@ -563,8 +568,6 @@ record_auto_save ()
   last_auto_save = num_nonmacro_input_chars;
 }
 
-Lisp_Object recursive_edit_unwind (), command_loop ();
-
 DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
   "Invoke the editor command loop recursively.\n\
 To get out of the recursive edit, a command can do `(throw 'exit nil)';\n\
@@ -1143,7 +1146,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
          from a macro should never cause a new frame to be selected.  */
       Vlast_event_frame = Qmacro;
 
-      if (executing_macro_index >= Flength (Vexecuting_macro))
+      if (executing_macro_index >= XFASTINT (Flength (Vexecuting_macro)))
         {
           XSET (c, Lisp_Int, -1);
           return c;
@@ -1161,8 +1164,8 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
       unread_switch_frame = Qnil;
 
       /* This event should make it into this_command_keys, and get echoed
-         again, so we go to reread, rather than reread_first.  */
-      goto reread;
+         again, so we go to reread_first, rather than reread.  */
+      goto reread_first;
     }
 
   /* Save outer setjmp data, in case called recursively.  */
@@ -1299,11 +1302,11 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
         return c;
 
       /* Strip the high bits, and maybe the meta bit too.  */
-      XSETINT (c, c & (meta_key ? 0377 : 0177));
+      XSETINT (c, XINT (c) & (meta_key ? 0377 : 0177));
 
       if (XTYPE (Vkeyboard_translate_table) == Lisp_String
-          && XSTRING (Vkeyboard_translate_table)->size > XINT (c))
-        XSETINT (c, XSTRING (Vkeyboard_translate_table)->data[c]);
+          && XSTRING (Vkeyboard_translate_table)->size > XFASTINT (c))
+        XSETINT (c, XSTRING (Vkeyboard_translate_table)->data[XFASTINT (c)]);
     }
 
   total_keys++;
@@ -1317,7 +1320,7 @@ read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
   if (dribble)
     {
       if (XTYPE (c) == Lisp_Int)
-        putc (c, dribble);
+        putc (XINT (c), dribble);
       else
         {
           Lisp_Object dribblee = c;
@@ -2727,9 +2730,9 @@ read_char_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
       else
         ch = XINT (obj);
 
-      if (obj != menu_prompt_more_char
+      if (! EQ (obj, menu_prompt_more_char)
           && (XTYPE (menu_prompt_more_char) != Lisp_Int
-              || obj != make_number (Ctl (XINT (menu_prompt_more_char)))))
+              || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
         return obj;
     }
 }
@@ -2777,7 +2780,7 @@ follow_key (key, nmaps, current, defs, next)
             /* Note that since we pass the resulting bindings through
                get_keymap_1, non-prefix bindings for meta-prefix-char
                disappear.  */
-            next[i] = get_keymap_1 (next[i], 0);
+            next[i] = get_keymap_1 (next[i], 0, 1);
           }
         else
           next[i] = Qnil;
@@ -2825,82 +2828,98 @@ follow_key (key, nmaps, current, defs, next)
   /* Given the set of bindings we've found, produce the next set of maps.  */
   if (first_binding < nmaps)
     for (i = 0; i < nmaps; i++)
-      next[i] = NILP (defs[i]) ? Qnil : get_keymap_1 (defs[i], 0);
+      next[i] = NILP (defs[i]) ? Qnil : get_keymap_1 (defs[i], 0, 1);
 
   return first_binding;
 }
 
-/* Read a sequence of keys that ends with a non prefix character
-   according to the keymaps in KEYMAPS[0..nmaps-1].  Keymaps appearing
-   earlier in KEYMAPS take precidence over those appearing later.
-
-   Store the sequence in KEYBUF, a buffer of size BUFSIZE.  Prompt
-   with PROMPT.  Echo starting immediately unless `prompt' is 0.
+/* Read a sequence of keys that ends with a non prefix character, 
+   storing it in KEYBUF, a buffer of size BUFSIZE.
+   Prompt with PROMPT.
    Return the length of the key sequence stored.
 
-   If the user switches frames in the midst of a key sequence, we
-   throw away any prefix we have read so far, and start afresh.  For
-   mouse clicks, we look up the click in the keymap of the buffer
-   clicked on, throwing away any prefix if it is not the same buffer
-   we used to be reading from.  */
+   Echo starting immediately unless `prompt' is 0.
+
+   Where a key sequence ends depends on the currently active keymaps.
+   These include any minor mode keymaps active in the current buffer,
+   the current buffer's local map, and the global map.
+
+   If a key sequence has no other bindings, we check Vfunction_key_map
+   to see if some trailing subsequence might be the beginning of a
+   function key's sequence.  If so, we try to read the whole function
+   key, and substitute its symbolic name into the key sequence.
+
+   We ignore unbound `down-' mouse clicks.  We turn unbound `drag-'
+   events into similar click events, if that would make them bound.
+
+   If we get a mouse click in a mode line, vertical divider, or other
+   non-text area, we treat the click as if it were prefixed by the
+   symbol denoting that area - `mode-line', `vertical-line', or
+   whatever.
+
+   If the sequence starts with a mouse click, we read the key sequence
+   with respect to the buffer clicked on, not the current buffer.
 
+   If the user switches frames in the midst of a key sequence, we put
+   off the switch-frame event until later; the next call to
+   read_char will return it.  */
 static int
 read_key_sequence (keybuf, bufsize, prompt)
      Lisp_Object *keybuf;
      int bufsize;
-     Lisp_Object prompt;
+     char *prompt;
 {
+  int count = specpdl_ptr - specpdl;
+
   /* How many keys there are in the current key sequence.  */
   int t;
 
-  /* The buffer that the most recently read event was typed at.  This
-     helps us read mouse clicks according to the buffer clicked in,
-     and notice when the mouse has moved from one frame to another.  */
-  struct buffer *last_event_buffer = current_buffer;
-
   /* The length of the echo buffer when we started reading, and
      the length of this_command_keys when we started reading.  */
   int echo_start;
-  int keys_start = this_command_key_count;
+  int keys_start;
 
   /* The number of keymaps we're scanning right now, and the number of
      keymaps we have allocated space for.  */
   int nmaps;
   int nmaps_allocated = 0;
 
-  /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
-     in the current keymaps, or nil where it is not a prefix.  */
-  Lisp_Object *submaps;
-
   /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
      the current keymaps.  */
   Lisp_Object *defs;
 
-  /* The index of the first keymap that has a binding for this key
-     sequence.  In other words, the lowest i such that defs[i] is
-     non-nil.*/
+  /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
+     in the current keymaps, or nil where it is not a prefix.  */
+  Lisp_Object *submaps;
+
+  /* The index in defs[] of the first keymap that has a binding for
+     this key sequence.  In other words, the lowest i such that
+     defs[i] is non-nil.  */
   int first_binding;
 
-  /* If mock_input > t, then KEYBUF[t] should be read as the next
+  /* If t < mock_input, then KEYBUF[t] should be read as the next
      input key.
 
      We use this to recover after recognizing a function key.  Once we
      realize that a suffix of the current key sequence is actually a
      function key's escape sequence, we replace the suffix with the
      function key's binding from Vfunction_key_map.  Now keybuf
-     contains a new and different key sequence, so the echo area and
-     the submaps and defs arrays are wrong.  In this situation, we set
-     mock_input to t, set t to 0, and jump to restart; the loop will
-     read keys from keybuf up until mock_input, which rebuilds the
-     state, and then it will resume reading characters from the keyboard.  */
+     contains a new and different key sequence, so the echo area,
+     this_command_keys, and the submaps and defs arrays are wrong.  In
+     this situation, we set mock_input to t, set t to 0, and jump to
+     restart_sequence; the loop will read keys from keybuf up until
+     mock_input, thus rebuilding the state; and then it will resume
+     reading characters from the keyboard.  */
   int mock_input = 0;
 
   /* If the sequence is unbound in submaps[], then
-     keymap[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
-     and fkey_map is its binding.  If mock_input is in use, these
-     might be > t, indicating that all function key scanning should
-     hold off until t reaches them.  */
+     keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
+     and fkey_map is its binding.
 
+     These might be > t, indicating that all function key scanning
+     should hold off until t reaches them.  We do this when we've just
+     recognized a function key, to avoid searching for the function
+     key's again in Vfunction_key_map.  */
   int fkey_start = 0, fkey_end = 0;
   Lisp_Object fkey_map = Vfunction_key_map;
 
@@ -2908,6 +2927,15 @@ read_key_sequence (keybuf, bufsize, prompt)
      we put it off for later.  While we're reading, we keep the event here.  */
   Lisp_Object delayed_switch_frame = Qnil;
 
+
+  /* If there is no function key map, turn off function key scanning.  */
+  if (NILP (Fkeymapp (Vfunction_key_map)))
+    fkey_start = fkey_end = bufsize + 1;
+
+  /* We need to save the current buffer in case we switch buffers to
+     find the right binding for a mouse click.  */
+  record_unwind_protect (save_excursion_restore, save_excursion_save ());
+                         
   last_nonmenu_event = Qnil;
 
   if (INTERACTIVE)
@@ -2918,22 +2946,18 @@ read_key_sequence (keybuf, bufsize, prompt)
         /* This doesn't put in a dash if the echo buffer is empty, so
            you don't always see a dash hanging out in the minibuffer.  */
         echo_dash ();
-      echo_start = echo_length ();
     }
 
-  /* If there is no function key map, turn off function key scanning.  */
-  if (NILP (Fkeymapp (Vfunction_key_map)))
-    fkey_start = fkey_end = bufsize + 1;
-
- restart:
-  t = 0;
-  this_command_key_count = keys_start;
-
-  /* This is a no-op the first time through, but if we restart, it
-     reverts the echo area to its original state.  */
+  /* Record the initial state of the echo area and this_command_keys;
+     we will need to restore them if we replay a key sequence.  */
   if (INTERACTIVE)
-    echo_truncate (echo_start);
+    echo_start = echo_length ();
+  keys_start = this_command_key_count;
 
+ replay_sequence_new_buffer:
+  /* Build our list of keymaps.
+     If the sequence starts with a mouse click, we may need to switch buffers
+     and jump back here; that's what replay_sequence_new_buffer is for.  */
   { 
     Lisp_Object *maps;
 
@@ -2945,7 +2969,7 @@ read_key_sequence (keybuf, bufsize, prompt)
         nmaps_allocated = nmaps;
       }
     bcopy (maps, submaps, (nmaps - 2) * sizeof (submaps[0]));
-    submaps[nmaps-2] = last_event_buffer->keymap;
+    submaps[nmaps-2] = current_buffer->keymap;
     submaps[nmaps-1] = global_map;
   }
 
@@ -2954,6 +2978,21 @@ read_key_sequence (keybuf, bufsize, prompt)
     if (! NILP (submaps[first_binding]))
       break;
 
+ replay_sequence:
+  /* We jump here when a function key substitution has forced us to
+     reprocess the current key sequence.  keybuf[0..mock_input] is the
+     sequence we want to reread.  */
+  t = 0;
+
+  /* These are no-ops the first time through, but if we restart, they
+     revert the echo area and this_command_keys to their original state.  */
+  this_command_key_count = keys_start;
+  if (INTERACTIVE)
+    echo_truncate (echo_start);
+
+  /* If the best binding for the current key sequence is a keymap,
+     or we may be looking at a function key's escape sequence, keep
+     on reading.  */
   while ((first_binding < nmaps && ! NILP (submaps[first_binding]))
          || (first_binding >= nmaps && fkey_start < t))
     {
@@ -2964,23 +3003,27 @@ read_key_sequence (keybuf, bufsize, prompt)
          while those allow us to restart the entire key sequence,
          echo_local_start and keys_local_start allow us to throw away
          just one key.  */
-      int echo_local_start = echo_length ();
-      int keys_local_start = this_command_key_count;
-      int local_first_binding = first_binding;
-      
+      int echo_local_start, keys_local_start, local_first_binding;
+
       if (t >= bufsize)
         error ("key sequence too long");
 
-    retry_key:
+      if (INTERACTIVE)
+        echo_local_start = echo_length ();
+      keys_local_start = this_command_key_count;
+      local_first_binding = first_binding;
+      
+    replay_key:
       /* These are no-ops, unless we throw away a keystroke below and
-         jumped back up to retry_key; in that case, these restore these
-         variables to their original state, allowing us to restart the
+         jumped back up to replay_key; in that case, these restore the
+         variables to their original state, allowing us to replay the
          loop.  */
-      echo_truncate (echo_local_start);
+      if (INTERACTIVE)
+        echo_truncate (echo_local_start);
       this_command_key_count = keys_local_start;
       first_binding = local_first_binding;
 
-      /* Are we re-reading a key sequence, as indicated by mock_input?  */
+      /* Does mock_input indicate that we are re-reading a key sequence?  */
       if (t < mock_input)
         {
           key = keybuf[t];
@@ -2991,33 +3034,64 @@ read_key_sequence (keybuf, bufsize, prompt)
       /* If not, we should actually read a character.  */
       else
         {
-          struct buffer *buf;
-
           key = read_char (!prompt, nmaps, submaps, last_nonmenu_event,
                            &used_mouse_menu);
 
-          /* The above routines return -1 at the end of a macro.
+          /* read_char returns -1 at the end of a macro.
              Emacs 18 handles this by returning immediately with a
              zero, so that's what we'll do.  */
           if (XTYPE (key) == Lisp_Int && XINT (key) < 0)
             {
-              unread_switch_frame = delayed_switch_frame;
-              return 0;
+              t = 0;
+              goto done;
             }
           
           Vquit_flag = Qnil;
 
           /* Clicks in non-text areas get prefixed by the symbol 
              in their CHAR-ADDRESS field.  For example, a click on
-             the mode line is prefixed by the symbol `mode-line'.  */
+             the mode line is prefixed by the symbol `mode-line'.
+
+             Furthermore, 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 (EVENT_HAS_PARAMETERS (key))
             {
               Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
+
               if (EQ (kind, Qmouse_click))
                 {
-                  Lisp_Object posn = POSN_BUFFER_POSN (EVENT_START (key));
+                  Lisp_Object window = POSN_WINDOW      (EVENT_START (key));
+                  Lisp_Object posn   = POSN_BUFFER_POSN (EVENT_START (key));
+
+                  /* Key sequences beginning with mouse clicks are
+                     read using the keymaps in the buffer clicked on,
+                     not the current buffer.  If we're at the
+                     beginning of a key sequence, switch buffers.  */
+                  if (t == 0
+                      && XTYPE (window) == Lisp_Window
+                      && XTYPE (XWINDOW (window)->buffer) == Lisp_Buffer
+                      && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+                    {
+                      if (XTYPE (posn) == Lisp_Symbol)
+                        {
+                          if (t + 1 >= bufsize)
+                            error ("key sequence too long");
+                          keybuf[t] = posn;
+                          keybuf[t+1] = key;
+                          mock_input = t + 2;
+                        }
+                      else
+                        {
+                          keybuf[t] = key;
+                          mock_input = t + 1;
+                        }
 
-                  if (XTYPE (posn) == Lisp_Symbol)
+                      set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+                      goto replay_sequence_new_buffer;
+                    }
+                  else if (XTYPE (posn) == Lisp_Symbol)
                     {
                       if (t + 1 >= bufsize)
                         error ("key sequence too long");
@@ -3025,7 +3099,7 @@ read_key_sequence (keybuf, bufsize, prompt)
                       keybuf[t+1] = key;
                       mock_input = t + 2;
 
-                      goto retry_key;
+                      goto replay_key;
                     }
                 }
               else if (EQ (kind, Qswitch_frame))
@@ -3036,57 +3110,14 @@ read_key_sequence (keybuf, bufsize, prompt)
                   if (t > 0)
                     {
                       delayed_switch_frame = key;
-                      goto retry_key;
+                      goto replay_key;
                     }
                 }
             }
-
-#if 0   /* This shouldn't be necessary any more, now that we have
-           switch-frame events.  */
-#ifdef MULTI_FRAME
-          /* What buffer was this event typed/moused at?  */
-          if (used_mouse_menu)
-            /* Never change last_event_buffer for using a menu.  */
-            buf = last_event_buffer;
-          else if (XTYPE (key) == Lisp_Int || XTYPE (key) == Lisp_Symbol)
-            {
-              buf = ((XTYPE (Vlast_event_frame) == Lisp_Frame)
-                     ? (XBUFFER
-                        (XWINDOW
-                         (FRAME_SELECTED_WINDOW
-                          (XFRAME (Vlast_event_frame)))->buffer))
-                     : last_event_buffer);
-            }
-          else if (EVENT_HAS_PARAMETERS (key))
-            {
-              Lisp_Object window = POSN_WINDOW (EVENT_START (key));
-
-              if (NILP (window))
-                abort ();
-
-              buf = XBUFFER (XWINDOW (window)->buffer);
-            }
-          else
-            abort ();
-
-          /* If this event came to a different buffer than the one
-             we're currently in, switch buffers and start a new key
-             sequence, starting with key.  */
-          if (buf != last_event_buffer)
-            {
-              last_event_buffer = buf;
-              Fselect_frame (Vlast_event_frame, Qnil);
-
-              /* Arrange to read key as the next event.  */
-              keybuf[0] = key;
-              mock_input = 1;
-
-              goto restart;
-            }
-#endif /* MULTI_FRAME */
-#endif /* 0 */
         }
-          
+
+      /* We have finally decided that KEY is something we might want
+         to look up.  */
       first_binding = (follow_key (key,
                                    nmaps   - first_binding,
                                    submaps + first_binding,
@@ -3094,7 +3125,7 @@ read_key_sequence (keybuf, bufsize, prompt)
                                    submaps + first_binding)
                        + first_binding);
 
-      /* If this key wasn't bound, we'll try some fallbacks.  */
+      /* If KEY wasn't bound, we'll try some fallbacks.  */
       if (first_binding >= nmaps)
         {
           Lisp_Object head = EVENT_HEAD (key);
@@ -3108,15 +3139,27 @@ read_key_sequence (keybuf, bufsize, prompt)
               /* We drop unbound `down-' events altogether.  */
               if (modifiers & down_modifier)
                 {
-                  /* Adding prefixes for non-textual mouse clicks creates
-                     two characters of mock input, and this can't be the
-                     first, so it's okay to clear mock_input in that case.
-                     Only function key expansion could create more than
-                     two keys, but that should never generate mouse events,
-                     so it's okay to nuke mock_input in that case too.
+                  /* To make sure that mock_input doesn't just give
+                     this event back to us; we want to delete this
+                     event from the mock input queue.  We could delete
+                     keybuf[t] and shift everything after that to the
+                     left by one spot, but we'd also have to fix up
+                     any variable that points into keybuf, and shifting
+                     isn't really necessary anyway.
+                     
+                     Adding prefixes for non-textual mouse clicks creates
+                     two characters of mock input, and this must be the
+                     second, so mock_input would be over anyway; it's okay
+                     to zero it.
+                     
+                     Beyond that, only function key expansion could
+                     create more than two keys, but that should never
+                     generate mouse events, so it's okay to zero
+                     mock_input in that case too.
+                     
                      Isn't this just the most wonderful code ever?  */
                   mock_input = 0;
-                  goto retry_key;
+                  goto replay_key;
                 }
 
               /* We turn unbound `drag-' events into `click-'
@@ -3159,7 +3202,7 @@ read_key_sequence (keybuf, bufsize, prompt)
       /* If the sequence is unbound, see if we can hang a function key
          off the end of it.  We only want to scan real keyboard input
          for function key sequences, so if mock_input says that we're
-         re-scanning after expanding a function key, don't examine it.  */
+         re-reading old events, don't examine it.  */
       if (first_binding >= nmaps
           && t >= mock_input)
         {
@@ -3168,20 +3211,26 @@ read_key_sequence (keybuf, bufsize, prompt)
           /* Scan from fkey_end until we find a bound suffix.  */
           while (fkey_end < t)
             {
+              Lisp_Object key;
+
+              key = keybuf[fkey_end++];
               /* Look up meta-characters by prefixing them
                  with meta_prefix_char.  I hate this.  */
-              if (keybuf[fkey_end] & 0x80)
-                fkey_next =
-                  get_keymap_1
-                    ((get_keyelt
-                      (access_keymap (fkey_map, meta_prefix_char, 1))),
-                     0);
+              if (XTYPE (key) == Lisp_Int && XINT (key) & 0x80)
+                {
+                  fkey_next =
+                    get_keymap_1
+                      (get_keyelt
+                       (access_keymap
+                        (fkey_map, meta_prefix_char, 1)),
+                       0, 1);
+                  XFASTINT (key) = XFASTINT (key) & 0x7f;
+                }
               else
                 fkey_next = fkey_map;
 
               fkey_next =
-                get_keyelt (access_keymap
-                            (fkey_next, keybuf[fkey_end++] & 0x7f, 1));
+                get_keyelt (access_keymap (fkey_next, key, 1));
 
               /* If keybuf[fkey_start..fkey_end] is bound in the
                  function key map and it's a suffix of the current
@@ -3201,10 +3250,10 @@ read_key_sequence (keybuf, bufsize, prompt)
                   mock_input = t;
                   fkey_start = fkey_end = t;
 
-                  goto restart;
+                  goto replay_sequence;
                 }
               
-              fkey_map = get_keymap_1 (fkey_next, 0);
+              fkey_map = get_keymap_1 (fkey_next, 0, 1);
 
               /* If we no longer have a bound suffix, try a new positions for 
                  fkey_start.  */
@@ -3221,7 +3270,9 @@ read_key_sequence (keybuf, bufsize, prompt)
                            ? defs[first_binding]
                            : Qnil);
 
+ done:
   unread_switch_frame = delayed_switch_frame;
+  unbind_to (count, Qnil);
   return t;
 }
 
@@ -3257,7 +3308,7 @@ typed while in this function is treated like any other character, and\n\
     this_command_key_count = 0;
 
   i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
-                         NILP (prompt)  ? 0 : XSTRING (prompt)->data);
+                         NILP (prompt) ? 0 : XSTRING (prompt)->data);
 
   UNGCPRO;
   return make_array (i, keybuf);