nread = (*read_socket_hook) (0, buf, KBD_BUFFER_SIZE, expected, expected);
else
{
- unsigned char cbuf[KBD_BUFFER_SIZE];
+ /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
+ the kbd_buffer can really hold. That may prevent loss
+ of characters on some systems when input is stuffed at us. */
+ unsigned char cbuf[KBD_BUFFER_SIZE - 1];
#ifdef FIONREAD
/* Find out how much input is available. */
if (nread > sizeof cbuf)
nread = sizeof cbuf;
#else /* no FIONREAD */
-#ifdef USG
+#if defined(USG) || defined(DGUX)
/* Read some input if available, but don't wait. */
nread = sizeof cbuf;
fcntl (fileno (stdin), F_SETFL, O_NDELAY);
/* Now read; for one reason or another, this will not block. */
while (1)
{
- nread = read (fileno (stdin), cbuf, nread);
+ int value = read (fileno (stdin), cbuf, nread);
#ifdef AIX
/* The kernel sometimes fails to deliver SIGHUP for ptys.
This looks incorrect, but it isn't, because _BSD causes
O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
and that causes a value other than 0 when there is no input. */
- if (nread == 0)
+ if (value == 0)
kill (SIGHUP, 0);
#endif
/* Retry the read if it is interrupted. */
- if (nread >= 0
+ if (value >= 0
|| ! (errno == EAGAIN || errno == EFAULT
#ifdef EBADSLT
|| errno == EBADSLT
#endif
))
- break;
+ {
+ nread = value;
+ break;
+ }
}
#ifndef FIONREAD
if (XINT (key) & shift_modifier)
XSETINT (key, XINT (key) & ~shift_modifier);
else
- XSETINT (key, DOWNCASE (XINT (key)));
+ XSETINT (key, (DOWNCASE (XINT (key) & 0x3ffff)
+ | (XINT (key) & ~0x3ffff)));
first_binding = nmaps;
for (i = nmaps - 1; i >= 0; i--)
Lisp_Object first_event;
#endif
+ struct buffer *starting_buffer;
+
int junk;
last_nonmenu_event = Qnil;
keybuf[0..mock_input] holds the sequence we should reread. */
replay_sequence:
+ starting_buffer = current_buffer;
+
/* Build our list of keymaps.
If we recognize a function key and replace its escape sequence in
keybuf with its symbol, or if the sequence starts with a mouse
if (! NILP (submaps[first_binding]))
break;
- /* 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. */
+ /* Start from the beginning in keybuf. */
t = 0;
/* These are no-ops the first time through, but if we restart, they
goto done;
}
+ /* If we have a quit that was typed in another frame, and
+ quit_throw_to_read_char switched buffers,
+ replay to get the right keymap. */
+ if (EQ (key, quit_char) && current_buffer != starting_buffer)
+ {
+ keybuf[t++] = key;
+ mock_input = t;
+ Vquit_flag = Qnil;
+ goto replay_sequence;
+ }
+
Vquit_flag = Qnil;
}
if (poll_suppress_count == 0)
abort ();
#endif
+ if (XFRAME (internal_last_event_frame) != selected_frame)
+ Fhandle_switch_frame (make_lispy_switch_frame (internal_last_event_frame));
_longjmp (getcjmp, 1);
}