upstream

19 files changed, 247 insertions, 91 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 548c80b3b85..8b47c52c23f 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,125 @@
+2012-09-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (read_char, requeued_events_pending_p, Finput_pending_p)
+        (Fdiscard_input, quit_throw_to_read_char, init_keyboard)
+        (syms_of_keyboard): Remove support for unread-command-char.
+
+2012-09-12  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (sys_kill): If PID is our process ID and the signal is
+        SIGABRT, call emacs_abort.  Avoids silently exiting upon assertion
+        violation.  (Bug#12426)
+
+2012-09-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c (jpeg_memory_src): Don't assume string len fits in unsigned.
+
+2012-09-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c: Add `inhibit-debugger'.
+        (Qinhibit_debugger): New symbol.
+        (call_debugger): Bind it instead of Qdebug_on_error.
+        (maybe_call_debugger): Test Vinhibit_debugger.
+        (syms_of_eval): Define inhibit-debugger.
+        * xdisp.c (set_message): Don't bind Qinhibit_debug_on_message.
+        (syms_of_xdisp): Remove inhibit-debug-on-message.
+
+2012-09-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid _setjmp/_longjmp problems with local nonvolatile variables.
+        If a nonvolatile local variable is written before a _longjmp to
+        the frame containing the variable, and is read after the _longjmp,
+        the value read is indeterminate.  Some local variables of type
+        'struct handler' and 'struct catchtag' are used in this way, so
+        mark each of their slots as volatile if the slot can be set before
+        _longjmp and read afterwards.
+        * lisp.h (struct handler): var and chosen_clause are now volatile.
+        (struct catchtag): val, next, and pdlcount are now volatile.
+
+        * bidi.c (bidi_push_it, bidi_pop_it):
+        * fns.c (copy_hash_table):
+        * image.c (define_image_type):
+        * keyboard.c (kbd_buffer_store_event_hold):
+        * process.c (Fprocess_send_eof):
+        * xfaces.c (x_create_gc) [HAVE_NS]:
+        * xgselect.c (xg_select):
+        Prefer assignment to memcpy when either will do.
+
+        * alloc.c (discard_killed_buffers): Tune and simplify a bit.
+        Use pointer-to-a-pointer to simplify and avoid a NILP check each
+        time an item is removed.  No need to mark this function 'inline';
+        the compiler knows better than we do.
+
+2012-09-11  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (ns_judge_scroll_bars): Pass NO to updateFrameSize.
+        (updateFrameSize:): Add delay parameter to updateFrameSize, send it
+        to change_frame_size (Bug#12388).
+        (windowDidResize:): Pass YES to updateFrameSize.
+
+        * nsterm.h: Add delay parameter to updateFrameSize.
+
+2012-09-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Discard killed buffers from deleted window and frame objects.
+        This reduces an amount of references to killed buffers and
+        helps GC to reclaim them faster.
+        * alloc.c (discard_killed_buffers): New function.
+        (mark_object): Use it for deleted windows and frames.
+        (mark_object): If symbol's value is set up for a killed buffer
+        or deleted frame, restore it's global binding.
+        * data.c (swap_in_global_binding): Add GC notice.
+        (swap_in_symval_forwarding): Use convenient set_blv_where.
+        * window.c (wset_next_buffers, wset_prev_buffers): Move ...
+        * window.h: ... to here.
+
+2012-09-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Convenient macro to check whether the buffer is live.
+        * buffer.h (BUFFER_LIVE_P): New macro.
+        * alloc.c, buffer.c, editfns.c, insdel.c, lread.c, marker.c:
+        * minibuf.c, print.c, process.c, window.c, xdisp.c: Use it.
+
+2012-09-11  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * xdisp.c (right_overwritten, right_overwriting): Also handle gstring
+        composition cases (Bug#12364).
+
+        * xterm.c (x_draw_glyph_string): Avoid overwriting inverted left
+        overhang of succeeding glyphs overlapping box cursor.
+
+        * w32term.c (x_draw_glyph_string): Likewise.
+
+2012-09-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Simplify, document, and port floating-point (Bug#12381).
+        The porting part of this patch fixes bugs on non-IEEE platforms
+        with frexp, ldexp, logb.
+        * data.c, lisp.h (Qdomain_error, Qsingularity_error, Qunderflow_error):
+        Now static.
+        * floatfns.c: Simplify discussion of functions that Emacs doesn't
+        support, by removing commented-out code and briefly listing the
+        C89 functions excluded.  The commented-out stuff was confusing
+        maintenance, e.g., we thought we needed cbrt but it was commented out.
+        (logb): Remove decl; no longer needed.
+        (isfinite): New macro, if not already supplied.
+        (isnan): Don't replace any existing macro.
+        (Ffrexp, Fldexp): Define even if !HAVE_COPYSIGN, as frexp and ldexp
+        are present on all C89 platforms.
+        (Ffrexp): Do not special-case zero, as frexp does the right thing
+        for that case.
+        (Flogb): Do not use logb, as it doesn't have the desired meaning
+        on hosts that use non-base-2 floating point.  Instead, stick with
+        frexp, which is C89 anyway.  Do not pass an infinity or a NaN to
+        frexp, to avoid getting an unspecified result.
+
+        * xdisp.c (Qinhibit_debug_on_message): Now static.
+
+2012-09-10  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (ns_update_begin): Set clip path to whole view by using
+        NSBezierPath (Bug#12131).
+
 2012-09-10  Chong Yidong  <cyd@gnu.org>
 
         * fns.c (Fdelq, Fdelete): Doc fix.
diff --git a/src/alloc.c b/src/alloc.c
index 7bbc0abcd9a..61cb7086c25 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5865,6 +5865,28 @@ mark_buffer (struct buffer *buffer)
     mark_buffer (buffer->base_buffer);
 }
 
+/* Remove killed buffers or items whose car is a killed buffer
+   from LIST and return changed LIST.  Called during GC.  */
+
+static Lisp_Object
+discard_killed_buffers (Lisp_Object list)
+{
+  Lisp_Object *prev = &list;
+  Lisp_Object tail;
+
+  for (tail = list; CONSP (tail); tail = XCDR (tail))
+    {
+      Lisp_Object tem = XCAR (tail);
+      if (CONSP (tem))
+        tem = XCAR (tem);
+      if (BUFFERP (tem) && !BUFFER_LIVE_P (XBUFFER (tem)))
+        *prev = XCDR (tail);
+      else
+        prev = &XCDR_AS_LVALUE (tail);
+    }
+  return list;
+}
+
 /* Determine type of generic Lisp_Object and mark it accordingly.  */
 
 void
@@ -6001,20 +6023,41 @@ mark_object (Lisp_Object arg)
             break;
 
           case PVEC_FRAME:
-            mark_vectorlike (ptr);
-            mark_face_cache (((struct frame *) ptr)->face_cache);
+            {
+              struct frame *f = (struct frame *) ptr;
+
+              /* For live frames, killed buffers are filtered out by
+                 store_frame_param.  For dead frames, we do it here in
+                 attempt to help GC to reclaim killed buffers faster.  */
+              if (!FRAME_LIVE_P (f))
+                fset_buffer_list (f, discard_killed_buffers (f->buffer_list));
+
+              mark_vectorlike (ptr);
+              mark_face_cache (f->face_cache);
+            }
             break;
 
           case PVEC_WINDOW:
             {
               struct window *w = (struct window *) ptr;
+              bool leaf = NILP (w->hchild) && NILP (w->vchild);
+
+              /* For live windows, Lisp code filters out killed buffers
+                 from both buffer lists.  For dead windows, we do it here
+                 in attempt to help GC to reclaim killed buffers faster.  */
+              if (leaf && NILP (w->buffer))
+                {
+                  wset_prev_buffers
+                    (w, discard_killed_buffers (w->prev_buffers));
+                  wset_next_buffers
+                    (w, discard_killed_buffers (w->next_buffers));
+                }
 
               mark_vectorlike (ptr);
               /* Mark glyphs for leaf windows.  Marking window
                  matrices is sufficient because frame matrices
                  use the same glyph memory.  */
-              if (NILP (w->hchild) && NILP (w->vchild)
-                  && w->current_matrix)
+              if (leaf && w->current_matrix)
                 {
                   mark_glyph_matrix (w->current_matrix);
                   mark_glyph_matrix (w->desired_matrix);
@@ -6081,10 +6124,14 @@ mark_object (Lisp_Object arg)
           case SYMBOL_LOCALIZED:
             {
               struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (ptr);
-              /* If the value is forwarded to a buffer or keyboard field,
-                 these are marked when we see the corresponding object.
-                 And if it's forwarded to a C variable, either it's not
-                 a Lisp_Object var, or it's staticpro'd already.  */
+              Lisp_Object where = blv->where;
+              /* If the value is set up for a killed buffer or deleted
+                 frame, restore it's global binding.  If the value is
+                 forwarded to a C variable, either it's not a Lisp_Object
+                 var, or it's staticpro'd already.  */
+              if ((BUFFERP (where) && !BUFFER_LIVE_P (XBUFFER (where)))
+                  || (FRAMEP (where) && !FRAME_LIVE_P (XFRAME (where))))
+                swap_in_global_binding (ptr);
               mark_object (blv->where);
               mark_object (blv->valcell);
               mark_object (blv->defcell);
diff --git a/src/bidi.c b/src/bidi.c
index 73fec3533a4..4186a46e19e 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -612,7 +612,7 @@ bidi_push_it (struct bidi_it *bidi_it)
   /* Save the current iterator state in its entirety after the last
      used cache slot.  */
   bidi_cache_ensure_space (bidi_cache_idx);
-  memcpy (&bidi_cache[bidi_cache_idx++], bidi_it, sizeof (struct bidi_it));
+  bidi_cache[bidi_cache_idx++] = *bidi_it;
 
   /* Push the current cache start onto the stack.  */
   eassert (bidi_cache_sp < IT_STACK_SIZE);
@@ -636,7 +636,7 @@ bidi_pop_it (struct bidi_it *bidi_it)
   bidi_cache_idx = bidi_cache_start - 1;
 
   /* Restore the bidi iterator state saved in the cache.  */
-  memcpy (bidi_it, &bidi_cache[bidi_cache_idx], sizeof (struct bidi_it));
+  *bidi_it = bidi_cache[bidi_cache_idx];
 
   /* Pop the previous cache start from the stack.  */
   if (bidi_cache_sp <= 0)
diff --git a/src/composite.h b/src/composite.h
index 68f5b27ee42..9462b932c66 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -113,7 +113,7 @@ extern Lisp_Object composition_temp;
    && (end - start) == COMPOSITION_LENGTH (prop))
 
 /* Return the Nth glyph of composition specified by CMP.  CMP is a
-   pointer to `struct composition'. */
+   pointer to `struct composition'.  */
 #define COMPOSITION_GLYPH(cmp, n)                                       \
   XINT (XVECTOR (XVECTOR (XHASH_TABLE (composition_hash_table)          \
                           ->key_and_value)                              \
diff --git a/src/data.c b/src/data.c
index 4678ac1208c..5d7f036b70d 100644
--- a/src/data.c
+++ b/src/data.c
@@ -948,8 +948,10 @@ store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newva
     }
 }
 
-/* Set up SYMBOL to refer to its global binding.
-   This makes it safe to alter the status of other bindings.  */
+/* Set up SYMBOL to refer to its global binding.  This makes it safe
+   to alter the status of other bindings.  BEWARE: this may be called
+   during the mark phase of GC, where we assume that Lisp_Object slots
+   of BLV are marked after this function has changed them.  */
 
 void
 swap_in_global_binding (struct Lisp_Symbol *symbol)
@@ -1008,7 +1010,7 @@ swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_
         else
           {
             tem1 = assq_no_quit (var, BVAR (current_buffer, local_var_alist));
-            XSETBUFFER (blv->where, current_buffer);
+            set_blv_where (blv, Fcurrent_buffer ());
           }
       }
       if (!(blv->found = !NILP (tem1)))
@@ -1162,7 +1164,7 @@ set_internal (Lisp_Object symbol, Lisp_Object newval, Lisp_Object where,
            the default binding is loaded, the loaded binding may be the
            wrong one.  */
         if (!EQ (blv->where, where)
-            /* Also unload a global binding (if the var is local_if_set). */
+            /* Also unload a global binding (if the var is local_if_set).  */
             || (EQ (blv->valcell, blv->defcell)))
           {
             /* The currently loaded binding is not necessarily valid.
diff --git a/src/eval.c b/src/eval.c
index 4f0d6c69a51..8a8a507a1b6 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -69,7 +69,7 @@ Lisp_Object Qautoload, Qmacro, Qexit, Qinteractive, Qcommandp;
 Lisp_Object Qinhibit_quit;
 Lisp_Object Qand_rest;
 static Lisp_Object Qand_optional;
-static Lisp_Object Qdebug_on_error;
+static Lisp_Object Qinhibit_debugger;
 static Lisp_Object Qdeclare;
 Lisp_Object Qinternal_interpreter_environment, Qclosure;
 
@@ -229,7 +229,7 @@ call_debugger (Lisp_Object arg)
   specbind (intern ("debugger-may-continue"),
             debug_while_redisplaying ? Qnil : Qt);
   specbind (Qinhibit_redisplay, Qnil);
-  specbind (Qdebug_on_error, Qnil);
+  specbind (Qinhibit_debugger, Qt);
 
 #if 0 /* Binding this prevents execution of Lisp code during
          redisplay, which necessarily leads to display problems.  */
@@ -1725,6 +1725,7 @@ maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig, Lisp_Object data)
       /* Don't try to run the debugger with interrupts blocked.
          The editing loop would return anyway.  */
       ! INPUT_BLOCKED_P
+      && NILP (Vinhibit_debugger)
       /* Does user want to enter debugger for this kind of error?  */
       && (EQ (sig, Qquit)
           ? debug_on_quit
@@ -3467,7 +3468,7 @@ before making `inhibit-quit' nil.  */);
 
   DEFSYM (Qinhibit_quit, "inhibit-quit");
   DEFSYM (Qautoload, "autoload");
-  DEFSYM (Qdebug_on_error, "debug-on-error");
+  DEFSYM (Qinhibit_debugger, "inhibit-debugger");
   DEFSYM (Qmacro, "macro");
   DEFSYM (Qdeclare, "declare");
 
@@ -3482,6 +3483,12 @@ before making `inhibit-quit' nil.  */);
   DEFSYM (Qclosure, "closure");
   DEFSYM (Qdebug, "debug");
 
+  DEFVAR_LISP ("inhibit-debugger", Vinhibit_debugger,
+               doc: /* Non-nil means never enter the debugger.
+Normally set while the debugger is already active, to avoid recursive
+invocations.  */);
+  Vinhibit_debugger = Qnil;
+
   DEFVAR_LISP ("debug-on-error", Vdebug_on_error,
                doc: /* Non-nil means enter debugger if an error is signaled.
 Does not apply to errors handled by `condition-case' or those
@@ -3491,7 +3498,7 @@ if one of its condition symbols appears in the list.
 When you evaluate an expression interactively, this variable
 is temporarily non-nil if `eval-expression-debug-on-error' is non-nil.
 The command `toggle-debug-on-error' toggles this.
-See also the variable `debug-on-quit'.  */);
+See also the variable `debug-on-quit' and `inhibit-debugger'.  */);
   Vdebug_on_error = Qnil;
 
   DEFVAR_LISP ("debug-ignored-errors", Vdebug_ignored_errors,
diff --git a/src/fns.c b/src/fns.c
index 95450c5e911..91dc6639150 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -3680,7 +3680,7 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
 
   h2 = allocate_hash_table ();
   next = h2->header.next.vector;
-  memcpy (h2, h1, sizeof *h2);
+  *h2 = *h1;
   h2->header.next.vector = next;
   h2->key_and_value = Fcopy_sequence (h1->key_and_value);
   h2->hash = Fcopy_sequence (h1->hash);
diff --git a/src/image.c b/src/image.c
index 4ec6105d72d..cf01602050f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -593,7 +593,7 @@ define_image_type (struct image_type *type, int loaded)
       /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
          The initialized data segment is read-only.  */
       struct image_type *p = xmalloc (sizeof *p);
-      memcpy (p, type, sizeof *p);
+      *p = *type;
       p->next = image_types;
       image_types = p;
       success = Qt;
@@ -6181,7 +6181,7 @@ our_memory_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
    reading the image.  */
 
 static void
-jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, unsigned int len)
+jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, ptrdiff_t len)
 {
   struct jpeg_source_mgr *src;
 
diff --git a/src/keyboard.c b/src/keyboard.c
index 691a06d36cf..de48b53053b 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2369,15 +2369,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       goto reread_first;
     }
 
-  if (unread_command_char != -1)
-    {
-      XSETINT (c, unread_command_char);
-      unread_command_char = -1;
-
-      reread = 1;
-      goto reread_first;
-    }
-
   if (CONSP (Vunread_command_events))
     {
       int was_disabled = 0;
@@ -2562,7 +2553,6 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
       /* Don't bring up a menu if we already have another event.  */
       && NILP (Vunread_command_events)
-      && unread_command_char < 0
       && !detect_input_pending_run_timers (0))
     {
       c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
@@ -2698,8 +2688,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       && !EQ (XCAR (prev_event), Qmenu_bar)
       && !EQ (XCAR (prev_event), Qtool_bar)
       /* Don't bring up a menu if we already have another event.  */
-      && NILP (Vunread_command_events)
-      && unread_command_char < 0)
+      && NILP (Vunread_command_events))
     {
       c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
 
@@ -3605,7 +3594,7 @@ kbd_buffer_store_event_hold (register struct input_event *event,
 
           if (hold_quit)
             {
-              memcpy (hold_quit, event, sizeof (*event));
+              *hold_quit = *event;
               return;
             }
 
@@ -4143,7 +4132,7 @@ kbd_buffer_get_event (KBOARD **kbp,
                 *used_mouse_menu = 1;
 #endif
 #ifdef HAVE_NS
-              /* certain system events are non-key events */
+              /* Certain system events are non-key events.  */
               if (used_mouse_menu
                   && event->kind == NS_NONKEY_EVENT)
                 *used_mouse_menu = 1;
@@ -4171,7 +4160,7 @@ kbd_buffer_get_event (KBOARD **kbp,
          so x remains nil.  */
       x = Qnil;
 
-      /* XXX Can f or mouse_position_hook be NULL here? */
+      /* XXX Can f or mouse_position_hook be NULL here?  */
       if (f && FRAME_TERMINAL (f)->mouse_position_hook)
         (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, 0, &bar_window,
                                                     &part, &x, &y, &t);
@@ -10469,7 +10458,7 @@ clear_input_pending (void)
 int
 requeued_events_pending_p (void)
 {
-  return (!NILP (Vunread_command_events) || unread_command_char != -1);
+  return (!NILP (Vunread_command_events));
 }
 
 
@@ -10479,7 +10468,7 @@ Actually, the value is nil only if we can be sure that no input is available;
 if there is a doubt, the value is t.  */)
   (void)
 {
-  if (!NILP (Vunread_command_events) || unread_command_char != -1
+  if (!NILP (Vunread_command_events)
       || !NILP (Vunread_post_input_method_events)
       || !NILP (Vunread_input_method_events))
     return (Qt);
@@ -10667,7 +10656,6 @@ Also end any kbd macro being defined.  */)
   update_mode_lines++;
 
   Vunread_command_events = Qnil;
-  unread_command_char = -1;
 
   discard_tty_input ();
 
@@ -11007,7 +10995,6 @@ quit_throw_to_read_char (int from_signal)
   input_pending = 0;
 
   Vunread_command_events = Qnil;
-  unread_command_char = -1;
 
 #if 0 /* Currently, sit_for is called from read_char without turning
          off polling.  And that can call set_waiting_for_input.
@@ -11394,12 +11381,11 @@ delete_kboard (KBOARD *kb)
 void
 init_keyboard (void)
 {
-  /* This is correct before outermost invocation of the editor loop */
+  /* This is correct before outermost invocation of the editor loop.  */
   command_loop_level = -1;
   immediate_quit = 0;
   quit_char = Ctl ('g');
   Vunread_command_events = Qnil;
-  unread_command_char = -1;
   timer_idleness_start_time = invalid_emacs_time ();
   total_keys = 0;
   recent_keys_index = 0;
@@ -11736,9 +11722,6 @@ as they will already have been added once as they were read for the first time.
 An element of the form (t . EVENT) forces EVENT to be added to that list.  */);
   Vunread_command_events = Qnil;
 
-  DEFVAR_INT ("unread-command-char", unread_command_char,
-              doc: /* If not -1, an object to be read as next command input event.  */);
-
   DEFVAR_LISP ("unread-post-input-method-events", Vunread_post_input_method_events,
                doc: /* List of events to be processed as input by input methods.
 These events are processed before `unread-command-events'
diff --git a/src/lisp.h b/src/lisp.h
index 0163a9bcdbc..41fa274a562 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2006,7 +2006,10 @@ extern ptrdiff_t specpdl_size;
 
 #define SPECPDL_INDEX() (specpdl_ptr - specpdl)
 
-/* Everything needed to describe an active condition case.  */
+/* Everything needed to describe an active condition case.
+
+   Members are volatile if their values need to survive _longjmp when
+   a 'struct handler' is a local variable.  */
 struct handler
   {
     /* The handler clauses and variable from the condition-case form.  */
@@ -2017,10 +2020,12 @@ struct handler
        error: handle all conditions, and errors can run the debugger
               or display a backtrace.  */
     Lisp_Object handler;
-    Lisp_Object var;
+
+    Lisp_Object volatile var;
+
     /* Fsignal stores here the condition-case clause that applies,
        and Fcondition_case thus knows which clause to run.  */
-    Lisp_Object chosen_clause;
+    Lisp_Object volatile chosen_clause;
 
     /* Used to effect the longjump out to the handler.  */
     struct catchtag *tag;
@@ -2046,19 +2051,21 @@ struct handler
    of the catch form.
 
    All the other members are concerned with restoring the interpreter
-   state.  */
+   state.
 
+   Members are volatile if their values need to survive _longjmp when
+   a 'struct catchtag' is a local variable.  */
 struct catchtag
 {
   Lisp_Object tag;
-  Lisp_Object val;
-  struct catchtag *next;
+  Lisp_Object volatile val;
+  struct catchtag *volatile next;
   struct gcpro *gcpro;
   jmp_buf jmp;
   struct backtrace *backlist;
   struct handler *handlerlist;
   EMACS_INT lisp_eval_depth;
-  ptrdiff_t pdlcount;
+  ptrdiff_t volatile pdlcount;
   int poll_suppress_count;
   int interrupt_input_blocked;
   struct byte_stack *byte_stack;
diff --git a/src/nsterm.h b/src/nsterm.h
index b1836692b2c..f3adab883a1 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -103,7 +103,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (void) setWindowClosing: (BOOL)closing;
 - (EmacsToolbar *) toolbar;
 - (void) deleteWorkingText;
-- (void) updateFrameSize;
+- (void) updateFrameSize: (BOOL) delay;
 
 #ifdef NS_IMPL_GNUSTEP
 /* Not declared, but useful. */
diff --git a/src/nsterm.m b/src/nsterm.m
index 798c9758376..f9611fd1210 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -3727,7 +3727,7 @@ ns_judge_scroll_bars (struct frame *f)
     }
 
   if (removed) 
-    [eview updateFrameSize];
+    [eview updateFrameSize: NO];
 }
 
 
@@ -5362,7 +5362,7 @@ not_in_argv (NSString *arg)
   return NO;
 }
 
-- (void) updateFrameSize
+- (void) updateFrameSize: (BOOL) delay;
 {
   NSWindow *window = [self window];
   NSRect wr = [window frame];
@@ -5400,7 +5400,7 @@ not_in_argv (NSString *arg)
       NSView *view = FRAME_NS_VIEW (emacsframe);
       FRAME_PIXEL_WIDTH (emacsframe) = neww;
       FRAME_PIXEL_HEIGHT (emacsframe) = newh;
-      change_frame_size (emacsframe, rows, cols, 0, 0, 1);
+      change_frame_size (emacsframe, rows, cols, 0, delay, 0);
       SET_FRAME_GARBAGED (emacsframe);
       cancel_mouse_face (emacsframe);
       [view setFrame: NSMakeRect (0, 0, neww, newh)];
@@ -5503,7 +5503,7 @@ not_in_argv (NSString *arg)
         x_set_window_size (emacsframe, 0, cols, rows);
       else
         {
-          [self updateFrameSize];
+          [self updateFrameSize: YES];
         }
     }
 #endif
diff --git a/src/process.c b/src/process.c
index 0ae68567d6b..f80b5e80c76 100644
--- a/src/process.c
+++ b/src/process.c
@@ -6367,9 +6367,8 @@ process has been transmitted to the serial port.  */)
       if (!proc_encode_coding_system[new_outfd])
         proc_encode_coding_system[new_outfd]
           = xmalloc (sizeof (struct coding_system));
-      memcpy (proc_encode_coding_system[new_outfd],
-              proc_encode_coding_system[old_outfd],
-              sizeof (struct coding_system));
+      *proc_encode_coding_system[new_outfd]
+        = *proc_encode_coding_system[old_outfd];
       memset (proc_encode_coding_system[old_outfd], 0,
               sizeof (struct coding_system));
 
diff --git a/src/w32proc.c b/src/w32proc.c
index b9239cbb99a..74427e76a4f 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1429,6 +1429,9 @@ sys_kill (int pid, int sig)
   int need_to_free = 0;
   int rc = 0;
 
+  if (pid == getpid () && sig == SIGABRT)
+    emacs_abort ();
+
   /* Only handle signals that will result in the process dying */
   if (sig != SIGINT && sig != SIGKILL && sig != SIGQUIT && sig != SIGHUP)
     {
diff --git a/src/window.c b/src/window.c
index 87429b51448..cf296a707e3 100644
--- a/src/window.c
+++ b/src/window.c
@@ -177,11 +177,6 @@ wset_new_total (struct window *w, Lisp_Object val)
   w->new_total = val;
 }
 static inline void
-wset_next_buffers (struct window *w, Lisp_Object val)
-{
-  w->next_buffers = val;
-}
-static inline void
 wset_normal_cols (struct window *w, Lisp_Object val)
 {
   w->normal_cols = val;
@@ -202,11 +197,6 @@ wset_pointm (struct window *w, Lisp_Object val)
   w->pointm = val;
 }
 static inline void
-wset_prev_buffers (struct window *w, Lisp_Object val)
-{
-  w->prev_buffers = val;
-}
-static inline void
 wset_right_fringe_width (struct window *w, Lisp_Object val)
 {
   w->right_fringe_width = val;
diff --git a/src/window.h b/src/window.h
index a70bc55bac5..62ae43a999d 100644
--- a/src/window.h
+++ b/src/window.h
@@ -414,7 +414,16 @@ wset_window_end_vpos (struct window *w, Lisp_Object val)
 {
   w->window_end_vpos = val;
 }
-
+WINDOW_INLINE void
+wset_prev_buffers (struct window *w, Lisp_Object val)
+{
+  w->prev_buffers = val;
+}
+WINDOW_INLINE void
+wset_next_buffers (struct window *w, Lisp_Object val)
+{
+  w->next_buffers = val;
+}
 
 /* 1 if W is a minibuffer window.  */
 
diff --git a/src/xdisp.c b/src/xdisp.c
index df402cd106e..3536e04fe8d 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -366,7 +366,6 @@ static Lisp_Object Qslice;
 Lisp_Object Qcenter;
 static Lisp_Object Qmargin, Qpointer;
 static Lisp_Object Qline_height;
-Lisp_Object Qinhibit_debug_on_message;
 
 /* These setters are used only in this file, so they can be private.  */
 static inline void
@@ -10644,8 +10643,6 @@ static void
 set_message (const char *s, Lisp_Object string,
              ptrdiff_t nbytes, int multibyte_p)
 {
-  ptrdiff_t count = SPECPDL_INDEX ();
-
   message_enable_multibyte
     = ((s && multibyte_p)
        || (STRINGP (string) && STRING_MULTIBYTE (string)));
@@ -10655,14 +10652,9 @@ set_message (const char *s, Lisp_Object string,
   message_buf_print = 0;
   help_echo_showing_p = 0;
 
-  if (NILP (Vinhibit_debug_on_message) && STRINGP (Vdebug_on_message)
+  if (STRINGP (Vdebug_on_message)
       && fast_string_match (Vdebug_on_message, string) >= 0)
-    {
-      specbind (Qinhibit_debug_on_message, Qt);
-      call_debugger (list2 (Qerror, string));
-    }
-
-  unbind_to (count, Qnil);
+    call_debugger (list2 (Qerror, string));
 }
 
 
@@ -12854,7 +12846,7 @@ overlay_arrow_at_row (struct it *it, struct glyph_row *row)
                     return make_number (fringe_bitmap);
                 }
 #endif
-              return make_number (-1); /* Use default arrow bitmap */
+              return make_number (-1); /* Use default arrow bitmap.  */
             }
           return overlay_arrow_string_or_property (var);
         }
@@ -29566,11 +29558,6 @@ Its value should be an ASCII acronym string, `hex-code', `empty-box', or
   DEFVAR_LISP ("debug-on-message", Vdebug_on_message,
                doc: /* If non-nil, debug if a message matching this regexp is displayed.  */);
   Vdebug_on_message = Qnil;
-
-  DEFVAR_LISP ("inhibit-debug-on-message", Vinhibit_debug_on_message,
-               doc: /* If non-nil, inhibit `debug-on-message' from entering the debugger.  */);
-  Vinhibit_debug_on_message = Qnil;
-  DEFSYM(Qinhibit_debug_on_message, "inhibit-debug-on-message");
 }
 
 
diff --git a/src/xfaces.c b/src/xfaces.c
index aee5158036f..c113c1a37b7 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -661,7 +661,7 @@ x_create_gc (struct frame *f,
              XGCValues *xgcv)
 {
   GC gc = xmalloc (sizeof *gc);
-  memcpy (gc, xgcv, sizeof (XGCValues));
+  *gc = *xgcv;
   return gc;
 }
 
diff --git a/src/xgselect.c b/src/xgselect.c
index 0c00d815820..5f4c7edfb79 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -49,9 +49,9 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
          && g_main_context_pending (context = g_main_context_default ())))
     return pselect (fds_lim, rfds, wfds, efds, timeout, sigmask);
 
-  if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds));
+  if (rfds) all_rfds = *rfds;
   else FD_ZERO (&all_rfds);
-  if (wfds) memcpy (&all_wfds, wfds, sizeof (all_rfds));
+  if (wfds) all_wfds = *wfds;
   else FD_ZERO (&all_wfds);
 
   n_gfds = g_main_context_query (context, G_PRIORITY_LOW, &tmo_in_millisec,