8 files changed, 184 insertions, 76 deletions

diff --git a/src/callint.c b/src/callint.c
index ed86bc90048..398bfde468b 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -244,7 +244,8 @@ usage: (funcall-interactively FUNCTION &rest ARGUMENTS)  */)
      (ptrdiff_t nargs, Lisp_Object *args)
 {
   specpdl_ref speccount = SPECPDL_INDEX ();
-  temporarily_switch_to_single_kboard (NULL);
+  if (!multiple_terminals_merge_keyboards)
+    temporarily_switch_to_single_kboard (NULL);
 
   /* Nothing special to do here, all the work is inside
      `called-interactively-p'.  Which will look for us as a marker in the
diff --git a/src/callproc.c b/src/callproc.c
index abb944c3aad..52977b29f30 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -2237,7 +2237,7 @@ the system.  */);
   Vrcs2log_program_name = build_string ("librcs2log.so");
 #endif /* !HAVE_ANDROID || ANDROID_STUBIFY */
 
-  DEFVAR_LISP ("command-line-max-length", Vcommand_line_max_length,
+  DEFVAR_INT ("command-line-max-length", command_line_max_length,
     doc: /* Maximum length of a command and its arguments on this system.
 This is measured in characters.
 Used by `multiple-command-partition-arguments'.  Other code calls that
@@ -2246,9 +2246,9 @@ multiple times on subsequent partitions of the list of arguments.
 (In a shell script, you might use the `xargs' utility.)  */);
 #if defined _SC_ARG_MAX
   /* Divide it by 4 as a crude way to go bytes->characters.  */
-  Vcommand_line_max_length = make_fixnum (sysconf (_SC_ARG_MAX) / 4);
+  command_line_max_length = sysconf (_SC_ARG_MAX) / 4;
 #else  /* defined _SC_ARG_MAX */
-  Vcommand_line_max_length = make_fixnum (4096);
+  command_line_max_length = 4096;
 #endif  /* defined _SC_ARG_MAX */
 
   defsubr (&Scall_process);
diff --git a/src/emacs.c b/src/emacs.c
index 17c56986083..6929886424f 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -2947,7 +2947,9 @@ sort_args (int argc, char **argv)
 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 2, "P",
        doc: /* Exit the Emacs job and kill it.
 If ARG is an integer, return ARG as the exit program code.
-If ARG is a string, stuff it as keyboard input.
+If ARG is a string, stuff it and then a newline as keyboard input,
+if Emacs is running interactively on a terminal and the platform
+supports and allows stuffing; this may need special privileges.
 Any other value of ARG, or ARG omitted, means return an
 exit code that indicates successful program termination.
 
diff --git a/src/keyboard.c b/src/keyboard.c
index ffe47460528..994356b0919 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -826,7 +826,7 @@ This function is called by the editor initialization to begin editing.  */)
      like it is done in the splash screen display, we have to
      make sure that we restore single_kboard as command_loop_1
      would have done if it were left normally.  */
-  if (command_loop_level > 0)
+  if (command_loop_level > 0 && !multiple_terminals_merge_keyboards)
     temporarily_switch_to_single_kboard (SELECTED_FRAME ());
 
   recursive_edit_1 ();
@@ -2297,6 +2297,7 @@ show_help_echo (Lisp_Object help, Lisp_Object window, Lisp_Object object,
 /* Input of single characters from keyboard.  */
 
 static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, bool *used_mouse_menu,
+                                         struct frame **event_frame,
                                          struct timespec *end_time);
 static void record_char (Lisp_Object c);
 
@@ -2342,7 +2343,8 @@ read_event_from_main_queue (struct timespec *end_time,
   restore_getcjmp (local_getcjmp);
   if (!end_time)
     timer_start_idle ();
-  c = kbd_buffer_get_event (&kb, used_mouse_menu, end_time);
+  struct frame *frame;
+  c = kbd_buffer_get_event (&kb, used_mouse_menu, &frame, end_time);
   unbind_to (count, Qnil);
 
   if (! NILP (c) && (kb != current_kboard))
@@ -2360,9 +2362,26 @@ read_event_from_main_queue (struct timespec *end_time,
       else
         XSETCDR (last, list1 (c));
       kb->kbd_queue_has_data = true;
-      c = Qnil;
       if (single_kboard)
-        goto start;
+        {
+          /* Typing and clicking in a locked frame is confusing because
+             it seems like Emacs has completely locked up (bug#79892).
+             Show a message about what's happening.  */
+          /* FIXME: We also display the message in the unlocked frame.
+             Can we avoid that?  */
+          if (frame
+              && (FIXNUMP (c) || (EVENT_HAS_PARAMETERS (c)
+                                  && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)),
+                                         Qmouse_click))))
+            {
+              AUTO_STRING (locked, "Frame is locked; see"
+                           " `multiple-terminals-merge-keyboards'"
+                           " variable");
+              message3_frame (Fformat_message (1, &locked), frame);
+            }
+          c = Qnil;
+          goto start;
+        }
       current_kboard = kb;
       return make_fixnum (-2);
     }
@@ -4005,6 +4024,7 @@ kbd_buffer_get_event_2 (Lisp_Object val)
 static Lisp_Object
 kbd_buffer_get_event (KBOARD **kbp,
                       bool *used_mouse_menu,
+                      struct frame **event_frame,
                       struct timespec *end_time)
 {
   Lisp_Object obj, str;
@@ -4019,6 +4039,8 @@ kbd_buffer_get_event (KBOARD **kbp,
   had_pending_conversion_events = false;
 #endif
 
+  *event_frame = NULL;
+
 #ifdef subprocesses
   if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE / 4)
     {
@@ -4179,6 +4201,9 @@ kbd_buffer_get_event (KBOARD **kbp,
       if (*kbp == 0)
         *kbp = current_kboard;  /* Better than returning null ptr?  */
 
+      if (FRAMEP (event->ie.frame_or_window))
+        *event_frame = XFRAME (event->ie.frame_or_window);
+
       obj = Qnil;
 
       /* These two kinds of events get special handling
@@ -4492,13 +4517,14 @@ kbd_buffer_get_event (KBOARD **kbp,
   /* Try generating a mouse motion event.  */
   else if (some_mouse_moved ())
     {
-      struct frame *f, *movement_frame = some_mouse_moved ();
+      struct frame *f;
       Lisp_Object bar_window;
       enum scroll_bar_part part;
       Lisp_Object x, y;
       Time t;
 
-      f = movement_frame;
+      *event_frame = some_mouse_moved ();
+      f = *event_frame;
       *kbp = current_kboard;
       /* Note that this uses F to determine which terminal to look at.
          If there is no valid info, it does not store anything
@@ -4535,8 +4561,8 @@ kbd_buffer_get_event (KBOARD **kbp,
         obj = make_lispy_movement (f, bar_window, part, x, y, t);
 
       if (!NILP (obj))
-        Vlast_event_device = (STRINGP (movement_frame->last_mouse_device)
-                              ? movement_frame->last_mouse_device
+        Vlast_event_device = (STRINGP ((*event_frame)->last_mouse_device)
+                              ? (*event_frame)->last_mouse_device
                               : virtual_core_pointer_name);
     }
 #ifdef HAVE_X_WINDOWS
@@ -12395,19 +12421,15 @@ DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
 If `cannot-suspend' is non-nil, or if the system doesn't support job
 control, run a subshell instead.
 
-If optional arg STUFFSTRING is non-nil, its characters are stuffed
-to be read as terminal input by Emacs's parent, after suspension.
+If optional arg STUFFSTRING is non-nil, stuff it and then a newline as
+keyboard input, if Emacs is running interactively on a terminal and the
+platform supports and allows stuffing; this may need special privileges.
 
 Before suspending, run the normal hook `suspend-hook'.
 After resumption run the normal hook `suspend-resume-hook'.
 
 Some operating systems cannot stop the Emacs process and resume it later.
-On such systems, Emacs starts a subshell instead of suspending.
-
-On some operating systems, stuffing characters into terminal input
-buffer requires special privileges or is not supported at all.
-On such systems, calling this function with non-nil STUFFSTRING might
-either signal an error or silently fail to stuff the characters.  */)
+On such systems, Emacs starts a subshell instead of suspending.  */)
   (Lisp_Object stuffstring)
 {
   specpdl_ref count = SPECPDL_INDEX ();
@@ -12446,38 +12468,34 @@ either signal an error or silently fail to stuff the characters.  */)
   return Qnil;
 }
 
-/* If STUFFSTRING is a string, stuff its contents as pending terminal input.
-   Then in any case stuff anything Emacs has read ahead and not used.  */
+/* If STUFFSTRING is a string, stuff its contents and then a newline as
+   pending terminal input.  Then stuff anything Emacs has read ahead and
+   not used.  However, do nothing if stuffing does not work.  */
 
 void
 stuff_buffered_input (Lisp_Object stuffstring)
 {
 #ifdef SIGTSTP  /* stuff_char is defined if SIGTSTP.  */
-  register unsigned char *p;
+  int bad_stuff = 0;
 
   if (STRINGP (stuffstring))
     {
-      register ptrdiff_t count;
-
-      p = SDATA (stuffstring);
-      count = SBYTES (stuffstring);
-      while (count-- > 0)
-        stuff_char (*p++);
-      stuff_char ('\n');
+      char *p = SSDATA (stuffstring);
+      for (ptrdiff_t i = SBYTES (stuffstring); !bad_stuff && 0 < i; i--)
+        bad_stuff = stuff_char (*p++);
+      if (!bad_stuff)
+        bad_stuff = stuff_char ('\n');
     }
 
-  /* Anything we have read ahead, put back for the shell to read.  */
-  /* ?? What should this do when we have multiple keyboards??
-     Should we ignore anything that was typed in at the "wrong" kboard?
-
-     rms: we should stuff everything back into the kboard
-     it came from.  */
+  /* Anything we have read ahead, put back for the shell to read.
+     When we have multiple keyboards, we should stuff everything back
+     into the keyboard it came from, but fixing this is low priority as
+     many systems prohibit stuffing for security reasons.  */
   for (; kbd_fetch_ptr != kbd_store_ptr;
        kbd_fetch_ptr = next_kbd_event (kbd_fetch_ptr))
     {
-
-      if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
-        stuff_char (kbd_fetch_ptr->ie.code);
+      if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT && !bad_stuff)
+        bad_stuff = stuff_char (kbd_fetch_ptr->ie.code);
 
       clear_event (&kbd_fetch_ptr->ie);
     }
@@ -14430,6 +14448,41 @@ function is called to remap that sequence.  */);
   Vcurrent_key_remap_sequence = Qnil;
   DEFSYM (Qcurrent_key_remap_sequence, "current-key-remap-sequence");
 
+  DEFVAR_BOOL ("multiple-terminals-merge-keyboards",
+               multiple_terminals_merge_keyboards,
+    doc: /* If non-nil, treat different terminals' keyboards as less isolated.
+
+Each terminal displaying Emacs frames has an associated keyboard.
+Normally, Emacs assumes that these keyboards are physically
+distinct, so that someone could be typing on one keyboard and
+someone else typing on another, into different frames on different
+terminals.  In certain situations, however, Emacs enters
+single-keyboard mode, in which input from all but one keyboard is
+blocked.  This prevents keys typed on one keyboard from interfering
+with an operation started on another keyboard.  The main operation
+to which this applies is entering a recursive edit, which includes
+all minibuffer prompting.
+
+Single-keyboard mode can be inconvenient when there are distinct
+terminals and so distinct keyboards, but only one user and one
+physical keyboard in control of Emacs.  This can happen with X
+forwarding: with a remote Emacs daemon and multiple frames created
+with a command like `ssh -X daemon-host emacsclient -c', then from
+the remote Emacs daemon's point of view there is one terminal and
+one keyboard per `ssh -X daemon-host' command invoked, but in fact a
+single local X server displays all frames, and there is just one
+physical keyboard.  In this situation, you may prefer to have the
+different frames behave as though they had been created with
+\\[make-frame-command].  In that case, starting a recursive edit in \
+one frame does
+not mean that keyboard input into other frames is blocked.
+
+If this option is non-nil, Emacs will not enter single-keyboard
+mode when entering a recursive edit.  It will still enter
+single-keyboard mode in certain other cases where doing so is
+necessary for the operation to work at all.  */);
+  multiple_terminals_merge_keyboards = false;
+
   pdumper_do_now_and_after_load (syms_of_keyboard_for_pdumper);
 
   DEFSYM (Qactivate_mark_hook, "activate-mark-hook");
diff --git a/src/lisp.h b/src/lisp.h
index c7afb07576b..37c34dfbe84 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4390,6 +4390,8 @@ extern void message1 (const char *);
 extern void message1_nolog (const char *);
 extern void message3 (Lisp_Object);
 extern void message3_nolog (Lisp_Object);
+extern void message3_frame (Lisp_Object, struct frame *);
+extern void message3_frame_nolog (Lisp_Object, struct frame *);
 extern void message_dolog (const char *, ptrdiff_t, bool, bool);
 extern void message_with_string (const char *, Lisp_Object, bool);
 extern void message_log_maybe_newline (void);
@@ -5278,7 +5280,7 @@ maybe_disable_address_randomization (int argc, char **argv)
 extern int emacs_exec_file (char const *, char *const *, char *const *);
 extern void init_standard_fds (void);
 extern char *emacs_get_current_dir_name (void);
-extern void stuff_char (char c);
+extern int stuff_char (char c);
 extern void init_foreground_group (void);
 extern void sys_subshell (void);
 extern void sys_suspend (void);
diff --git a/src/minibuf.c b/src/minibuf.c
index e49663e2f86..c716ac0d811 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -712,7 +712,8 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
   if (minibuffer_auto_raise)
     Fraise_frame (mini_frame);
 
-  temporarily_switch_to_single_kboard (XFRAME (mini_frame));
+  if (!multiple_terminals_merge_keyboards)
+    temporarily_switch_to_single_kboard (XFRAME (mini_frame));
 
   /* We have to do this after saving the window configuration
      since that is what restores the current buffer.  */
diff --git a/src/sysdep.c b/src/sysdep.c
index 2f5572009fb..8895655566e 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -390,23 +390,22 @@ discard_tty_input (void)
 
 /* Arrange for character C to be read as the next input from
    the terminal.
+   Return 0 on success, -1 otherwise.
    XXX What if we have multiple ttys?
 */
 
-void
+int
 stuff_char (char c)
 {
-  if (! (FRAMEP (selected_frame)
-         && FRAME_LIVE_P (XFRAME (selected_frame))
-         && FRAME_TERMCAP_P (XFRAME (selected_frame))))
-    return;
-
 /* Should perhaps error if in batch mode */
 #ifdef TIOCSTI
-  ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
-#else /* no TIOCSTI */
-  error ("Cannot stuff terminal input characters in this version of Unix");
+  if (FRAMEP (selected_frame)
+      && FRAME_LIVE_P (XFRAME (selected_frame))
+      && FRAME_TERMCAP_P (XFRAME (selected_frame)))
+    return ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
 #endif /* no TIOCSTI */
+
+  return -1;
 }
 
 #endif /* SIGTSTP */
diff --git a/src/xdisp.c b/src/xdisp.c
index f5e2b6e2d24..c8e4bf0cf10 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -510,6 +510,10 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 /* Holds the list (error).  */
 static Lisp_Object list_of_error;
 
+/* Forward declarations.  */
+static void restore_selected_window (Lisp_Object);
+static void restore_frame_selected_window (Lisp_Object);
+
 #ifdef HAVE_WINDOW_SYSTEM
 
 /* Test if overflow newline into fringe.  Called with iterator IT
@@ -12481,15 +12485,8 @@ message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
 }
 
 
-/* Display an echo area message M with a specified length of NBYTES
-   bytes.  The string may include null characters.  If M is not a
-   string, clear out any existing message, and let the mini-buffer
-   text show through.
-
-   This function cancels echoing.  */
-
-void
-message3 (Lisp_Object m)
+static void
+log_message (Lisp_Object m)
 {
   clear_message (true, true);
   cancel_echoing ();
@@ -12506,10 +12503,34 @@ message3 (Lisp_Object m)
       message_dolog (buffer, nbytes, true, multibyte);
       SAFE_FREE ();
     }
+}
+
+/* Display an echo area message M with a specified length of NBYTES
+   bytes.  The string may include null characters.  If M is not a
+   string, clear out any existing message, and let the mini-buffer
+   text show through.
+
+   This function cancels echoing.  */
+
+void
+message3 (Lisp_Object m)
+{
+  log_message (m);
   if (! inhibit_message)
     message3_nolog (m);
 }
 
+/* Display an echo area message M on frame F, which may not be the
+   selected frame.  */
+
+void
+message3_frame (Lisp_Object m, struct frame *f)
+{
+  log_message (m);
+  if (! inhibit_message)
+    message3_frame_nolog (m, f);
+}
+
 /* Log the message M to stderr.  Log an empty line if M is not a string.  */
 
 static void
@@ -12538,7 +12559,7 @@ message_to_stderr (Lisp_Object m)
     errputc ('\n');
 }
 
-/* The non-logging version of message3.
+/* The non-logging versions of message3 & message3_frame.
    This does not cancel echoing, because it is used for echoing.
    Perhaps we need to make a separate function for echoing
    and make this cancel echoing.  */
@@ -12546,28 +12567,55 @@ message_to_stderr (Lisp_Object m)
 void
 message3_nolog (Lisp_Object m)
 {
+  message3_frame_nolog (m, NULL);
+}
+
+void
+message3_frame_nolog (Lisp_Object m, struct frame *f)
+{
   struct frame *sf = SELECTED_FRAME ();
+  if (!f) f = sf;
 
-  if (FRAME_INITIAL_P (sf))
+  if (FRAME_INITIAL_P (f))
     message_to_stderr (m);
-  /* Error messages get reported properly by cmd_error, so this must be just an
-     informative message; if the frame hasn't really been initialized yet, just
-     toss it.  */
-  else if (INTERACTIVE && sf->glyphs_initialized_p)
+  /* Error messages get reported properly by cmd_error, so this must be
+     just an informative message; therefore if the frame hasn't really
+     been initialized yet, just toss it.  */
+  else if (INTERACTIVE && f->glyphs_initialized_p)
     {
-      /* Get the frame containing the mini-buffer
-         that the selected frame is using.  */
-      Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
-      Lisp_Object frame = XWINDOW (mini_window)->frame;
-      struct frame *f = XFRAME (frame);
+      Lisp_Object frame = Qnil;
+      struct frame *mbf = NULL;
+      specpdl_ref count = SPECPDL_INDEX ();
+
+      if (f == sf)
+        {
+          /* Get the frame containing the mini-buffer that the selected
+             frame is using.  */
+          Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (f);
+          frame = XWINDOW (mini_window)->frame;
+          mbf = XFRAME (frame);
 
-      if (FRAME_VISIBLE_P (sf) && !FRAME_VISIBLE_P (f))
-        Fmake_frame_visible (frame);
+          if (FRAME_VISIBLE_P (f) && !FRAME_VISIBLE_P (mbf))
+            Fmake_frame_visible (frame);
+        }
+      else
+        {
+          /* We temporarily switch frame, show the message, and then
+             when we unwind the message will normally still be visible
+             in the other frame, at least for a few seconds.  */
+          record_unwind_protect
+            (restore_selected_window, selected_window);
+          record_unwind_protect
+            (restore_frame_selected_window, f->selected_window);
+          XSETFRAME (frame, f);
+          selected_frame = frame;
+          selected_window = FRAME_SELECTED_WINDOW (f);
+        }
 
       if (STRINGP (m) && SCHARS (m) > 0)
         {
           set_message (m);
-          if (minibuffer_auto_raise)
+          if (minibuffer_auto_raise && !NILP (frame))
             Fraise_frame (frame);
           /* Assume we are not echoing.
              (If we are, echo_now will override this.)  */
@@ -12579,8 +12627,10 @@ message3_nolog (Lisp_Object m)
       do_pending_window_change (false);
       echo_area_display (true);
       do_pending_window_change (false);
-      if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
-        (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
+      if (mbf && FRAME_TERMINAL (mbf)->frame_up_to_date_hook)
+        (*FRAME_TERMINAL (mbf)->frame_up_to_date_hook) (mbf);
+
+      unbind_to (count, Qnil);
     }
 }