Merge from trunk, configury not fixed yet.

23 files changed, 1557 insertions, 515 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 4245a1f0256..0b4ccb0708a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,232 @@
+2013-05-15  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * regex.c (regex_compile) [\=, \>, \<]: Don't forget to set laststart.
+
+2013-05-14  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_wnd_proc): Don't call WINDOW_HEADER_LINE_HEIGHT
+        unless we know that the window w is a leaf window.
+        Another attempt at solving bug#14062.
+
+2013-05-14  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfont.m (ns_spec_to_descriptor): Retain and autorelease
+        fdesc (Bug#14375).
+
+2013-05-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c (gif_load): Check that subimages fit (Bug#14345).
+
+2013-05-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lread.c (skip_dyn_eof): New function.
+        (read1): Use it to skip the end of a file in response to #@00.
+
+        * doc.c (get_doc_string): Slightly relax the sanity checking.
+
+2013-05-09  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfns.m: Include IOGraphicsLib.h if Cocoa.
+        (Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource): Declare.
+        (MonitorInfo): New struct.
+        (free_monitors, ns_screen_name, ns_make_monitor_attribute_list)
+        (Fns_display_monitor_attributes_list): New functions.
+        (display-usable-bounds): Remove.
+        (syms_of_nsfns): DEFSYM Qgeometry, Qworkarea, Qmm_size, Qframes and
+        Qsource.
+
+2013-05-09  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xterm.h (GTK_PREREQ): Remove, replacing with GTK_CHECK_VERSION.
+        (GTK_CHECK_VERSION): New macro, if not already defined.
+        All uses of GTK_PREREQ, GTK_MAJOR_VERSION, etc.
+        replaced by GTK_CHECK_VERSION.
+
+2013-05-08  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xterm.h (GTK_PREREQ): New macro.
+        All simple uses of GTK_MAJOR_VERSION and GTK_MINOR_VERSION changed
+        to use this macro instead, for consistency and clarity.
+
+2013-05-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (row_for_charpos_p): New function, with code of
+        cursor_row_p, but accepts an additional argument CHARPOS instead
+        of using a hardcoded PT.
+        (cursor_row_p): Call row_for_charpos_p with 2nd argument PT.
+        (row_containing_pos): Call row_for_charpos_p instead of partially
+        doing the same.  Fixes cursor positioning under longlines-mode
+        when longlines-show-effect includes more than one newline, when
+        moving the cursor vertically up.
+
+2013-05-08  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in (ACL_H): New macro.
+        ($(BLD)/fileio.$(O)): Update dependencies.
+
+2013-05-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use Gnulib ACL implementation, for benefit of Solaris etc. (Bug#14295)
+        * Makefile.in (LIB_ACL): New macro.
+        (LIBACL_LIBS): Remove.
+        (LIBES): Use LIB_ACL, not LIBACL_LIBS.
+        * fileio.c: Include <acl.h>.
+        Use HAVE_ACL_SET_FILE rather than HAVE_POSIX_ACL.
+        (ACL_NOT_WELL_SUPPORTED): Remove.  All uses replaced by
+        !acl_errno_valid.
+        (Fcopy_file) [!WINDOWSNT]: Use qcopy_acl instead of rolling
+        it ourselves.
+
+        * unexelf.c: Don't assume ElfW (Half) fits in int.
+        (entry_address, find_section, unexec): Use ptrdiff_t, not int,
+        when dealing with ElfW (Half) values, since they can exceed 2**31
+        on 64-bit OpenBSD hosts.  Problem reported privately by Han Boetes.
+        (entry_address): Omit unused NUM arg.  All uses changed.
+
+2013-05-07  Juri Linkov  <juri@jurta.org>
+
+        * callint.c (Fcall_interactively): Set `visargs[i]' for code 'n'
+        to the string converted from number with `Fnumber_to_string'.
+        (Bug#14254)
+
+2013-05-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xfns.c (x_get_net_workarea): Define only if !GTK || GTK<3.4.
+        This fixes a problem introduced by my previous change.
+
+2013-05-07  Glenn Morris  <rgm@gnu.org>
+
+        * lread.c (readchar): Don't read from a dead buffer.  (Bug#14280)
+
+2013-05-07  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xfns.c: Move misplaced ifndef USE_GTK from previous checkin.
+
+2013-05-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Static checking by GCC 4.8.0.
+        * xfns.c (x_get_net_workarea, struct MonitorInfo, free_monitors)
+        (x_get_monitor_for_frame, x_make_monitor_attribute_list)
+        (x_get_monitor_attributes_fallback)
+        (x_get_monitor_attributes_xinerama)
+        (x_get_monitor_attributes_xrandr, x_get_monitor_attributes):
+        Define only if USE_GTK.
+        (free_monitors): Define only if HAVE_XINERAMA || HAVE_XRANDR.
+        (x_get_monitor_attributes_fallback): Omit unused locals.
+        (x_get_monitor_attributes_xinerama, Fx_display_monitor_attributes_list):
+        Use double, not float, to avoid mixed-mode floating point arithmetic.
+
+2013-05-07  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+            Jan Djärv  <jan.h.d@swipnet.se>
+
+        * Makefile.in (XRANDR_LIBS, XRANDR_CFLAGS, XINERAMA_LIBS)
+        (XINERAMA_CFLAGS): New macros.
+        (ALL_CFLAGS, LIBES): Use them.
+
+        * xfns.c: Include <X11/extensions/Xrandr.h> if HAVE_XRANDR, and
+        include <X11/extensions/Xinerama.h> if HAVE_XINERAMA.
+        (Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource): New variables.
+        (syms_of_xfns): DEFSYM them.
+        (struct MonitorInfo): New struct.
+        (x_get_net_workarea, free_monitors, x_get_monitor_for_frame)
+        (x_make_monitor_attribute_list, x_get_monitor_attributes_fallback)
+        (x_get_monitor_attributes_xrandr, x_get_monitor_attributes)
+        (x_get_monitor_attributes_xinerama): New functions.
+        (Fx_display_monitor_attributes_list): New primitive.
+        (syms_of_xfns): Defsubr it.
+
+        * xterm.h (x_display_info): Add Xatom_net_workarea and
+        Xatom_net_current_desktop.
+
+        * xterm.c (x_term_init): Initialize dpyinfo->Xatom_net_workarea
+        and dpyinfo->Xatom_net_current_desktop.
+
+2013-05-06  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (pos_visible_p): Use the special code for finding the
+        beginning of a display property or overlay for any "replacing"
+        display property, not just for display strings.  This solves
+        incorrect reporting of position by posn-at-point.  (Bug#14241)
+
+2013-05-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * unexelf.c: Fix some 32-bit integer problems, notably when debugging.
+        Include <limits.h>, <stdbool.h>, <intprops.h>, <verify.h>.
+        Verify that ElfW (Half) fits in int.
+        (fatal): Use same signature as lisp.h.
+        (UNEXELF_DEBUG): New macro, replacing DEBUG, so that people can
+        configure and build with -DUNEXELF_DEBUG without worrying about
+        other modules that use DEBUG.
+        (DEBUG_LOG) [UNEXELF_DEBUG]: New macro.  All debug code that prints
+        possibly-wide integers now uses it instead of plain fprintf.
+        (entry_address): New function, which avoids problems with 32-bit
+        overflow on 64-bit hosts.
+        (OLD_SECTION_H, NEW_SECTION_H, NEW_PROGRAM_H): Use it.
+        (round_up): Don't assume the remainder fits in int.
+        (find_section): Use bool for boolean.  Simplify debug code.
+        (unexec): Don't assume file sizes fit in int or size_t.
+        Omit unnecessary trailing newline in 'fatal' format.
+        Use strerror rather than outputting decimal error number.
+        Remove unused code when emacs is not defined;
+        this file relies on Emacs now.
+        Don't assume e_phnum and e_shnum are positive.
+
+        * regex.c: Fix problems when DEBUG is defined.
+        (extract_number, extract_number_and_incr): Define regardless of
+        whether DEBUG is defined; that's simpler and makes the code less
+        likely to go stale in the normal case when DEBUG is not defined.
+        Return int rather than taking an int * arg.  All callers changed.
+        (DEBUG_PRINT1, DEBUG_PRINT2, DEBUG_PRINT3, DEBUG_PRINT4):
+        Remove, replacing with ...
+        (DEBUG_PRINT): New macro.  All callers changed.
+        (DEBUG_COMPILES_ARGUMENTS): New macro.
+        (print_fastmap, print_partial_compiled_pattern) [DEBUG]:
+        (print_compiled_pattern, print_double_string) [DEBUG]:
+        Use prototype rather than old-style definition.
+        (print_partial_compiled_pattern, print_compiled_pattern) [DEBUG]:
+        (ENSURE_FAIL_STACK, PUSH_FAILURE_REG) [DEBUG]:
+        (POP_FAILURE_REG_OR_COUNT, PUSH_FAILURE_POINT) [DEBUG]:
+        (POP_FAILURE_POINT, re_match_2_internal) [DEBUG]:
+        Don't assume ptrdiff_t, size_t, and long are the same width as int.
+        (POINTER_TO_OFFSET): Return ptrdiff_t, not regoff_t.
+        This matters only when DEBUG is defined.
+
+2013-05-05  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (set_iterator_to_next): Set the
+        ignore_overlay_strings_at_pos_p flag only if we are _really_
+        iterating over an overlay string, as indicated by the
+        current.overlay_string_index member.  (Bug#14306)
+
+2013-05-05  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (ns_update_menubar): Move initialization of submenuTitle
+        to where it is used, to avoid autorelease issues (Bug#14050).
+
+2013-05-05  Paul Eggert  <eggert@cs.ucla.edu>
+
+        `write-region-inhibit-fsync' defaults to noninteractive (Bug#14273).
+        * fileio.c (syms_of_fileio): Implement this.
+        * filelock.c (create_lock_file): If symbolic links don't work, so
+        we use a regular file as a lock file, do not fsync the lock file;
+        it's not needed.
+
+2013-05-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * minibuf.c (Fread_minibuffer, Feval_minibuffer): Move to Elisp.
+        (syms_of_minibuf): Adjust accodingly.
+        * lread.c (Fread):
+        * callint.c (Fcall_interactively): Adjust calls accordingly.
+
+2013-05-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispextern.h (WINDOW_WANTS_HEADER_LINE_P): Verify that
+        w->contents is a buffer before computing everything else.
+        Use parentheses to disambiguate last part of the condition.
+
+        * w32fns.c (w32_wnd_proc): Remove temporary code used to trap
+        assertion violations.  (Bug#14062)
+
 2013-05-01  David Reitter  <david.reitter@gmail.com>
 
         * nsfns.m (ns_tooltip): Initialize.
@@ -35,6 +264,7 @@
         size.
 
 2013-04-26  Paul Eggert  <eggert@cs.ucla.edu>
+
         Port better to AIX (Bug#14258).
         * lisp.h (ENUM_BF) [__IBMC__]: Make it 'unsigned int' here, too,
         to pacify AIX xlc.
diff --git a/src/Makefile.in b/src/Makefile.in
index d12f8dbe130..2e1764723ec 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -137,6 +137,7 @@ LIBOTF_LIBS = @LIBOTF_LIBS@
 M17N_FLT_CFLAGS = @M17N_FLT_CFLAGS@
 M17N_FLT_LIBS = @M17N_FLT_LIBS@
 
+LIB_ACL=@LIB_ACL@
 LIB_CLOCK_GETTIME=@LIB_CLOCK_GETTIME@
 LIB_EACCESS=@LIB_EACCESS@
 LIB_FDATASYNC=@LIB_FDATASYNC@
@@ -232,6 +233,12 @@ IMAGEMAGICK_CFLAGS= @IMAGEMAGICK_CFLAGS@
 LIBXML2_LIBS = @LIBXML2_LIBS@
 LIBXML2_CFLAGS = @LIBXML2_CFLAGS@
 
+XRANDR_LIBS = @XRANDR_LIBS@
+XRANDR_CFLAGS = @XRANDR_CFLAGS@
+
+XINERAMA_LIBS = @XINERAMA_LIBS@
+XINERAMA_CFLAGS = @XINERAMA_CFLAGS@
+
 ## widget.o if USE_X_TOOLKIT, otherwise empty.
 WIDGET_OBJ=@WIDGET_OBJ@
 
@@ -288,8 +295,6 @@ LIBSELINUX_LIBS = @LIBSELINUX_LIBS@
 LIBGNUTLS_LIBS = @LIBGNUTLS_LIBS@
 LIBGNUTLS_CFLAGS = @LIBGNUTLS_CFLAGS@
 
-LIBACL_LIBS = @LIBACL_LIBS@
-
 LIB_PTHREAD_SIGMASK = @LIB_PTHREAD_SIGMASK@
 
 INTERVALS_H = dispextern.h intervals.h composite.h
@@ -329,7 +334,7 @@ ALL_CFLAGS=-Demacs $(MYCPPFLAGS) -I. -I$(srcdir) \
   -I$(lib) -I$(srcdir)/../lib \
   $(C_SWITCH_MACHINE) $(C_SWITCH_SYSTEM) $(C_SWITCH_X_SITE) \
   $(GNUSTEP_CFLAGS) $(CFLAGS_SOUND) $(RSVG_CFLAGS) $(IMAGEMAGICK_CFLAGS) \
-  $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) \
+  $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) $(XRANDR_CFLAGS) $(XINERAMA_CFLAGS) \
   $(SETTINGS_CFLAGS) $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS) \
   $(LIBOTF_CFLAGS) $(M17N_FLT_CFLAGS) $(DEPFLAGS) \
   $(LIBGNUTLS_CFLAGS) \
@@ -407,13 +412,13 @@ ALLOBJS = $(FIRSTFILE_OBJ) $(VMLIMIT_OBJ) $(obj) $(otherobj)
 ## Construct full set of libraries to be linked.
 LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
    $(LIBX_OTHER) $(LIBSOUND) \
-   $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_CLOCK_GETTIME) \
+   $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_ACL) $(LIB_CLOCK_GETTIME) \
    $(LIB_EACCESS) $(LIB_FDATASYNC) $(LIB_TIMER_TIME) $(DBUS_LIBS) \
-   $(LIB_EXECINFO) \
+   $(LIB_EXECINFO) $(XRANDR_LIBS) $(XINERAMA_LIBS) \
    $(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
-   $(LIBACL_LIBS) $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(LIB_PTHREAD_SIGMASK) \
+   $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(LIB_PTHREAD_SIGMASK) \
    $(LIB_MATH)
 
 all: emacs$(EXEEXT) $(OTHER_FILES)
diff --git a/src/buffer.c b/src/buffer.c
index 3810d3db079..abebdf21135 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5501,6 +5501,8 @@ This is the same as (default-value 'left-margin).  */);
   DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
                           tab_width,
                           doc: /* Default value of `tab-width' for buffers that do not override it.
+NOTE: This controls the display width of a TAB character, and not
+the size of an indentation step.
 This is the same as (default-value 'tab-width).  */);
 
   DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
@@ -5692,6 +5694,8 @@ Linefeed indents to this column in Fundamental mode.  */);
   DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer, tab_width),
                      Qintegerp,
                      doc: /* Distance between tab stops (for display of tab characters), in columns.
+NOTE: This controls the display width of a TAB character, and not
+the size of an indentation step.
 This should be an integer greater than zero.  */);
 
   DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer, ctl_arrow), Qnil,
diff --git a/src/callint.c b/src/callint.c
index 940ff3ed249..0651b68dc05 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -251,6 +251,9 @@ invoke it.  If KEYS is omitted or nil, the return value of
 `this-command-keys-vector' is used.  */)
   (Lisp_Object function, Lisp_Object record_flag, Lisp_Object keys)
 {
+  /* `args' will contain the array of arguments to pass to the function.
+     `visargs' will contain the same list but in a nicer form, so that if we
+     pass it to `Fformat' it will be understandable to a human.  */
   Lisp_Object *args, *visargs;
   Lisp_Object specs;
   Lisp_Object filter_specs;
@@ -685,6 +688,9 @@ invoke it.  If KEYS is omitted or nil, the return value of
             goto have_prefix_arg;
         case 'n':               /* Read number from minibuffer.  */
           args[i] = call1 (Qread_number, callint_message);
+          /* Passing args[i] directly stimulates compiler bug.  */
+          teml = args[i];
+          visargs[i] = Fnumber_to_string (teml);
           break;
 
         case 'P':               /* Prefix arg in raw form.  Does no I/O.  */
@@ -733,12 +739,12 @@ invoke it.  If KEYS is omitted or nil, the return value of
           break;
 
         case 'x':               /* Lisp expression read but not evaluated.  */
-          args[i] = Fread_minibuffer (callint_message, Qnil);
+          args[i] = call1 (intern ("read-minibuffer"), callint_message);
           visargs[i] = last_minibuf_string;
           break;
 
         case 'X':               /* Lisp expression read and evaluated.  */
-          args[i] = Feval_minibuffer (callint_message, Qnil);
+          args[i] = call1 (intern ("eval-minibuffer"), callint_message);
           visargs[i] = last_minibuf_string;
           break;
 
@@ -790,6 +796,8 @@ invoke it.  If KEYS is omitted or nil, the return value of
 
   if (arg_from_tty || !NILP (record_flag))
     {
+      /* We don't need `visargs' any more, so let's recycle it since we need
+         an array of just the same size.  */
       visargs[0] = function;
       for (i = 1; i < nargs; i++)
         {
diff --git a/src/dispextern.h b/src/dispextern.h
index 5ce7b19f173..50a32ffaf8f 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1423,13 +1423,14 @@ struct glyph_string
 /* Value is true if window W wants a header line.  */
 
 #define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
-  (!MINI_WINDOW_P ((W))                                                 \
-   && !(W)->pseudo_window_p                                             \
-   && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))              \
-   && BUFFERP ((W)->contents)                                           \
-   && !NILP (BVAR (XBUFFER ((W)->contents), header_line_format))        \
-   && WINDOW_TOTAL_LINES (W) > 1                                        \
-   + !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format)))
+  (BUFFERP ((W)->contents)                                              \
+   ? (!MINI_WINDOW_P ((W))                                              \
+      && !(W)->pseudo_window_p                                          \
+      && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME ((W))))           \
+      && !NILP (BVAR (XBUFFER ((W)->contents), header_line_format))     \
+      && WINDOW_TOTAL_LINES (W) >                                       \
+          (1 + !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format)))) \
+   : 0)
 
 /* Return proper value to be used as baseline offset of font that has
    ASCENT and DESCENT to draw characters by the font at the vertical
diff --git a/src/doc.c b/src/doc.c
index 7234fb38bf9..770cb1eb646 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -215,14 +215,20 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
   if (CONSP (filepos))
     {
       int test = 1;
-      if (get_doc_string_buffer[offset - test++] != ' ')
-        return Qnil;
-      while (get_doc_string_buffer[offset - test] >= '0'
-             && get_doc_string_buffer[offset - test] <= '9')
-        test++;
-      if (get_doc_string_buffer[offset - test++] != '@'
-          || get_doc_string_buffer[offset - test] != '#')
-        return Qnil;
+      /* A dynamic docstring should be either at the very beginning of a "#@
+         comment" or right after a dynamic docstring delimiter (in case we
+         pack several such docstrings within the same comment).  */
+      if (get_doc_string_buffer[offset - test] != '\037')
+        {
+          if (get_doc_string_buffer[offset - test++] != ' ')
+            return Qnil;
+          while (get_doc_string_buffer[offset - test] >= '0'
+                 && get_doc_string_buffer[offset - test] <= '9')
+            test++;
+          if (get_doc_string_buffer[offset - test++] != '@'
+              || get_doc_string_buffer[offset - test] != '#')
+            return Qnil;
+        }
     }
   else
     {
diff --git a/src/fileio.c b/src/fileio.c
index 1049522e5a9..fe1bce16ca0 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -36,7 +36,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <selinux/context.h>
 #endif
 
-#ifdef HAVE_POSIX_ACL
+#ifdef HAVE_ACL_SET_FILE
 #include <sys/acl.h>
 #endif
 
@@ -81,26 +81,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define DRIVE_LETTER(x) c_tolower (x)
 #endif
 
-#ifdef HAVE_POSIX_ACL
-/* FIXME: this macro was copied from gnulib's private acl-internal.h
-   header file.  */
-/* Recognize some common errors such as from an NFS mount that does
-   not support ACLs, even when local drives do.  */
-#if defined __APPLE__ && defined __MACH__ /* Mac OS X */
-#define ACL_NOT_WELL_SUPPORTED(Err)                                     \
-  ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY || (Err) == ENOENT)
-#elif defined EOPNOTSUPP /* Tru64 NFS */
-#define ACL_NOT_WELL_SUPPORTED(Err)                                     \
-  ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY || (Err) == EOPNOTSUPP)
-#elif defined WINDOWSNT
-#define ACL_NOT_WELL_SUPPORTED(Err)  ((Err) == ENOTSUP)
-#else
-#define ACL_NOT_WELL_SUPPORTED(Err)                                     \
-  ((Err) == ENOTSUP || (Err) == ENOSYS || (Err) == EINVAL || (Err) == EBUSY)
-#endif
-#endif  /* HAVE_POSIX_ACL */
-
 #include "systime.h"
+#include <acl.h>
 #include <allocator.h>
 #include <careadlinkat.h>
 #include <stat-time.h>
@@ -1988,7 +1970,7 @@ entries (depending on how Emacs was built).  */)
   security_context_t con;
   int conlength = 0;
 #endif
-#ifdef HAVE_POSIX_ACL
+#ifdef WINDOWSNT
   acl_t acl = NULL;
 #endif
 
@@ -2028,11 +2010,9 @@ entries (depending on how Emacs was built).  */)
 #ifdef WINDOWSNT
   if (!NILP (preserve_extended_attributes))
     {
-#ifdef HAVE_POSIX_ACL
       acl = acl_get_file (SDATA (encoded_file), ACL_TYPE_ACCESS);
-      if (acl == NULL && !ACL_NOT_WELL_SUPPORTED (errno))
+      if (acl == NULL && acl_errno_valid (errno))
         report_file_error ("Getting ACL", Fcons (file, Qnil));
-#endif
     }
   if (!CopyFile (SDATA (encoded_file),
                  SDATA (encoded_newname),
@@ -2069,17 +2049,15 @@ entries (depending on how Emacs was built).  */)
       /* Restore original attributes.  */
       SetFileAttributes (filename, attributes);
     }
-#ifdef HAVE_POSIX_ACL
   if (acl != NULL)
     {
       bool fail =
         acl_set_file (SDATA (encoded_newname), ACL_TYPE_ACCESS, acl) != 0;
-      if (fail && !ACL_NOT_WELL_SUPPORTED (errno))
+      if (fail && acl_errno_valid (errno))
         report_file_error ("Setting ACL", Fcons (newname, Qnil));
 
       acl_free (acl);
     }
-#endif
 #else /* not WINDOWSNT */
   immediate_quit = 1;
   ifd = emacs_open (SSDATA (encoded_file), O_RDONLY, 0);
@@ -2103,12 +2081,6 @@ entries (depending on how Emacs was built).  */)
             report_file_error ("Doing fgetfilecon", Fcons (file, Qnil));
         }
 #endif
-
-#ifdef HAVE_POSIX_ACL
-      acl = acl_get_fd (ifd);
-      if (acl == NULL && !ACL_NOT_WELL_SUPPORTED (errno))
-        report_file_error ("Getting ACL", Fcons (file, Qnil));
-#endif
     }
 
   if (out_st.st_mode != 0
@@ -2156,7 +2128,7 @@ entries (depending on how Emacs was built).  */)
   immediate_quit = 0;
 
 #ifndef MSDOS
-  /* Preserve the original file modes, and if requested, also its
+  /* Preserve the original file permissions, and if requested, also its
      owner and group.  */
   {
     mode_t mode_mask = 07777;
@@ -2173,8 +2145,16 @@ entries (depending on how Emacs was built).  */)
               mode_mask |= 02000;
           }
       }
-    if (fchmod (ofd, st.st_mode & mode_mask) != 0)
-      report_file_error ("Doing chmod", Fcons (newname, Qnil));
+
+    switch (!NILP (preserve_extended_attributes)
+            ? qcopy_acl (SSDATA (encoded_file), ifd,
+                         SSDATA (encoded_newname), ofd,
+                         st.st_mode & mode_mask)
+            : fchmod (ofd, st.st_mode & mode_mask))
+      {
+      case -2: report_file_error ("Copying permissions from", list1 (file));
+      case -1: report_file_error ("Copying permissions to", list1 (newname));
+      }
   }
 #endif  /* not MSDOS */
 
@@ -2191,17 +2171,6 @@ entries (depending on how Emacs was built).  */)
     }
 #endif
 
-#ifdef HAVE_POSIX_ACL
-  if (acl != NULL)
-    {
-      bool fail = acl_set_fd (ofd, acl) != 0;
-      if (fail && !ACL_NOT_WELL_SUPPORTED (errno))
-        report_file_error ("Setting ACL", Fcons (newname, Qnil));
-
-      acl_free (acl);
-    }
-#endif
-
   if (!NILP (keep_time))
     {
       EMACS_TIME atime = get_stat_atime (&st);
@@ -3111,7 +3080,7 @@ was unable to determine the ACL entries.  */)
 {
   Lisp_Object absname;
   Lisp_Object handler;
-#ifdef HAVE_POSIX_ACL
+#ifdef HAVE_ACL_SET_FILE
   acl_t acl;
   Lisp_Object acl_string;
   char *str;
@@ -3126,7 +3095,7 @@ was unable to determine the ACL entries.  */)
   if (!NILP (handler))
     return call2 (handler, Qfile_acl, absname);
 
-#ifdef HAVE_POSIX_ACL
+#ifdef HAVE_ACL_SET_FILE
   absname = ENCODE_FILE (absname);
 
   acl = acl_get_file (SSDATA (absname), ACL_TYPE_ACCESS);
@@ -3164,7 +3133,7 @@ support.  */)
 {
   Lisp_Object absname;
   Lisp_Object handler;
-#ifdef HAVE_POSIX_ACL
+#ifdef HAVE_ACL_SET_FILE
   Lisp_Object encoded_absname;
   acl_t acl;
   bool fail;
@@ -3178,7 +3147,7 @@ support.  */)
   if (!NILP (handler))
     return call3 (handler, Qset_file_acl, absname, acl_string);
 
-#ifdef HAVE_POSIX_ACL
+#ifdef HAVE_ACL_SET_FILE
   if (STRINGP (acl_string))
     {
       acl = acl_from_text (SSDATA (acl_string));
@@ -3193,7 +3162,7 @@ support.  */)
       fail = (acl_set_file (SSDATA (encoded_absname), ACL_TYPE_ACCESS,
                             acl)
               != 0);
-      if (fail && !ACL_NOT_WELL_SUPPORTED (errno))
+      if (fail && acl_errno_valid (errno))
         report_file_error ("Setting ACL", Fcons (absname, Qnil));
 
       acl_free (acl);
@@ -4979,15 +4948,14 @@ This calls `write-region-annotate-functions' at the start, and
 
   immediate_quit = 0;
 
-  /* fsync appears to change the modtime on BSD4.2.
-     Disk full in NFS may be reported here.  */
-  /* mib says that closing the file will try to write as fast as NFS can do
-     it, and that means the fsync here is not crucial for autosave files.  */
+  /* fsync is not crucial for auto-save files, since they might lose
+     some work anyway.  */
   if (!auto_saving && !write_region_inhibit_fsync)
     {
-      /* Transfer data and metadata to disk, retrying if interrupted.  Also,
-         ignore EINVAL which happens when fsync is not supported on this
-         file.  */
+      /* Transfer data and metadata to disk, retrying if interrupted.
+         fsync can report a write failure here, e.g., due to disk full
+         under NFS.  But ignore EINVAL, which means fsync is not
+         supported on this file.  */
       while (fsync (desc) != 0)
         if (errno != EINTR)
           {
@@ -6069,11 +6037,28 @@ in the buffer; this is the default behavior, because the auto-save
 file is usually more useful if it contains the deleted text.  */);
   Vauto_save_include_big_deletions = Qnil;
 
+  /* fsync can be a significant performance hit.  Often it doesn't
+     suffice to make the file-save operation survive a crash.  For
+     batch scripts, which are typically part of larger shell commands
+     that don't fsync other files, its effect on performance can be
+     significant so its utility is particularly questionable.
+     Hence, for now by default fsync is used only when interactive.
+
+     For more on why fsync often fails to work on today's hardware, see:
+     Zheng M et al. Understanding the robustness of SSDs under power fault.
+     11th USENIX Conf. on File and Storage Technologies, 2013 (FAST '13), 271-84
+     http://www.usenix.org/system/files/conference/fast13/fast13-final80.pdf
+
+     For more on why fsync does not suffice even if it works properly, see:
+     Roche X. Necessary step(s) to synchronize filename operations on disk.
+     Austin Group Defect 672, 2013-03-19
+     http://austingroupbugs.net/view.php?id=672  */
   DEFVAR_BOOL ("write-region-inhibit-fsync", write_region_inhibit_fsync,
                doc: /* Non-nil means don't call fsync in `write-region'.
 This variable affects calls to `write-region' as well as save commands.
-A non-nil value may result in data loss!  */);
-  write_region_inhibit_fsync = 0;
+Setting this to nil may avoid data loss if the system loses power or
+the operating system crashes.  */);
+  write_region_inhibit_fsync = noninteractive;
 
   DEFVAR_BOOL ("delete-by-moving-to-trash", delete_by_moving_to_trash,
                doc: /* Specifies whether to use the system's trash can.
diff --git a/src/filelock.c b/src/filelock.c
index f17d3182eab..de6aba8385c 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -437,14 +437,8 @@ create_lock_file (char *lfname, char *lock_info_str, bool force)
           if (emacs_write (fd, lock_info_str, lock_info_len) != lock_info_len
               || (need_fchmod && fchmod (fd, world_readable) != 0))
             err = errno;
-          else
-            while (fsync (fd) != 0)
-              if (errno != EINTR)
-                {
-                  if (errno != EINVAL)
-                    err = errno;
-                  break;
-                }
+          /* There is no need to call fsync here, as the contents of
+             the lock file need not survive system crashes.  */
           if (emacs_close (fd) != 0)
             err = errno;
           if (!err && rename_lock_file (nonce, lfname, force) != 0)
diff --git a/src/gtkutil.c b/src/gtkutil.c
index f83d8660fcc..8ac58f18158 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -70,13 +70,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
 #endif
-#if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
+#if GTK_CHECK_VERSION (2, 12, 0)
 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
 #else
 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
 #endif
 
-#if GTK_MAJOR_VERSION > 3 || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION >= 2)
+#if GTK_CHECK_VERSION (3, 2, 0)
 #define USE_NEW_GTK_FONT_CHOOSER 1
 #else
 #define USE_NEW_GTK_FONT_CHOOSER 0
@@ -202,7 +202,7 @@ xg_display_close (Display *dpy)
       gdpy_def = gdpy_new;
     }
 
-#if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
+#if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
   /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
      http://bugzilla.gnome.org/show_bug.cgi?id=85715).  This way we
      can continue running, but there will be memory leaks.  */
@@ -1155,7 +1155,8 @@ xg_create_frame_widgets (FRAME_PTR f)
      has backported it to Gtk+ 2.0 and they add the resize grip for
      Gtk+ 2.0 applications also.  But it has a bug that makes Emacs loop
      forever, so disable the grip.  */
-#if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
+#if (! GTK_CHECK_VERSION (3, 0, 0) \
+     && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
   gtk_window_set_has_resize_grip (GTK_WINDOW (wtop), FALSE);
 #endif
 
diff --git a/src/image.c b/src/image.c
index 2dae63a294f..f9f6ce70040 100644
--- a/src/image.c
+++ b/src/image.c
@@ -7263,6 +7263,25 @@ gif_load (struct frame *f, struct image *img)
       return 0;
     }
 
+  /* Check that the selected subimages fit.  It's not clear whether
+     the GIF spec requires this, but Emacs can crash if they don't fit.  */
+  for (j = 0; j <= idx; ++j)
+    {
+      struct SavedImage *subimage = gif->SavedImages + j;
+      int subimg_width = subimage->ImageDesc.Width;
+      int subimg_height = subimage->ImageDesc.Height;
+      int subimg_top = subimage->ImageDesc.Top;
+      int subimg_left = subimage->ImageDesc.Left;
+      if (! (0 <= subimg_width && 0 <= subimg_height
+             && 0 <= subimg_top && subimg_top <= height - subimg_height
+             && 0 <= subimg_left && subimg_left <= width - subimg_width))
+        {
+          image_error ("Subimage does not fit in image", Qnil, Qnil);
+          fn_DGifCloseFile (gif);
+          return 0;
+        }
+    }
+
   /* Create the X image and pixmap.  */
   if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg, &img->pixmap))
     {
diff --git a/src/lread.c b/src/lread.c
index 8e623e838c7..15821662fc8 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -201,6 +201,9 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
 
       ptrdiff_t pt_byte = BUF_PT_BYTE (inbuffer);
 
+      if (! BUFFER_LIVE_P (inbuffer))
+        return -1;
+
       if (pt_byte >= BUF_ZV_BYTE (inbuffer))
         return -1;
 
@@ -375,6 +378,19 @@ skip_dyn_bytes (Lisp_Object readcharfun, ptrdiff_t n)
     }
 }
 
+static void
+skip_dyn_eof (Lisp_Object readcharfun)
+{
+  if (FROM_FILE_P (readcharfun))
+    {
+      block_input ();           /* FIXME: Not sure if it's needed.  */
+      fseek (instream, 0, SEEK_END);
+      unblock_input ();
+    }
+  else
+    while (READCHAR >= 0);
+}
+
 /* Unread the character C in the way appropriate for the stream READCHARFUN.
    If the stream is a user function, call it with the char as argument.  */
 
@@ -1976,7 +1992,9 @@ STREAM or the value of `standard-input' may be:
   if (EQ (stream, Qt))
     stream = Qread_char;
   if (EQ (stream, Qread_char))
-    return Fread_minibuffer (build_string ("Lisp expression: "), Qnil);
+    /* FIXME: ¿¡ When is this used !?  */
+    return call1 (intern ("read-minibuffer"),
+                  build_string ("Lisp expression: "));
 
   return read_internal_start (stream, Qnil, Qnil);
 }
@@ -2617,7 +2635,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
       if (c == '@')
         {
           enum { extra = 100 };
-          ptrdiff_t i, nskip = 0;
+          ptrdiff_t i, nskip = 0, digits = 0;
 
           /* Read a decimal integer.  */
           while ((c = READCHAR) >= 0
@@ -2625,8 +2643,14 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
             {
               if ((STRING_BYTES_BOUND - extra) / 10 <= nskip)
                 string_overflow ();
+              digits++;
               nskip *= 10;
               nskip += c - '0';
+              if (digits == 2 && nskip == 0)
+                { /* We've just seen #@00, which means "skip to end".  */
+                  skip_dyn_eof (readcharfun);
+                  return Qnil;
+                }
             }
           if (nskip > 0)
             /* We can't use UNREAD here, because in the code below we side-step
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index aacc258cd11..3484d6c70c8 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -388,6 +388,9 @@ EMACS_ROOT = ..
 GNU_LIB = $(EMACS_ROOT)/lib
 NT_INC = $(EMACS_ROOT)/nt/inc
 
+ACL_H          = $(GNU_LIB)/acl.h \
+                 $(NT_INC)/sys/stat.h \
+                 $(NT_INC)/stdbool.h
 SYSTIME_H      = $(SRC)/systime.h \
                  $(NT_INC)/sys/time.h \
                  $(GNU_LIB)/timespec.h
@@ -848,6 +851,7 @@ $(BLD)/fileio.$(O) : \
         $(NT_INC)/sys/stat.h \
         $(NT_INC)/unistd.h \
         $(GNU_LIB)/allocator.h \
+        $(ACL_H) \
         $(BUFFER_H) \
         $(CAREADLINKAT_H) \
         $(CHARACTER_H) \
diff --git a/src/minibuf.c b/src/minibuf.c
index b96d27e0742..b69a16eff42 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -986,34 +986,6 @@ and some related functions, which use zero-indexing for POSITION.  */)
   return val;
 }
 
-DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
-       doc: /* Return a Lisp object read using the minibuffer, unevaluated.
-Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
-is a string to insert in the minibuffer before reading.
-\(INITIAL-CONTENTS can also be a cons of a string and an integer.
-Such arguments are used as in `read-from-minibuffer'.)  */)
-  (Lisp_Object prompt, Lisp_Object initial_contents)
-{
-  CHECK_STRING (prompt);
-  return read_minibuf (Vminibuffer_local_map, initial_contents,
-                       prompt, 1, Qminibuffer_history,
-                       make_number (0), Qnil, 0, 0);
-}
-
-DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
-       doc: /* Return value of Lisp expression read using the minibuffer.
-Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
-is a string to insert in the minibuffer before reading.
-\(INITIAL-CONTENTS can also be a cons of a string and an integer.
-Such arguments are used as in `read-from-minibuffer'.)  */)
-  (Lisp_Object prompt, Lisp_Object initial_contents)
-{
-  return Feval (read_minibuf (Vread_expression_map, initial_contents,
-                              prompt, 1, Qread_expression_history,
-                              make_number (0), Qnil, 0, 0),
-                Qnil);
-}
-
 /* Functions that use the minibuffer to read various things.  */
 
 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
@@ -2137,15 +2109,9 @@ properties.  */);
   Vminibuffer_prompt_properties
     = Fcons (intern_c_string ("read-only"), Fcons (Qt, Qnil));
 
-  DEFVAR_LISP ("read-expression-map", Vread_expression_map,
-               doc: /* Minibuffer keymap used for reading Lisp expressions.  */);
-  Vread_expression_map = Qnil;
-
   defsubr (&Sactive_minibuffer_window);
   defsubr (&Sset_minibuffer_window);
   defsubr (&Sread_from_minibuffer);
-  defsubr (&Seval_minibuffer);
-  defsubr (&Sread_minibuffer);
   defsubr (&Sread_string);
   defsubr (&Sread_command);
   defsubr (&Sread_variable);
diff --git a/src/nsfns.m b/src/nsfns.m
index 0d9ebe0ef50..497a856aa10 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -44,6 +44,10 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #include "fontset.h"
 #include "font.h"
 
+#ifdef NS_IMPL_COCOA
+#include <IOKit/graphics/IOGraphicsLib.h>
+#endif
+
 #if 0
 int fns_trace_num = 1;
 #define NSTRACE(x)        fprintf (stderr, "%s:%d: [%d] " #x "\n",        \
@@ -101,6 +105,8 @@ static int as_status;
 static ptrdiff_t image_cache_refcount;
 #endif
 
+static Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
+
 /* ==========================================================================
 
     Internal utility functions
@@ -1502,7 +1508,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
 
   ret = (ret == NSOKButton) || panelOK;
 
-  if (ret) 
+  if (ret)
     {
       NSString *str = [panel getFilename];
       if (! str) str = [panel getDirectory];
@@ -1699,7 +1705,7 @@ If omitted or nil, the selected frame's display is used.  */)
      (Lisp_Object display)
 {
   NSWindowDepth depth;
-  
+
   check_ns_display_info (display);
   depth = [ns_get_screen (display) depth];
 
@@ -2267,7 +2273,7 @@ DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
 {
   NSWindowDepth depth;
   NSString *colorSpace;
-  
+
   check_ns_display_info (display);
   depth = [ns_get_screen (display) depth];
   colorSpace = NSColorSpaceFromDepth (depth);
@@ -2321,35 +2327,221 @@ If omitted or nil, that stands for the selected frame's display.  */)
   return make_number ((int) [ns_get_screen (display) frame].size.height);
 }
 
+struct MonitorInfo {
+  XRectangle geom, work;
+  int mm_width, mm_height;
+  char *name;
+};
 
-DEFUN ("display-usable-bounds", Fns_display_usable_bounds,
-       Sns_display_usable_bounds, 0, 1, 0,
-       doc: /* Return the bounds of the usable part of the screen.
-The return value is a list of integers (LEFT TOP WIDTH HEIGHT), which
-are the boundaries of the usable part of the screen, excluding areas
-reserved for the Mac menu, dock, and so forth.
+static void
+free_monitors (struct MonitorInfo *monitors, int n_monitors)
+{
+  int i;
+  for (i = 0; i < n_monitors; ++i)
+    xfree (monitors[i].name);
+  xfree (monitors);
+}
 
-The screen queried corresponds to DISPLAY, which should be either a
-frame, a display name (a string), or terminal ID.  If omitted or nil,
-that stands for the selected frame's display. */)
-     (Lisp_Object display)
+#ifdef NS_IMPL_COCOA
+/* Returns the name for the screen that DICT came from, or NULL.
+   Caller must free return value.
+*/
+
+char *
+ns_screen_name (CGDirectDisplayID did)
+{
+  char *name = NULL;
+  NSDictionary *info = (NSDictionary *)
+    IODisplayCreateInfoDictionary (CGDisplayIOServicePort (did),
+                                   kIODisplayOnlyPreferredName);
+  NSDictionary *names
+    = [info objectForKey:
+              [NSString stringWithUTF8String:kDisplayProductName]];
+
+  if ([names count] > 0) {
+    NSString *n = [names objectForKey: [[names allKeys] objectAtIndex:0]];
+    if (n != nil)
+      name = xstrdup ([n UTF8String]);
+  }
+
+  [info release];
+  return name;
+}
+#endif
+
+static Lisp_Object
+ns_make_monitor_attribute_list (struct MonitorInfo *monitors,
+                                int n_monitors,
+                                int primary_monitor,
+                                const char *source)
+{
+  Lisp_Object monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
+  Lisp_Object frame, rest, attributes_list = Qnil;
+  Lisp_Object primary_monitor_attributes = Qnil;
+  NSArray *screens = [NSScreen screens];
+  int i;
+
+  FOR_EACH_FRAME (rest, frame)
+    {
+      struct frame *f = XFRAME (frame);
+
+      if (FRAME_NS_P (f))
+        {
+          NSView *view = FRAME_NS_VIEW (f);
+          NSScreen *screen = [[view window] screen];
+          NSUInteger k;
+
+          i = -1;
+          for (k = 0; i == -1 && k < [screens count]; ++k)
+            {
+              if ([screens objectAtIndex: k] == screen)
+                i = (int)k;
+            }
+
+          if (i > -1)
+            ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
+        }
+    }
+
+  for (i = 0; i < n_monitors; ++i)
+    {
+      Lisp_Object geometry, workarea, attributes = Qnil;
+      struct MonitorInfo *mi = &monitors[i];
+
+      if (mi->geom.width == 0) continue;
+
+      workarea = list4i (mi->work.x, mi->work.y,
+                         mi->work.width, mi->work.height);
+      geometry = list4i (mi->geom.x, mi->geom.y,
+                         mi->geom.width, mi->geom.height);
+      attributes = Fcons (Fcons (Qsource,
+                                 make_string (source, strlen (source))),
+                          attributes);
+      attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
+                          attributes);
+      attributes = Fcons (Fcons (Qmm_size,
+                                 list2i (mi->mm_width, mi->mm_height)),
+                          attributes);
+      attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
+      attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
+      if (mi->name)
+        attributes = Fcons (Fcons (Qname, make_string (mi->name,
+                                                       strlen (mi->name))),
+                            attributes);
+
+      if (i == primary_monitor)
+        primary_monitor_attributes = attributes;
+      else
+        attributes_list = Fcons (attributes, attributes_list);
+    }
+
+  if (!NILP (primary_monitor_attributes))
+    attributes_list = Fcons (primary_monitor_attributes, attributes_list);
+  return attributes_list;
+}
+
+DEFUN ("ns-display-monitor-attributes-list",
+       Fns_display_monitor_attributes_list,
+       Sns_display_monitor_attributes_list,
+       0, 1, 0,
+       doc: /* Return a list of physical monitor attributes on the X display TERMINAL.
+
+The optional argument TERMINAL specifies which display to ask about.
+TERMINAL should be a terminal object, a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display.
+
+In addition to the standard attribute keys listed in
+`display-monitor-attributes-list', the following keys are contained in
+the attributes:
+
+ source -- String describing the source from which multi-monitor
+           information is obtained, \"NS\" is always the source."
+
+Internal use only, use `display-monitor-attributes-list' instead.  */)
+  (Lisp_Object terminal)
 {
-  NSScreen *screen;
-  NSRect vScreen;
+  struct terminal *term = get_terminal (terminal, 1);
+  NSArray *screens;
+  NSUInteger i, n_monitors;
+  struct MonitorInfo *monitors;
+  Lisp_Object attributes_list = Qnil;
+  CGFloat primary_display_height = 0;
 
-  check_ns_display_info (display);
-  screen = ns_get_screen (display);
-  if (!screen)
+  if (term->type != output_ns)
     return Qnil;
 
-  vScreen = [screen visibleFrame];
+  screens = [NSScreen screens];
+  n_monitors = [screens count];
+  if (n_monitors == 0)
+    return Qnil;
+
+  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+
+  for (i = 0; i < [screens count]; ++i)
+    {
+      NSScreen *s = [screens objectAtIndex:i];
+      struct MonitorInfo *m = &monitors[i];
+      NSRect fr = [s frame];
+      NSRect vfr = [s visibleFrame];
+      NSDictionary *dict = [s deviceDescription];
+      NSValue *resval = [dict valueForKey:NSDeviceResolution];
+      short y, vy;
+
+#ifdef NS_IMPL_COCOA
+      NSNumber *nid = [dict objectForKey:@"NSScreenNumber"];
+      CGDirectDisplayID did = [nid unsignedIntValue];
+#endif
+      if (i == 0)
+        {
+          primary_display_height = fr.size.height;
+          y = (short) fr.origin.y;
+          vy = (short) vfr.origin.y;
+        }
+      else
+        {
+          // Flip y coordinate as NS has y starting from the bottom.
+          y = (short) (primary_display_height - fr.size.height - fr.origin.y);
+          vy = (short) (primary_display_height -
+                        vfr.size.height - vfr.origin.y);
+        }
+      
+      m->geom.x = (short) fr.origin.x;
+      m->geom.y = y;
+      m->geom.width = (unsigned short) fr.size.width;
+      m->geom.height = (unsigned short) fr.size.height;
+
+      m->work.x = (short) vfr.origin.x;
+      // y is flipped on NS, so vy - y are pixels missing at the bottom,
+      // and fr.size.height - vfr.size.height are pixels missing in total.
+      // Pixels missing at top are
+      // fr.size.height - vfr.size.height - vy + y.
+      // work.y is then pixels missing at top + y.
+      m->work.y = (short) (fr.size.height - vfr.size.height) - vy + y + y;
+      m->work.width = (unsigned short) vfr.size.width;
+      m->work.height = (unsigned short) vfr.size.height;
+
+#ifdef NS_IMPL_COCOA
+      m->name = ns_screen_name (did);
+
+      {
+        CGSize mms = CGDisplayScreenSize (did);
+        m->mm_width = (int) mms.width;
+        m->mm_height = (int) mms.height;
+      }
+
+#else
+      // Assume 92 dpi as x-display-mm-height/x-display-mm-width does.
+      m->mm_width = (int) (25.4 * fr.size.width / 92.0);
+      m->mm_height = (int) (25.4 * fr.size.height / 92.0);
+#endif
+    }
+
+  // Primary monitor is always first for NS.
+  attributes_list = ns_make_monitor_attribute_list (monitors, n_monitors,
+                                                    0, "NS");
 
-  /* NS coordinate system is upside-down.
-     Transform to screen-specific coordinates. */
-  return list4i (vScreen.origin.x,
-                 [screen frame].size.height
-                 - vScreen.size.height - vScreen.origin.y,
-                 vScreen.size.width, vScreen.size.height);
+  free_monitors (monitors, n_monitors);
+  return attributes_list;
 }
 
 
@@ -2546,7 +2738,7 @@ Value is t if tooltip was open, nil otherwise.  */)
 
 /*
   Handle arrow/function/control keys and copy/paste/cut in file dialogs.
-  Return YES if handeled, NO if not.
+  Return YES if handled, NO if not.
  */
 static BOOL
 handlePanelKeys (NSSavePanel *panel, NSEvent *theEvent)
@@ -2729,6 +2921,11 @@ handlePanelKeys (NSSavePanel *panel, NSEvent *theEvent)
 void
 syms_of_nsfns (void)
 {
+  DEFSYM (Qgeometry, "geometry");
+  DEFSYM (Qworkarea, "workarea");
+  DEFSYM (Qmm_size, "mm-size");
+  DEFSYM (Qframes, "frames");
+  DEFSYM (Qsource, "source");
   Qfontsize = intern_c_string ("fontsize");
   staticpro (&Qfontsize);
 
@@ -2774,7 +2971,7 @@ be used as the image of the icon representing the frame.  */);
   defsubr (&Sx_server_version);
   defsubr (&Sx_display_pixel_width);
   defsubr (&Sx_display_pixel_height);
-  defsubr (&Sns_display_usable_bounds);
+  defsubr (&Sns_display_monitor_attributes_list);
   defsubr (&Sx_display_mm_width);
   defsubr (&Sx_display_mm_height);
   defsubr (&Sx_display_screens);
diff --git a/src/nsfont.m b/src/nsfont.m
index ebee363651f..9ab369d1fcd 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -151,10 +151,13 @@ ns_spec_to_descriptor (Lisp_Object font_spec)
     if ([tdict count] > 0)
         [fdAttrs setObject: tdict forKey: NSFontTraitsAttribute];
 
-    fdesc = [NSFontDescriptor fontDescriptorWithFontAttributes: fdAttrs];
+    fdesc = [[[NSFontDescriptor fontDescriptorWithFontAttributes: fdAttrs]
+               retain] autorelease];
+
     if (family != nil)
       {
-        fdesc = [fdesc fontDescriptorWithFamily: family];
+        NSFontDescriptor *fdesc2 = [fdesc fontDescriptorWithFamily: family];
+        fdesc = [[fdesc2 retain] autorelease];
       }
 
     [fdAttrs release];
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 648b568d180..baa683941f8 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -119,7 +119,6 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
   id menu = [NSApp mainMenu];
   static EmacsMenu *last_submenu = nil;
   BOOL needsSet = NO;
-  const char *submenuTitle = [[submenu title] UTF8String];
   bool owfi;
   Lisp_Object items;
   widget_value *wv, *first_wv, *prev_wv = 0;
@@ -239,7 +238,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
           /* FIXME: we'd like to only parse the needed submenu, but this
                was causing crashes in the _common parsing code.. need to make
                sure proper initialization done.. */
-/*        if (submenu && strcmp (submenuTitle, SSDATA (string)))
+/*        if (submenu && strcmp ([[submenu title] UTF8String], SSDATA (string)))
              continue; */
 
           submenu_start[i] = menu_items_used;
@@ -259,7 +258,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
         {
           /* should have found a menu for this one but didn't */
           fprintf (stderr, "ERROR: did not find lisp menu for submenu '%s'.\n",
-                  submenuTitle);
+                  [[submenu title] UTF8String]);
           discard_menu_items ();
           unbind_to (specpdl_count, Qnil);
           [pool release];
@@ -346,8 +345,6 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
           string = AREF (items, i + 1);
           if (NILP (string))
             break;
-/*           if (submenu && strcmp (submenuTitle, SSDATA (string)))
-               continue; */
 
           wv->name = SSDATA (string);
           update_submenu_strings (wv->contents);
@@ -358,6 +355,7 @@ ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
          create a new menu for each sub and fill it. */
       if (submenu)
         {
+          const char *submenuTitle = [[submenu title] UTF8String];
           for (wv = first_wv->contents; wv; wv = wv->next)
             {
               if (!strcmp (submenuTitle, wv->name))
diff --git a/src/regex.c b/src/regex.c
index 648f2529649..04429386f84 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -710,51 +710,27 @@ typedef enum
    at SOURCE.  */
 
 #define EXTRACT_NUMBER(destination, source)                             \
-  do {                                                                  \
-    (destination) = *(source) & 0377;                                   \
-    (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8;           \
-  } while (0)
+  ((destination) = extract_number (source))
 
-#ifdef DEBUG
-static void
-extract_number (int *dest, re_char *source)
+static int
+extract_number (re_char *source)
 {
-  int temp = SIGN_EXTEND_CHAR (*(source + 1));
-  *dest = *source & 0377;
-  *dest += temp << 8;
+  return (SIGN_EXTEND_CHAR (source[1]) << 8) + source[0];
 }
 
-# ifndef EXTRACT_MACROS /* To debug the macros.  */
-#  undef EXTRACT_NUMBER
-#  define EXTRACT_NUMBER(dest, src) extract_number (&dest, src)
-# endif /* not EXTRACT_MACROS */
-
-#endif /* DEBUG */
-
 /* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
    SOURCE must be an lvalue.  */
 
 #define EXTRACT_NUMBER_AND_INCR(destination, source)                    \
-  do {                                                                  \
-    EXTRACT_NUMBER (destination, source);                               \
-    (source) += 2;                                                      \
-  } while (0)
+  ((destination) = extract_number_and_incr (&source))
 
-#ifdef DEBUG
-static void
-extract_number_and_incr (int *destination, re_char **source)
+static int
+extract_number_and_incr (re_char **source)
 {
-  extract_number (destination, *source);
+  int num = extract_number (*source);
   *source += 2;
+  return num;
 }
-
-# ifndef EXTRACT_MACROS
-#  undef EXTRACT_NUMBER_AND_INCR
-#  define EXTRACT_NUMBER_AND_INCR(dest, src) \
-  extract_number_and_incr (&dest, &src)
-# endif /* not EXTRACT_MACROS */
-
-#endif /* DEBUG */
 
 /* Store a multibyte character in three contiguous bytes starting
    DESTINATION, and increment DESTINATION to the byte after where the
@@ -861,10 +837,8 @@ extract_number_and_incr (int *destination, re_char **source)
 static int debug = -100000;
 
 # define DEBUG_STATEMENT(e) e
-# define DEBUG_PRINT1(x) if (debug > 0) printf (x)
-# define DEBUG_PRINT2(x1, x2) if (debug > 0) printf (x1, x2)
-# define DEBUG_PRINT3(x1, x2, x3) if (debug > 0) printf (x1, x2, x3)
-# define DEBUG_PRINT4(x1, x2, x3, x4) if (debug > 0) printf (x1, x2, x3, x4)
+# define DEBUG_PRINT(...) if (debug > 0) printf (__VA_ARGS__)
+# define DEBUG_COMPILES_ARGUMENTS
 # define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)                          \
   if (debug > 0) print_partial_compiled_pattern (s, e)
 # define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)                 \
@@ -873,9 +847,8 @@ static int debug = -100000;
 
 /* Print the fastmap in human-readable form.  */
 
-void
-print_fastmap (fastmap)
-    char *fastmap;
+static void
+print_fastmap (char *fastmap)
 {
   unsigned was_a_range = 0;
   unsigned i = 0;
@@ -905,10 +878,8 @@ print_fastmap (fastmap)
 /* Print a compiled pattern string in human-readable form, starting at
    the START pointer into it and ending just before the pointer END.  */
 
-void
-print_partial_compiled_pattern (start, end)
-    re_char *start;
-    re_char *end;
+static void
+print_partial_compiled_pattern (re_char *start, re_char *end)
 {
   int mcnt, mcnt2;
   re_char *p = start;
@@ -923,7 +894,7 @@ print_partial_compiled_pattern (start, end)
   /* Loop over pattern commands.  */
   while (p < pend)
     {
-      fprintf (stderr, "%d:\t", p - start);
+      fprintf (stderr, "%td:\t", p - start);
 
       switch ((re_opcode_t) *p++)
         {
@@ -1027,51 +998,58 @@ print_partial_compiled_pattern (start, end)
           break;
 
         case on_failure_jump:
-          extract_number_and_incr (&mcnt, &p);
-          fprintf (stderr, "/on_failure_jump to %d", p + mcnt - start);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          fprintf (stderr, "/on_failure_jump to %td", p + mcnt - start);
           break;
 
         case on_failure_keep_string_jump:
-          extract_number_and_incr (&mcnt, &p);
-          fprintf (stderr, "/on_failure_keep_string_jump to %d", p + mcnt - start);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          fprintf (stderr, "/on_failure_keep_string_jump to %td",
+                   p + mcnt - start);
           break;
 
         case on_failure_jump_nastyloop:
-          extract_number_and_incr (&mcnt, &p);
-          fprintf (stderr, "/on_failure_jump_nastyloop to %d", p + mcnt - start);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          fprintf (stderr, "/on_failure_jump_nastyloop to %td",
+                   p + mcnt - start);
           break;
 
         case on_failure_jump_loop:
-          extract_number_and_incr (&mcnt, &p);
-          fprintf (stderr, "/on_failure_jump_loop to %d", p + mcnt - start);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          fprintf (stderr, "/on_failure_jump_loop to %td",
+                   p + mcnt - start);
           break;
 
         case on_failure_jump_smart:
-          extract_number_and_incr (&mcnt, &p);
-          fprintf (stderr, "/on_failure_jump_smart to %d", p + mcnt - start);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          fprintf (stderr, "/on_failure_jump_smart to %td",
+                   p + mcnt - start);
           break;
 
         case jump:
-          extract_number_and_incr (&mcnt, &p);
-          fprintf (stderr, "/jump to %d", p + mcnt - start);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          fprintf (stderr, "/jump to %td", p + mcnt - start);
           break;
 
         case succeed_n:
-          extract_number_and_incr (&mcnt, &p);
-          extract_number_and_incr (&mcnt2, &p);
-          fprintf (stderr, "/succeed_n to %d, %d times", p - 2 + mcnt - start, mcnt2);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          EXTRACT_NUMBER_AND_INCR (mcnt2, p);
+          fprintf (stderr, "/succeed_n to %td, %d times",
+                   p - 2 + mcnt - start, mcnt2);
           break;
 
         case jump_n:
-          extract_number_and_incr (&mcnt, &p);
-          extract_number_and_incr (&mcnt2, &p);
-          fprintf (stderr, "/jump_n to %d, %d times", p - 2 + mcnt - start, mcnt2);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          EXTRACT_NUMBER_AND_INCR (mcnt2, p);
+          fprintf (stderr, "/jump_n to %td, %d times",
+                   p - 2 + mcnt - start, mcnt2);
           break;
 
         case set_number_at:
-          extract_number_and_incr (&mcnt, &p);
-          extract_number_and_incr (&mcnt2, &p);
-          fprintf (stderr, "/set_number_at location %d to %d", p - 2 + mcnt - start, mcnt2);
+          EXTRACT_NUMBER_AND_INCR (mcnt, p);
+          EXTRACT_NUMBER_AND_INCR (mcnt2, p);
+          fprintf (stderr, "/set_number_at location %td to %d",
+                   p - 2 + mcnt - start, mcnt2);
           break;
 
         case wordbound:
@@ -1151,13 +1129,12 @@ print_partial_compiled_pattern (start, end)
       fprintf (stderr, "\n");
     }
 
-  fprintf (stderr, "%d:\tend of pattern.\n", p - start);
+  fprintf (stderr, "%td:\tend of pattern.\n", p - start);
 }
 
 
-void
-print_compiled_pattern (bufp)
-    struct re_pattern_buffer *bufp;
+static void
+print_compiled_pattern (struct re_pattern_buffer *bufp)
 {
   re_char *buffer = bufp->buffer;
 
@@ -1171,7 +1148,7 @@ print_compiled_pattern (bufp)
       print_fastmap (bufp->fastmap);
     }
 
-  printf ("re_nsub: %d\t", bufp->re_nsub);
+  printf ("re_nsub: %zu\t", bufp->re_nsub);
   printf ("regs_alloc: %d\t", bufp->regs_allocated);
   printf ("can_be_null: %d\t", bufp->can_be_null);
   printf ("no_sub: %d\t", bufp->no_sub);
@@ -1183,13 +1160,9 @@ print_compiled_pattern (bufp)
 }
 
 
-void
-print_double_string (where, string1, size1, string2, size2)
-    re_char *where;
-    re_char *string1;
-    re_char *string2;
-    ssize_t size1;
-    ssize_t size2;
+static void
+print_double_string (re_char *where, re_char *string1, ssize_t size1,
+                     re_char *string2, ssize_t size2)
 {
   ssize_t this_char;
 
@@ -1216,10 +1189,12 @@ print_double_string (where, string1, size1, string2, size2)
 # define assert(e)
 
 # define DEBUG_STATEMENT(e)
-# define DEBUG_PRINT1(x)
-# define DEBUG_PRINT2(x1, x2)
-# define DEBUG_PRINT3(x1, x2, x3)
-# define DEBUG_PRINT4(x1, x2, x3, x4)
+# if __STDC_VERSION__ < 199901L
+#  define DEBUG_COMPILES_ARGUMENTS
+#  define DEBUG_PRINT /* 'DEBUG_PRINT (x, y)' discards X and Y.  */ (void)
+# else
+#  define DEBUG_PRINT(...)
+# endif
 # define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
 # define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
 
@@ -1469,20 +1444,21 @@ typedef struct
 while (REMAINING_AVAIL_SLOTS <= space) {                                \
   if (!GROW_FAIL_STACK (fail_stack))                                    \
     return -2;                                                          \
-  DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n", (fail_stack).size);\
-  DEBUG_PRINT2 ("        slots available: %d\n", REMAINING_AVAIL_SLOTS);\
+  DEBUG_PRINT ("\n  Doubled stack; size now: %zd\n", (fail_stack).size);\
+  DEBUG_PRINT ("         slots available: %zd\n", REMAINING_AVAIL_SLOTS);\
 }
 
 /* Push register NUM onto the stack.  */
 #define PUSH_FAILURE_REG(num)                                           \
 do {                                                                    \
   char *destination;                                                    \
+  long n = num;                                                         \
   ENSURE_FAIL_STACK(3);                                                 \
-  DEBUG_PRINT4 ("    Push reg %d (spanning %p -> %p)\n",                \
-                num, regstart[num], regend[num]);                       \
-  PUSH_FAILURE_POINTER (regstart[num]);                                 \
-  PUSH_FAILURE_POINTER (regend[num]);                                   \
-  PUSH_FAILURE_INT (num);                                               \
+  DEBUG_PRINT ("    Push reg %ld (spanning %p -> %p)\n",                \
+               n, regstart[n], regend[n]);                              \
+  PUSH_FAILURE_POINTER (regstart[n]);                                   \
+  PUSH_FAILURE_POINTER (regend[n]);                                     \
+  PUSH_FAILURE_INT (n);                                                 \
 } while (0)
 
 /* Change the counter's value to VAL, but make sure that it will
@@ -1493,7 +1469,7 @@ do {									\
   int c;                                                                \
   ENSURE_FAIL_STACK(3);                                                 \
   EXTRACT_NUMBER (c, ptr);                                              \
-  DEBUG_PRINT4 ("    Push number %p = %d -> %d\n", ptr, c, val);        \
+  DEBUG_PRINT ("    Push number %p = %d -> %d\n", ptr, c, val);         \
   PUSH_FAILURE_INT (c);                                                 \
   PUSH_FAILURE_POINTER (ptr);                                           \
   PUSH_FAILURE_INT (-1);                                                \
@@ -1511,14 +1487,14 @@ do {									\
       unsigned char *ptr = (unsigned char*) POP_FAILURE_POINTER ();     \
       pfreg = POP_FAILURE_INT ();                                       \
       STORE_NUMBER (ptr, pfreg);                                        \
-      DEBUG_PRINT3 ("     Pop counter %p = %d\n", ptr, pfreg);          \
+      DEBUG_PRINT ("     Pop counter %p = %ld\n", ptr, pfreg);          \
     }                                                                   \
   else                                                                  \
     {                                                                   \
       regend[pfreg] = POP_FAILURE_POINTER ();                           \
       regstart[pfreg] = POP_FAILURE_POINTER ();                         \
-      DEBUG_PRINT4 ("     Pop reg %d (spanning %p -> %p)\n",            \
-                    pfreg, regstart[pfreg], regend[pfreg]);             \
+      DEBUG_PRINT ("     Pop reg %ld (spanning %p -> %p)\n",            \
+                   pfreg, regstart[pfreg], regend[pfreg]);              \
     }                                                                   \
 } while (0)
 
@@ -1538,10 +1514,10 @@ do {									\
           cycle = 1;                                                    \
           break;                                                        \
         }                                                               \
-      DEBUG_PRINT2 ("  Other pattern: %p\n", FAILURE_PAT (failure));    \
+      DEBUG_PRINT ("  Other pattern: %p\n", FAILURE_PAT (failure));     \
       failure = NEXT_FAILURE_HANDLE(failure);                           \
     }                                                                   \
-  DEBUG_PRINT2 ("  Other string: %p\n", FAILURE_STR (failure));         \
+  DEBUG_PRINT ("  Other string: %p\n", FAILURE_STR (failure));          \
 } while (0)
 
 /* Push the information about the state we will need
@@ -1560,23 +1536,23 @@ do {									\
      of 0 + -1 isn't done as unsigned.  */                              \
                                                                         \
   DEBUG_STATEMENT (nfailure_points_pushed++);                           \
-  DEBUG_PRINT1 ("\nPUSH_FAILURE_POINT:\n");                             \
-  DEBUG_PRINT2 ("  Before push, next avail: %d\n", (fail_stack).avail); \
-  DEBUG_PRINT2 ("                       size: %d\n", (fail_stack).size);\
+  DEBUG_PRINT ("\nPUSH_FAILURE_POINT:\n");                              \
+  DEBUG_PRINT ("  Before push, next avail: %zd\n", (fail_stack).avail); \
+  DEBUG_PRINT ("                        size: %zd\n", (fail_stack).size);\
                                                                         \
   ENSURE_FAIL_STACK (NUM_NONREG_ITEMS);                                 \
                                                                         \
-  DEBUG_PRINT1 ("\n");                                                  \
+  DEBUG_PRINT ("\n");                                                   \
                                                                         \
-  DEBUG_PRINT2 ("  Push frame index: %d\n", fail_stack.frame);          \
+  DEBUG_PRINT ("  Push frame index: %zd\n", fail_stack.frame);          \
   PUSH_FAILURE_INT (fail_stack.frame);                                  \
                                                                         \
-  DEBUG_PRINT2 ("  Push string %p: `", string_place);                   \
+  DEBUG_PRINT ("  Push string %p: `", string_place);                    \
   DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, size2);\
-  DEBUG_PRINT1 ("'\n");                                                 \
+  DEBUG_PRINT ("'\n");                                                  \
   PUSH_FAILURE_POINTER (string_place);                                  \
                                                                         \
-  DEBUG_PRINT2 ("  Push pattern %p: ", pattern);                        \
+  DEBUG_PRINT ("  Push pattern %p: ", pattern);                         \
   DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern, pend);                   \
   PUSH_FAILURE_POINTER (pattern);                                       \
                                                                         \
@@ -1609,28 +1585,28 @@ do {									\
   assert (!FAIL_STACK_EMPTY ());                                        \
                                                                         \
   /* Remove failure points and point to how many regs pushed.  */       \
-  DEBUG_PRINT1 ("POP_FAILURE_POINT:\n");                                \
-  DEBUG_PRINT2 ("  Before pop, next avail: %d\n", fail_stack.avail);    \
-  DEBUG_PRINT2 ("                    size: %d\n", fail_stack.size);     \
+  DEBUG_PRINT ("POP_FAILURE_POINT:\n");                                 \
+  DEBUG_PRINT ("  Before pop, next avail: %zd\n", fail_stack.avail);    \
+  DEBUG_PRINT ("                     size: %zd\n", fail_stack.size);    \
                                                                         \
   /* Pop the saved registers.  */                                       \
   while (fail_stack.frame < fail_stack.avail)                           \
     POP_FAILURE_REG_OR_COUNT ();                                        \
                                                                         \
-  pat = POP_FAILURE_POINTER ();                         \
-  DEBUG_PRINT2 ("  Popping pattern %p: ", pat);                         \
+  pat = POP_FAILURE_POINTER ();                                         \
+  DEBUG_PRINT ("  Popping pattern %p: ", pat);                          \
   DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);                       \
                                                                         \
   /* If the saved string location is NULL, it came from an              \
      on_failure_keep_string_jump opcode, and we want to throw away the  \
      saved NULL, thus retaining our current position in the string.  */ \
   str = POP_FAILURE_POINTER ();                                         \
-  DEBUG_PRINT2 ("  Popping string %p: `", str);                         \
+  DEBUG_PRINT ("  Popping string %p: `", str);                          \
   DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);      \
-  DEBUG_PRINT1 ("'\n");                                                 \
+  DEBUG_PRINT ("'\n");                                                  \
                                                                         \
   fail_stack.frame = POP_FAILURE_INT ();                                \
-  DEBUG_PRINT2 ("  Popping  frame index: %d\n", fail_stack.frame);      \
+  DEBUG_PRINT ("  Popping  frame index: %zd\n", fail_stack.frame);      \
                                                                         \
   assert (fail_stack.avail >= 0);                                       \
   assert (fail_stack.frame <= fail_stack.avail);                        \
@@ -2493,7 +2469,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
 
 #ifdef DEBUG
   debug++;
-  DEBUG_PRINT1 ("\nCompiling pattern: ");
+  DEBUG_PRINT ("\nCompiling pattern: ");
   if (debug > 0)
     {
       unsigned debug_count;
@@ -2646,7 +2622,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
             goto normal_char;
         handle_plus:
         case '*':
-          /* If there is no previous pattern... */
+          /* If there is no previous pattern...  */
           if (!laststart)
             {
               if (syntax & RE_CONTEXT_INVALID_OPS)
@@ -2754,7 +2730,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
                   }
               }
             else                /* not greedy */
-              { /* I wish the greedy and non-greedy cases could be merged. */
+              { /* I wish the greedy and non-greedy cases could be merged.  */
 
                 GET_BUFFER_SPACE (7); /* We might use less.  */
                 if (many_times_ok)
@@ -3058,7 +3034,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
 
                 /* Allocate space for COUNT + RANGE_TABLE.  Needs two
                    bytes for flags, two for COUNT, and three bytes for
-                   each character. */
+                   each character.  */
                 GET_BUFFER_SPACE (4 + used * 3);
 
                 /* Indicate the existence of range table.  */
@@ -3485,6 +3461,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
             /* There is no way to specify the before_dot and after_dot
                operators.  rms says this is ok.  --karl  */
             case '=':
+              laststart = b;
               BUF_PUSH (at_dot);
               break;
 
@@ -3533,12 +3510,14 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
             case '<':
               if (syntax & RE_NO_GNU_OPS)
                 goto normal_char;
+              laststart = b;
               BUF_PUSH (wordbeg);
               break;
 
             case '>':
               if (syntax & RE_NO_GNU_OPS)
                 goto normal_char;
+              laststart = b;
               BUF_PUSH (wordend);
               break;
 
@@ -3697,7 +3676,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
   if (debug > 0)
     {
       re_compile_fastmap (bufp);
-      DEBUG_PRINT1 ("\nCompiled pattern: \n");
+      DEBUG_PRINT ("\nCompiled pattern: \n");
       print_compiled_pattern (bufp);
     }
   debug--;
@@ -4523,8 +4502,8 @@ static int bcmp_translate (re_char *s1, re_char *s2,
    and `string2' into an offset from the beginning of that string.  */
 #define POINTER_TO_OFFSET(ptr)                  \
   (FIRST_STRING_P (ptr)                         \
-   ? ((regoff_t) ((ptr) - string1))             \
-   : ((regoff_t) ((ptr) - string2 + size1)))
+   ? (ptr) - string1                            \
+   : (ptr) - string2 + (ptrdiff_t) size1)
 
 /* Call before fetching a character with *d.  This switches over to
    string2 if necessary.
@@ -4711,7 +4690,7 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
       /* If we're at the end of the pattern, we can change.  */
       if (skip_one_char (p1))
         {
-          DEBUG_PRINT1 ("  End of pattern: fast loop.\n");
+          DEBUG_PRINT ("  End of pattern: fast loop.\n");
           return 1;
         }
       break;
@@ -4727,7 +4706,7 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
           {
             if (c != RE_STRING_CHAR (p1 + 2, multibyte))
               {
-                DEBUG_PRINT3 ("  '%c' != '%c' => fast loop.\n", c, p1[2]);
+                DEBUG_PRINT ("  '%c' != '%c' => fast loop.\n", c, p1[2]);
                 return 1;
               }
           }
@@ -4752,14 +4731,14 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
                that we can't change to pop_failure_jump.  */
             if (!not)
               {
-                DEBUG_PRINT1 ("  No match => fast loop.\n");
+                DEBUG_PRINT ("   No match => fast loop.\n");
                 return 1;
               }
           }
         else if ((re_opcode_t) *p1 == anychar
                  && c == '\n')
           {
-            DEBUG_PRINT1 ("   . != \\n => fast loop.\n");
+            DEBUG_PRINT ("   . != \\n => fast loop.\n");
             return 1;
           }
       }
@@ -4802,7 +4781,7 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
               if (idx == p2[1]
                   || idx == CHARSET_BITMAP_SIZE (p1))
                 {
-                  DEBUG_PRINT1 ("        No match => fast loop.\n");
+                  DEBUG_PRINT ("         No match => fast loop.\n");
                   return 1;
                 }
             }
@@ -4819,7 +4798,7 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
 
               if (idx == p2[1])
                 {
-                  DEBUG_PRINT1 ("        No match => fast loop.\n");
+                  DEBUG_PRINT ("         No match => fast loop.\n");
                   return 1;
                 }
               }
@@ -4945,7 +4924,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                      ssize_t pos, struct re_registers *regs, ssize_t stop)
 {
   /* General temporaries.  */
-  ssize_t mcnt;
+  int mcnt;
   size_t reg;
 
   /* Just past the end of the corresponding string.  */
@@ -4987,7 +4966,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
 #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
   fail_stack_type fail_stack;
 #endif
-#ifdef DEBUG
+#ifdef DEBUG_COMPILES_ARGUMENTS
   unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
 #endif
 
@@ -5032,12 +5011,12 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
      and need to test it, it's not garbage.  */
   re_char *match_end = NULL;
 
-#ifdef DEBUG
+#ifdef DEBUG_COMPILES_ARGUMENTS
   /* Counts the total number of registers pushed.  */
   unsigned num_regs_pushed = 0;
 #endif
 
-  DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");
+  DEBUG_PRINT ("\n\nEntering re_match_2.\n");
 
   INIT_FAIL_STACK ();
 
@@ -5133,22 +5112,25 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
       dend = end_match_1;
     }
 
-  DEBUG_PRINT1 ("The compiled pattern is: ");
+  DEBUG_PRINT ("The compiled pattern is: ");
   DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
-  DEBUG_PRINT1 ("The string to match is: `");
+  DEBUG_PRINT ("The string to match is: `");
   DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
-  DEBUG_PRINT1 ("'\n");
+  DEBUG_PRINT ("'\n");
 
   /* This loops over pattern commands.  It exits by returning from the
      function if the match is complete, or it drops through if the match
      fails at this starting point in the input data.  */
   for (;;)
     {
-      DEBUG_PRINT2 ("\n%p: ", p);
+      DEBUG_PRINT ("\n%p: ", p);
 
       if (p == pend)
-        { /* End of pattern means we might have succeeded.  */
-          DEBUG_PRINT1 ("end of pattern ... ");
+        {
+          ptrdiff_t dcnt;
+
+          /* End of pattern means we might have succeeded.  */
+          DEBUG_PRINT ("end of pattern ... ");
 
           /* If we haven't matched the entire string, and we want the
              longest match, try backtracking.  */
@@ -5168,7 +5150,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
               else
                 best_match_p = !FIRST_STRING_P (d);
 
-              DEBUG_PRINT1 ("backtracking.\n");
+              DEBUG_PRINT ("backtracking.\n");
 
               if (!FAIL_STACK_EMPTY ())
                 { /* More failure points to try.  */
@@ -5179,7 +5161,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                       best_regs_set = true;
                       match_end = d;
 
-                      DEBUG_PRINT1 ("\nSAVING match as best so far.\n");
+                      DEBUG_PRINT ("\nSAVING match as best so far.\n");
 
                       for (reg = 1; reg < num_regs; reg++)
                         {
@@ -5201,7 +5183,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                      For example, the pattern `x.*y.*z' against the
                      strings `x-' and `y-z-', if the two strings are
                      not consecutive in memory.  */
-                  DEBUG_PRINT1 ("Restoring best registers.\n");
+                  DEBUG_PRINT ("Restoring best registers.\n");
 
                   d = match_end;
                   dend = ((d >= string1 && d <= end1)
@@ -5216,7 +5198,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
             } /* d != end_match_2 */
 
         succeed_label:
-          DEBUG_PRINT1 ("Accepting match.\n");
+          DEBUG_PRINT ("Accepting match.\n");
 
           /* If caller wants register contents data back, do it.  */
           if (regs && !bufp->no_sub)
@@ -5276,10 +5258,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                     regs->start[reg] = regs->end[reg] = -1;
                   else
                     {
-                      regs->start[reg]
-                        = (regoff_t) POINTER_TO_OFFSET (regstart[reg]);
-                      regs->end[reg]
-                        = (regoff_t) POINTER_TO_OFFSET (regend[reg]);
+                      regs->start[reg] = POINTER_TO_OFFSET (regstart[reg]);
+                      regs->end[reg] = POINTER_TO_OFFSET (regend[reg]);
                     }
                 }
 
@@ -5292,17 +5272,17 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                 regs->start[reg] = regs->end[reg] = -1;
             } /* regs && !bufp->no_sub */
 
-          DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",
-                        nfailure_points_pushed, nfailure_points_popped,
-                        nfailure_points_pushed - nfailure_points_popped);
-          DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);
+          DEBUG_PRINT ("%u failure points pushed, %u popped (%u remain).\n",
+                       nfailure_points_pushed, nfailure_points_popped,
+                       nfailure_points_pushed - nfailure_points_popped);
+          DEBUG_PRINT ("%u registers pushed.\n", num_regs_pushed);
 
-          mcnt = POINTER_TO_OFFSET (d) - pos;
+          dcnt = POINTER_TO_OFFSET (d) - pos;
 
-          DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);
+          DEBUG_PRINT ("Returning %td from re_match_2.\n", dcnt);
 
           FREE_VARIABLES ();
-          return mcnt;
+          return dcnt;
         }
 
       /* Otherwise match next pattern command.  */
@@ -5311,11 +5291,11 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         /* Ignore these.  Used to ignore the n of succeed_n's which
            currently have n == 0.  */
         case no_op:
-          DEBUG_PRINT1 ("EXECUTING no_op.\n");
+          DEBUG_PRINT ("EXECUTING no_op.\n");
           break;
 
         case succeed:
-          DEBUG_PRINT1 ("EXECUTING succeed.\n");
+          DEBUG_PRINT ("EXECUTING succeed.\n");
           goto succeed_label;
 
         /* Match the next n pattern characters exactly.  The following
@@ -5323,7 +5303,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
            are the characters to match.  */
         case exactn:
           mcnt = *p++;
-          DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);
+          DEBUG_PRINT ("EXECUTING exactn %d.\n", mcnt);
 
           /* Remember the start point to rollback upon failure.  */
           dfail = d;
@@ -5429,7 +5409,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
             int buf_charlen;
             re_wchar_t buf_ch;
 
-            DEBUG_PRINT1 ("EXECUTING anychar.\n");
+            DEBUG_PRINT ("EXECUTING anychar.\n");
 
             PREFETCH ();
             buf_ch = RE_STRING_CHAR_AND_LENGTH (d, buf_charlen,
@@ -5442,7 +5422,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                     && buf_ch == '\000'))
               goto fail;
 
-            DEBUG_PRINT2 ("  Matched `%d'.\n", *d);
+            DEBUG_PRINT ("  Matched `%d'.\n", *d);
             d += buf_charlen;
           }
           break;
@@ -5469,7 +5449,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
             /* Whether matching against a unibyte character.  */
             boolean unibyte_char = false;
 
-            DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : "");
+            DEBUG_PRINT ("EXECUTING charset%s.\n", not ? "_not" : "");
 
             range_table_exists = CHARSET_RANGE_TABLE_EXISTS_P (&p[-1]);
 
@@ -5553,14 +5533,14 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
            matched within the group is recorded (in the internal
            registers data structure) under the register number.  */
         case start_memory:
-          DEBUG_PRINT2 ("EXECUTING start_memory %d:\n", *p);
+          DEBUG_PRINT ("EXECUTING start_memory %d:\n", *p);
 
           /* In case we need to undo this operation (via backtracking).  */
-          PUSH_FAILURE_REG ((unsigned int)*p);
+          PUSH_FAILURE_REG (*p);
 
           regstart[*p] = d;
           regend[*p] = NULL;    /* probably unnecessary.  -sm  */
-          DEBUG_PRINT2 ("  regstart: %d\n", POINTER_TO_OFFSET (regstart[*p]));
+          DEBUG_PRINT ("  regstart: %td\n", POINTER_TO_OFFSET (regstart[*p]));
 
           /* Move past the register number and inner group count.  */
           p += 1;
@@ -5570,7 +5550,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         /* The stop_memory opcode represents the end of a group.  Its
            argument is the same as start_memory's: the register number.  */
         case stop_memory:
-          DEBUG_PRINT2 ("EXECUTING stop_memory %d:\n", *p);
+          DEBUG_PRINT ("EXECUTING stop_memory %d:\n", *p);
 
           assert (!REG_UNSET (regstart[*p]));
           /* Strictly speaking, there should be code such as:
@@ -5588,7 +5568,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
              is *not* undone.  */
 
           regend[*p] = d;
-          DEBUG_PRINT2 ("      regend: %d\n", POINTER_TO_OFFSET (regend[*p]));
+          DEBUG_PRINT ("      regend: %td\n", POINTER_TO_OFFSET (regend[*p]));
 
           /* Move past the register number and the inner group count.  */
           p += 1;
@@ -5601,7 +5581,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           {
             register re_char *d2, *dend2;
             int regno = *p++;   /* Get which register to match against.  */
-            DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);
+            DEBUG_PRINT ("EXECUTING duplicate %d.\n", regno);
 
             /* Can't back reference a group which we've never matched.  */
             if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
@@ -5623,6 +5603,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                      ? regend[regno] : end_match_1);
             for (;;)
               {
+                ptrdiff_t dcnt;
+
                 /* If necessary, advance to next segment in register
                    contents.  */
                 while (d2 == dend2)
@@ -5641,23 +5623,23 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
                 PREFETCH ();
 
                 /* How many characters left in this segment to match.  */
-                mcnt = dend - d;
+                dcnt = dend - d;
 
                 /* Want how many consecutive characters we can match in
                    one shot, so, if necessary, adjust the count.  */
-                if (mcnt > dend2 - d2)
-                  mcnt = dend2 - d2;
+                if (dcnt > dend2 - d2)
+                  dcnt = dend2 - d2;
 
                 /* Compare that many; failure if mismatch, else move
                    past them.  */
                 if (RE_TRANSLATE_P (translate)
-                    ? bcmp_translate (d, d2, mcnt, translate, target_multibyte)
-                    : memcmp (d, d2, mcnt))
+                    ? bcmp_translate (d, d2, dcnt, translate, target_multibyte)
+                    : memcmp (d, d2, dcnt))
                   {
                     d = dfail;
                     goto fail;
                   }
-                d += mcnt, d2 += mcnt;
+                d += dcnt, d2 += dcnt;
               }
           }
           break;
@@ -5666,7 +5648,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         /* begline matches the empty string at the beginning of the string
            (unless `not_bol' is set in `bufp'), and after newlines.  */
         case begline:
-          DEBUG_PRINT1 ("EXECUTING begline.\n");
+          DEBUG_PRINT ("EXECUTING begline.\n");
 
           if (AT_STRINGS_BEG (d))
             {
@@ -5685,7 +5667,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
 
         /* endline is the dual of begline.  */
         case endline:
-          DEBUG_PRINT1 ("EXECUTING endline.\n");
+          DEBUG_PRINT ("EXECUTING endline.\n");
 
           if (AT_STRINGS_END (d))
             {
@@ -5702,7 +5684,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
 
         /* Match at the very beginning of the data.  */
         case begbuf:
-          DEBUG_PRINT1 ("EXECUTING begbuf.\n");
+          DEBUG_PRINT ("EXECUTING begbuf.\n");
           if (AT_STRINGS_BEG (d))
             break;
           goto fail;
@@ -5710,7 +5692,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
 
         /* Match at the very end of the data.  */
         case endbuf:
-          DEBUG_PRINT1 ("EXECUTING endbuf.\n");
+          DEBUG_PRINT ("EXECUTING endbuf.\n");
           if (AT_STRINGS_END (d))
             break;
           goto fail;
@@ -5734,8 +5716,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
            case; that seems worse than this.  */
         case on_failure_keep_string_jump:
           EXTRACT_NUMBER_AND_INCR (mcnt, p);
-          DEBUG_PRINT3 ("EXECUTING on_failure_keep_string_jump %d (to %p):\n",
-                        mcnt, p + mcnt);
+          DEBUG_PRINT ("EXECUTING on_failure_keep_string_jump %d (to %p):\n",
+                       mcnt, p + mcnt);
 
           PUSH_FAILURE_POINT (p - 3, NULL);
           break;
@@ -5756,8 +5738,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
              the loop.  */
         case on_failure_jump_nastyloop:
           EXTRACT_NUMBER_AND_INCR (mcnt, p);
-          DEBUG_PRINT3 ("EXECUTING on_failure_jump_nastyloop %d (to %p):\n",
-                        mcnt, p + mcnt);
+          DEBUG_PRINT ("EXECUTING on_failure_jump_nastyloop %d (to %p):\n",
+                       mcnt, p + mcnt);
 
           assert ((re_opcode_t)p[-4] == no_op);
           {
@@ -5777,8 +5759,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         case on_failure_jump_loop:
         on_failure:
           EXTRACT_NUMBER_AND_INCR (mcnt, p);
-          DEBUG_PRINT3 ("EXECUTING on_failure_jump_loop %d (to %p):\n",
-                        mcnt, p + mcnt);
+          DEBUG_PRINT ("EXECUTING on_failure_jump_loop %d (to %p):\n",
+                       mcnt, p + mcnt);
           {
             int cycle = 0;
             CHECK_INFINITE_LOOP (p - 3, d);
@@ -5809,8 +5791,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
            pop_failure_jump back to this on_failure_jump.  */
         case on_failure_jump:
           EXTRACT_NUMBER_AND_INCR (mcnt, p);
-          DEBUG_PRINT3 ("EXECUTING on_failure_jump %d (to %p):\n",
-                        mcnt, p + mcnt);
+          DEBUG_PRINT ("EXECUTING on_failure_jump %d (to %p):\n",
+                       mcnt, p + mcnt);
 
           PUSH_FAILURE_POINT (p -3, d);
           break;
@@ -5824,8 +5806,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
            on_failure_keep_string_jump instead of on_failure_jump.  */
         case on_failure_jump_smart:
           EXTRACT_NUMBER_AND_INCR (mcnt, p);
-          DEBUG_PRINT3 ("EXECUTING on_failure_jump_smart %d (to %p).\n",
-                        mcnt, p + mcnt);
+          DEBUG_PRINT ("EXECUTING on_failure_jump_smart %d (to %p).\n",
+                       mcnt, p + mcnt);
           {
             re_char *p1 = p; /* Next operation.  */
             /* Here, we discard `const', making re_match non-reentrant.  */
@@ -5845,14 +5827,14 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
             if (mutually_exclusive_p (bufp, p1, p2))
               {
                 /* Use a fast `on_failure_keep_string_jump' loop.  */
-                DEBUG_PRINT1 ("  smart exclusive => fast loop.\n");
+                DEBUG_PRINT ("  smart exclusive => fast loop.\n");
                 *p3 = (unsigned char) on_failure_keep_string_jump;
                 STORE_NUMBER (p2 - 2, mcnt + 3);
               }
             else
               {
                 /* Default to a safe `on_failure_jump' loop.  */
-                DEBUG_PRINT1 ("  smart default => slow loop.\n");
+                DEBUG_PRINT ("  smart default => slow loop.\n");
                 *p3 = (unsigned char) on_failure_jump;
               }
             DEBUG_STATEMENT (debug -= 2);
@@ -5864,9 +5846,9 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         unconditional_jump:
           IMMEDIATE_QUIT_CHECK;
           EXTRACT_NUMBER_AND_INCR (mcnt, p);    /* Get the amount to jump.  */
-          DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
+          DEBUG_PRINT ("EXECUTING jump %d ", mcnt);
           p += mcnt;                            /* Do the jump.  */
-          DEBUG_PRINT2 ("(to %p).\n", p);
+          DEBUG_PRINT ("(to %p).\n", p);
           break;
 
 
@@ -5875,7 +5857,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         case succeed_n:
           /* Signedness doesn't matter since we only compare MCNT to 0.  */
           EXTRACT_NUMBER (mcnt, p + 2);
-          DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);
+          DEBUG_PRINT ("EXECUTING succeed_n %d.\n", mcnt);
 
           /* Originally, mcnt is how many times we HAVE to succeed.  */
           if (mcnt != 0)
@@ -5894,7 +5876,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         case jump_n:
           /* Signedness doesn't matter since we only compare MCNT to 0.  */
           EXTRACT_NUMBER (mcnt, p + 2);
-          DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);
+          DEBUG_PRINT ("EXECUTING jump_n %d.\n", mcnt);
 
           /* Originally, this is how many times we CAN jump.  */
           if (mcnt != 0)
@@ -5913,14 +5895,14 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         case set_number_at:
           {
             unsigned char *p2;  /* Location of the counter.  */
-            DEBUG_PRINT1 ("EXECUTING set_number_at.\n");
+            DEBUG_PRINT ("EXECUTING set_number_at.\n");
 
             EXTRACT_NUMBER_AND_INCR (mcnt, p);
             /* Here, we discard `const', making re_match non-reentrant.  */
             p2 = (unsigned char*) p + mcnt;
             /* Signedness doesn't matter since we only copy MCNT's bits .  */
             EXTRACT_NUMBER_AND_INCR (mcnt, p);
-            DEBUG_PRINT3 ("  Setting %p to %d.\n", p2, mcnt);
+            DEBUG_PRINT ("  Setting %p to %d.\n", p2, mcnt);
             PUSH_NUMBER (p2, mcnt);
             break;
           }
@@ -5929,7 +5911,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         case notwordbound:
           {
             boolean not = (re_opcode_t) *(p - 1) == notwordbound;
-            DEBUG_PRINT2 ("EXECUTING %swordbound.\n", not?"not":"");
+            DEBUG_PRINT ("EXECUTING %swordbound.\n", not ? "not" : "");
 
             /* We SUCCEED (or FAIL) in one of the following cases: */
 
@@ -5971,7 +5953,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           }
 
         case wordbeg:
-          DEBUG_PRINT1 ("EXECUTING wordbeg.\n");
+          DEBUG_PRINT ("EXECUTING wordbeg.\n");
 
           /* We FAIL in one of the following cases: */
 
@@ -6016,7 +5998,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           break;
 
         case wordend:
-          DEBUG_PRINT1 ("EXECUTING wordend.\n");
+          DEBUG_PRINT ("EXECUTING wordend.\n");
 
           /* We FAIL in one of the following cases: */
 
@@ -6061,7 +6043,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           break;
 
         case symbeg:
-          DEBUG_PRINT1 ("EXECUTING symbeg.\n");
+          DEBUG_PRINT ("EXECUTING symbeg.\n");
 
           /* We FAIL in one of the following cases: */
 
@@ -6104,7 +6086,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           break;
 
         case symend:
-          DEBUG_PRINT1 ("EXECUTING symend.\n");
+          DEBUG_PRINT ("EXECUTING symend.\n");
 
           /* We FAIL in one of the following cases: */
 
@@ -6151,7 +6133,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           {
             boolean not = (re_opcode_t) *(p - 1) == notsyntaxspec;
             mcnt = *p++;
-            DEBUG_PRINT3 ("EXECUTING %ssyntaxspec %d.\n", not?"not":"", mcnt);
+            DEBUG_PRINT ("EXECUTING %ssyntaxspec %d.\n", not ? "not" : "",
+                         mcnt);
             PREFETCH ();
 #ifdef emacs
             {
@@ -6174,19 +6157,19 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
 
 #ifdef emacs
         case before_dot:
-          DEBUG_PRINT1 ("EXECUTING before_dot.\n");
+          DEBUG_PRINT ("EXECUTING before_dot.\n");
           if (PTR_BYTE_POS (d) >= PT_BYTE)
             goto fail;
           break;
 
         case at_dot:
-          DEBUG_PRINT1 ("EXECUTING at_dot.\n");
+          DEBUG_PRINT ("EXECUTING at_dot.\n");
           if (PTR_BYTE_POS (d) != PT_BYTE)
             goto fail;
           break;
 
         case after_dot:
-          DEBUG_PRINT1 ("EXECUTING after_dot.\n");
+          DEBUG_PRINT ("EXECUTING after_dot.\n");
           if (PTR_BYTE_POS (d) <= PT_BYTE)
             goto fail;
           break;
@@ -6196,8 +6179,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
           {
             boolean not = (re_opcode_t) *(p - 1) == notcategoryspec;
             mcnt = *p++;
-            DEBUG_PRINT3 ("EXECUTING %scategoryspec %d.\n",
-                          not?"not":"", mcnt);
+            DEBUG_PRINT ("EXECUTING %scategoryspec %d.\n",
+                         not ? "not" : "", mcnt);
             PREFETCH ();
 
             {
@@ -6226,7 +6209,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
         {
           re_char *str, *pat;
           /* A restart point is known.  Restore to that state.  */
-          DEBUG_PRINT1 ("\nFAIL:\n");
+          DEBUG_PRINT ("\nFAIL:\n");
           POP_FAILURE_POINT (str, pat);
           switch (*pat++)
             {
@@ -6271,7 +6254,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
   FREE_VARIABLES ();
 
   return -1;                            /* Failure to match.  */
-} /* re_match_2 */
+}
 
 /* Subroutine definitions for re_match_2.  */
 
diff --git a/src/unexelf.c b/src/unexelf.c
index d3659404f9c..4e50bb86367 100644
--- a/src/unexelf.c
+++ b/src/unexelf.c
@@ -388,16 +388,19 @@ temacs:
 #include <config.h>
 #include <unexec.h>
 
-extern void fatal (const char *msgid, ...);
+extern _Noreturn void fatal (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
 
-#include <sys/types.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <memory.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <sys/stat.h>
-#include <memory.h>
-#include <errno.h>
+#include <sys/types.h>
 #include <unistd.h>
-#include <fcntl.h>
+
 #if !defined (__NetBSD__) && !defined (__OpenBSD__)
 #include <elf.h>
 #endif /* not __NetBSD__ and not __OpenBSD__ */
@@ -519,6 +522,18 @@ typedef struct {
 # define ElfW(type) ElfExpandBitsW (ELFSIZE, type)
 #endif
 
+/* The code often converts ElfW (Half) values like e_shentsize to ptrdiff_t;
+   check that this doesn't lose information.  */
+#include <intprops.h>
+#include <verify.h>
+verify ((! TYPE_SIGNED (ElfW (Half))
+         || PTRDIFF_MIN <= TYPE_MINIMUM (ElfW (Half)))
+        && TYPE_MAXIMUM (ElfW (Half)) <= PTRDIFF_MAX);
+
+#ifdef UNEXELF_DEBUG
+# define DEBUG_LOG(expr) fprintf (stderr, #expr " 0x%jx\n", (uintmax_t) (expr))
+#endif
+
 /* Get the address of a particular section or program header entry,
  * accounting for the size of the entries.
  */
@@ -546,17 +561,21 @@ typedef struct {
    Apr 23, 1996
    */
 
+static void *
+entry_address (void *section_h, ptrdiff_t idx, ptrdiff_t entsize)
+{
+  char *h = section_h;
+  return h + idx * entsize;
+}
+
 #define OLD_SECTION_H(n) \
-     (*(ElfW (Shdr) *) ((byte *) old_section_h + old_file_h->e_shentsize * (n)))
+  (*(ElfW (Shdr) *) entry_address (old_section_h, n, old_file_h->e_shentsize))
 #define NEW_SECTION_H(n) \
-     (*(ElfW (Shdr) *) ((byte *) new_section_h + new_file_h->e_shentsize * (n)))
+  (*(ElfW (Shdr) *) entry_address (new_section_h, n, new_file_h->e_shentsize))
 #define NEW_PROGRAM_H(n) \
-     (*(ElfW (Phdr) *) ((byte *) new_program_h + new_file_h->e_phentsize * (n)))
+  (*(ElfW (Phdr) *) entry_address (new_program_h, n, new_file_h->e_phentsize))
 
-#define PATCH_INDEX(n) \
-  do { \
-         if ((int) (n) >= old_bss_index) \
-           (n)++; } while (0)
+#define PATCH_INDEX(n) ((n) += old_bss_index <= (n))
 typedef unsigned char byte;
 
 /* Round X up to a multiple of Y.  */
@@ -564,7 +583,7 @@ typedef unsigned char byte;
 static ElfW (Addr)
 round_up (ElfW (Addr) x, ElfW (Addr) y)
 {
-  int rem = x % y;
+  ElfW (Addr) rem = x % y;
   if (rem == 0)
     return x;
   return x - rem + y;
@@ -575,33 +594,28 @@ round_up (ElfW (Addr) x, ElfW (Addr) y)
    about the file we are looking in.
 
    If we don't find the section NAME, that is a fatal error
-   if NOERROR is 0; we return -1 if NOERROR is nonzero.  */
+   if NOERROR is false; return -1 if NOERROR is true.  */
 
-static int
+static ptrdiff_t
 find_section (const char *name, const char *section_names, const char *file_name,
-              ElfW (Ehdr) *old_file_h, ElfW (Shdr) *old_section_h, int noerror)
+              ElfW (Ehdr) *old_file_h, ElfW (Shdr) *old_section_h,
+              bool noerror)
 {
-  int idx;
+  ptrdiff_t idx;
 
   for (idx = 1; idx < old_file_h->e_shnum; idx++)
     {
-#ifdef DEBUG
-      fprintf (stderr, "Looking for %s - found %s\n", name,
-               section_names + OLD_SECTION_H (idx).sh_name);
+      char const *found_name = section_names + OLD_SECTION_H (idx).sh_name;
+#ifdef UNEXELF_DEBUG
+      fprintf (stderr, "Looking for %s - found %s\n", name, found_name);
 #endif
-      if (!strcmp (section_names + OLD_SECTION_H (idx).sh_name,
-                   name))
-        break;
-    }
-  if (idx == old_file_h->e_shnum)
-    {
-      if (noerror)
-        return -1;
-      else
-        fatal ("Can't find %s in %s.\n", name, file_name);
+      if (strcmp (name, found_name) == 0)
+        return idx;
     }
 
-  return idx;
+  if (! noerror)
+    fatal ("Can't find %s in %s", name, file_name);
+  return -1;
 }
 
 /* ****************************************************************
@@ -616,11 +630,9 @@ find_section (const char *name, const char *section_names, const char *file_name
 void
 unexec (const char *new_name, const char *old_name)
 {
-  int new_file, old_file, new_file_size;
-
-#if defined (emacs) || !defined (DEBUG)
+  int new_file, old_file;
+  off_t new_file_size;
   void *new_break;
-#endif
 
   /* Pointers to the base of the image of the two files.  */
   caddr_t old_base, new_base;
@@ -647,14 +659,15 @@ unexec (const char *new_name, const char *old_name)
   ElfW (Off)  old_bss_offset;
   ElfW (Word) new_data2_incr;
 
-  int n, nn;
-  int old_bss_index, old_sbss_index, old_plt_index;
-  int old_data_index, new_data2_index;
+  ptrdiff_t n, nn;
+  ptrdiff_t old_bss_index, old_sbss_index, old_plt_index;
+  ptrdiff_t old_data_index, new_data2_index;
 #if defined _SYSTYPE_SYSV || defined __sgi
-  int old_mdebug_index;
+  ptrdiff_t old_mdebug_index;
 #endif
   struct stat stat_buf;
-  int old_file_size;
+  off_t old_file_size;
+  int mask;
 
   /* Open the old file, allocate a buffer of the right size, and read
      in the file contents.  */
@@ -662,15 +675,15 @@ unexec (const char *new_name, const char *old_name)
   old_file = open (old_name, O_RDONLY);
 
   if (old_file < 0)
-    fatal ("Can't open %s for reading: errno %d\n", old_name, errno);
+    fatal ("Can't open %s for reading: %s", old_name, strerror (errno));
 
-  if (fstat (old_file, &stat_buf) == -1)
-    fatal ("Can't fstat (%s): errno %d\n", old_name, errno);
+  if (fstat (old_file, &stat_buf) != 0)
+    fatal ("Can't fstat (%s): %s", old_name, strerror (errno));
 
 #if MAP_ANON == 0
   mmap_fd = open ("/dev/zero", O_RDONLY);
   if (mmap_fd < 0)
-    fatal ("Can't open /dev/zero for reading: errno %d\n", errno, 0);
+    fatal ("Can't open /dev/zero for reading: %s", strerror (errno));
 #endif
 
   /* We cannot use malloc here because that may use sbrk.  If it does,
@@ -678,13 +691,15 @@ unexec (const char *new_name, const char *old_name)
      extra careful to use the correct value of sbrk(0) after
      allocating all buffers in the code below, which we aren't.  */
   old_file_size = stat_buf.st_size;
+  if (! (0 <= old_file_size && old_file_size <= SIZE_MAX))
+    fatal ("File size out of range");
   old_base = mmap (NULL, old_file_size, PROT_READ | PROT_WRITE,
                    MAP_ANON | MAP_PRIVATE, mmap_fd, 0);
   if (old_base == MAP_FAILED)
-    fatal ("Can't allocate buffer for %s\n", old_name, 0);
+    fatal ("Can't allocate buffer for %s: %s", old_name, strerror (errno));
 
-  if (read (old_file, old_base, stat_buf.st_size) != stat_buf.st_size)
-    fatal ("Didn't read all of %s: errno %d\n", old_name, errno);
+  if (read (old_file, old_base, old_file_size) != old_file_size)
+    fatal ("Didn't read all of %s: %s", old_name, strerror (errno));
 
   /* Get pointers to headers & section names */
 
@@ -755,12 +770,8 @@ unexec (const char *new_name, const char *old_name)
   old_data_index = find_section (".data", old_section_names,
                                  old_name, old_file_h, old_section_h, 0);
 
-#if defined (emacs) || !defined (DEBUG)
   new_break = sbrk (0);
   new_bss_addr = (ElfW (Addr)) new_break;
-#else
-  new_bss_addr = old_bss_addr + old_bss_size + 0x1234;
-#endif
   new_data2_addr = old_bss_addr;
   new_data2_size = new_bss_addr - old_bss_addr;
   new_data2_offset = OLD_SECTION_H (old_data_index).sh_offset
@@ -771,38 +782,38 @@ unexec (const char *new_name, const char *old_name)
      section) was unaligned.  */
   new_data2_incr = new_data2_size + (new_data2_offset - old_bss_offset);
 
-#ifdef DEBUG
-  fprintf (stderr, "old_bss_index %d\n", old_bss_index);
-  fprintf (stderr, "old_bss_addr %x\n", old_bss_addr);
-  fprintf (stderr, "old_bss_size %x\n", old_bss_size);
-  fprintf (stderr, "old_bss_offset %x\n", old_bss_offset);
-  fprintf (stderr, "new_bss_addr %x\n", new_bss_addr);
-  fprintf (stderr, "new_data2_addr %x\n", new_data2_addr);
-  fprintf (stderr, "new_data2_size %x\n", new_data2_size);
-  fprintf (stderr, "new_data2_offset %x\n", new_data2_offset);
-  fprintf (stderr, "new_data2_incr %x\n", new_data2_incr);
+#ifdef UNEXELF_DEBUG
+  fprintf (stderr, "old_bss_index %td\n", old_bss_index);
+  DEBUG_LOG (old_bss_addr);
+  DEBUG_LOG (old_bss_size);
+  DEBUG_LOG (old_bss_offset);
+  DEBUG_LOG (new_bss_addr);
+  DEBUG_LOG (new_data2_addr);
+  DEBUG_LOG (new_data2_size);
+  DEBUG_LOG (new_data2_offset);
+  DEBUG_LOG (new_data2_incr);
 #endif
 
-  if ((uintptr_t) new_bss_addr < (uintptr_t) old_bss_addr + old_bss_size)
-    fatal (".bss shrank when undumping???\n", 0, 0);
+  if (new_bss_addr < old_bss_addr + old_bss_size)
+    fatal (".bss shrank when undumping");
 
   /* Set the output file to the right size.  Allocate a buffer to hold
      the image of the new file.  Set pointers to various interesting
-     objects.  stat_buf still has old_file data.  */
+     objects.  */
 
   new_file = open (new_name, O_RDWR | O_CREAT, 0666);
   if (new_file < 0)
-    fatal ("Can't creat (%s): errno %d\n", new_name, errno);
+    fatal ("Can't creat (%s): %s", new_name, strerror (errno));
 
-  new_file_size = stat_buf.st_size + old_file_h->e_shentsize + new_data2_incr;
+  new_file_size = old_file_size + old_file_h->e_shentsize + new_data2_incr;
 
   if (ftruncate (new_file, new_file_size))
-    fatal ("Can't ftruncate (%s): errno %d\n", new_name, errno);
+    fatal ("Can't ftruncate (%s): %s", new_name, strerror (errno));
 
   new_base = mmap (NULL, new_file_size, PROT_READ | PROT_WRITE,
                    MAP_ANON | MAP_PRIVATE, mmap_fd, 0);
   if (new_base == MAP_FAILED)
-    fatal ("Can't allocate buffer for %s\n", old_name, 0);
+    fatal ("Can't allocate buffer for %s: %s", old_name, strerror (errno));
 
   new_file_h = (ElfW (Ehdr) *) new_base;
   new_program_h = (ElfW (Phdr) *) ((byte *) new_base + old_file_h->e_phoff);
@@ -825,11 +836,11 @@ unexec (const char *new_name, const char *old_name)
   new_file_h->e_shoff += new_data2_incr;
   new_file_h->e_shnum += 1;
 
-#ifdef DEBUG
-  fprintf (stderr, "Old section offset %x\n", old_file_h->e_shoff);
-  fprintf (stderr, "Old section count %d\n", old_file_h->e_shnum);
-  fprintf (stderr, "New section offset %x\n", new_file_h->e_shoff);
-  fprintf (stderr, "New section count %d\n", new_file_h->e_shnum);
+#ifdef UNEXELF_DEBUG
+  DEBUG_LOG (old_file_h->e_shoff);
+  fprintf (stderr, "Old section count %td\n", (ptrdiff_t) old_file_h->e_shnum);
+  DEBUG_LOG (new_file_h->e_shoff);
+  fprintf (stderr, "New section count %td\n", (ptrdiff_t) new_file_h->e_shnum);
 #endif
 
   /* Fix up a new program header.  Extend the writable data segment so
@@ -839,7 +850,7 @@ unexec (const char *new_name, const char *old_name)
      to adjust the offset and address of any segment that is above
      data2, just in case we decide to allow this later.  */
 
-  for (n = new_file_h->e_phnum - 1; n >= 0; n--)
+  for (n = new_file_h->e_phnum; --n >= 0; )
     {
       /* Compute maximum of all requirements for alignment of section.  */
       ElfW (Word) alignment = (NEW_PROGRAM_H (n)).p_align;
@@ -857,7 +868,7 @@ unexec (const char *new_name, const char *old_name)
           > (old_sbss_index == -1
              ? old_bss_addr
              : round_up (old_bss_addr, alignment)))
-          fatal ("Program segment above .bss in %s\n", old_name, 0);
+          fatal ("Program segment above .bss in %s", old_name);
 
       if (NEW_PROGRAM_H (n).p_type == PT_LOAD
           && (round_up ((NEW_PROGRAM_H (n)).p_vaddr
@@ -867,7 +878,7 @@ unexec (const char *new_name, const char *old_name)
         break;
     }
   if (n < 0)
-    fatal ("Couldn't find segment next to .bss in %s\n", old_name, 0);
+    fatal ("Couldn't find segment next to .bss in %s", old_name);
 
   /* Make sure that the size includes any padding before the old .bss
      section.  */
@@ -875,7 +886,7 @@ unexec (const char *new_name, const char *old_name)
   NEW_PROGRAM_H (n).p_memsz = NEW_PROGRAM_H (n).p_filesz;
 
 #if 0 /* Maybe allow section after data2 - does this ever happen? */
-  for (n = new_file_h->e_phnum - 1; n >= 0; n--)
+  for (n = new_file_h->e_phnum; --n >= 0; )
     {
       if (NEW_PROGRAM_H (n).p_vaddr
           && NEW_PROGRAM_H (n).p_vaddr >= new_data2_addr)
@@ -894,7 +905,7 @@ unexec (const char *new_name, const char *old_name)
 
   /* Walk through all section headers, insert the new data2 section right
      before the new bss section. */
-  for (n = 1, nn = 1; n < (int) old_file_h->e_shnum; n++, nn++)
+  for (n = 1, nn = 1; n < old_file_h->e_shnum; n++, nn++)
     {
       caddr_t src;
       /* If it is (s)bss section, insert the new data2 section before it.  */
@@ -1076,8 +1087,9 @@ temacs:
       if (NEW_SECTION_H (nn).sh_type == SHT_MIPS_DEBUG
           && old_mdebug_index != -1)
         {
-          int diff = NEW_SECTION_H (nn).sh_offset
-                - OLD_SECTION_H (old_mdebug_index).sh_offset;
+          ptrdiff_t new_offset = NEW_SECTION_H (nn).sh_offset;
+          ptrdiff_t old_offset = OLD_SECTION_H (old_mdebug_index).sh_offset;
+          ptrdiff_t diff = new_offset - old_offset;
           HDRR *phdr = (HDRR *)(NEW_SECTION_H (nn).sh_offset + new_base);
 
           if (diff)
@@ -1157,7 +1169,7 @@ temacs:
           || NEW_SECTION_H (nn).sh_type == SHT_DYNSYM)
         {
           ElfW (Shdr) *spt = &NEW_SECTION_H (nn);
-          unsigned int num = spt->sh_size / spt->sh_entsize;
+          ptrdiff_t num = spt->sh_size / spt->sh_entsize;
           ElfW (Sym) * sym = (ElfW (Sym) *) (NEW_SECTION_H (nn).sh_offset +
                                            new_base);
           for (; num--; sym++)
@@ -1173,7 +1185,7 @@ temacs:
     }
 
   /* Update the symbol values of _edata and _end.  */
-  for (n = new_file_h->e_shnum - 1; n; n--)
+  for (n = new_file_h->e_shnum; 0 < --n; )
     {
       byte *symnames;
       ElfW (Sym) *symp, *symendp;
@@ -1233,7 +1245,7 @@ temacs:
 
   /* This loop seeks out relocation sections for the data section, so
      that it can undo relocations performed by the runtime linker.  */
-  for (n = new_file_h->e_shnum - 1; n; n--)
+  for (n = new_file_h->e_shnum; 0 < --n; )
     {
       ElfW (Shdr) section = NEW_SECTION_H (n);
 
@@ -1293,8 +1305,8 @@ temacs:
   /* Write out new_file, and free the buffers.  */
 
   if (write (new_file, new_base, new_file_size) != new_file_size)
-    fatal ("Didn't write %d bytes to %s: errno %d\n",
-           new_file_size, new_name, errno);
+    fatal ("Didn't write %lu bytes to %s: %s",
+           (unsigned long) new_file_size, new_name, strerror (errno));
   munmap (old_base, old_file_size);
   munmap (new_base, new_file_size);
 
@@ -1304,18 +1316,18 @@ temacs:
   close (mmap_fd);
 #endif
 
-  if (close (old_file))
-    fatal ("Can't close (%s): errno %d\n", old_name, errno);
+  if (close (old_file) != 0)
+    fatal ("Can't close (%s): %s", old_name, strerror (errno));
 
-  if (close (new_file))
-    fatal ("Can't close (%s): errno %d\n", new_name, errno);
+  if (close (new_file) != 0)
+    fatal ("Can't close (%s): %s", new_name, strerror (errno));
 
-  if (stat (new_name, &stat_buf) == -1)
-    fatal ("Can't stat (%s): errno %d\n", new_name, errno);
+  if (stat (new_name, &stat_buf) != 0)
+    fatal ("Can't stat (%s): %s", new_name, strerror (errno));
 
-  n = umask (777);
-  umask (n);
-  stat_buf.st_mode |= 0111 & ~n;
-  if (chmod (new_name, stat_buf.st_mode) == -1)
-    fatal ("Can't chmod (%s): errno %d\n", new_name, errno);
+  mask = umask (777);
+  umask (mask);
+  stat_buf.st_mode |= 0111 & ~mask;
+  if (chmod (new_name, stat_buf.st_mode) != 0)
+    fatal ("Can't chmod (%s): %s", new_name, strerror (errno));
 }
diff --git a/src/w32fns.c b/src/w32fns.c
index 0785e685e6a..d7ac0dd1a6c 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3183,28 +3183,9 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
           form.ptCurrentPos.y = w32_system_caret_y;
 
           form.rcArea.left = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, 0);
-
-#ifdef ENABLE_CHECKING
-          /* Temporary code to catch crashes in computing form.rcArea.top.  */
-          eassert (FRAMEP (w->frame));
-          eassert (BUFFERP (w->contents));
-          {
-            int wmbp = WINDOW_MENU_BAR_P (w);
-            int wtbp = WINDOW_TOOL_BAR_P (w);
-            struct frame *wf = WINDOW_XFRAME (w);
-            int fibw = FRAME_INTERNAL_BORDER_WIDTH (wf);
-            int wtel = WINDOW_TOP_EDGE_LINE (w);
-            int wflh = FRAME_LINE_HEIGHT (wf);
-            int wwhlp= WINDOW_WANTS_HEADER_LINE_P (w);
-            int chlh = CURRENT_HEADER_LINE_HEIGHT (w);
-            int whlh = (wwhlp ? chlh : 0);
-
-            form.rcArea.top = ((wmbp || wtbp) ? 0 : fibw) + wtel * wflh + whlh;
-          }
-#else
-          form.rcArea.top = (WINDOW_TOP_EDGE_Y (w)
-                             + WINDOW_HEADER_LINE_HEIGHT (w));
-#endif
+          form.rcArea.top = WINDOW_TOP_EDGE_Y (w);
+          if (BUFFERP (w->contents))
+            form.rcArea.top += WINDOW_HEADER_LINE_HEIGHT (w);
           form.rcArea.right = (WINDOW_BOX_RIGHT_EDGE_X (w)
                                - WINDOW_RIGHT_MARGIN_WIDTH (w)
                                - WINDOW_RIGHT_FRINGE_WIDTH (w));
diff --git a/src/xdisp.c b/src/xdisp.c
index 41214880a56..0a79e6fd891 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -794,6 +794,7 @@ static void set_iterator_to_next (struct it *, int);
 static void mark_window_display_accurate_1 (struct window *, int);
 static int single_display_spec_string_p (Lisp_Object, Lisp_Object);
 static int display_prop_string_p (Lisp_Object, Lisp_Object);
+static int row_for_charpos_p (struct glyph_row *, ptrdiff_t);
 static int cursor_row_p (struct glyph_row *);
 static int redisplay_mode_lines (Lisp_Object, int);
 static char *decode_mode_spec_coding (Lisp_Object, char *, int);
@@ -1392,23 +1393,34 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
               Lisp_Object cpos = make_number (charpos);
               Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
               Lisp_Object string = string_from_display_spec (spec);
+              struct text_pos tpos;
+              int replacing_spec_p;
               bool newline_in_string
                 = (STRINGP (string)
                    && memchr (SDATA (string), '\n', SBYTES (string)));
+
+              SET_TEXT_POS (tpos, charpos, CHAR_TO_BYTE (charpos));
+              replacing_spec_p
+                = (!NILP (spec)
+                   && handle_display_spec (NULL, spec, Qnil, Qnil, &tpos,
+                                           charpos, FRAME_WINDOW_P (it.f)));
               /* The tricky code below is needed because there's a
                  discrepancy between move_it_to and how we set cursor
-                 when the display line ends in a newline from a
-                 display string.  move_it_to will stop _after_ such
-                 display strings, whereas set_cursor_from_row
-                 conspires with cursor_row_p to place the cursor on
-                 the first glyph produced from the display string.  */
+                 when PT is at the beginning of a portion of text
+                 covered by a display property or an overlay with a
+                 display property, or the display line ends in a
+                 newline from a display string.  move_it_to will stop
+                 _after_ such display strings, whereas
+                 set_cursor_from_row conspires with cursor_row_p to
+                 place the cursor on the first glyph produced from the
+                 display string.  */
 
               /* We have overshoot PT because it is covered by a
-                 display property whose value is a string.  If the
-                 string includes embedded newlines, we are also in the
-                 wrong display line.  Backtrack to the correct line,
-                 where the display string begins.  */
-              if (newline_in_string)
+                 display property that replaces the text it covers.
+                 If the string includes embedded newlines, we are also
+                 in the wrong display line.  Backtrack to the correct
+                 line, where the display property begins.  */
+              if (replacing_spec_p)
                 {
                   Lisp_Object startpos, endpos;
                   EMACS_INT start, end;
@@ -1434,7 +1446,8 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                      rightmost character on a line that is
                      continued or word-wrapped.  */
                   if (it3.method == GET_FROM_BUFFER
-                      && it3.c == '\n')
+                      && (it3.c == '\n'
+                          || FETCH_BYTE (IT_BYTEPOS (it3)) == '\n'))
                     move_it_by_lines (&it3, 1);
                   else if (move_it_in_display_line_to (&it3, -1,
                                                        it3.current_x
@@ -1502,6 +1515,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                      produced from the string, until we find the
                      rightmost glyph not from the string.  */
                   if (it3_moved
+                      && newline_in_string
                       && IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
                     {
                       struct glyph *g = it3.glyph_row->glyphs[TEXT_AREA]
@@ -7153,6 +7167,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
           else if (it->dpvec_char_len > 0)
             {
               if (it->method == GET_FROM_STRING
+                  && it->current.overlay_string_index >= 0
                   && it->n_overlay_strings > 0)
                 it->ignore_overlay_strings_at_pos_p = 1;
               it->len = it->dpvec_char_len;
@@ -16895,10 +16910,9 @@ row_containing_pos (struct window *w, ptrdiff_t charpos,
              || (MATRIX_ROW_END_CHARPOS (row) == charpos
                  /* The end position of a row equals the start
                     position of the next row.  If CHARPOS is there, we
-                    would rather display it in the next line, except
-                    when this line ends in ZV.  */
-                 && !row->ends_at_zv_p
-                 && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
+                    would rather consider it displayed in the next
+                    line, except when this line ends in ZV.  */
+                 && !row_for_charpos_p (row, charpos)))
           && charpos >= MATRIX_ROW_START_CHARPOS (row))
         {
           struct glyph *g;
@@ -16906,10 +16920,10 @@ row_containing_pos (struct window *w, ptrdiff_t charpos,
           if (NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
               || (!best_row && !row->continued_p))
             return row;
-          /* In bidi-reordered rows, there could be several rows
-             occluding point, all of them belonging to the same
-             continued line.  We need to find the row which fits
-             CHARPOS the best.  */
+          /* In bidi-reordered rows, there could be several rows whose
+             edges surround CHARPOS, all of these rows belonging to
+             the same continued line.  We need to find the row which
+             fits CHARPOS the best.  */
           for (g = row->glyphs[TEXT_AREA];
                g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
                g++)
@@ -18713,15 +18727,15 @@ highlight_trailing_whitespace (struct frame *f, struct glyph_row *row)
 
 
 /* Value is non-zero if glyph row ROW should be
-   used to hold the cursor.  */
+   considered to hold the buffer position CHARPOS.  */
 
 static int
-cursor_row_p (struct glyph_row *row)
+row_for_charpos_p (struct glyph_row *row, ptrdiff_t charpos)
 {
   int result = 1;
 
-  if (PT == CHARPOS (row->end.pos)
-      || PT == MATRIX_ROW_END_CHARPOS (row))
+  if (charpos == CHARPOS (row->end.pos)
+      || charpos == MATRIX_ROW_END_CHARPOS (row))
     {
       /* Suppose the row ends on a string.
          Unless the row is continued, that means it ends on a newline
@@ -18747,7 +18761,7 @@ cursor_row_p (struct glyph_row *row)
                 if (STRINGP (glyph->object))
                   {
                     Lisp_Object prop
-                      = Fget_char_property (make_number (PT),
+                      = Fget_char_property (make_number (charpos),
                                             Qdisplay, Qnil);
                     result =
                       (!NILP (prop)
@@ -18801,6 +18815,15 @@ cursor_row_p (struct glyph_row *row)
   return result;
 }
 
+/* Value is non-zero if glyph row ROW should be
+   used to hold the cursor.  */
+
+static int
+cursor_row_p (struct glyph_row *row)
+{
+  return row_for_charpos_p (row, PT);
+}
+
 
 
 /* Push the property PROP so that it will be rendered at the current
diff --git a/src/xfns.c b/src/xfns.c
index f4c24cb09a0..46cd10e5f2f 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -59,6 +59,13 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "xsettings.h"
 
+#ifdef HAVE_XRANDR
+#include <X11/extensions/Xrandr.h>
+#endif
+#ifdef HAVE_XINERAMA
+#include <X11/extensions/Xinerama.h>
+#endif
+
 #ifdef USE_GTK
 #include "gtkutil.h"
 #endif
@@ -126,6 +133,7 @@ extern LWLIB_ID widget_id_tick;
 static Lisp_Object Qsuppress_icon;
 static Lisp_Object Qundefined_color;
 static Lisp_Object Qcompound_text, Qcancel_timer;
+static Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
 Lisp_Object Qfont_param;
 
 #ifdef GLYPH_DEBUG
@@ -3791,6 +3799,575 @@ If omitted or nil, that stands for the selected frame's display.  */)
   else
     return Qnil;
 }
+
+/* Store the geometry of the workarea on display DPYINFO into *RECT.
+   Return false if and only if the workarea information cannot be
+   obtained via the _NET_WORKAREA root window property.  */
+
+#if ! GTK_CHECK_VERSION (3, 4, 0)
+static bool
+x_get_net_workarea (struct x_display_info *dpyinfo, XRectangle *rect)
+{
+  Display *dpy = dpyinfo->display;
+  long offset, max_len;
+  Atom target_type, actual_type;
+  unsigned long actual_size, bytes_remaining;
+  int rc, actual_format;
+  unsigned char *tmp_data = NULL;
+  bool result = false;
+
+  x_catch_errors (dpy);
+  offset = 0;
+  max_len = 1;
+  target_type = XA_CARDINAL;
+  rc = XGetWindowProperty (dpy, dpyinfo->root_window,
+                           dpyinfo->Xatom_net_current_desktop,
+                           offset, max_len, False, target_type,
+                           &actual_type, &actual_format, &actual_size,
+                           &bytes_remaining, &tmp_data);
+  if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
+      && actual_format == 32 && actual_size == max_len)
+    {
+      long current_desktop = ((long *) tmp_data)[0];
+
+      XFree (tmp_data);
+      tmp_data = NULL;
+
+      offset = 4 * current_desktop;
+      max_len = 4;
+      rc = XGetWindowProperty (dpy, dpyinfo->root_window,
+                               dpyinfo->Xatom_net_workarea,
+                               offset, max_len, False, target_type,
+                               &actual_type, &actual_format, &actual_size,
+                               &bytes_remaining, &tmp_data);
+      if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
+          && actual_format == 32 && actual_size == max_len)
+        {
+          long *values = (long *) tmp_data;
+
+          rect->x = values[0];
+          rect->y = values[1];
+          rect->width = values[2];
+          rect->height = values[3];
+
+          XFree (tmp_data);
+          tmp_data = NULL;
+
+          result = true;
+        }
+    }
+  if (tmp_data)
+    XFree (tmp_data);
+  x_uncatch_errors ();
+
+  return result;
+}
+#endif
+
+#ifndef USE_GTK
+
+struct MonitorInfo {
+  XRectangle geom, work;
+  int mm_width, mm_height;
+  char *name;
+};
+
+#if defined HAVE_XINERAMA || defined HAVE_XRANDR
+static void
+free_monitors (struct MonitorInfo *monitors, int n_monitors)
+{
+  int i;
+  for (i = 0; i < n_monitors; ++i)
+    xfree (monitors[i].name);
+  xfree (monitors);
+}
+#endif /* HAVE_XINERAMA || HAVE_XRANDR */
+
+
+/* Return monitor number where F is "most" or closest to.  */
+static int
+x_get_monitor_for_frame (struct frame *f,
+                         struct MonitorInfo *monitors,
+                         int n_monitors)
+{
+  XRectangle frect;
+  int area = 0, dist = -1;
+  int best_area = -1, best_dist = -1;
+  int i;
+
+  if (n_monitors == 1) return 0;
+  frect.x = f->left_pos;
+  frect.y = f->top_pos;
+  frect.width = FRAME_PIXEL_WIDTH (f);
+  frect.height = FRAME_PIXEL_HEIGHT (f);
+
+  for (i = 0; i < n_monitors; ++i)
+    {
+      struct MonitorInfo *mi = &monitors[i];
+      XRectangle res;
+      int a = 0;
+
+      if (mi->geom.width == 0) continue;
+
+      if (x_intersect_rectangles (&mi->geom, &frect, &res))
+        {
+          a = res.width * res.height;
+          if (a > area)
+            {
+              area = a;
+              best_area = i;
+            }
+        }
+
+      if (a == 0 && area == 0)
+        {
+          int dx, dy, d;
+          if (frect.x + frect.width < mi->geom.x)
+            dx = mi->geom.x - frect.x + frect.width;
+          else if (frect.x > mi->geom.x + mi->geom.width)
+            dx = frect.x - mi->geom.x + mi->geom.width;
+          else
+            dx = 0;
+          if (frect.y + frect.height < mi->geom.y)
+            dy = mi->geom.y - frect.y + frect.height;
+          else if (frect.y > mi->geom.y + mi->geom.height)
+            dy = frect.y - mi->geom.y + mi->geom.height;
+          else
+            dy = 0;
+
+          d = dx*dx + dy*dy;
+          if (dist == -1 || dist > d)
+            {
+              dist = d;
+              best_dist = i;
+            }
+        }
+    }
+
+  return best_area != -1 ? best_area : (best_dist != -1 ? best_dist : 0);
+}
+
+static Lisp_Object
+x_make_monitor_attribute_list (struct MonitorInfo *monitors,
+                               int n_monitors,
+                               int primary_monitor,
+                               struct x_display_info *dpyinfo,
+                               const char *source)
+{
+  Lisp_Object monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
+  Lisp_Object frame, rest, attributes_list = Qnil;
+  Lisp_Object primary_monitor_attributes = Qnil;
+  int i;
+
+  FOR_EACH_FRAME (rest, frame)
+    {
+      struct frame *f = XFRAME (frame);
+
+      if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo
+          && !EQ (frame, tip_frame))
+        {
+          i = x_get_monitor_for_frame (f, monitors, n_monitors);
+          ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
+        }
+    }
+
+  for (i = 0; i < n_monitors; ++i)
+    {
+      Lisp_Object geometry, workarea, attributes = Qnil;
+      struct MonitorInfo *mi = &monitors[i];
+
+      if (mi->geom.width == 0) continue;
+
+      workarea = list4i (mi->work.x, mi->work.y,
+                         mi->work.width, mi->work.height);
+      geometry = list4i (mi->geom.x, mi->geom.y,
+                         mi->geom.width, mi->geom.height);
+      attributes = Fcons (Fcons (Qsource,
+                                 make_string (source, strlen (source))),
+                          attributes);
+      attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
+                          attributes);
+      attributes = Fcons (Fcons (Qmm_size,
+                                 list2i (mi->mm_width, mi->mm_height)),
+                          attributes);
+      attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
+      attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
+      if (mi->name)
+        attributes = Fcons (Fcons (Qname, make_string (mi->name,
+                                                       strlen (mi->name))),
+                            attributes);
+
+      if (i == primary_monitor)
+        primary_monitor_attributes = attributes;
+      else
+        attributes_list = Fcons (attributes, attributes_list);
+    }
+
+  if (!NILP (primary_monitor_attributes))
+    attributes_list = Fcons (primary_monitor_attributes, attributes_list);
+  return attributes_list;
+}
+
+static Lisp_Object
+x_get_monitor_attributes_fallback (struct x_display_info *dpyinfo)
+{
+  struct MonitorInfo monitor;
+  XRectangle workarea_r;
+
+  /* Fallback: treat (possibly) multiple physical monitors as if they
+     formed a single monitor as a whole.  This should provide a
+     consistent result at least on single monitor environments.  */
+  monitor.geom.x = monitor.geom.y = 0;
+  monitor.geom.width = x_display_pixel_width (dpyinfo);
+  monitor.geom.height = x_display_pixel_height (dpyinfo);
+  monitor.mm_width = WidthMMOfScreen (dpyinfo->screen);
+  monitor.mm_height = HeightMMOfScreen (dpyinfo->screen);
+  monitor.name = xstrdup ("combined screen");
+
+  if (x_get_net_workarea (dpyinfo, &workarea_r))
+    monitor.work = workarea_r;
+  else
+    monitor.work = monitor.geom;
+  return x_make_monitor_attribute_list (&monitor, 1, 0, dpyinfo, "fallback");
+}
+
+
+#ifdef HAVE_XINERAMA
+static Lisp_Object
+x_get_monitor_attributes_xinerama (struct x_display_info *dpyinfo)
+{
+  int n_monitors, i;
+  Lisp_Object attributes_list = Qnil;
+  Display *dpy = dpyinfo->display;
+  XineramaScreenInfo *info = XineramaQueryScreens (dpy, &n_monitors);
+  struct MonitorInfo *monitors;
+  double mm_width_per_pixel, mm_height_per_pixel;
+
+  if (! info || n_monitors == 0)
+    {
+      if (info)
+        XFree (info);
+      return attributes_list;
+    }
+
+  mm_width_per_pixel = ((double) WidthMMOfScreen (dpyinfo->screen)
+                        / x_display_pixel_width (dpyinfo));
+  mm_height_per_pixel = ((double) HeightMMOfScreen (dpyinfo->screen)
+                         / x_display_pixel_height (dpyinfo));
+  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+  for (i = 0; i < n_monitors; ++i)
+    {
+      struct MonitorInfo *mi = &monitors[i];
+      XRectangle workarea_r;
+
+      mi->geom.x = info[i].x_org;
+      mi->geom.y = info[i].y_org;
+      mi->geom.width = info[i].width;
+      mi->geom.height = info[i].height;
+      mi->mm_width = mi->geom.width * mm_width_per_pixel + 0.5;
+      mi->mm_height = mi->geom.height * mm_height_per_pixel + 0.5;
+      mi->name = 0;
+
+      /* Xinerama usually have primary monitor first, just use that.  */
+      if (i == 0 && x_get_net_workarea (dpyinfo, &workarea_r))
+        {
+          mi->work = workarea_r;
+          if (! x_intersect_rectangles (&mi->geom, &mi->work, &mi->work))
+            mi->work = mi->geom;
+        }
+      else
+        mi->work = mi->geom;
+    }
+  XFree (info);
+
+  attributes_list = x_make_monitor_attribute_list (monitors,
+                                                   n_monitors,
+                                                   0,
+                                                   dpyinfo,
+                                                   "Xinerama");
+  free_monitors (monitors, n_monitors);
+  return attributes_list;
+}
+#endif /* HAVE_XINERAMA */
+
+
+#ifdef HAVE_XRANDR
+static Lisp_Object
+x_get_monitor_attributes_xrandr (struct x_display_info *dpyinfo)
+{
+  Lisp_Object attributes_list = Qnil;
+  XRRScreenResources *resources;
+  Display *dpy = dpyinfo->display;
+  int i, n_monitors, primary = -1;
+  RROutput pxid = None;
+  struct MonitorInfo *monitors;
+
+#ifdef HAVE_XRRGETSCREENRESOURCESCURRENT
+  resources = XRRGetScreenResourcesCurrent (dpy, dpyinfo->root_window);
+#else
+  resources = XRRGetScreenResources (dpy, dpyinfo->root_window);
+#endif
+  if (! resources || resources->noutput == 0)
+    {
+      if (resources)
+        XRRFreeScreenResources (resources);
+      return Qnil;
+    }
+  n_monitors = resources->noutput;
+  monitors = (struct MonitorInfo *) xzalloc (n_monitors * sizeof (*monitors));
+
+#ifdef HAVE_XRRGETOUTPUTPRIMARY
+  pxid = XRRGetOutputPrimary (dpy, dpyinfo->root_window);
+#endif
+
+  for (i = 0; i < n_monitors; ++i)
+    {
+      XRROutputInfo *info = XRRGetOutputInfo (dpy, resources,
+                                              resources->outputs[i]);
+      Connection conn = info ? info->connection : RR_Disconnected;
+      RRCrtc id = info ? info->crtc : None;
+
+      if (strcmp (info->name, "default") == 0)
+        {
+          /* Non XRandr 1.2 driver, does not give useful data.  */
+          XRRFreeOutputInfo (info);
+          XRRFreeScreenResources (resources);
+          free_monitors (monitors, n_monitors);
+          return Qnil;
+        }
+
+      if (conn != RR_Disconnected && id != None)
+        {
+          XRRCrtcInfo *crtc = XRRGetCrtcInfo (dpy, resources, id);
+          struct MonitorInfo *mi = &monitors[i];
+          XRectangle workarea_r;
+
+          if (! crtc)
+            {
+              XRRFreeOutputInfo (info);
+              continue;
+            }
+
+          mi->geom.x = crtc->x;
+          mi->geom.y = crtc->y;
+          mi->geom.width = crtc->width;
+          mi->geom.height = crtc->height;
+          mi->mm_width = info->mm_width;
+          mi->mm_height = info->mm_height;
+          mi->name = xstrdup (info->name);
+
+          if (pxid != None && pxid == resources->outputs[i])
+            primary = i;
+          else if (primary == -1 && strcmp (info->name, "LVDS") == 0)
+            primary = i;
+
+          if (i == primary && x_get_net_workarea (dpyinfo, &workarea_r))
+            {
+              mi->work= workarea_r;
+              if (! x_intersect_rectangles (&mi->geom, &mi->work, &mi->work))
+                mi->work = mi->geom;
+            }
+          else
+            mi->work = mi->geom;
+
+          XRRFreeCrtcInfo (crtc);
+        }
+      XRRFreeOutputInfo (info);
+    }
+  XRRFreeScreenResources (resources);
+
+  attributes_list = x_make_monitor_attribute_list (monitors,
+                                                   n_monitors,
+                                                   primary,
+                                                   dpyinfo,
+                                                   "XRandr");
+  free_monitors (monitors, n_monitors);
+  return attributes_list;
+}
+#endif /* HAVE_XRANDR */
+
+static Lisp_Object
+x_get_monitor_attributes (struct x_display_info *dpyinfo)
+{
+  Lisp_Object attributes_list = Qnil;
+  Display *dpy = dpyinfo->display;
+
+#ifdef HAVE_XRANDR
+  int xrr_event_base, xrr_error_base;
+  bool xrr_ok = false;
+  xrr_ok = XRRQueryExtension (dpy, &xrr_event_base, &xrr_error_base);
+  if (xrr_ok)
+    {
+      int xrr_major, xrr_minor;
+      XRRQueryVersion (dpy, &xrr_major, &xrr_minor);
+      xrr_ok = (xrr_major == 1 && xrr_minor >= 2) || xrr_major > 1;
+    }
+
+  if (xrr_ok)
+    attributes_list = x_get_monitor_attributes_xrandr (dpyinfo);
+#endif /* HAVE_XRANDR */
+
+#ifdef HAVE_XINERAMA
+  if (NILP (attributes_list))
+    {
+      int xin_event_base, xin_error_base;
+      bool xin_ok = false;
+      xin_ok = XineramaQueryExtension (dpy, &xin_event_base, &xin_error_base);
+      if (xin_ok && XineramaIsActive (dpy))
+        attributes_list = x_get_monitor_attributes_xinerama (dpyinfo);
+    }
+#endif /* HAVE_XINERAMA */
+
+  if (NILP (attributes_list))
+    attributes_list = x_get_monitor_attributes_fallback (dpyinfo);
+
+  return attributes_list;
+}
+
+#endif /* !USE_GTK */
+
+DEFUN ("x-display-monitor-attributes-list", Fx_display_monitor_attributes_list,
+       Sx_display_monitor_attributes_list,
+       0, 1, 0,
+       doc: /* Return a list of physical monitor attributes on the X display TERMINAL.
+
+The optional argument TERMINAL specifies which display to ask about.
+TERMINAL should be a terminal object, a frame or a display name (a string).
+If omitted or nil, that stands for the selected frame's display.
+
+In addition to the standard attribute keys listed in
+`display-monitor-attributes-list', the following keys are contained in
+the attributes:
+
+ source -- String describing the source from which multi-monitor
+           information is obtained, one of \"Gdk\", \"XRandr\",
+           \"Xinerama\", or \"fallback\"
+
+Internal use only, use `display-monitor-attributes-list' instead.  */)
+  (Lisp_Object terminal)
+{
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
+  Lisp_Object attributes_list = Qnil;
+
+#ifdef USE_GTK
+  double mm_width_per_pixel, mm_height_per_pixel;
+  GdkDisplay *gdpy;
+  GdkScreen *gscreen;
+  gint primary_monitor = 0, n_monitors, i;
+  Lisp_Object primary_monitor_attributes = Qnil;
+  Lisp_Object monitor_frames, rest, frame;
+  static const char *source = "Gdk";
+
+  block_input ();
+  mm_width_per_pixel = ((double) WidthMMOfScreen (dpyinfo->screen)
+                        / x_display_pixel_width (dpyinfo));
+  mm_height_per_pixel = ((double) HeightMMOfScreen (dpyinfo->screen)
+                         / x_display_pixel_height (dpyinfo));
+  gdpy = gdk_x11_lookup_xdisplay (dpyinfo->display);
+  gscreen = gdk_display_get_default_screen (gdpy);
+#if GTK_CHECK_VERSION (2, 20, 0)
+  primary_monitor = gdk_screen_get_primary_monitor (gscreen);
+#endif
+  n_monitors = gdk_screen_get_n_monitors (gscreen);
+  monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
+  FOR_EACH_FRAME (rest, frame)
+    {
+      struct frame *f = XFRAME (frame);
+
+      if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo
+          && !EQ (frame, tip_frame))
+        {
+          GdkWindow *gwin = gtk_widget_get_window (FRAME_GTK_WIDGET (f));
+
+          i = gdk_screen_get_monitor_at_window (gscreen, gwin);
+          ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
+        }
+    }
+
+  i = n_monitors;
+  while (i-- > 0)
+    {
+      Lisp_Object geometry, workarea, attributes = Qnil;
+      gint width_mm = -1, height_mm = -1;
+      GdkRectangle rec;
+
+      attributes = Fcons (Fcons (Qsource,
+                                 make_string (source, strlen (source))),
+                          attributes);
+      attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
+                          attributes);
+
+      gdk_screen_get_monitor_geometry (gscreen, i, &rec);
+      geometry = list4i (rec.x, rec.y, rec.width, rec.height);
+
+#if GTK_CHECK_VERSION (2, 14, 0)
+      width_mm = gdk_screen_get_monitor_width_mm (gscreen, i);
+      height_mm = gdk_screen_get_monitor_height_mm (gscreen, i);
+#endif
+      if (width_mm < 0)
+        width_mm = rec.width * mm_width_per_pixel + 0.5;
+      if (height_mm < 0)
+        height_mm = rec.height * mm_height_per_pixel + 0.5;
+      attributes = Fcons (Fcons (Qmm_size,
+                                 list2i (width_mm, height_mm)),
+                          attributes);
+
+#if GTK_CHECK_VERSION (3, 4, 0)
+      gdk_screen_get_monitor_workarea (gscreen, i, &rec);
+      workarea = list4i (rec.x, rec.y, rec.width, rec.height);
+#else
+      /* Emulate the behavior of GTK+ 3.4.  */
+      {
+        XRectangle workarea_r;
+
+        workarea = Qnil;
+        if (i == primary_monitor && x_get_net_workarea (dpyinfo, &workarea_r))
+          {
+            GdkRectangle work;
+
+            work.x = workarea_r.x;
+            work.y = workarea_r.y;
+            work.width = workarea_r.width;
+            work.height = workarea_r.height;
+            if (gdk_rectangle_intersect (&rec, &work, &work))
+              workarea = list4i (work.x, work.y, work.width, work.height);
+          }
+        if (NILP (workarea))
+          workarea = geometry;
+      }
+#endif
+      attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
+
+      attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
+#if GTK_CHECK_VERSION (2, 14, 0)
+      {
+        char *name = gdk_screen_get_monitor_plug_name (gscreen, i);
+        if (name)
+          attributes = Fcons (Fcons (Qname, make_string (name, strlen (name))),
+                              attributes);
+      }
+#endif
+
+      if (i == primary_monitor)
+        primary_monitor_attributes = attributes;
+      else
+        attributes_list = Fcons (attributes, attributes_list);
+    }
+
+  if (!NILP (primary_monitor_attributes))
+    attributes_list = Fcons (primary_monitor_attributes, attributes_list);
+  unblock_input ();
+#else  /* not USE_GTK */
+
+  block_input ();
+  attributes_list = x_get_monitor_attributes (dpyinfo);
+  unblock_input ();
+
+#endif  /* not USE_GTK */
+
+  return attributes_list;
+}
+
 
 int
 x_pixel_width (register struct frame *f)
@@ -5701,6 +6278,11 @@ syms_of_xfns (void)
   DEFSYM (Qundefined_color, "undefined-color");
   DEFSYM (Qcompound_text, "compound-text");
   DEFSYM (Qcancel_timer, "cancel-timer");
+  DEFSYM (Qgeometry, "geometry");
+  DEFSYM (Qworkarea, "workarea");
+  DEFSYM (Qmm_size, "mm-size");
+  DEFSYM (Qframes, "frames");
+  DEFSYM (Qsource, "source");
   DEFSYM (Qfont_param, "font-parameter");
   /* This is the end of symbol initialization.  */
 
@@ -5864,6 +6446,7 @@ When using Gtk+ tooltips, the tooltip face is not used.  */);
   defsubr (&Sx_display_visual_class);
   defsubr (&Sx_display_backing_store);
   defsubr (&Sx_display_save_under);
+  defsubr (&Sx_display_monitor_attributes_list);
   defsubr (&Sx_wm_set_size_hint);
   defsubr (&Sx_create_frame);
   defsubr (&Sx_open_connection);
diff --git a/src/xterm.c b/src/xterm.c
index e4a681031ef..7505aa3936b 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -9921,7 +9921,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
         dpy = DEFAULT_GDK_DISPLAY ();
 
-#if GTK_MAJOR_VERSION <= 2 && GTK_MINOR_VERSION <= 90
+#if ! GTK_CHECK_VERSION (2, 90, 0)
         /* Load our own gtkrc if it exists.  */
         {
           const char *file = "~/.emacs.d/gtkrc";
@@ -10251,6 +10251,8 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
       { "_NET_WM_WINDOW_OPACITY", &dpyinfo->Xatom_net_wm_window_opacity },
       { "_NET_ACTIVE_WINDOW", &dpyinfo->Xatom_net_active_window },
       { "_NET_FRAME_EXTENTS", &dpyinfo->Xatom_net_frame_extents },
+      { "_NET_CURRENT_DESKTOP", &dpyinfo->Xatom_net_current_desktop },
+      { "_NET_WORKAREA", &dpyinfo->Xatom_net_workarea },
       /* Session management */
       { "SM_CLIENT_ID", &dpyinfo->Xatom_SM_CLIENT_ID },
       { "_XSETTINGS_SETTINGS", &dpyinfo->Xatom_xsettings_prop },
diff --git a/src/xterm.h b/src/xterm.h
index 16effc5c9ea..4a5ebc66370 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -53,14 +53,26 @@ typedef GtkWidget *xt_or_gtk_widget;
 #undef XSync
 #define XSync(d, b) do { gdk_window_process_all_updates (); \
                          XSync (d, b);  } while (0)
+#endif /* USE_GTK */
+
+/* True iff GTK's version is at least I.J.K.  */
+#ifndef GTK_CHECK_VERSION
+# ifdef USE_GTK
+#  define GTK_CHECK_VERSION(i, j, k) \
+     ((i) \
+      < GTK_MAJOR_VERSION + ((j) \
+                             < GTK_MINOR_VERSION + ((k) \
+                                                    <= GTK_MICRO_VERSION)))
+# else
+#  define GTK_CHECK_VERSION(i, j, k) 0
+# endif
+#endif
 
 /* The GtkTooltip API came in 2.12, but gtk-enable-tooltips in 2.14. */
-#if GTK_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 13
+#if GTK_CHECK_VERSION (2, 14, 0)
 #define USE_GTK_TOOLTIP
 #endif
 
-#endif /* USE_GTK */
-
 
 /* Bookkeeping to distinguish X versions.  */
 
@@ -346,7 +358,8 @@ struct x_display_info
   Atom Xatom_net_wm_state, Xatom_net_wm_state_fullscreen,
     Xatom_net_wm_state_maximized_horz, Xatom_net_wm_state_maximized_vert,
     Xatom_net_wm_state_sticky, Xatom_net_wm_state_hidden,
-    Xatom_net_frame_extents;
+    Xatom_net_frame_extents,
+    Xatom_net_current_desktop, Xatom_net_workarea;
 
   /* XSettings atoms and windows.  */
   Atom Xatom_xsettings_sel, Xatom_xsettings_prop, Xatom_xsettings_mgr;