Merge from mainline.

12 files changed, 234 insertions, 57 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 64b13a5ac28..b7b2d5fba4b 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,58 @@
+2013-07-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * fns.c (toplevel): Remove comment before Fsafe_length because
+        it checks for QUIT.
+
+2013-07-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * frame.c (delete_frame): Avoid unnecessary 'this_f' test (Bug#14970).
+
+2013-07-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_wnd_proc) <WM_IME_STARTCOMPOSITION>: Make sure the
+        frame which got the message is still alive, before dereferencing
+        its pointer.  (Bug#14970)
+
+        * frame.c (delete_frame): Test "this" frame's minibuffer window to
+        be a live window, before using it as such.  (Bug#14970)
+
+2013-07-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (w32_read_socket) <WM_KILLFOCUS>: Call
+        w32_detect_focus_change instead of doing part of its job by hand.
+        This fixes the problem whereby FOCUS_OUT events were not sent to
+        the event queue.
+
+2013-07-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * process.c (Fprocess_list): Doc fix.
+
+        * w32term.c (w32_read_socket) <WM_EMACS_PAINT>: Warn about frame
+        being re-exposed only if it didn't ask to become visible.
+        <WM_SIZE>: Under SIZE_RESTORED, only set the frame visible if it
+        was previously iconified.  (Bug#14841)
+        (x_iconify_frame): Mark the frame iconified.
+
+2013-07-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * eval.c (get_backtrace_frame, backtrace_eval_unrewind): Now static.
+        (backtrace_eval_unrewind): ';' -> '{}' to pacify GCC.
+
+2013-07-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (set_specpdl_old_value): New function.
+        (unbind_to): Minor simplification.
+        (get_backtrace_frame): New function.
+        (Fbacktrace_frame): Use it.  Add `base' argument.
+        (backtrace_eval_unrewind, Fbacktrace_eval): New functions.
+        (syms_of_eval): Export backtrace-eval.
+        * xterm.c (x_focus_changed): Simplify.
+
+2013-07-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Finsert_file_contents): Avoid double-close (Bug#14936).
+
 2013-07-24  Eli Zaretskii  <eliz@gnu.org>
 
         * xdisp.c (redisplay_window): Instead of moving point out of
diff --git a/src/ChangeLog.12 b/src/ChangeLog.12
index 2b22690bb87..053baa3d487 100644
--- a/src/ChangeLog.12
+++ b/src/ChangeLog.12
@@ -69,7 +69,7 @@
 
         * dispnew.c (update_window): Use MATRIX_ROW and MATRIX_MODE_LINE_ROW.
 
-2013-03-10  handa  <handa@gnu.org>
+2013-03-10  Kenichi Handa  <handa@gnu.org>
 
         * lisp.h (adjust_after_replace): Extern it.
 
@@ -11043,7 +11043,7 @@
         * nsterm.m (x_free_frame_resources): Move xfree so freed memory isn't
         referenced (Bug#11583).
 
-2012-06-16  Aurelien Aptel  <aurelien.aptel@gmail.com>
+2012-06-16  Aurélien Aptel  <aurelien.aptel@gmail.com>
 
         Implement wave-style variant of underlining.
         * dispextern.h (face_underline_type): New enum.
@@ -21400,7 +21400,7 @@
 
         * process.c (Fformat_network_address): Doc fix.
 
-2011-04-08  T.V. Raman  <tv.raman.tv@gmail.com>  (tiny change)
+2011-04-08  T. V. Raman  <tv.raman.tv@gmail.com>  (tiny change)
 
         * xml.c (parse_region): Avoid creating spurious whitespace nodes.
 
diff --git a/src/ChangeLog.9 b/src/ChangeLog.9
index b451b78944f..2e1d41b2495 100644
--- a/src/ChangeLog.9
+++ b/src/ChangeLog.9
@@ -10644,7 +10644,7 @@
         (syms_of_xfns) [GLYPH_DEBUG]: Don't defsubr removed functions.
         (syms_of_xfns): Initialize Qcenter.
 
-        * eval.c (Fsignal): If lisp_eval_depth or spepdl_size are near
+        * eval.c (Fsignal): If lisp_eval_depth or specpdl_size are near
         to the limits, increase the limits.
 
 2000-05-01  Kenichi Handa  <handa@etl.go.jp>
diff --git a/src/eval.c b/src/eval.c
index 6cb2b7a92b8..cb716690e3c 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -138,6 +138,13 @@ specpdl_old_value (union specbinding *pdl)
   return pdl->let.old_value;
 }
 
+static void
+set_specpdl_old_value (union specbinding *pdl, Lisp_Object val)
+{
+  eassert (pdl->kind >= SPECPDL_LET);
+  pdl->let.old_value = val;
+}
+
 static Lisp_Object
 specpdl_where (union specbinding *pdl)
 {
@@ -3301,6 +3308,8 @@ unbind_to (ptrdiff_t count, Lisp_Object value)
         case SPECPDL_UNWIND_VOID:
           specpdl_ptr->unwind_void.func ();
           break;
+        case SPECPDL_BACKTRACE:
+          break;
         case SPECPDL_LET:
           /* If variable has a trivial value (no forwarding), we can
              just set it.  No need to check for constant symbols here,
@@ -3315,27 +3324,20 @@ unbind_to (ptrdiff_t count, Lisp_Object value)
             Fset_default (specpdl_symbol (specpdl_ptr),
                           specpdl_old_value (specpdl_ptr));
           break;
-        case SPECPDL_BACKTRACE:
+        case SPECPDL_LET_DEFAULT:
+          Fset_default (specpdl_symbol (specpdl_ptr),
+                        specpdl_old_value (specpdl_ptr));
           break;
         case SPECPDL_LET_LOCAL:
-        case SPECPDL_LET_DEFAULT:
-          { /* If the symbol is a list, it is really (SYMBOL WHERE
-             . CURRENT-BUFFER) where WHERE is either nil, a buffer, or a
-             frame.  If WHERE is a buffer or frame, this indicates we
-             bound a variable that had a buffer-local or frame-local
-             binding.  WHERE nil means that the variable had the default
-             value when it was bound.  CURRENT-BUFFER is the buffer that
-             was current when the variable was bound.  */
+          {
             Lisp_Object symbol = specpdl_symbol (specpdl_ptr);
             Lisp_Object where = specpdl_where (specpdl_ptr);
             Lisp_Object old_value = specpdl_old_value (specpdl_ptr);
             eassert (BUFFERP (where));
 
-            if (specpdl_ptr->kind == SPECPDL_LET_DEFAULT)
-              Fset_default (symbol, old_value);
             /* If this was a local binding, reset the value in the appropriate
                buffer, but only if that buffer's binding still exists.  */
-            else if (!NILP (Flocal_variable_p (symbol, where)))
+            if (!NILP (Flocal_variable_p (symbol, where)))
               set_internal (symbol, old_value, where, 1);
           }
           break;
@@ -3422,7 +3424,30 @@ Output stream used is value of `standard-output'.  */)
   return Qnil;
 }
 
-DEFUN ("backtrace-frame", Fbacktrace_frame, Sbacktrace_frame, 1, 1, NULL,
+static union specbinding *
+get_backtrace_frame (Lisp_Object nframes, Lisp_Object base)
+{
+  union specbinding *pdl = backtrace_top ();
+  register EMACS_INT i;
+
+  CHECK_NATNUM (nframes);
+
+  if (!NILP (base))
+    { /* Skip up to `base'.  */
+      base = Findirect_function (base, Qt);
+      while (backtrace_p (pdl)
+             && !EQ (base, Findirect_function (backtrace_function (pdl), Qt)))
+        pdl = backtrace_next (pdl);
+    }
+
+  /* Find the frame requested.  */
+  for (i = XFASTINT (nframes); i > 0 && backtrace_p (pdl); i--)
+    pdl = backtrace_next (pdl);
+
+  return pdl;
+}
+
+DEFUN ("backtrace-frame", Fbacktrace_frame, Sbacktrace_frame, 1, 2, NULL,
        doc: /* Return the function and arguments NFRAMES up from current execution point.
 If that frame has not evaluated the arguments yet (or is a special form),
 the value is (nil FUNCTION ARG-FORMS...).
@@ -3431,17 +3456,12 @@ the value is (t FUNCTION ARG-VALUES...).
 A &rest arg is represented as the tail of the list ARG-VALUES.
 FUNCTION is whatever was supplied as car of evaluated list,
 or a lambda expression for macro calls.
-If NFRAMES is more than the number of frames, the value is nil.  */)
-  (Lisp_Object nframes)
+If NFRAMES is more than the number of frames, the value is nil.
+If BASE is non-nil, it should be a function and NFRAMES counts from its
+nearest activation frame.  */)
+  (Lisp_Object nframes, Lisp_Object base)
 {
-  union specbinding *pdl = backtrace_top ();
-  register EMACS_INT i;
-
-  CHECK_NATNUM (nframes);
-
-  /* Find the frame requested.  */
-  for (i = 0; backtrace_p (pdl) && i < XFASTINT (nframes); i++)
-    pdl = backtrace_next (pdl);
+  union specbinding *pdl = get_backtrace_frame (nframes, base);
 
   if (!backtrace_p (pdl))
     return Qnil;
@@ -3456,6 +3476,109 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
     }
 }
 
+/* For backtrace-eval, we want to temporarily unwind the last few elements of
+   the specpdl stack, and then rewind them.  We store the pre-unwind values
+   directly in the pre-existing specpdl elements (i.e. we swap the current
+   value and the old value stored in the specpdl), kind of like the inplace
+   pointer-reversal trick.  As it turns out, the rewind does the same as the
+   unwind, except it starts from the other end of the specpdl stack, so we use
+   the same function for both unwind and rewind.  */
+static void
+backtrace_eval_unrewind (int distance)
+{
+  union specbinding *tmp = specpdl_ptr;
+  int step = -1;
+  if (distance < 0)
+    { /* It's a rewind rather than unwind.  */
+      tmp += distance - 1;
+      step = 1;
+      distance = -distance;
+    }
+
+  for (; distance > 0; distance--)
+    {
+      tmp += step;
+      /*  */
+      switch (tmp->kind)
+        {
+          /* FIXME: Ideally we'd like to "temporarily unwind" (some of) those
+             unwind_protect, but the problem is that we don't know how to
+             rewind them afterwards.  */
+        case SPECPDL_UNWIND:
+        case SPECPDL_UNWIND_PTR:
+        case SPECPDL_UNWIND_INT:
+        case SPECPDL_UNWIND_VOID:
+        case SPECPDL_BACKTRACE:
+          break;
+        case SPECPDL_LET:
+          /* If variable has a trivial value (no forwarding), we can
+             just set it.  No need to check for constant symbols here,
+             since that was already done by specbind.  */
+          if (XSYMBOL (specpdl_symbol (tmp))->redirect
+              == SYMBOL_PLAINVAL)
+            {
+              struct Lisp_Symbol *sym = XSYMBOL (specpdl_symbol (tmp));
+              Lisp_Object old_value = specpdl_old_value (tmp);
+              set_specpdl_old_value (tmp, SYMBOL_VAL (sym));
+              SET_SYMBOL_VAL (sym, old_value);
+              break;
+            }
+          else
+            {
+              /* FALLTHROUGH!
+                 NOTE: we only ever come here if make_local_foo was used for
+                 the first time on this var within this let.  */
+            }
+        case SPECPDL_LET_DEFAULT:
+          {
+            Lisp_Object sym = specpdl_symbol (tmp);
+            Lisp_Object old_value = specpdl_old_value (tmp);
+            set_specpdl_old_value (tmp, Fdefault_value (sym));
+            Fset_default (sym, old_value);
+          }
+          break;
+        case SPECPDL_LET_LOCAL:
+          {
+            Lisp_Object symbol = specpdl_symbol (tmp);
+            Lisp_Object where = specpdl_where (tmp);
+            Lisp_Object old_value = specpdl_old_value (tmp);
+            eassert (BUFFERP (where));
+
+            /* If this was a local binding, reset the value in the appropriate
+               buffer, but only if that buffer's binding still exists.  */
+            if (!NILP (Flocal_variable_p (symbol, where)))
+              {
+                set_specpdl_old_value
+                  (tmp, Fbuffer_local_value (symbol, where));
+                set_internal (symbol, old_value, where, 1);
+              }
+          }
+          break;
+        }
+    }
+}
+
+DEFUN ("backtrace-eval", Fbacktrace_eval, Sbacktrace_eval, 2, 3, NULL,
+       doc: /* Evaluate EXP in the context of some activation frame.
+NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'.  */)
+     (Lisp_Object exp, Lisp_Object nframes, Lisp_Object base)
+{
+  union specbinding *pdl = get_backtrace_frame (nframes, base);
+  ptrdiff_t count = SPECPDL_INDEX ();
+  ptrdiff_t distance = specpdl_ptr - pdl;
+  eassert (distance >= 0);
+
+  if (!backtrace_p (pdl))
+    error ("Activation frame not found!");
+
+  backtrace_eval_unrewind (distance);
+  record_unwind_protect_int (backtrace_eval_unrewind, -distance);
+
+  /* Use eval_sub rather than Feval since the main motivation behind
+     backtrace-eval is to be able to get/set the value of lexical variables
+     from the debugger.  */
+  return unbind_to (count, eval_sub (exp));
+}
 
 void
 mark_specpdl (void)
@@ -3701,6 +3824,7 @@ alist of active lexical bindings.  */);
   defsubr (&Sbacktrace_debug);
   defsubr (&Sbacktrace);
   defsubr (&Sbacktrace_frame);
+  defsubr (&Sbacktrace_eval);
   defsubr (&Sspecial_variable_p);
   defsubr (&Sfunctionp);
 }
diff --git a/src/fileio.c b/src/fileio.c
index a19fcd9f663..c47b3533145 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3860,7 +3860,8 @@ by calling `format-decode', which see.  */)
       if (same_at_start - BEGV_BYTE == end_offset - beg_offset)
         {
           emacs_close (fd);
-          specpdl_ptr--;
+          clear_unwind_protect (fd_index);
+
           /* Truncate the buffer to the size of the file.  */
           del_range_1 (same_at_start, same_at_end, 0, 0);
           goto handled;
diff --git a/src/fns.c b/src/fns.c
index 9fd0ad2a9d1..6f81635ab9d 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -146,8 +146,6 @@ To get the number of bytes, use `string-bytes'.  */)
   return val;
 }
 
-/* This does not check for quits.  That is safe since it must terminate.  */
-
 DEFUN ("safe-length", Fsafe_length, Ssafe_length, 1, 1, 0,
        doc: /* Return the length of a list, but avoid error or infinite loop.
 This function never gets an error.  If LIST is not really a list,
diff --git a/src/frame.c b/src/frame.c
index 5fa54052cd2..95f53569561 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1157,10 +1157,14 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
 
       FOR_EACH_FRAME (frames, this)
         {
-          if (! EQ (this, frame)
-              && EQ (frame,
-                     WINDOW_FRAME (XWINDOW
-                                   (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
+          Lisp_Object fminiw;
+
+          if (EQ (this, frame))
+            continue;
+
+          fminiw = FRAME_MINIBUF_WINDOW (XFRAME (this));
+
+          if (WINDOWP (fminiw) && EQ (frame, WINDOW_FRAME (XWINDOW (fminiw))))
             {
               /* If we MUST delete this frame, delete the other first.
                  But do this only if FORCE equals `noelisp'.  */
diff --git a/src/nsterm.m b/src/nsterm.m
index 61538798337..14706f6b91d 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -4473,9 +4473,9 @@ ns_term_shutdown (int sig)
 
 #ifdef NS_IMPL_COCOA
   /* If no dialog and none of our frames have focus and it is a move, skip it.
-     It is a mouse move in an auxillary menu, i.e. on the top right on OSX,
+     It is a mouse move in an auxiliary menu, i.e. on the top right on OSX,
      such as Wifi, sound, date or similar.
-     This prevents "spooky" highlightning in the frame under the menu.  */
+     This prevents "spooky" highlighting in the frame under the menu.  */
   if (type == NSMouseMoved && [NSApp modalWindow] == nil)
     {
       struct ns_display_info *di;
diff --git a/src/process.c b/src/process.c
index 34783fae5fd..d87a1803fe2 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1330,7 +1330,7 @@ Returns nil if format of ADDRESS is invalid.  */)
 }
 
 DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0,
-       doc: /* Return a list of all processes.  */)
+       doc: /* Return a list of all processes that are Emacs sub-processes.  */)
   (void)
 {
   return Fmapcar (Qcdr, Vprocess_alist);
diff --git a/src/w32fns.c b/src/w32fns.c
index 675b716f3b0..2b06936d119 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3213,6 +3213,8 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
              described by W was deleted, as indicated by its buffer
              field being reset to nil.  */
           f = x_window_to_frame (dpyinfo, hwnd);
+          if (!(f && FRAME_LIVE_P (f)))
+            break;
           w = XWINDOW (FRAME_SELECTED_WINDOW (f));
           /* Punt if someone changed the frame's selected window
              behind our back. */
diff --git a/src/w32term.c b/src/w32term.c
index 2fe3fe07462..a596a487f3d 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -4360,8 +4360,9 @@ w32_read_socket (struct terminal *terminal,
                   SET_FRAME_VISIBLE (f, 1);
                   SET_FRAME_ICONIFIED (f, 0);
                   SET_FRAME_GARBAGED (f);
-                  DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
-                             SDATA (f->name)));
+                  if (!f->output_data.w32->asked_for_visible)
+                    DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
+                               SDATA (f->name)));
 
                   /* WM_PAINT serves as MapNotify as well, so report
                      visibility changes properly.  */
@@ -4819,7 +4820,8 @@ w32_read_socket (struct terminal *terminal,
                   {
                     bool iconified = FRAME_ICONIFIED_P (f);
 
-                    SET_FRAME_VISIBLE (f, 1);
+                    if (iconified)
+                      SET_FRAME_VISIBLE (f, 1);
                     SET_FRAME_ICONIFIED (f, 0);
 
                     /* wait_reading_process_output will notice this
@@ -4921,16 +4923,11 @@ w32_read_socket (struct terminal *terminal,
           break;
 
         case WM_KILLFOCUS:
+          w32_detect_focus_change (dpyinfo, &msg, &inev);
           f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
 
           if (f)
             {
-              if (f == dpyinfo->w32_focus_event_frame)
-                dpyinfo->w32_focus_event_frame = 0;
-
-              if (f == dpyinfo->w32_focus_frame)
-                x_new_focus_frame (dpyinfo, 0);
-
               if (f == hlinfo->mouse_face_mouse_frame)
                 {
                   /* If we move outside the frame, then we're
@@ -6129,6 +6126,9 @@ x_iconify_frame (struct frame *f)
   /* Simulate the user minimizing the frame.  */
   SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
 
+  SET_FRAME_VISIBLE (f, 0);
+  SET_FRAME_ICONIFIED (f, 1);
+
   unblock_input ();
 }
 
diff --git a/src/xterm.c b/src/xterm.c
index 74e495e5645..b3534871da9 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -3435,17 +3435,10 @@ x_focus_changed (int type, int state, struct x_display_info *dpyinfo, struct fra
           /* Don't stop displaying the initial startup message
              for a switch-frame event we don't need.  */
           /* When run as a daemon, Vterminal_frame is always NIL.  */
-          if ((NILP (Vterminal_frame) || EQ (Fdaemonp(), Qt))
-              && CONSP (Vframe_list)
-              && !NILP (XCDR (Vframe_list)))
-            {
-              bufp->arg = Qt;
-            }
-          else
-            {
-              bufp->arg = Qnil;
-            }
-
+          bufp->arg = (((NILP (Vterminal_frame) || EQ (Fdaemonp (), Qt))
+                        && CONSP (Vframe_list)
+                        && !NILP (XCDR (Vframe_list)))
+                       ? Qt : Qnil);
           bufp->kind = FOCUS_IN_EVENT;
           XSETFRAME (bufp->frame_or_window, frame);
         }