merge trunk

39 files changed, 472 insertions, 905 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 8a05f19985f..0d441761ce5 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -3,6 +3,171 @@
         * composite.c (composition_reseat_it): Handle the case that a
         grapheme cluster is not covered by a single font (Bug#12352).
 
+2012-09-21  Chong Yidong  <cyd@gnu.org>
+
+        * image.c (define_image_type): Avoid adding duplicate types to
+        image_types (Bug#12463).  Suggested by Jörg Walter.
+
+2012-09-21  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * unexmacosx.c: Define LC_DATA_IN_CODE if not defined.
+        (print_load_command_name): Add case LC_DATA_IN_CODE.
+        (dump_it) [LC_DATA_IN_CODE]: Call copy_linkedit_data.
+
+2012-09-21  Glenn Morris  <rgm@gnu.org>
+
+        * eval.c (Frun_hook_with_args_until_success)
+        (Frun_hook_with_args_until_failure): Doc fixes.  (Bug#12393)
+
+2012-09-21  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * fileio.c (Ffile_selinux_context): Only call freecon when
+        lgetfilecon succeeded.
+        (Fset_file_selinux_context): Likewise.  (Bug#12444)
+
+2012-09-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (try_window_reusing_current_matrix): Under bidi
+        reordering, locate the cursor by calling set_cursor_from_row; if
+        that fails, clear the desired glyph matrix before returning a
+        failure indication to the caller.  Fixes leaving garbled display
+        when fast scrolling with a down-key.  (Bug#12403)
+        (compute_stop_pos_backwards): Fix a typo that caused crashes while
+        scrolling through multibyte text.
+
+2012-09-20  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c (mark_object) <PVEC_WINDOW>: Mark prev/next_buffers *after*
+        calling mark_vectorlike since that's the one that marks the window.
+        (mark_discard_killed_buffers): Mark the final cdr.
+        * window.h (struct window): Move prev/next_buffers to the
+        non-standard fields.
+        * window.c (make_window): Initialize prev/next_buffers manually.
+
+2012-09-20  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Omit unused arg EXPECTED from socket hooks.
+        * keyboard.c (gobble_input, read_avail_input, tty_read_avail_input):
+        * nsterm.m (ns_term_init):
+        * termhooks.h (struct terminal.read_socket_hook):
+        * w32inevt.c (w32_console_read_socket):
+        * w32term.c (w32_read_socket):
+        * xterm.c (XTread_socket):
+        Omit unused arg EXPECTED.  All callers changed.
+        (store_user_signal_events): Return void, not int, since callers no
+        longer care about the return value.  All uses changed.
+
+2012-09-20  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32gui.h (XParseGeometry): Do not declare.
+
+2012-09-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * w32inevt.c (w32_console_read_socket): Return -1 on failure, not 0.
+        Ignore 'expected'. See Eli Zaretskii in
+        <http://bugs.gnu.org/12471#8> (last line).
+
+        * frame.c (read_integer): Remove.  All uses replaced by strtol/strtoul.
+        (XParseGeometry): Now static.  Substitute extremal values for
+        values that are out of range.
+
+2012-09-19  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * w32xfns.c (read_integer, XParseGeometry): Move to frame.c.
+
+        * nsfns.m (XParseGeometry): Remove.
+        (Fx_create_frame): Call x_set_offset to correctly interpret
+        top_pos in geometry.
+
+        * frame.c (read_integer, XParseGeometry): Moved from w32xfns.c.
+        (Fx_parse_geometry): If there is a space in string, call
+        Qns_parse_geometry, otherwise do as on other terms (Bug#12368).
+
+2012-09-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * search.c (scan_buffer): Use character positions in calls to
+        region_cache_forward and region_cache_backward, not byte
+        positions.  (Bug#12196)
+
+        * w32term.c (w32_read_socket): Set pending_signals to 1, like
+        xterm.c does.  Reported by Daniel Colascione <dancol@dancol.org>.
+
+        * ralloc.c (r_alloc_init) [!SYSTEM_MALLOC]: Initialize
+        __malloc_extra_blocks to 32 instead of 64, like alloc.c did in
+        emacs_blocked_malloc, now deleted.
+
+2012-09-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Remove no-longer-needed Solaris 2.4 vfork bug workaround.
+        The workaround was for improving performance on Solaris 2.4, but
+        is getting in the way now.  Emacs will still work if someone is
+        still running Solaris 2.4 in a museum somewhere; Sun dropped
+        support for Solaris 2.4 in 2003.
+        * callproc.c (Fcall_process) [HAVE_WORKING_VFORK]:
+        * process.c (create_process) [HAVE_WORKING_VFORK]:
+        Omit now-unnecessary workaround for the Solaris 2.4 vfork bug,
+        since Emacs no longer uses vfork on that platform.
+
+2012-09-17  Glenn Morris  <rgm@gnu.org>
+
+        * emacs.c: Use COPYRIGHT.
+
+2012-09-16  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Remove configure's --without-sync-input option (Bug#12450).
+        When auditing signal-handling in preparation for cleaning it up,
+        I found that SYNC_INPUT has race conditions and would be a real
+        pain to fix.  Since it's an undocumented and deprecated
+        configure-time option, now seems like a good time to remove it.
+        Also see <http://bugs.gnu.org/11080#16>.
+        * alloc.c (_bytes_used, __malloc_extra_blocks, _malloc_internal)
+        (_free_internal) [!DOUG_LEA_MALLOC]: Remove decls.
+        (alloc_mutex) [!SYSTEM_MALLOC && !SYNC_INPUT && HAVE_PTHREAD]:
+        (malloc_hysteresis):
+        (check_depth) [XMALLOC_OVERRUN_CHECK]:
+        (MALLOC_BLOCK_INPUT, MALLOC_UNBLOCK_INPUT):
+        (__malloc_hook, __realloc_hook, __free_hook, BYTES_USED)
+        (dont_register_blocks, bytes_used_when_reconsidered)
+        (bytes_used_when_full, emacs_blocked_free, emacs_blocked_malloc)
+        (emacs_blocked_realloc, reset_malloc_hooks, uninterrupt_malloc):
+        [!SYSTEM_MALLOC && !SYNC_INPUT]:
+        Remove. All uses removed.
+        (MALLOC_BLOCK_INPUT, MALLOC_UNBLOCK_INPUT): Use a different
+        implementation, one that depends on whether the new macro
+        XMALLOC_BLOCK_INPUT_CHECK is defined, not on whether SYNC_INPUT
+        is defined.
+        * atimer.c (run_timers, handle_alarm_signal):
+        * keyboard.c (pending_signal, poll_for_input_1, poll_for_input)
+        (handle_async_input, process_pending_signals)
+        (handle_input_available_signal, init_keyboard):
+        * nsterm.m (ns_read_socket):
+        * process.c (wait_reading_process_output):
+        * regex.c (immediate_quit, IMMEDIATE_QUIT_CHECK):
+        * sysdep.c (emacs_sigaction_init) [SA_RESTART]:
+        (emacs_write):
+        * xterm.c (XTread_socket):
+        Assume SYNC_INPUT.
+        * conf_post.h (SA_RESTART) [IRIX6_5]: Do not #undef.
+        * eval.c (handling_signal): Remove.  All uses removed.
+        * lisp.h (ELSE_PENDING_SIGNALS): Remove.
+        All uses replaced with the SYNC_INPUT version.
+        (reset_malloc_hooks, uninterrupt_malloc, handling_signal):
+        Remove decls.
+        * sysdep.c, syssignal.h (main_thread) [FORWARD_SIGNAL_TO_MAIN_THREAD]:
+        Now static.
+
+        * font.c (Ffont_shape_gstring): Remove unused local.
+
+2012-09-16  Glenn Morris  <rgm@gnu.org>
+
+        * Makefile.in (clean): No longer run nextstep's clean.
+
+        * Makefile.in (ns_appdir, ns_appbindir, ns_appsrc): Remove variables.
+        (ns_frag): Remove.
+        (ns-app): Move here from ns.mk, and simplify.
+        (clean): Simplify nextstep entry.
+        * ns.mk: Remove file.
+
 2012-09-17  Kenichi Handa  <handa@gnu.org>
 
         * font.c (Ffont_shape_gstring): Fix previous change; GLYPHs may
diff --git a/src/Makefile.in b/src/Makefile.in
index fe4cff5d8cc..37da170edbd 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -255,9 +255,6 @@ MSDOS_OBJ =
 ## w16select.o termcap.o if MSDOS && HAVE_X_WINDOWS.
 MSDOS_X_OBJ =
 
-ns_appdir=@ns_appdir@
-ns_appbindir=@ns_appbindir@
-ns_appsrc=@ns_appsrc@
 NS_OBJ=@NS_OBJ@
 ## nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o if HAVE_NS.
 NS_OBJC_OBJ=@NS_OBJC_OBJ@
@@ -501,8 +498,9 @@ $(OLDXMENU): $(OLDXMENU_TARGET)
 doc.o: buildobj.h
 
 
-## If HAVE_NS, some ns-specific rules (for OTHER_FILES) are inserted here.
-@ns_frag@
+ns-app: emacs$(EXEEXT)
+        cd ../nextstep && $(MAKE) $(MFLAGS) all
+
 
 .PHONY: mostlyclean clean bootstrap-clean distclean maintainer-clean
 .PHONY: versionclean extraclean frc
@@ -516,7 +514,6 @@ mostlyclean:
 clean: mostlyclean
         rm -f emacs-*.*.*$(EXEEXT) emacs$(EXEEXT)
         -rm -rf $(DEPDIR)
-        test "X$(ns_appdir)" = "X" || rm -rf $(ns_appdir)
 
 ## bootstrap-clean is used to clean up just before a bootstrap.
 ## It should remove all files generated during a compilation/bootstrap,
diff --git a/src/alloc.c b/src/alloc.c
index 0bfbb0c88b1..02ba2f5f9e3 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -85,68 +85,8 @@ extern void *sbrk ();
 
 #define MMAP_MAX_AREAS 100000000
 
-#else /* not DOUG_LEA_MALLOC */
-
-/* The following come from gmalloc.c.  */
-
-extern size_t _bytes_used;
-extern size_t __malloc_extra_blocks;
-extern void *_malloc_internal (size_t);
-extern void _free_internal (void *);
-
 #endif /* not DOUG_LEA_MALLOC */
 
-#if ! defined SYSTEM_MALLOC && ! defined SYNC_INPUT
-#ifdef HAVE_PTHREAD
-
-# include "syssignal.h"
-
-/* When GTK uses the file chooser dialog, different backends can be loaded
-   dynamically.  One such a backend is the Gnome VFS backend that gets loaded
-   if you run Gnome.  That backend creates several threads and also allocates
-   memory with malloc.
-
-   Also, gconf and gsettings may create several threads.
-
-   If Emacs sets malloc hooks (! SYSTEM_MALLOC) and the emacs_blocked_*
-   functions below are called from malloc, there is a chance that one
-   of these threads preempts the Emacs main thread and the hook variables
-   end up in an inconsistent state.  So we have a mutex to prevent that (note
-   that the backend handles concurrent access to malloc within its own threads
-   but Emacs code running in the main thread is not included in that control).
-
-   When UNBLOCK_INPUT is called, reinvoke_input_signal may be called.  If this
-   happens in one of the backend threads we will have two threads that tries
-   to run Emacs code at once, and the code is not prepared for that.
-   To prevent that, we only call BLOCK/UNBLOCK from the main thread.  */
-
-static pthread_mutex_t alloc_mutex;
-
-#define BLOCK_INPUT_ALLOC                               \
-  do                                                    \
-    {                                                   \
-      if (pthread_equal (pthread_self (), main_thread)) \
-        BLOCK_INPUT;                                    \
-      pthread_mutex_lock (&alloc_mutex);                \
-    }                                                   \
-  while (0)
-#define UNBLOCK_INPUT_ALLOC                             \
-  do                                                    \
-    {                                                   \
-      pthread_mutex_unlock (&alloc_mutex);              \
-      if (pthread_equal (pthread_self (), main_thread)) \
-        UNBLOCK_INPUT;                                  \
-    }                                                   \
-  while (0)
-
-#else /* ! defined HAVE_PTHREAD */
-
-#define BLOCK_INPUT_ALLOC BLOCK_INPUT
-#define UNBLOCK_INPUT_ALLOC UNBLOCK_INPUT
-
-#endif /* ! defined HAVE_PTHREAD */
-#endif /* ! defined SYSTEM_MALLOC && ! defined SYNC_INPUT */
-
 /* Mark, unmark, query mark bit of a Lisp string.  S must be a pointer
    to a struct Lisp_String.  */
 
@@ -205,10 +145,6 @@ static char *spare_memory[7];
 
 #define SPARE_MEMORY (1 << 14)
 
-/* Number of extra blocks malloc should get when it needs more core.  */
-
-static int malloc_hysteresis;
-
 /* Initialize it to a nonzero value to force it into data space
    (rather than bss space).  That way unexec will remap it into text
    space (pure), on some systems.  We have not implemented the
@@ -413,12 +349,12 @@ static void mark_memory (void *, void *);
 static void mem_init (void);
 static struct mem_node *mem_insert (void *, void *, enum mem_type);
 static void mem_insert_fixup (struct mem_node *);
-#endif
 static void mem_rotate_left (struct mem_node *);
 static void mem_rotate_right (struct mem_node *);
 static void mem_delete (struct mem_node *);
 static void mem_delete_fixup (struct mem_node *);
 static inline struct mem_node *mem_find (void *);
+#endif
 
 
 #if GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS
@@ -587,39 +523,17 @@ xmalloc_get_size (unsigned char *ptr)
 }
 
 
-/* The call depth in overrun_check functions.  For example, this might happen:
-   xmalloc()
-     overrun_check_malloc()
-       -> malloc -> (via hook)_-> emacs_blocked_malloc
-          -> overrun_check_malloc
-             call malloc  (hooks are NULL, so real malloc is called).
-             malloc returns 10000.
-             add overhead, return 10016.
-      <- (back in overrun_check_malloc)
-      add overhead again, return 10032
-   xmalloc returns 10032.
-
-   (time passes).
-
-   xfree(10032)
-     overrun_check_free(10032)
-       decrease overhead
-       free(10016)  <-  crash, because 10000 is the original pointer.  */
-
-static ptrdiff_t check_depth;
-
 /* Like malloc, but wraps allocated block with header and trailer.  */
 
 static void *
 overrun_check_malloc (size_t size)
 {
   register unsigned char *val;
-  int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
-  if (SIZE_MAX - overhead < size)
+  if (SIZE_MAX - XMALLOC_OVERRUN_CHECK_OVERHEAD < size)
     emacs_abort ();
 
-  val = malloc (size + overhead);
-  if (val && check_depth == 1)
+  val = malloc (size + XMALLOC_OVERRUN_CHECK_OVERHEAD);
+  if (val)
     {
       memcpy (val, xmalloc_overrun_check_header, XMALLOC_OVERRUN_CHECK_SIZE);
       val += XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE;
@@ -627,7 +541,6 @@ overrun_check_malloc (size_t size)
       memcpy (val + size, xmalloc_overrun_check_trailer,
               XMALLOC_OVERRUN_CHECK_SIZE);
     }
-  --check_depth;
   return val;
 }
 
@@ -639,12 +552,10 @@ static void *
 overrun_check_realloc (void *block, size_t size)
 {
   register unsigned char *val = (unsigned char *) block;
-  int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
-  if (SIZE_MAX - overhead < size)
+  if (SIZE_MAX - XMALLOC_OVERRUN_CHECK_OVERHEAD < size)
     emacs_abort ();
 
   if (val
-      && check_depth == 1
       && memcmp (xmalloc_overrun_check_header,
                  val - XMALLOC_OVERRUN_CHECK_SIZE - XMALLOC_OVERRUN_SIZE_SIZE,
                  XMALLOC_OVERRUN_CHECK_SIZE) == 0)
@@ -658,9 +569,9 @@ overrun_check_realloc (void *block, size_t size)
       memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE);
     }
 
-  val = realloc (val, size + overhead);
+  val = realloc (val, size + XMALLOC_OVERRUN_CHECK_OVERHEAD);
 
-  if (val && check_depth == 1)
+  if (val)
     {
       memcpy (val, xmalloc_overrun_check_header, XMALLOC_OVERRUN_CHECK_SIZE);
       val += XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE;
@@ -668,7 +579,6 @@ overrun_check_realloc (void *block, size_t size)
       memcpy (val + size, xmalloc_overrun_check_trailer,
               XMALLOC_OVERRUN_CHECK_SIZE);
     }
-  --check_depth;
   return val;
 }
 
@@ -679,9 +589,7 @@ overrun_check_free (void *block)
 {
   unsigned char *val = (unsigned char *) block;
 
-  ++check_depth;
   if (val
-      && check_depth == 1
       && memcmp (xmalloc_overrun_check_header,
                  val - XMALLOC_OVERRUN_CHECK_SIZE - XMALLOC_OVERRUN_SIZE_SIZE,
                  XMALLOC_OVERRUN_CHECK_SIZE) == 0)
@@ -701,7 +609,6 @@ overrun_check_free (void *block)
     }
 
   free (val);
-  --check_depth;
 }
 
 #undef malloc
@@ -712,14 +619,33 @@ overrun_check_free (void *block)
 #define free overrun_check_free
 #endif
 
-#ifdef SYNC_INPUT
-/* When using SYNC_INPUT, we don't call malloc from a signal handler, so
-   there's no need to block input around malloc.  */
-#define MALLOC_BLOCK_INPUT   ((void)0)
-#define MALLOC_UNBLOCK_INPUT ((void)0)
+/* If compiled with XMALLOC_BLOCK_INPUT_CHECK, define a symbol
+   BLOCK_INPUT_IN_MEMORY_ALLOCATORS that is visible to the debugger.
+   If that variable is set, block input while in one of Emacs's memory
+   allocation functions.  There should be no need for this debugging
+   option, since signal handlers do not allocate memory, but Emacs
+   formerly allocated memory in signal handlers and this compile-time
+   option remains as a way to help debug the issue should it rear its
+   ugly head again.  */
+#ifdef XMALLOC_BLOCK_INPUT_CHECK
+bool block_input_in_memory_allocators EXTERNALLY_VISIBLE;
+static void
+malloc_block_input (void)
+{
+  if (block_input_in_memory_allocators)
+    BLOCK_INPUT;
+}
+static void
+malloc_unblock_input (void)
+{
+  if (block_input_in_memory_allocators)
+    UNBLOCK_INPUT;
+}
+# define MALLOC_BLOCK_INPUT malloc_block_input ()
+# define MALLOC_UNBLOCK_INPUT malloc_unblock_input ()
 #else
-#define MALLOC_BLOCK_INPUT   BLOCK_INPUT
-#define MALLOC_UNBLOCK_INPUT UNBLOCK_INPUT
+# define MALLOC_BLOCK_INPUT ((void) 0)
+# define MALLOC_UNBLOCK_INPUT ((void) 0)
 #endif
 
 /* Like malloc but check for no memory and block interrupt input..  */
@@ -788,8 +714,7 @@ xfree (void *block)
   free (block);
   MALLOC_UNBLOCK_INPUT;
   /* We don't call refill_memory_reserve here
-     because that duplicates doing so in emacs_blocked_free
-     and the criterion should go there.  */
+     because in practice the call in r_alloc_free seems to suffice.  */
 }
 
 
@@ -1216,256 +1141,6 @@ lisp_align_free (void *block)
 }
 
 
-#ifndef SYSTEM_MALLOC
-
-/* Arranging to disable input signals while we're in malloc.
-
-   This only works with GNU malloc.  To help out systems which can't
-   use GNU malloc, all the calls to malloc, realloc, and free
-   elsewhere in the code should be inside a BLOCK_INPUT/UNBLOCK_INPUT
-   pair; unfortunately, we have no idea what C library functions
-   might call malloc, so we can't really protect them unless you're
-   using GNU malloc.  Fortunately, most of the major operating systems
-   can use GNU malloc.  */
-
-#ifndef SYNC_INPUT
-/* When using SYNC_INPUT, we don't call malloc from a signal handler, so
-   there's no need to block input around malloc.  */
-
-#ifndef DOUG_LEA_MALLOC
-extern void * (*__malloc_hook) (size_t, const void *);
-extern void * (*__realloc_hook) (void *, size_t, const void *);
-extern void (*__free_hook) (void *, const void *);
-/* Else declared in malloc.h, perhaps with an extra arg.  */
-#endif /* DOUG_LEA_MALLOC */
-static void * (*old_malloc_hook) (size_t, const void *);
-static void * (*old_realloc_hook) (void *,  size_t, const void*);
-static void (*old_free_hook) (void*, const void*);
-
-#ifdef DOUG_LEA_MALLOC
-#  define BYTES_USED (mallinfo ().uordblks)
-#else
-#  define BYTES_USED _bytes_used
-#endif
-
-#ifdef GC_MALLOC_CHECK
-static bool dont_register_blocks;
-#endif
-
-static size_t bytes_used_when_reconsidered;
-
-/* Value of _bytes_used, when spare_memory was freed.  */
-
-static size_t bytes_used_when_full;
-
-/* This function is used as the hook for free to call.  */
-
-static void
-emacs_blocked_free (void *ptr, const void *ptr2)
-{
-  BLOCK_INPUT_ALLOC;
-
-#ifdef GC_MALLOC_CHECK
-  if (ptr)
-    {
-      struct mem_node *m;
-
-      m = mem_find (ptr);
-      if (m == MEM_NIL || m->start != ptr)
-        {
-          fprintf (stderr,
-                   "Freeing `%p' which wasn't allocated with malloc\n", ptr);
-          emacs_abort ();
-        }
-      else
-        {
-          /* fprintf (stderr, "free %p...%p (%p)\n", m->start, m->end, ptr); */
-          mem_delete (m);
-        }
-    }
-#endif /* GC_MALLOC_CHECK */
-
-  __free_hook = old_free_hook;
-  free (ptr);
-
-  /* If we released our reserve (due to running out of memory),
-     and we have a fair amount free once again,
-     try to set aside another reserve in case we run out once more.  */
-  if (! NILP (Vmemory_full)
-      /* Verify there is enough space that even with the malloc
-         hysteresis this call won't run out again.
-         The code here is correct as long as SPARE_MEMORY
-         is substantially larger than the block size malloc uses.  */
-      && (bytes_used_when_full
-          > ((bytes_used_when_reconsidered = BYTES_USED)
-             + max (malloc_hysteresis, 4) * SPARE_MEMORY)))
-    refill_memory_reserve ();
-
-  __free_hook = emacs_blocked_free;
-  UNBLOCK_INPUT_ALLOC;
-}
-
-
-/* This function is the malloc hook that Emacs uses.  */
-
-static void *
-emacs_blocked_malloc (size_t size, const void *ptr)
-{
-  void *value;
-
-  BLOCK_INPUT_ALLOC;
-  __malloc_hook = old_malloc_hook;
-#ifdef DOUG_LEA_MALLOC
-  /* Segfaults on my system.  --lorentey */
-  /* mallopt (M_TOP_PAD, malloc_hysteresis * 4096); */
-#else
-    __malloc_extra_blocks = malloc_hysteresis;
-#endif
-
-  value = malloc (size);
-
-#ifdef GC_MALLOC_CHECK
-  {
-    struct mem_node *m = mem_find (value);
-    if (m != MEM_NIL)
-      {
-        fprintf (stderr, "Malloc returned %p which is already in use\n",
-                 value);
-        fprintf (stderr, "Region in use is %p...%p, %td bytes, type %d\n",
-                 m->start, m->end, (char *) m->end - (char *) m->start,
-                 m->type);
-        emacs_abort ();
-      }
-
-    if (!dont_register_blocks)
-      {
-        mem_insert (value, (char *) value + max (1, size), allocated_mem_type);
-        allocated_mem_type = MEM_TYPE_NON_LISP;
-      }
-  }
-#endif /* GC_MALLOC_CHECK */
-
-  __malloc_hook = emacs_blocked_malloc;
-  UNBLOCK_INPUT_ALLOC;
-
-  /* fprintf (stderr, "%p malloc\n", value); */
-  return value;
-}
-
-
-/* This function is the realloc hook that Emacs uses.  */
-
-static void *
-emacs_blocked_realloc (void *ptr, size_t size, const void *ptr2)
-{
-  void *value;
-
-  BLOCK_INPUT_ALLOC;
-  __realloc_hook = old_realloc_hook;
-
-#ifdef GC_MALLOC_CHECK
-  if (ptr)
-    {
-      struct mem_node *m = mem_find (ptr);
-      if (m == MEM_NIL || m->start != ptr)
-        {
-          fprintf (stderr,
-                   "Realloc of %p which wasn't allocated with malloc\n",
-                   ptr);
-          emacs_abort ();
-        }
-
-      mem_delete (m);
-    }
-
-  /* fprintf (stderr, "%p -> realloc\n", ptr); */
-
-  /* Prevent malloc from registering blocks.  */
-  dont_register_blocks = 1;
-#endif /* GC_MALLOC_CHECK */
-
-  value = realloc (ptr, size);
-
-#ifdef GC_MALLOC_CHECK
-  dont_register_blocks = 0;
-
-  {
-    struct mem_node *m = mem_find (value);
-    if (m != MEM_NIL)
-      {
-        fprintf (stderr, "Realloc returns memory that is already in use\n");
-        emacs_abort ();
-      }
-
-    /* Can't handle zero size regions in the red-black tree.  */
-    mem_insert (value, (char *) value + max (size, 1), MEM_TYPE_NON_LISP);
-  }
-
-  /* fprintf (stderr, "%p <- realloc\n", value); */
-#endif /* GC_MALLOC_CHECK */
-
-  __realloc_hook = emacs_blocked_realloc;
-  UNBLOCK_INPUT_ALLOC;
-
-  return value;
-}
-
-
-#ifdef HAVE_PTHREAD
-/* Called from Fdump_emacs so that when the dumped Emacs starts, it has a
-   normal malloc.  Some thread implementations need this as they call
-   malloc before main.  The pthread_self call in BLOCK_INPUT_ALLOC then
-   calls malloc because it is the first call, and we have an endless loop.  */
-
-void
-reset_malloc_hooks (void)
-{
-  __free_hook = old_free_hook;
-  __malloc_hook = old_malloc_hook;
-  __realloc_hook = old_realloc_hook;
-}
-#endif /* HAVE_PTHREAD */
-
-
-/* Called from main to set up malloc to use our hooks.  */
-
-void
-uninterrupt_malloc (void)
-{
-#ifdef HAVE_PTHREAD
-#ifdef DOUG_LEA_MALLOC
-  pthread_mutexattr_t attr;
-
-  /*  GLIBC has a faster way to do this, but let's keep it portable.
-      This is according to the Single UNIX Specification.  */
-  pthread_mutexattr_init (&attr);
-  pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
-  pthread_mutex_init (&alloc_mutex, &attr);
-#else  /* !DOUG_LEA_MALLOC */
-  /* Some systems such as Solaris 2.6 don't have a recursive mutex,
-     and the bundled gmalloc.c doesn't require it.  */
-  pthread_mutex_init (&alloc_mutex, NULL);
-#endif /* !DOUG_LEA_MALLOC */
-#endif /* HAVE_PTHREAD */
-
-  if (__free_hook != emacs_blocked_free)
-    old_free_hook = __free_hook;
-  __free_hook = emacs_blocked_free;
-
-  if (__malloc_hook != emacs_blocked_malloc)
-    old_malloc_hook = __malloc_hook;
-  __malloc_hook = emacs_blocked_malloc;
-
-  if (__realloc_hook != emacs_blocked_realloc)
-    old_realloc_hook = __realloc_hook;
-  __realloc_hook = emacs_blocked_realloc;
-}
-
-#endif /* not SYNC_INPUT */
-#endif /* not SYSTEM_MALLOC */
-
-
-
 /***********************************************************************
                          Interval Allocation
  ***********************************************************************/
@@ -1511,8 +1186,6 @@ make_interval (void)
 {
   INTERVAL val;
 
-  /* eassert (!handling_signal); */
-
   MALLOC_BLOCK_INPUT;
 
   if (interval_free_list)
@@ -1896,8 +1569,6 @@ allocate_string (void)
 {
   struct Lisp_String *s;
 
-  /* eassert (!handling_signal); */
-
   MALLOC_BLOCK_INPUT;
 
   /* If the free-list is empty, allocate a new string_block, and
@@ -2589,8 +2260,6 @@ make_float (double float_value)
 {
   register Lisp_Object val;
 
-  /* eassert (!handling_signal); */
-
   MALLOC_BLOCK_INPUT;
 
   if (float_free_list)
@@ -2698,8 +2367,6 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
 {
   register Lisp_Object val;
 
-  /* eassert (!handling_signal); */
-
   MALLOC_BLOCK_INPUT;
 
   if (cons_free_list)
@@ -3205,9 +2872,6 @@ allocate_vectorlike (ptrdiff_t len)
 
   MALLOC_BLOCK_INPUT;
 
-  /* This gets triggered by code which I haven't bothered to fix.  --Stef  */
-  /* eassert (!handling_signal); */
-
   if (len == 0)
     p = XVECTOR (zero_vector);
   else
@@ -3492,8 +3156,6 @@ Its value and function definition are void, and its property list is nil.  */)
 
   CHECK_STRING (name);
 
-  /* eassert (!handling_signal); */
-
   MALLOC_BLOCK_INPUT;
 
   if (symbol_free_list)
@@ -3578,8 +3240,6 @@ allocate_misc (enum Lisp_Misc_Type type)
 {
   Lisp_Object val;
 
-  /* eassert (!handling_signal); */
-
   MALLOC_BLOCK_INPUT;
 
   if (marker_free_list)
@@ -3799,12 +3459,6 @@ memory_full (size_t nbytes)
               lisp_free (spare_memory[i]);
             spare_memory[i] = 0;
           }
-
-      /* Record the space now used.  When it decreases substantially,
-         we can refill the memory reserve.  */
-#if !defined SYSTEM_MALLOC && !defined SYNC_INPUT
-      bytes_used_when_full = BYTES_USED;
-#endif
     }
 
   /* This used to call error, but if we've run out of memory, we could
@@ -3942,7 +3596,7 @@ mem_insert (void *start, void *end, enum mem_type type)
 
   /* Create a new node.  */
 #ifdef GC_MALLOC_CHECK
-  x = _malloc_internal (sizeof *x);
+  x = malloc (sizeof *x);
   if (x == NULL)
     emacs_abort ();
 #else
@@ -4166,7 +3820,7 @@ mem_delete (struct mem_node *z)
     mem_delete_fixup (x);
 
 #ifdef GC_MALLOC_CHECK
-  _free_internal (y);
+  free (y);
 #else
   xfree (y);
 #endif
@@ -5867,7 +5521,7 @@ mark_buffer (struct buffer *buffer)
 }
 
 /* Remove killed buffers or items whose car is a killed buffer from
-   LIST, and mark other items. Return changed LIST, which is marked.  */
+   LIST, and mark other items.  Return changed LIST, which is marked.  */
 
 static Lisp_Object
 mark_discard_killed_buffers (Lisp_Object list)
@@ -5889,6 +5543,7 @@ mark_discard_killed_buffers (Lisp_Object list)
           prev = &XCDR_AS_LVALUE (tail);
         }
     }
+  mark_object (tail);
   return list;
 }
 
@@ -6037,18 +5692,8 @@ mark_object (Lisp_Object arg)
               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, mark_discard_killed_buffers (w->prev_buffers));
-                  wset_next_buffers
-                    (w, mark_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.  */
@@ -6057,6 +5702,15 @@ mark_object (Lisp_Object arg)
                   mark_glyph_matrix (w->current_matrix);
                   mark_glyph_matrix (w->desired_matrix);
                 }
+
+              /* Filter out killed buffers from both buffer lists
+                 in attempt to help GC to reclaim killed buffers faster.
+                 We can do it elsewhere for live windows, but this is the
+                 best place to do it for dead windows.  */
+              wset_prev_buffers
+                (w, mark_discard_killed_buffers (w->prev_buffers));
+              wset_next_buffers
+                (w, mark_discard_killed_buffers (w->next_buffers));
             }
             break;
 
@@ -6767,12 +6421,6 @@ init_alloc_once (void)
   init_strings ();
   init_vectors ();
 
-#ifdef REL_ALLOC
-  malloc_hysteresis = 32;
-#else
-  malloc_hysteresis = 0;
-#endif
-
   refill_memory_reserve ();
   gc_cons_threshold = GC_DEFAULT_THRESHOLD;
 }
diff --git a/src/atimer.c b/src/atimer.c
index 80b813fe4fe..5dbd807872a 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -369,7 +369,6 @@ run_timers (void)
   if (! atimers)
     pending_atimers = 0;
 
-#ifdef SYNC_INPUT
   if (pending_atimers)
     pending_signals = 1;
   else
@@ -377,10 +376,6 @@ run_timers (void)
       pending_signals = interrupt_input_pending;
       set_alarm ();
     }
-#else
-  if (! pending_atimers)
-    set_alarm ();
-#endif
 }
 
 
@@ -391,11 +386,7 @@ static void
 handle_alarm_signal (int sig)
 {
   pending_atimers = 1;
-#ifdef SYNC_INPUT
   pending_signals = 1;
-#else
-  run_timers ();
-#endif
 }
 
 static void
diff --git a/src/bytecode.c b/src/bytecode.c
index b151078f60f..5f4fdcc5eff 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -458,7 +458,8 @@ unmark_byte_stack (void)
         Fsignal (Qquit, Qnil);                          \
         AFTER_POTENTIAL_GC ();                          \
       }                                                 \
-    ELSE_PENDING_SIGNALS                                \
+    else if (pending_signals)                           \
+      process_pending_signals ();                       \
   } while (0)
 
 
diff --git a/src/callproc.c b/src/callproc.c
index 9171337ee76..2604d295f3e 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -496,11 +496,6 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     register char **save_environ = environ;
     register int fd1 = fd[1];
     int fd_error = fd1;
-#ifdef HAVE_WORKING_VFORK
-    sigset_t procmask;
-    sigset_t blocked;
-    struct sigaction sigpipe_action;
-#endif
 
     if (fd_output >= 0)
       fd1 = fd_output;
@@ -587,17 +582,6 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
                        0, current_dir);
 #else  /* not WINDOWSNT */
 
-#ifdef HAVE_WORKING_VFORK
-    /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
-       this sets the parent's signal handlers as well as the child's.
-       So delay all interrupts whose handlers the child might munge,
-       and record the current handlers so they can be restored later.  */
-    sigemptyset (&blocked);
-    sigaddset (&blocked, SIGPIPE);
-    sigaction (SIGPIPE, 0, &sigpipe_action);
-    pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
-#endif
-
     BLOCK_INPUT;
 
     /* vfork, and prevent local vars from being clobbered by the vfork.  */
@@ -645,9 +629,6 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
         /* GConf causes us to ignore SIGPIPE, make sure it is restored
            in the child.  */
         signal (SIGPIPE, SIG_DFL);
-#ifdef HAVE_WORKING_VFORK
-        pthread_sigmask (SIG_SETMASK, &procmask, 0);
-#endif
 
         child_setup (filefd, fd1, fd_error, (char **) new_argv,
                      0, current_dir);
@@ -655,12 +636,6 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
     UNBLOCK_INPUT;
 
-#ifdef HAVE_WORKING_VFORK
-    /* Restore the signal state.  */
-    sigaction (SIGPIPE, &sigpipe_action, 0);
-    pthread_sigmask (SIG_SETMASK, &procmask, 0);
-#endif
-
 #endif /* not WINDOWSNT */
 
     /* The MSDOS case did this already.  */
diff --git a/src/conf_post.h b/src/conf_post.h
index 94934ffeadf..0c4d029bc5d 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -90,7 +90,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 char *_getpty();
 #endif
 
-#undef SA_RESTART     /* not the same as defining BROKEN_SA_RESTART */
 #endif /* IRIX6_5 */
 
 #ifdef MSDOS
diff --git a/src/dispnew.c b/src/dispnew.c
index 5827316a7b7..fc966581adb 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -5971,7 +5971,7 @@ sit_for (Lisp_Object timeout, bool reading, int do_display)
 
 
 #ifdef USABLE_SIGIO
-  gobble_input (0);
+  gobble_input ();
 #endif
 
   wait_reading_process_output (sec, nsec, reading ? -1 : 1, do_display,
diff --git a/src/emacs.c b/src/emacs.c
index 1416bf76c43..d4b52ab64ea 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -88,7 +88,7 @@ extern void moncontrol (int mode);
 #endif
 
 static const char emacs_version[] = VERSION;
-static const char emacs_copyright[] = "Copyright (C) 2012 Free Software Foundation, Inc.";
+static const char emacs_copyright[] = COPYRIGHT;
 
 /* Empty lisp strings.  To avoid having to build any others.  */
 Lisp_Object empty_unibyte_string, empty_multibyte_string;
@@ -848,14 +848,10 @@ main (int argc, char **argv)
   /* Arrange to get warning messages as memory fills up.  */
   memory_warnings (0, malloc_warning);
 
-  /* Call malloc at least once, to run the initial __malloc_hook.
+  /* Call malloc at least once, to run malloc_initialize_hook.
      Also call realloc and free for consistency.  */
   free (realloc (malloc (4), 4));
 
-# ifndef SYNC_INPUT
-  /* Arrange to disable interrupt input inside malloc etc.  */
-  uninterrupt_malloc ();
-# endif /* not SYNC_INPUT */
 #endif  /* not SYSTEM_MALLOC */
 
 #if defined (MSDOS) || defined (WINDOWSNT)
@@ -2143,12 +2139,6 @@ You must run Emacs in batch mode in order to dump it.  */)
     memory_warnings (my_edata, malloc_warning);
   }
 #endif /* not WINDOWSNT */
-#if defined (HAVE_PTHREAD) && !defined SYNC_INPUT
-  /* Pthread may call malloc before main, and then we will get an endless
-     loop, because pthread_self (see alloc.c) calls malloc the first time
-     it is called on some systems.  */
-  reset_malloc_hooks ();
-#endif
 #endif /* not SYSTEM_MALLOC */
 #ifdef DOUG_LEA_MALLOC
   malloc_state_ptr = malloc_get_state ();
diff --git a/src/eval.c b/src/eval.c
index 6cca13a8fda..e47478bb1f1 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -117,12 +117,6 @@ static EMACS_INT when_entered_debugger;
 
 Lisp_Object Vsignaling_function;
 
-/* Set to non-zero while processing X events.  Checked in Feval to
-   make sure the Lisp interpreter isn't called from a signal handler,
-   which is unsafe because the interpreter isn't reentrant.  */
-
-int handling_signal;
-
 /* If non-nil, Lisp code must not be run since some part of Emacs is
    in an inconsistent state.  Currently, x-create-frame uses this to
    avoid triggering window-configuration-change-hook while the new
@@ -1106,7 +1100,6 @@ unwind_to_catch (struct catchtag *catch, Lisp_Object value)
   /* Restore certain special C variables.  */
   set_poll_suppress_count (catch->poll_suppress_count);
   UNBLOCK_INPUT_TO (catch->interrupt_input_blocked);
-  handling_signal = 0;
   immediate_quit = 0;
 
   do
@@ -1486,7 +1479,7 @@ See also the function `condition-case'.  */)
   struct handler *h;
   struct backtrace *bp;
 
-  immediate_quit = handling_signal = 0;
+  immediate_quit = 0;
   abort_on_gc = 0;
   if (gc_in_progress || waiting_for_input)
     emacs_abort ();
@@ -2039,9 +2032,6 @@ eval_sub (Lisp_Object form)
   struct backtrace backtrace;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
-  if (handling_signal)
-    emacs_abort ();
-
   if (SYMBOLP (form))
     {
       /* Look up its binding in the lexical environment.
@@ -2409,6 +2399,7 @@ If it is a list of functions, those functions are called, in order,
 with the given arguments ARGS, until one of them
 returns a non-nil value.  Then we return that value.
 However, if they all return nil, we return nil.
+If the value of HOOK is nil, this function returns nil.
 
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
@@ -2430,10 +2421,12 @@ DEFUN ("run-hook-with-args-until-failure", Frun_hook_with_args_until_failure,
 HOOK should be a symbol, a hook variable.  If HOOK has a non-nil
 value, that value may be a function or a list of functions to be
 called to run the hook.  If the value is a function, it is called with
-the given arguments and its return value is returned.
+the given arguments.  Then we return nil if the function returns nil,
+and t if it returns non-nil.
 If it is a list of functions, those functions are called, in order,
 with the given arguments ARGS, until one of them returns nil.
-Then we return nil.  However, if they all return non-nil, we return non-nil.
+Then we return nil.  However, if they all return non-nil, we return t.
+If the value of HOOK is nil, this function returns t.
 
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
@@ -3104,8 +3097,6 @@ specbind (Lisp_Object symbol, Lisp_Object value)
 {
   struct Lisp_Symbol *sym;
 
-  eassert (!handling_signal);
-
   CHECK_SYMBOL (symbol);
   sym = XSYMBOL (symbol);
   if (specpdl_ptr == specpdl + specpdl_size)
@@ -3199,8 +3190,6 @@ specbind (Lisp_Object symbol, Lisp_Object value)
 void
 record_unwind_protect (Lisp_Object (*function) (Lisp_Object), Lisp_Object arg)
 {
-  eassert (!handling_signal);
-
   if (specpdl_ptr == specpdl + specpdl_size)
     grow_specpdl ();
   specpdl_ptr->func = function;
diff --git a/src/fileio.c b/src/fileio.c
index ca71af7ed95..6c4e34d7312 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2833,9 +2833,8 @@ or if SELinux is disabled, or if Emacs lacks SELinux support.  */)
           if (context_range_get (context))
             values[3] = build_string (context_range_get (context));
           context_free (context);
+          freecon (con);
         }
-      if (con)
-        freecon (con);
     }
 #endif
 
@@ -2914,12 +2913,10 @@ compiled with SELinux support.  */)
             report_file_error ("Doing lsetfilecon", Fcons (absname, Qnil));
 
           context_free (parsed_con);
+          freecon (con);
         }
       else
         report_file_error ("Doing lgetfilecon", Fcons (absname, Qnil));
-
-      if (con)
-        freecon (con);
     }
 #endif
 
diff --git a/src/font.c b/src/font.c
index fc970254a62..1f22fee88ee 100644
--- a/src/font.c
+++ b/src/font.c
@@ -4303,7 +4303,7 @@ GSTRING.  */)
 {
   struct font *font;
   Lisp_Object font_object, n, glyph;
-  ptrdiff_t i, j, from, to;
+  ptrdiff_t i, from, to;
 
   if (! composition_gstring_p (gstring))
     signal_error ("Invalid glyph-string: ", gstring);
diff --git a/src/frame.c b/src/frame.c
index 6930dac3ce8..f3d16171516 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -3897,6 +3897,95 @@ x_default_parameter (struct frame *f, Lisp_Object alist, Lisp_Object prop,
 }
 
 
+#if !defined (HAVE_X_WINDOWS) && defined (NoValue)
+
+/*
+ *    XParseGeometry parses strings of the form
+ *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
+ *   width, height, xoffset, and yoffset are unsigned integers.
+ *   Example:  "=80x24+300-49"
+ *   The equal sign is optional.
+ *   It returns a bitmask that indicates which of the four values
+ *   were actually found in the string.  For each value found,
+ *   the corresponding argument is updated;  for each value
+ *   not found, the corresponding argument is left unchanged.
+ */
+
+static int
+XParseGeometry (char *string,
+                int *x, int *y,
+                unsigned int *width, unsigned int *height)
+{
+  int mask = NoValue;
+  char *strind;
+  unsigned long int tempWidth, tempHeight;
+  long int tempX, tempY;
+  char *nextCharacter;
+
+  if (string == NULL || *string == '\0')
+    return mask;
+  if (*string == '=')
+    string++;  /* ignore possible '=' at beg of geometry spec */
+
+  strind = string;
+  if (*strind != '+' && *strind != '-' && *strind != 'x')
+    {
+      tempWidth = strtoul (strind, &nextCharacter, 10);
+      if (strind == nextCharacter)
+        return 0;
+      strind = nextCharacter;
+      mask |= WidthValue;
+    }
+
+  if (*strind == 'x' || *strind == 'X')
+    {
+      strind++;
+      tempHeight = strtoul (strind, &nextCharacter, 10);
+      if (strind == nextCharacter)
+        return 0;
+      strind = nextCharacter;
+      mask |= HeightValue;
+    }
+
+  if (*strind == '+' || *strind == '-')
+    {
+      if (*strind == '-')
+        mask |= XNegative;
+      tempX = strtol (strind, &nextCharacter, 10);
+      if (strind == nextCharacter)
+        return 0;
+      strind = nextCharacter;
+      mask |= XValue;
+      if (*strind == '+' || *strind == '-')
+        {
+          if (*strind == '-')
+            mask |= YNegative;
+          tempY = strtol (strind, &nextCharacter, 10);
+          if (strind == nextCharacter)
+            return 0;
+          strind = nextCharacter;
+          mask |= YValue;
+        }
+    }
+
+  /* If strind isn't at the end of the string then it's an invalid
+     geometry specification. */
+
+  if (*strind != '\0')
+    return 0;
+
+  if (mask & XValue)
+    *x = clip_to_bounds (INT_MIN, tempX, INT_MAX);
+  if (mask & YValue)
+    *y = clip_to_bounds (INT_MIN, tempY, INT_MAX);
+  if (mask & WidthValue)
+    *width = min (tempWidth, UINT_MAX);
+  if (mask & HeightValue)
+    *height = min (tempHeight, UINT_MAX);
+  return mask;
+}
+
+#endif /* !defined (HAVE_X_WINDOWS) && defined (NoValue) */
 
 
 /* NS used to define x-parse-geometry in ns-win.el, but that confused
@@ -3917,15 +4006,16 @@ or a list (- N) meaning -N pixels relative to bottom/right corner.
 On Nextstep, this just calls `ns-parse-geometry'.  */)
   (Lisp_Object string)
 {
-#ifdef HAVE_NS
-  return call1 (Qns_parse_geometry, string);
-#else
   int geometry, x, y;
   unsigned int width, height;
   Lisp_Object result;
 
   CHECK_STRING (string);
 
+#ifdef HAVE_NS
+  if (strchr (SSDATA (string), ' ') != NULL)
+    return call1 (Qns_parse_geometry, string);
+#endif
   geometry = XParseGeometry (SSDATA (string),
                              &x, &y, &width, &height);
   result = Qnil;
@@ -3961,7 +4051,6 @@ On Nextstep, this just calls `ns-parse-geometry'.  */)
     result = Fcons (Fcons (Qheight, make_number (height)), result);
 
   return result;
-#endif /* HAVE_NS */
 }
 
 
diff --git a/src/image.c b/src/image.c
index 8fc1c8637eb..8d690df8abb 100644
--- a/src/image.c
+++ b/src/image.c
@@ -590,9 +590,15 @@ define_image_type (struct image_type *type, int loaded)
     success = Qnil;
   else
     {
+      struct image_type *p;
+      Lisp_Object target_type = *(type->type);
+      for (p = image_types; p; p = p->next)
+        if (EQ (*(p->type), target_type))
+          return Qt;
+
       /* 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);
+      p = xmalloc (sizeof *p);
       *p = *type;
       p->next = image_types;
       image_types = p;
diff --git a/src/intervals.c b/src/intervals.c
index 5a47cacb2dd..584ee1e923d 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -673,8 +673,7 @@ find_interval (register INTERVAL tree, register ptrdiff_t position)
 
   eassert (relative_position <= TOTAL_LENGTH (tree));
 
-  if (!handling_signal)
-    tree = balance_possible_root_interval (tree);
+  tree = balance_possible_root_interval (tree);
 
   while (1)
     {
diff --git a/src/keyboard.c b/src/keyboard.c
index d164083fb86..098d3530ef8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -84,9 +84,7 @@ int interrupt_input_pending;
    pending_atimers separately, to reduce code size.  So, any code that
    changes interrupt_input_pending or pending_atimers should update
    this too.  */
-#ifdef SYNC_INPUT
 int pending_signals;
-#endif
 
 #define KBD_BUFFER_SIZE 4096
 
@@ -415,7 +413,7 @@ static EMACS_TIME timer_last_idleness_start_time;
 /* Function for init_keyboard to call with no args (if nonzero).  */
 static void (*keyboard_init_hook) (void);
 
-static int read_avail_input (int);
+static int read_avail_input (void);
 static void get_input_pending (int *, int);
 static int readable_events (int);
 static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
@@ -450,7 +448,7 @@ static void timer_stop_idle (void);
 static void timer_resume_idle (void);
 static void deliver_user_signal (int);
 static char *find_user_signal_name (int);
-static int store_user_signal_events (void);
+static void store_user_signal_events (void);
 
 /* These setters are used only in this file, so they can be private.  */
 static inline void
@@ -2010,17 +2008,9 @@ static struct atimer *poll_timer;
 void
 poll_for_input_1 (void)
 {
-/* Tell ns_read_socket() it is being called asynchronously so it can avoid
-   doing anything dangerous.  */
-#ifdef HAVE_NS
-  ++handling_signal;
-#endif
   if (interrupt_input_blocked == 0
       && !waiting_for_input)
-    read_avail_input (0);
-#ifdef HAVE_NS
-  --handling_signal;
-#endif
+    read_avail_input ();
 }
 
 /* Timer callback function for poll_timer.  TIMER is equal to
@@ -2031,12 +2021,8 @@ poll_for_input (struct atimer *timer)
 {
   if (poll_suppress_count == 0)
     {
-#ifdef SYNC_INPUT
       interrupt_input_pending = 1;
       pending_signals = 1;
-#else
-      poll_for_input_1 ();
-#endif
     }
 }
 
@@ -3857,7 +3843,7 @@ kbd_buffer_get_event (KBOARD **kbp,
          interrupt handlers have not read it, read it now.  */
 
 #ifdef USABLE_SIGIO
-      gobble_input (0);
+      gobble_input ();
 #endif
       if (kbd_fetch_ptr != kbd_store_ptr)
         break;
@@ -3883,8 +3869,7 @@ kbd_buffer_get_event (KBOARD **kbp,
         wait_reading_process_output (0, 0, -1, 1, Qnil, NULL, 0);
 
       if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
-        /* Pass 1 for EXPECT since we just waited to have input.  */
-        read_avail_input (1);
+        read_avail_input ();
     }
 
   if (CONSP (Vunread_command_events))
@@ -6748,14 +6733,14 @@ get_input_pending (int *addr, int flags)
     return;
 
   /* Try to read some input and see how much we get.  */
-  gobble_input (0);
+  gobble_input ();
   *addr = (!NILP (Vquit_flag) || readable_events (flags));
 }
 
 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary.  */
 
 void
-gobble_input (int expected)
+gobble_input (void)
 {
 #ifdef USABLE_SIGIO
   if (interrupt_input)
@@ -6764,7 +6749,7 @@ gobble_input (int expected)
       sigemptyset (&blocked);
       sigaddset (&blocked, SIGIO);
       pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
-      read_avail_input (expected);
+      read_avail_input ();
       pthread_sigmask (SIG_SETMASK, &procmask, 0);
     }
   else
@@ -6778,13 +6763,13 @@ gobble_input (int expected)
       sigemptyset (&blocked);
       sigaddset (&blocked, SIGALRM);
       pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
-      read_avail_input (expected);
+      read_avail_input ();
       pthread_sigmask (SIG_SETMASK, &procmask, 0);
     }
   else
 #endif
 #endif
-    read_avail_input (expected);
+    read_avail_input ();
 }
 
 /* Put a BUFFER_SWITCH_EVENT in the buffer
@@ -6840,15 +6825,14 @@ record_asynch_buffer_change (void)
    this is a bad time to try to read input.  */
 
 static int
-read_avail_input (int expected)
+read_avail_input (void)
 {
   int nread = 0;
   int err = 0;
   struct terminal *t;
 
   /* Store pending user signal events, if any.  */
-  if (store_user_signal_events ())
-    expected = 0;
+  store_user_signal_events ();
 
   /* Loop through the available terminals, and call their input hooks.  */
   t = terminal_list;
@@ -6865,11 +6849,8 @@ read_avail_input (int expected)
           hold_quit.kind = NO_EVENT;
 
           /* No need for FIONREAD or fcntl; just say don't wait.  */
-          while (nr = (*t->read_socket_hook) (t, expected, &hold_quit), nr > 0)
-            {
-              nread += nr;
-              expected = 0;
-            }
+          while (0 < (nr = (*t->read_socket_hook) (t, &hold_quit)))
+            nread += nr;
 
           if (nr == -1)          /* Not OK to read input now.  */
             {
@@ -6964,7 +6945,6 @@ decode_keyboard_code (struct tty_display_info *tty,
 
 int
 tty_read_avail_input (struct terminal *terminal,
-                      int expected,
                       struct input_event *hold_quit)
 {
   /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
@@ -7176,36 +7156,23 @@ tty_read_avail_input (struct terminal *terminal,
   return nread;
 }
 
-#if defined SYNC_INPUT || defined USABLE_SIGIO
 static void
 handle_async_input (void)
 {
   interrupt_input_pending = 0;
-#ifdef SYNC_INPUT
   pending_signals = pending_atimers;
-#endif
-/* Tell ns_read_socket() it is being called asynchronously so it can avoid
-   doing anything dangerous.  */
-#ifdef HAVE_NS
-  ++handling_signal;
-#endif
+
   while (1)
     {
-      int nread;
-      nread = read_avail_input (1);
+      int nread = read_avail_input ();
       /* -1 means it's not ok to read the input now.
          UNBLOCK_INPUT will read it later; now, avoid infinite loop.
          0 means there was no keyboard input available.  */
       if (nread <= 0)
         break;
     }
-#ifdef HAVE_NS
-  --handling_signal;
-#endif
 }
-#endif /* SYNC_INPUT || USABLE_SIGIO */
 
-#ifdef SYNC_INPUT
 void
 process_pending_signals (void)
 {
@@ -7213,24 +7180,17 @@ process_pending_signals (void)
     handle_async_input ();
   do_pending_atimers ();
 }
-#endif
 
 #ifdef USABLE_SIGIO
 
 static void
 handle_input_available_signal (int sig)
 {
-#ifdef SYNC_INPUT
   interrupt_input_pending = 1;
   pending_signals = 1;
-#endif
 
   if (input_available_clear_time)
     *input_available_clear_time = make_emacs_time (0, 0);
-
-#ifndef SYNC_INPUT
-  handle_async_input ();
-#endif
 }
 
 static void
@@ -7356,25 +7316,25 @@ find_user_signal_name (int sig)
   return NULL;
 }
 
-static int
+static void
 store_user_signal_events (void)
 {
   struct user_signal_info *p;
   struct input_event buf;
-  int nstored = 0;
+  bool buf_initialized = 0;
 
   for (p = user_signals; p; p = p->next)
     if (p->npending > 0)
       {
         sigset_t blocked, procmask;
 
-        if (nstored == 0)
+        if (! buf_initialized)
           {
             memset (&buf, 0, sizeof buf);
             buf.kind = USER_SIGNAL_EVENT;
             buf.frame_or_window = selected_frame;
+            buf_initialized = 1;
           }
-        nstored += p->npending;
 
         sigemptyset (&blocked);
         sigaddset (&blocked, p->sig);
@@ -7390,8 +7350,6 @@ store_user_signal_events (void)
 
         pthread_sigmask (SIG_SETMASK, &procmask, 0);
       }
-
-  return nstored;
 }
 
 
@@ -11365,9 +11323,7 @@ init_keyboard (void)
   input_pending = 0;
   interrupt_input_blocked = 0;
   interrupt_input_pending = 0;
-#ifdef SYNC_INPUT
   pending_signals = 0;
-#endif
 
   /* This means that command_loop_1 won't try to select anything the first
      time through.  */
diff --git a/src/keyboard.h b/src/keyboard.h
index 91484b3649b..3601f68be9f 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -523,7 +523,7 @@ extern void input_poll_signal (int);
 extern void start_polling (void);
 extern void stop_polling (void);
 extern void set_poll_suppress_count (int);
-extern void gobble_input (int);
+extern void gobble_input (void);
 extern int input_polling_used (void);
 extern void clear_input_pending (void);
 extern int requeued_events_pending_p (void);
@@ -547,8 +547,7 @@ extern Lisp_Object menu_item_eval_property (Lisp_Object);
 extern int  kbd_buffer_events_waiting (int);
 extern void add_user_signal (int, const char *);
 
-extern int tty_read_avail_input (struct terminal *, int,
-                                 struct input_event *);
+extern int tty_read_avail_input (struct terminal *, struct input_event *);
 extern EMACS_TIME timer_check (void);
 extern void mark_kboards (void);
 
diff --git a/src/lisp.h b/src/lisp.h
index 447c6bd296b..3a473a60b48 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2107,22 +2107,16 @@ extern char *stack_bottom;
    If quit-flag is set to `kill-emacs' the SIGINT handler has received
    a request to exit Emacs when it is safe to do.  */
 
-#ifdef SYNC_INPUT
 extern void process_pending_signals (void);
 extern int pending_signals;
-#define ELSE_PENDING_SIGNALS                            \
-  else if (pending_signals)                             \
-    process_pending_signals ();
-#else  /* not SYNC_INPUT */
-#define ELSE_PENDING_SIGNALS
-#endif  /* not SYNC_INPUT */
 
 extern void process_quit_flag (void);
 #define QUIT                                            \
   do {                                                  \
     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
       process_quit_flag ();                             \
-    ELSE_PENDING_SIGNALS                                \
+    else if (pending_signals)                           \
+      process_pending_signals ();                       \
   } while (0)
 
 
@@ -2846,8 +2840,6 @@ extern void memory_warnings (void *, void (*warnfun) (const char *));
 /* Defined in alloc.c.  */
 extern void check_pure_size (void);
 extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
-extern void reset_malloc_hooks (void);
-extern void uninterrupt_malloc (void);
 extern void malloc_warning (const char *);
 extern _Noreturn void memory_full (size_t);
 extern _Noreturn void buffer_memory_full (ptrdiff_t);
@@ -3043,7 +3035,6 @@ extern Lisp_Object Qand_rest;
 extern Lisp_Object Vautoload_queue;
 extern Lisp_Object Vsignaling_function;
 extern Lisp_Object inhibit_lisp_code;
-extern int handling_signal;
 #if BYTE_MARK_STACK
 extern struct catchtag *catchlist;
 extern struct handler *handlerlist;
diff --git a/src/ns.mk b/src/ns.mk
deleted file mode 100644
index 77fbf5845d9..00000000000
--- a/src/ns.mk
+++ /dev/null
@@ -1,39 +0,0 @@
-### autodeps.mk --- src/Makefile fragment for GNU Emacs
-
-## Copyright (C) 2008-2012 Free Software Foundation, Inc.
-
-## This file is part of GNU Emacs.
-
-## GNU Emacs is free software: you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation, either version 3 of the License, or
-## (at your option) any later version.
-## 
-## GNU Emacs is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-## GNU General Public License for more details.
-## 
-## You should have received a copy of the GNU General Public License
-## along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-### Commentary:
-
-## This is inserted in src/Makefile if HAVE_NS. 
-
-## The only reason this is in a separate file is because $ns_appdir,
-## which appears as a target, is empty on non-NS builds.  Some makes
-## do not like empty targets, even if they are never used.
-
-${ns_appdir}: ${ns_appsrc}
-        rm -fr ${ns_appdir}
-        ${MKDIR_P} ${ns_appdir}
-        ( cd ${ns_appsrc} ; tar cfh - . ) | ( cd ${ns_appdir} ; umask 022; tar xf - )
-
-${ns_appbindir}/Emacs: emacs${EXEEXT}
-        ${MKDIR_P} ${ns_appbindir}
-        cp -f emacs${EXEEXT} ${ns_appbindir}/Emacs
-
-ns-app: ${ns_appdir} ${ns_appbindir}/Emacs
-
-### ns.mk ends here
diff --git a/src/nsfns.m b/src/nsfns.m
index 072005d2d3d..e2c8c3722c0 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -870,16 +870,6 @@ x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 }
 
 
-/* Xism; we stub out (we do implement this in ns-win.el) */
-int
-XParseGeometry (char *string, int *x, int *y,
-                unsigned int *width, unsigned int *height)
-{
-  message1 ("Warning: XParseGeometry not supported under NS.\n");
-  return 0;
-}
-
-
 /* TODO: move to nsterm? */
 int
 ns_lisp_to_cursor_type (Lisp_Object arg)
@@ -1399,6 +1389,9 @@ This function is an internal primitive--use `make-frame' instead.  */)
 
   UNGCPRO;
 
+  if (window_prompting & USPosition)
+    x_set_offset (f, f->left_pos, f->top_pos, 1);
+
   /* Make sure windows on this frame appear in calls to next-window
      and similar functions.  */
   Vwindow_list = Qnil;
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 3057f4f6a20..907d3eac622 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -588,10 +588,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
      From 10.6 on, we could also use -[NSMenu propertiesToUpdate]: In the
      key press case, NSMenuPropertyItemImage (e.g.) won't be set.
   */
-  if (trackingMenu == 0
-      /* Also, don't try this if from an event picked up asynchronously,
-         as lots of lisp evaluation happens in ns_update_menubar. */
-      || handling_signal != 0)
+  if (trackingMenu == 0)
     return;
 /*fprintf (stderr, "Updating menu '%s'\n", [[self title] UTF8String]); NSLog (@"%@\n", event); */
   ns_update_menubar (frame, 1, self);
diff --git a/src/nsterm.m b/src/nsterm.m
index 41520ce74d1..aa869e3ff44 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -3336,8 +3336,7 @@ ns_send_appdefined (int value)
 }
 
 static int
-ns_read_socket (struct terminal *terminal, int expected,
-                struct input_event *hold_quit)
+ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
 /* --------------------------------------------------------------------------
      External (hook): Post an event to ourself and keep reading events until
      we read it back again.  In effect process all events which were waiting.
@@ -3355,16 +3354,12 @@ ns_read_socket (struct terminal *terminal, int expected,
   if (interrupt_input_blocked)
     {
       interrupt_input_pending = 1;
-#ifdef SYNC_INPUT
       pending_signals = 1;
-#endif
       return -1;
     }
 
   interrupt_input_pending = 0;
-#ifdef SYNC_INPUT
   pending_signals = pending_atimers;
-#endif
 
   BLOCK_INPUT;
   n_emacs_events_pending = 0;
@@ -3726,7 +3721,7 @@ ns_judge_scroll_bars (struct frame *f)
       removed = YES;
     }
 
-  if (removed) 
+  if (removed)
     [eview updateFrameSize: NO];
 }
 
@@ -3988,7 +3983,6 @@ ns_term_init (Lisp_Object display_name)
   /* count object allocs (About, click icon); on OS X use ObjectAlloc tool */
   /*GSDebugAllocationActive (YES); */
   BLOCK_INPUT;
-  handling_signal = 0;
 
   baud_rate = 38400;
   Fset_input_interrupt_mode (Qnil);
@@ -4209,7 +4203,7 @@ ns_term_init (Lisp_Object display_name)
                             NSColorPboardType,
                             NSFontPboardType, nil] retain];
 
-  
+
   [NSApp run];
   ns_do_open_file = YES;
   return dpyinfo;
@@ -6239,7 +6233,7 @@ not_in_argv (NSString *arg)
       NSRect r = [super constrainFrameRect:frameRect toScreen:screen];
       return r;
     }
-  
+
   if (f->output_data.ns->dont_constrain
       || ns_menu_bar_should_be_hidden ())
     return frameRect;
diff --git a/src/process.c b/src/process.c
index 6dbff6f4b16..c654369627d 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1609,14 +1609,10 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 #if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
   int wait_child_setup[2];
 #endif
+#ifdef SIGCHLD
   sigset_t blocked, procmask;
-  struct sigaction sigint_action;
-  struct sigaction sigquit_action;
-  struct sigaction sigpipe_action;
-#ifdef AIX
-  struct sigaction sighup_action;
 #endif
-  /* Use volatile to protect variables from being clobbered by longjmp.  */
+  /* Use volatile to protect variables from being clobbered by vfork.  */
   volatile int forkin, forkout;
   volatile int pty_flag = 0;
 
@@ -1708,25 +1704,13 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   XPROCESS (process)->pty_flag = pty_flag;
   pset_status (XPROCESS (process), Qrun);
 
+#ifdef SIGCHLD
   /* Delay interrupts until we have a chance to store
      the new fork's pid in its process structure */
   sigemptyset (&blocked);
-#ifdef SIGCHLD
   sigaddset (&blocked, SIGCHLD);
-#endif
-#ifdef HAVE_WORKING_VFORK
-  /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
-     this sets the parent's signal handlers as well as the child's.
-     So delay all interrupts whose handlers the child might munge,
-     and record the current handlers so they can be restored later.  */
-  sigaddset (&blocked, SIGINT );  sigaction (SIGINT , 0, &sigint_action );
-  sigaddset (&blocked, SIGQUIT);  sigaction (SIGQUIT, 0, &sigquit_action);
-  sigaddset (&blocked, SIGPIPE);  sigaction (SIGPIPE, 0, &sigpipe_action);
-#ifdef AIX
-  sigaddset (&blocked, SIGHUP );  sigaction (SIGHUP , 0, &sighup_action );
-#endif
-#endif /* HAVE_WORKING_VFORK */
   pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
+#endif
 
   FD_SET (inchannel, &input_wait_mask);
   FD_SET (inchannel, &non_keyboard_wait_mask);
@@ -1879,8 +1863,10 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
            in the child.  */
         signal (SIGPIPE, SIG_DFL);
 
+#ifdef SIGCHLD
         /* Stop blocking signals in the child.  */
         pthread_sigmask (SIG_SETMASK, &procmask, 0);
+#endif
 
         if (pty_flag)
           child_setup_tty (xforkout);
@@ -1959,19 +1945,10 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 #endif
     }
 
-  /* Restore the signal state whether vfork succeeded or not.
-     (We will signal an error, below, if it failed.)  */
-#ifdef HAVE_WORKING_VFORK
-  /* Restore the parent's signal handlers.  */
-  sigaction (SIGINT, &sigint_action, 0);
-  sigaction (SIGQUIT, &sigquit_action, 0);
-  sigaction (SIGPIPE, &sigpipe_action, 0);
-#ifdef AIX
-  sigaction (SIGHUP, &sighup_action, 0);
-#endif
-#endif /* HAVE_WORKING_VFORK */
+#ifdef SIGCHLD
   /* Stop blocking signals in the parent.  */
   pthread_sigmask (SIG_SETMASK, &procmask, 0);
+#endif
 
   /* Now generate the error if vfork failed.  */
   if (pid < 0)
@@ -4395,10 +4372,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
          Otherwise, do pending quit if requested.  */
       if (read_kbd >= 0)
         QUIT;
-#ifdef SYNC_INPUT
       else
         process_pending_signals ();
-#endif
 
       /* Exit now if the cell we're waiting for became non-nil.  */
       if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
diff --git a/src/ralloc.c b/src/ralloc.c
index b0134ea730a..9a4b1ada229 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -1204,9 +1204,15 @@ r_alloc_init (void)
   UNBLOCK_INPUT;
 #else
 #ifndef SYSTEM_MALLOC
-  /* Give GNU malloc's morecore some hysteresis
-     so that we move all the relocatable blocks much less often.  */
-  __malloc_extra_blocks = 64;
+  /* Give GNU malloc's morecore some hysteresis so that we move all
+     the relocatable blocks much less often.  The number used to be
+     64, but alloc.c would override that with 32 in code that was
+     removed when SYNC_INPUT became the only input handling mode.
+     That code was conditioned on !DOUG_LEA_MALLOC, so the call to
+     mallopt above is left unchanged.  (Actually, I think there's no
+     system nowadays that uses DOUG_LEA_MALLOC and also uses
+     REL_ALLOC.)  */
+  __malloc_extra_blocks = 32;
 #endif
 #endif
 
diff --git a/src/regex.c b/src/regex.c
index 92264ccae23..17562043df1 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1831,9 +1831,9 @@ typedef struct
 /* The next available element.  */
 #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
 
-/* Explicit quit checking is only used on NTemacs and whenever we
-   use polling to process input events.  */
-#if defined emacs && (defined WINDOWSNT || defined SYNC_INPUT) && defined QUIT
+/* Explicit quit checking is needed for Emacs, which uses polling to
+   process input events.  */
+#ifdef emacs
 extern int immediate_quit;
 # define IMMEDIATE_QUIT_CHECK                   \
     do {                                        \
diff --git a/src/search.c b/src/search.c
index 99fd7971e4c..1735ade5d8a 100644
--- a/src/search.c
+++ b/src/search.c
@@ -674,7 +674,7 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
            obstacle --- the last character the dumb search loop should
            examine.  */
         ptrdiff_t ceiling_byte = CHAR_TO_BYTE (end) - 1;
-        ptrdiff_t start_byte = CHAR_TO_BYTE (start);
+        ptrdiff_t start_byte;
         ptrdiff_t tem;
 
         /* If we're looking for a newline, consult the newline cache
@@ -684,18 +684,22 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
             ptrdiff_t next_change;
             immediate_quit = 0;
             while (region_cache_forward
-                   (current_buffer, newline_cache, start_byte, &next_change))
-              start_byte = next_change;
+                   (current_buffer, newline_cache, start, &next_change))
+              start = next_change;
             immediate_quit = allow_quit;
 
+            start_byte = CHAR_TO_BYTE (start);
+
             /* START should never be after END.  */
             if (start_byte > ceiling_byte)
               start_byte = ceiling_byte;
 
             /* Now the text after start is an unknown region, and
                next_change is the position of the next known region. */
-            ceiling_byte = min (next_change - 1, ceiling_byte);
+            ceiling_byte = min (CHAR_TO_BYTE (next_change) - 1, ceiling_byte);
           }
+        else
+          start_byte = CHAR_TO_BYTE (start);
 
         /* The dumb loop can only scan text stored in contiguous
            bytes. BUFFER_CEILING_OF returns the last character
@@ -747,7 +751,7 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
       {
         /* The last character to check before the next obstacle.  */
         ptrdiff_t ceiling_byte = CHAR_TO_BYTE (end);
-        ptrdiff_t start_byte = CHAR_TO_BYTE (start);
+        ptrdiff_t start_byte;
         ptrdiff_t tem;
 
         /* Consult the newline cache, if appropriate.  */
@@ -756,18 +760,22 @@ scan_buffer (register int target, ptrdiff_t start, ptrdiff_t end,
             ptrdiff_t next_change;
             immediate_quit = 0;
             while (region_cache_backward
-                   (current_buffer, newline_cache, start_byte, &next_change))
-              start_byte = next_change;
+                   (current_buffer, newline_cache, start, &next_change))
+              start = next_change;
             immediate_quit = allow_quit;
 
+            start_byte = CHAR_TO_BYTE (start);
+
             /* Start should never be at or before end.  */
             if (start_byte <= ceiling_byte)
               start_byte = ceiling_byte + 1;
 
             /* Now the text before start is an unknown region, and
                next_change is the position of the next known region. */
-            ceiling_byte = max (next_change, ceiling_byte);
+            ceiling_byte = max (CHAR_TO_BYTE (next_change), ceiling_byte);
           }
+        else
+          start_byte = CHAR_TO_BYTE (start);
 
         /* Stop scanning before the gap.  */
         tem = BUFFER_FLOOR_OF (start_byte - 1);
diff --git a/src/sysdep.c b/src/sysdep.c
index 9065b38d6fc..dbfd9efc7d4 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1447,27 +1447,21 @@ emacs_sigaction_init (struct sigaction *action, signal_handler_t handler)
   action->sa_handler = handler;
   action->sa_flags = 0;
 #if defined (SA_RESTART)
-  /* Emacs mostly works better with restartable system services. If this
-     flag exists, we probably want to turn it on here.
-     However, on some systems (only hpux11 at present) this resets the
-     timeout of `select' which means that `select' never finishes if
-     it keeps getting signals.
-     We define BROKEN_SA_RESTART on those systems.  */
-  /* It's not clear why the comment above says "mostly works better".  --Stef
-     When SYNC_INPUT is set, we don't want SA_RESTART because we need to poll
+  /* SA_RESTART causes interruptible functions with timeouts (e.g.,
+     'select') to reset their timeout on some platforms (e.g.,
+     HP-UX 11), which is not what we want.  Also, when Emacs is
+     interactive, we don't want SA_RESTART because we need to poll
      for pending input so we need long-running syscalls to be interrupted
      after a signal that sets the interrupt_input_pending flag.  */
   /* Non-interactive keyboard input goes through stdio, where we always
      want restartable system calls.  */
-# if defined (BROKEN_SA_RESTART) || defined (SYNC_INPUT)
   if (noninteractive)
-# endif
     action->sa_flags = SA_RESTART;
 #endif
 }
 
 #ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
-pthread_t main_thread;
+static pthread_t main_thread;
 #endif
 
 /* If we are on the main thread, handle the signal SIG with HANDLER.
@@ -1914,11 +1908,9 @@ emacs_write (int fildes, const char *buf, ptrdiff_t nbyte)
         {
           if (errno == EINTR)
             {
-#ifdef SYNC_INPUT
               /* I originally used `QUIT' but that might causes files to
                  be truncated if you hit C-g in the middle of it.  --Stef  */
               process_pending_signals ();
-#endif
               continue;
             }
           else
diff --git a/src/syssignal.h b/src/syssignal.h
index 5e733dd812d..e309e6725b7 100644
--- a/src/syssignal.h
+++ b/src/syssignal.h
@@ -64,8 +64,4 @@ extern void emacs_sigaction_init (struct sigaction *, signal_handler_t);
 char *strsignal (int);
 #endif
 
-#ifdef FORWARD_SIGNAL_TO_MAIN_THREAD
-extern pthread_t main_thread;
-#endif
-
 void handle_on_main_thread (int, signal_handler_t);
diff --git a/src/termhooks.h b/src/termhooks.h
index 46962a1217d..53e401de409 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -592,23 +592,14 @@ struct terminal
 
      TERMINAL indicates which terminal device to read from.  Input
      events should be read into BUF, the size of which is given in
-     SIZE.  EXPECTED is non-zero if the caller suspects that new input
-     is available.
+     SIZE.
 
      A positive return value indicates that that many input events
-     where read into BUF.
+     were read into BUF.
      Zero means no events were immediately available.
      A value of -1 means a transient read error, while -2 indicates
-     that the device was closed (hangup), and it should be deleted.
-
-     XXX Please note that a non-zero value of EXPECTED only means that
-     there is available input on at least one of the currently opened
-     terminal devices -- but not necessarily on this device.
-     Therefore, in most cases EXPECTED should be simply ignored.
-
-     XXX This documentation needs to be updated.  */
+     that the device was closed (hangup), and it should be deleted.  */
   int (*read_socket_hook) (struct terminal *terminal,
-                           int expected,
                            struct input_event *hold_quit);
 
   /* Called when a frame's display becomes entirely up to date.  */
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index 05a16466dfb..d38b91e955a 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -117,6 +117,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <assert.h>
 
+/* LC_DATA_IN_CODE is not defined in mach-o/loader.h on OS X 10.7.
+   But it is used if we build with "Command Line Tools for Xcode 4.5
+   (OS X Lion) - Septemper 2012".  */
+#ifndef LC_DATA_IN_CODE
+#define LC_DATA_IN_CODE 0x29 /* table of non-instructions in __text */
+#endif
+
 #ifdef _LP64
 #define mach_header                     mach_header_64
 #define segment_command                 segment_command_64
@@ -612,6 +619,11 @@ print_load_command_name (int lc)
       printf ("LC_MAIN          ");
       break;
 #endif
+#ifdef LC_DATA_IN_CODE
+    case LC_DATA_IN_CODE:
+      printf ("LC_DATA_IN_CODE  ");
+      break;
+#endif
 #ifdef LC_SOURCE_VERSION
     case LC_SOURCE_VERSION:
       printf ("LC_SOURCE_VERSION");
@@ -1178,9 +1190,9 @@ copy_dyld_info (struct load_command *lc, long delta)
 #endif
 
 #ifdef LC_FUNCTION_STARTS
-/* Copy a LC_FUNCTION_STARTS/LC_DYLIB_CODE_SIGN_DRS load command from
-   the input file to the output file, adjusting the data offset
-   field.  */
+/* Copy a LC_FUNCTION_STARTS/LC_DATA_IN_CODE/LC_DYLIB_CODE_SIGN_DRS
+   load command from the input file to the output file, adjusting the
+   data offset field.  */
 static void
 copy_linkedit_data (struct load_command *lc, long delta)
 {
@@ -1274,6 +1286,9 @@ dump_it (void)
 #endif
 #ifdef LC_FUNCTION_STARTS
       case LC_FUNCTION_STARTS:
+#ifdef LC_DATA_IN_CODE
+      case LC_DATA_IN_CODE:
+#endif
 #ifdef LC_DYLIB_CODE_SIGN_DRS
       case LC_DYLIB_CODE_SIGN_DRS:
 #endif
diff --git a/src/w32gui.h b/src/w32gui.h
index 1ea185bfaa1..0da8de97f23 100644
--- a/src/w32gui.h
+++ b/src/w32gui.h
@@ -118,9 +118,6 @@ extern int nCmdShow;
 #define PBaseSize       (1L << 8) /* program specified base for incrementing */
 #define PWinGravity     (1L << 9) /* program specified window gravity */
 
-extern int XParseGeometry (char *, int *, int *, unsigned *, unsigned *);
-
-
 typedef struct {
     int x, y;
     unsigned width, height;
diff --git a/src/w32inevt.c b/src/w32inevt.c
index ee07db5335b..a96d8d70483 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -744,10 +744,9 @@ maybe_generate_resize_event (void)
 
 int
 w32_console_read_socket (struct terminal *terminal,
-                         int expected,
                          struct input_event *hold_quit)
 {
-  int nev, ret = 0, add;
+  int nev, add;
   int isdead;
 
   if (interrupt_input_blocked)
@@ -767,8 +766,7 @@ w32_console_read_socket (struct terminal *terminal,
           /* If nev == -1, there was some kind of error
              If nev == 0 then waitp must be zero and no events were available
              so return.  */
-          UNBLOCK_INPUT;
-          return nev;
+          break;
         }
 
       while (nev > 0)
@@ -812,9 +810,6 @@ w32_console_read_socket (struct terminal *terminal,
           queue_ptr++;
           nev--;
         }
-
-      if (ret > 0 || expected == 0)
-        break;
     }
 
   /* We don't get told about changes in the window size (only the buffer
@@ -824,5 +819,5 @@ w32_console_read_socket (struct terminal *terminal,
     maybe_generate_resize_event ();
 
   UNBLOCK_INPUT;
-  return ret;
+  return nev;
 }
diff --git a/src/w32inevt.h b/src/w32inevt.h
index c874e58ef39..319688b877b 100644
--- a/src/w32inevt.h
+++ b/src/w32inevt.h
@@ -21,7 +21,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 extern int w32_console_unicode_input;
 
-extern int w32_console_read_socket (struct terminal *term, int numchars,
+extern int w32_console_read_socket (struct terminal *term,
                                     struct input_event *hold_quit);
 extern void w32_console_mouse_position (FRAME_PTR *f, int insist,
                                         Lisp_Object *bar_window,
diff --git a/src/w32term.c b/src/w32term.c
index 69a16e1852b..b8227c52fed 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -4137,8 +4137,6 @@ static char dbcs_lead = 0;
    We return the number of characters stored into the buffer,
    thus pretending to be `read'.
 
-   EXPECTED is nonzero if the caller knows input is available.
-
    Some of these messages are reposted back to the message queue since the
    system calls the windows proc directly in a context where we cannot return
    the data nor can we guarantee the state we are in.  So if we dispatch them
@@ -4149,7 +4147,7 @@ static char dbcs_lead = 0;
 */
 
 static int
-w32_read_socket (struct terminal *terminal, int expected,
+w32_read_socket (struct terminal *terminal,
                  struct input_event *hold_quit)
 {
   int count = 0;
@@ -4162,6 +4160,7 @@ w32_read_socket (struct terminal *terminal, int expected,
   if (interrupt_input_blocked)
     {
       interrupt_input_pending = 1;
+      pending_signals = 1;
       return -1;
     }
 
diff --git a/src/w32xfns.c b/src/w32xfns.c
index 33f40fc7c01..018dd14cb80 100644
--- a/src/w32xfns.c
+++ b/src/w32xfns.c
@@ -303,138 +303,6 @@ drain_message_queue (void)
     }
 }
 
-
-/*
- *    XParseGeometry parses strings of the form
- *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
- *   width, height, xoffset, and yoffset are unsigned integers.
- *   Example:  "=80x24+300-49"
- *   The equal sign is optional.
- *   It returns a bitmask that indicates which of the four values
- *   were actually found in the string.  For each value found,
- *   the corresponding argument is updated;  for each value
- *   not found, the corresponding argument is left unchanged.
- */
-
-static int
-read_integer (register char *string, char **NextString)
-{
-  register int Result = 0;
-  int Sign = 1;
-
-  if (*string == '+')
-    string++;
-  else if (*string == '-')
-    {
-      string++;
-      Sign = -1;
-    }
-  for (; (*string >= '0') && (*string <= '9'); string++)
-    {
-      Result = (Result * 10) + (*string - '0');
-    }
-  *NextString = string;
-  if (Sign >= 0)
-    return (Result);
-  else
-    return (-Result);
-}
-
-int
-XParseGeometry (char *string,
-                int *x, int *y,
-                unsigned int *width, unsigned int *height)
-{
-  int mask = NoValue;
-  register char *strind;
-  unsigned int tempWidth, tempHeight;
-  int tempX, tempY;
-  char *nextCharacter;
-
-  if ((string == NULL) || (*string == '\0')) return (mask);
-  if (*string == '=')
-    string++;  /* ignore possible '=' at beg of geometry spec */
-
-  strind = (char *)string;
-  if (*strind != '+' && *strind != '-' && *strind != 'x')
-    {
-      tempWidth = read_integer (strind, &nextCharacter);
-      if (strind == nextCharacter)
-        return (0);
-      strind = nextCharacter;
-      mask |= WidthValue;
-    }
-
-  if (*strind == 'x' || *strind == 'X')
-    {
-      strind++;
-      tempHeight = read_integer (strind, &nextCharacter);
-      if (strind == nextCharacter)
-        return (0);
-      strind = nextCharacter;
-      mask |= HeightValue;
-    }
-
-  if ((*strind == '+') || (*strind == '-'))
-    {
-      if (*strind == '-')
-        {
-          strind++;
-          tempX = -read_integer (strind, &nextCharacter);
-          if (strind == nextCharacter)
-            return (0);
-          strind = nextCharacter;
-          mask |= XNegative;
-
-        }
-      else
-        {
-          strind++;
-          tempX = read_integer (strind, &nextCharacter);
-          if (strind == nextCharacter)
-            return (0);
-          strind = nextCharacter;
-        }
-      mask |= XValue;
-      if ((*strind == '+') || (*strind == '-'))
-        {
-          if (*strind == '-')
-            {
-              strind++;
-              tempY = -read_integer (strind, &nextCharacter);
-              if (strind == nextCharacter)
-                return (0);
-              strind = nextCharacter;
-              mask |= YNegative;
-            }
-          else
-            {
-              strind++;
-              tempY = read_integer (strind, &nextCharacter);
-              if (strind == nextCharacter)
-                return (0);
-              strind = nextCharacter;
-            }
-          mask |= YValue;
-        }
-    }
-
-  /* If strind isn't at the end of the string then it's an invalid
-     geometry specification. */
-
-  if (*strind != '\0') return (0);
-
-  if (mask & XValue)
-    *x = tempX;
-  if (mask & YValue)
-    *y = tempY;
-  if (mask & WidthValue)
-    *width = tempWidth;
-  if (mask & HeightValue)
-    *height = tempHeight;
-  return (mask);
-}
-
 /* x_sync is a no-op on W32.  */
 void
 x_sync (struct frame *f)
diff --git a/src/window.c b/src/window.c
index fbccab8b358..a6f1104587e 100644
--- a/src/window.c
+++ b/src/window.c
@@ -3462,7 +3462,11 @@ make_window (void)
   wset_vertical_scroll_bar_type (w, Qt);
   wset_window_end_pos (w, make_number (0));
   wset_window_end_vpos (w, make_number (0));
-
+  /* These Lisp fields are marked specially so they're not set to nil by
+     allocate_window.  */
+  wset_prev_buffers (w, Qnil);
+  wset_next_buffers (w, Qnil);
+  
   /* Initialize non-Lisp data.  Note that allocate_window zeroes out all
      non-Lisp data, so do it only for slots which should not be zero.  */
   w->nrows_scale_factor = w->ncols_scale_factor = 1;
diff --git a/src/window.h b/src/window.h
index 62ae43a999d..115b361194c 100644
--- a/src/window.h
+++ b/src/window.h
@@ -220,13 +220,6 @@ struct window
     /* t means this window's child windows are not (re-)combined.  */
     Lisp_Object combination_limit;
 
-    /* Alist of <buffer, window-start, window-point> triples listing
-       buffers previously shown in this window.  */
-    Lisp_Object prev_buffers;
-
-    /* List of buffers re-shown in this window.  */
-    Lisp_Object next_buffers;
-
     /* An alist with parameters.  */
     Lisp_Object window_parameters;
 
@@ -238,6 +231,14 @@ struct window
     struct glyph_matrix *current_matrix;
     struct glyph_matrix *desired_matrix;
 
+    /* The two Lisp_Object fields below are marked in a special way,
+       which is why they're placed after `current_matrix'.  */
+    /* Alist of <buffer, window-start, window-point> triples listing
+       buffers previously shown in this window.  */
+    Lisp_Object prev_buffers;
+    /* List of buffers re-shown in this window.  */
+    Lisp_Object next_buffers;
+
     /* Number saying how recently window was selected.  */
     int use_time;
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 8e0975cf65a..f00719be37a 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -7755,7 +7755,7 @@ compute_stop_pos_backwards (struct it *it)
     {
       it->end_charpos = min (charpos + 1, ZV);
       charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
-      SET_TEXT_POS (pos, charpos, BYTE_TO_CHAR (charpos));
+      SET_TEXT_POS (pos, charpos, CHAR_TO_BYTE (charpos));
       reseat_1 (it, pos, 0);
       compute_stop_pos (it);
       /* We must advance forward, right?  */
@@ -9290,12 +9290,6 @@ add_to_log (const char *format, Lisp_Object arg1, Lisp_Object arg2)
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   USE_SAFE_ALLOCA;
 
-  /* Do nothing if called asynchronously.  Inserting text into
-     a buffer may call after-change-functions and alike and
-     that would means running Lisp asynchronously.  */
-  if (handling_signal)
-    return;
-
   fmt = msg = Qnil;
   GCPRO4 (fmt, msg, arg1, arg2);
 
@@ -16750,28 +16744,33 @@ try_window_reusing_current_matrix (struct window *w)
             }
           if (row < bottom_row)
             {
-              struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
-              struct glyph *end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
-
-              /* Can't use this optimization with bidi-reordered glyph
-                 rows, unless cursor is already at point. */
+              /* Can't simply scan the row for point with
+                 bidi-reordered glyph rows.  Let set_cursor_from_row
+                 figure out where to put the cursor, and if it fails,
+                 give up.  */
               if (!NILP (BVAR (XBUFFER (w->buffer), bidi_display_reordering)))
                 {
-                  if (!(w->cursor.hpos >= 0
-                        && w->cursor.hpos < row->used[TEXT_AREA]
-                        && BUFFERP (glyph->object)
-                        && glyph->charpos == PT))
-                    return 0;
+                  if (!set_cursor_from_row (w, row, w->current_matrix,
+                                            0, 0, 0, 0))
+                    {
+                      clear_glyph_matrix (w->desired_matrix);
+                      return 0;
+                    }
                 }
               else
-                for (; glyph < end
-                       && (!BUFFERP (glyph->object)
-                           || glyph->charpos < PT);
-                     glyph++)
-                  {
-                    w->cursor.hpos++;
-                    w->cursor.x += glyph->pixel_width;
-                  }
+                {
+                  struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
+                  struct glyph *end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
+
+                  for (; glyph < end
+                         && (!BUFFERP (glyph->object)
+                             || glyph->charpos < PT);
+                       glyph++)
+                    {
+                      w->cursor.hpos++;
+                      w->cursor.x += glyph->pixel_width;
+                    }
+                }
             }
         }
 
diff --git a/src/xterm.c b/src/xterm.c
index 900a1d78b80..8c955d0e576 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -7109,19 +7109,15 @@ x_dispatch_event (XEvent *event, Display *display)
 
 
 /* Read events coming from the X server.
-   This routine is called by the SIGIO handler only if SYNC_INPUT is
-   not defined.
-   We return as soon as there are no more events to be read.
+   Return as soon as there are no more events to be read.
 
-   We return the number of characters stored into the buffer,
+   Return the number of characters stored into the buffer,
    thus pretending to be `read' (except the characters we store
    in the keyboard buffer can be multibyte, so are not necessarily
-   C chars).
-
-   EXPECTED is nonzero if the caller knows input is available.  */
+   C chars).  */
 
 static int
-XTread_socket (struct terminal *terminal, int expected, struct input_event *hold_quit)
+XTread_socket (struct terminal *terminal, struct input_event *hold_quit)
 {
   int count = 0;
   int event_found = 0;
@@ -7129,25 +7125,17 @@ XTread_socket (struct terminal *terminal, int expected, struct input_event *hold
   if (interrupt_input_blocked)
     {
       interrupt_input_pending = 1;
-#ifdef SYNC_INPUT
       pending_signals = 1;
-#endif
       return -1;
     }
 
   interrupt_input_pending = 0;
-#ifdef SYNC_INPUT
   pending_signals = pending_atimers;
-#endif
   BLOCK_INPUT;
 
   /* So people can tell when we have read the available input.  */
   input_signal_count++;
 
-#ifndef SYNC_INPUT
-  ++handling_signal;
-#endif
-
   /* For debugging, this gives a way to fake an I/O error.  */
   if (terminal->display_info.x == XTread_socket_fake_io_error)
     {
@@ -7236,9 +7224,6 @@ XTread_socket (struct terminal *terminal, int expected, struct input_event *hold
       pending_autoraise_frame = 0;
     }
 
-#ifndef SYNC_INPUT
-  --handling_signal;
-#endif
   UNBLOCK_INPUT;
 
   return count;
@@ -7788,7 +7773,6 @@ x_connection_closed (Display *dpy, const char *error_message)
 
   error_msg = alloca (strlen (error_message) + 1);
   strcpy (error_msg, error_message);
-  handling_signal = 0;
 
   /* Inhibit redisplay while frames are being deleted. */
   specbind (Qinhibit_redisplay, Qt);