Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs

8 files changed, 457 insertions, 249 deletions

diff --git a/src/Makefile.in b/src/Makefile.in
index 60aa6866718..5a3d0bd0445 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -347,15 +347,14 @@ am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 am__v_at_0 = @
 am__v_at_1 =
 
-DEPDIR=deps
 AUTO_DEPEND = @AUTO_DEPEND@
-
+DEPDIR = deps
 ifeq ($(AUTO_DEPEND),yes)
-DEPFLAGS = -MMD -MF ${DEPDIR}/$*.d -MP
-MKDEPDIR = ${MKDIR_P} ${DEPDIR}
+  DEPFLAGS = -MMD -MF $(DEPDIR)/$*.d -MP
+  -include $(ALLOBJS:%.o=$(DEPDIR)/%.d)
 else
-DEPFLAGS =
-MKDEPDIR = :
+  DEPFLAGS =
+  include $(srcdir)/deps.mk
 endif
 
 # Flags that might be in WARN_CFLAGS but are not valid for Objective C.
@@ -383,10 +382,8 @@ ALL_OBJC_CFLAGS = $(EMACS_CFLAGS) \
 
 .SUFFIXES: .m
 .c.o:
-        @$(MKDEPDIR)
         $(AM_V_CC)$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $(PROFILING_CFLAGS) $<
 .m.o:
-        @$(MKDEPDIR)
         $(AM_V_CC)$(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $(PROFILING_CFLAGS) $<
 
 ## lastfile must follow all files whose initialized data areas should
@@ -650,8 +647,7 @@ mostlyclean:
         rm -f globals.h gl-stamp
         rm -f *.res *.tmp
 clean: mostlyclean
-        rm -f emacs-*.*.*$(EXEEXT) emacs$(EXEEXT)
-        -rm -rf $(DEPDIR)
+        rm -f emacs-*.*.*$(EXEEXT) emacs$(EXEEXT) $(DEPDIR)/*
 
 ## bootstrap-clean is used to clean up just before a bootstrap.
 ## It should remove all files generated during a compilation/bootstrap,
@@ -666,6 +662,7 @@ bootstrap-clean: clean
 
 distclean: bootstrap-clean
         rm -f Makefile lisp.mk
+        rm -fr $(DEPDIR)
 
 maintainer-clean: distclean
         rm -f TAGS
@@ -755,11 +752,3 @@ else
 endif
         @: Compile some files earlier to speed up further compilation.
         $(MAKE) -C ../lisp compile-first EMACS="$(bootstrap_exe)"
-
-ifeq ($(AUTO_DEPEND),yes)
--include $(ALLOBJS:%.o=${DEPDIR}/%.d)
-else
-include $(srcdir)/deps.mk
-endif
-
-### Makefile.in ends here
diff --git a/src/editfns.c b/src/editfns.c
index 65c0c721d11..2dafd8e7b1b 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -4356,7 +4356,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                   sprintf_buf[0] = XINT (args[n]);
                   sprintf_bytes = prec != 0;
                 }
-              else if (conversion == 'd')
+              else if (conversion == 'd' || conversion == 'i')
                 {
                   /* For float, maybe we should use "%1.0f"
                      instead so it also works for values outside
diff --git a/src/fns.c b/src/fns.c
index 10653558eb5..de7fc1b47fc 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -38,7 +38,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 static void sort_vector_copy (Lisp_Object, ptrdiff_t,
                               Lisp_Object *restrict, Lisp_Object *restrict);
-static bool internal_equal (Lisp_Object, Lisp_Object, int, bool, Lisp_Object);
+enum equal_kind { EQUAL_NO_QUIT, EQUAL_PLAIN, EQUAL_INCLUDING_PROPERTIES };
+static bool internal_equal (Lisp_Object, Lisp_Object,
+                            enum equal_kind, int, Lisp_Object);
 
 DEFUN ("identity", Fidentity, Sidentity, 1, 1, 0,
        doc: /* Return the argument unchanged.  */
@@ -1377,7 +1379,7 @@ The value is actually the tail of LIST whose car is ELT.  */)
   FOR_EACH_TAIL (tail)
     {
       Lisp_Object tem = XCAR (tail);
-      if (FLOATP (tem) && internal_equal (elt, tem, 0, 0, Qnil))
+      if (FLOATP (tem) && equal_no_quit (elt, tem))
         return tail;
     }
   CHECK_LIST_END (tail, list);
@@ -1428,7 +1430,8 @@ The value is actually the first element of LIST whose car equals KEY.  */)
 }
 
 /* Like Fassoc but never report an error and do not allow quits.
-   Use only on objects known to be non-circular lists.  */
+   Use only on keys and lists known to be non-circular, and on keys
+   that are not too deep and are not window configurations.  */
 
 Lisp_Object
 assoc_no_quit (Lisp_Object key, Lisp_Object list)
@@ -1437,7 +1440,7 @@ assoc_no_quit (Lisp_Object key, Lisp_Object list)
     {
       Lisp_Object car = XCAR (list);
       if (CONSP (car)
-          && (EQ (XCAR (car), key) || !NILP (Fequal (XCAR (car), key))))
+          && (EQ (XCAR (car), key) || equal_no_quit (XCAR (car), key)))
         return car;
     }
   return Qnil;
@@ -2085,7 +2088,7 @@ Floating-point numbers of equal value are `eql', but they may not be `eq'.  */)
   (Lisp_Object obj1, Lisp_Object obj2)
 {
   if (FLOATP (obj1))
-    return internal_equal (obj1, obj2, 0, 0, Qnil) ? Qt : Qnil;
+    return equal_no_quit (obj1, obj2) ? Qt : Qnil;
   else
     return EQ (obj1, obj2) ? Qt : Qnil;
 }
@@ -2098,31 +2101,50 @@ Vectors and strings are compared element by element.
 Numbers are compared by value, but integers cannot equal floats.
  (Use `=' if you want integers and floats to be able to be equal.)
 Symbols must match exactly.  */)
-  (register Lisp_Object o1, Lisp_Object o2)
+  (Lisp_Object o1, Lisp_Object o2)
 {
-  return internal_equal (o1, o2, 0, 0, Qnil) ? Qt : Qnil;
+  return internal_equal (o1, o2, EQUAL_PLAIN, 0, Qnil) ? Qt : Qnil;
 }
 
 DEFUN ("equal-including-properties", Fequal_including_properties, Sequal_including_properties, 2, 2, 0,
        doc: /* Return t if two Lisp objects have similar structure and contents.
 This is like `equal' except that it compares the text properties
 of strings.  (`equal' ignores text properties.)  */)
-  (register Lisp_Object o1, Lisp_Object o2)
+  (Lisp_Object o1, Lisp_Object o2)
 {
-  return internal_equal (o1, o2, 0, 1, Qnil) ? Qt : Qnil;
+  return (internal_equal (o1, o2, EQUAL_INCLUDING_PROPERTIES, 0, Qnil)
+          ? Qt : Qnil);
 }
 
-/* DEPTH is current depth of recursion.  Signal an error if it
-   gets too deep.
-   PROPS means compare string text properties too.  */
+/* Return true if O1 and O2 are equal.  Do not quit or check for cycles.
+   Use this only on arguments that are cycle-free and not too large and
+   are not window configurations.  */
+
+bool
+equal_no_quit (Lisp_Object o1, Lisp_Object o2)
+{
+  return internal_equal (o1, o2, EQUAL_NO_QUIT, 0, Qnil);
+}
+
+/* Return true if O1 and O2 are equal.  EQUAL_KIND specifies what kind
+   of equality test to use: if it is EQUAL_NO_QUIT, do not check for
+   cycles or large arguments or quits; if EQUAL_PLAIN, do ordinary
+   Lisp equality; and if EQUAL_INCLUDING_PROPERTIES, do
+   equal-including-properties.
+
+   If DEPTH is the current depth of recursion; signal an error if it
+   gets too deep.  HT is a hash table used to detect cycles; if nil,
+   it has not been allocated yet.  But ignore the last two arguments
+   if EQUAL_KIND == EQUAL_NO_QUIT.  */
 
 static bool
-internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
-                Lisp_Object ht)
+internal_equal (Lisp_Object o1, Lisp_Object o2, enum equal_kind equal_kind,
+                int depth, Lisp_Object ht)
 {
  tail_recurse:
   if (depth > 10)
     {
+      eassert (equal_kind != EQUAL_NO_QUIT);
       if (depth > 200)
         error ("Stack overflow in equal");
       if (NILP (ht))
@@ -2138,7 +2160,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
               { /* `o1' was seen already.  */
                 Lisp_Object o2s = HASH_VALUE (h, i);
                 if (!NILP (Fmemq (o2, o2s)))
-                  return 1;
+                  return true;
                 else
                   set_hash_value_slot (h, i, Fcons (o2, o2s));
               }
@@ -2150,9 +2172,9 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
     }
 
   if (EQ (o1, o2))
-    return 1;
+    return true;
   if (XTYPE (o1) != XTYPE (o2))
-    return 0;
+    return false;
 
   switch (XTYPE (o1))
     {
@@ -2166,31 +2188,42 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
       }
 
     case Lisp_Cons:
-      {
+      if (equal_kind == EQUAL_NO_QUIT)
+        for (; CONSP (o1); o1 = XCDR (o1))
+          {
+            if (! CONSP (o2))
+              return false;
+            if (! equal_no_quit (XCAR (o1), XCAR (o2)))
+              return false;
+            o2 = XCDR (o2);
+            if (EQ (XCDR (o1), o2))
+              return true;
+          }
+      else
         FOR_EACH_TAIL (o1)
           {
             if (! CONSP (o2))
               return false;
-            if (! internal_equal (XCAR (o1), XCAR (o2), depth + 1, props, ht))
+            if (! internal_equal (XCAR (o1), XCAR (o2),
+                                  equal_kind, depth + 1, ht))
               return false;
             o2 = XCDR (o2);
             if (EQ (XCDR (o1), o2))
               return true;
           }
-        depth++;
-        goto tail_recurse;
-      }
+      depth++;
+      goto tail_recurse;
 
     case Lisp_Misc:
       if (XMISCTYPE (o1) != XMISCTYPE (o2))
-        return 0;
+        return false;
       if (OVERLAYP (o1))
         {
           if (!internal_equal (OVERLAY_START (o1), OVERLAY_START (o2),
-                               depth + 1, props, ht)
+                               equal_kind, depth + 1, ht)
               || !internal_equal (OVERLAY_END (o1), OVERLAY_END (o2),
-                                  depth + 1, props, ht))
-            return 0;
+                                  equal_kind, depth + 1, ht))
+            return false;
           o1 = XOVERLAY (o1)->plist;
           o2 = XOVERLAY (o2)->plist;
           depth++;
@@ -2212,20 +2245,23 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
            actually checks that the objects have the same type as well as the
            same size.  */
         if (ASIZE (o2) != size)
-          return 0;
+          return false;
         /* Boolvectors are compared much like strings.  */
         if (BOOL_VECTOR_P (o1))
           {
             EMACS_INT size = bool_vector_size (o1);
             if (size != bool_vector_size (o2))
-              return 0;
+              return false;
             if (memcmp (bool_vector_data (o1), bool_vector_data (o2),
                         bool_vector_bytes (size)))
-              return 0;
-            return 1;
+              return false;
+            return true;
           }
         if (WINDOW_CONFIGURATIONP (o1))
-          return compare_window_configurations (o1, o2, 0);
+          {
+            eassert (equal_kind != EQUAL_NO_QUIT);
+            return compare_window_configurations (o1, o2, false);
+          }
 
         /* Aside from them, only true vectors, char-tables, compiled
            functions, and fonts (font-spec, font-entity, font-object)
@@ -2234,7 +2270,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
           {
             if (((size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
                 < PVEC_COMPILED)
-              return 0;
+              return false;
             size &= PSEUDOVECTOR_SIZE_MASK;
           }
         for (i = 0; i < size; i++)
@@ -2242,29 +2278,30 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props,
             Lisp_Object v1, v2;
             v1 = AREF (o1, i);
             v2 = AREF (o2, i);
-            if (!internal_equal (v1, v2, depth + 1, props, ht))
-              return 0;
+            if (!internal_equal (v1, v2, equal_kind, depth + 1, ht))
+              return false;
           }
-        return 1;
+        return true;
       }
       break;
 
     case Lisp_String:
       if (SCHARS (o1) != SCHARS (o2))
-        return 0;
+        return false;
       if (SBYTES (o1) != SBYTES (o2))
-        return 0;
+        return false;
       if (memcmp (SDATA (o1), SDATA (o2), SBYTES (o1)))
-        return 0;
-      if (props && !compare_string_intervals (o1, o2))
-        return 0;
-      return 1;
+        return false;
+      if (equal_kind == EQUAL_INCLUDING_PROPERTIES
+          && !compare_string_intervals (o1, o2))
+        return false;
+      return true;
 
     default:
       break;
     }
 
-  return 0;
+  return false;
 }
 
 
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 3a00e362221..63f01436413 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -783,33 +783,55 @@ xg_set_geometry (struct frame *f)
 {
   if (f->size_hint_flags & (USPosition | PPosition))
     {
-      int left = f->left_pos;
-      int xneg = f->size_hint_flags & XNegative;
-      int top = f->top_pos;
-      int yneg = f->size_hint_flags & YNegative;
-      char geom_str[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
-      guint id;
-
-      if (xneg)
-        left = -left;
-      if (yneg)
-        top = -top;
-
-      sprintf (geom_str, "=%dx%d%c%d%c%d",
-               FRAME_PIXEL_WIDTH (f),
-               FRAME_PIXEL_HEIGHT (f),
-               (xneg ? '-' : '+'), left,
-               (yneg ? '-' : '+'), top);
-
-      /* Silence warning about visible children.  */
-      id = g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
-                              | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
-
-      if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
-                                      geom_str))
-        fprintf (stderr, "Failed to parse: '%s'\n", geom_str);
-
-      g_log_remove_handler ("Gtk", id);
+      if (x_gtk_use_window_move)
+        {
+          /* Handle negative positions without consulting
+             gtk_window_parse_geometry (Bug#25851).  The position will
+             be off by scrollbar width + window manager decorations.  */
+          if (f->size_hint_flags & XNegative)
+            f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
+                           - FRAME_PIXEL_WIDTH (f) + f->left_pos);
+
+          if (f->size_hint_flags & YNegative)
+            f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
+                          - FRAME_PIXEL_HEIGHT (f) + f->top_pos);
+
+          gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
+                           f->left_pos, f->top_pos);
+
+          /* Reset size hint flags.  */
+          f->size_hint_flags &= ~ (XNegative | YNegative);
+        }
+      else
+        {
+          int left = f->left_pos;
+          int xneg = f->size_hint_flags & XNegative;
+          int top = f->top_pos;
+          int yneg = f->size_hint_flags & YNegative;
+          char geom_str[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
+          guint id;
+
+          if (xneg)
+            left = -left;
+          if (yneg)
+            top = -top;
+
+          sprintf (geom_str, "=%dx%d%c%d%c%d",
+                   FRAME_PIXEL_WIDTH (f),
+                   FRAME_PIXEL_HEIGHT (f),
+                   (xneg ? '-' : '+'), left,
+                   (yneg ? '-' : '+'), top);
+
+          /* Silence warning about visible children.  */
+          id = g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
+                                  | G_LOG_FLAG_RECURSION, my_log_handler, NULL);
+
+          if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
+                                          geom_str))
+            fprintf (stderr, "Failed to parse: '%s'\n", geom_str);
+
+          g_log_remove_handler ("Gtk", id);
+        }
     }
 }
 
@@ -1406,6 +1428,13 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
   else if (win_gravity == StaticGravity)
     size_hints.win_gravity = GDK_GRAVITY_STATIC;
 
+  if (x_gtk_use_window_move)
+    {
+      if (flags & PPosition) hint_flags |= GDK_HINT_POS;
+      if (flags & USPosition) hint_flags |= GDK_HINT_USER_POS;
+      if (flags & USSize) hint_flags |= GDK_HINT_USER_SIZE;
+    }
+
   if (user_position)
     {
       hint_flags &= ~GDK_HINT_POS;
diff --git a/src/inotify.c b/src/inotify.c
index 61ef6153286..290701349ef 100644
--- a/src/inotify.c
+++ b/src/inotify.c
@@ -41,24 +41,40 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef IN_ONLYDIR
 # define IN_ONLYDIR 0
 #endif
+#define INOTIFY_DEFAULT_MASK (IN_ALL_EVENTS | IN_EXCL_UNLINK)
 
 /* File handle for inotify.  */
 static int inotifyfd = -1;
 
-/* Assoc list of files being watched.
-   Format: (watch-descriptor name callback)
- */
+/* Alist of files being watched.  We want the returned descriptor to
+   be unique for every watch, but inotify returns the same descriptor
+   WD for multiple calls to inotify_add_watch with the same file.
+   Supply a nonnegative integer ID, so that WD and ID together
+   uniquely identify a watch/file combination.
+
+   For the same reason, we also need to store the watch's mask and we
+   can't allow the following flags to be used.
+
+   IN_EXCL_UNLINK
+   IN_MASK_ADD
+   IN_ONESHOT
+   IN_ONLYDIR
+
+   Each element of this list is of the form (DESCRIPTOR . WATCHES)
+   where no two DESCRIPTOR values are the same.  DESCRIPTOR represents
+   the inotify watch descriptor and WATCHES is a list with elements of
+   the form (ID FILENAME CALLBACK MASK), where ID is the integer
+   described above, FILENAME names the file being watched, CALLBACK is
+   invoked when the event occurs, and MASK represents the aspects
+   being watched.  The WATCHES list is sorted by ID.  Although
+   DESCRIPTOR and MASK are ordinarily integers, they are conses when
+   representing integers outside of fixnum range.  */
+
 static Lisp_Object watch_list;
 
 static Lisp_Object
-make_watch_descriptor (int wd)
+mask_to_aspects (uint32_t mask)
 {
-  /* TODO replace this with a Misc Object! */
-  return make_number (wd);
-}
-
-static Lisp_Object
-mask_to_aspects (uint32_t mask) {
   Lisp_Object aspects = Qnil;
   if (mask & IN_ACCESS)
     aspects = Fcons (Qaccess, aspects);
@@ -95,77 +111,6 @@ mask_to_aspects (uint32_t mask) {
   return aspects;
 }
 
-static Lisp_Object
-inotifyevent_to_event (Lisp_Object watch_object, struct inotify_event const *ev)
-{
-  Lisp_Object name = Qnil;
-  if (ev->len > 0)
-    {
-      size_t const len = strlen (ev->name);
-      name = make_unibyte_string (ev->name, min (len, ev->len));
-      name = DECODE_FILE (name);
-    }
-  else
-    name = XCAR (XCDR (watch_object));
-
-  return list2 (list4 (make_watch_descriptor (ev->wd),
-                       mask_to_aspects (ev->mask),
-                       name,
-                       make_number (ev->cookie)),
-                Fnth (make_number (2), watch_object));
-}
-
-/* This callback is called when the FD is available for read.  The inotify
-   events are read from FD and converted into input_events.  */
-static void
-inotify_callback (int fd, void *_)
-{
-  struct input_event event;
-  Lisp_Object watch_object;
-  int to_read;
-  char *buffer;
-  ssize_t n;
-  size_t i;
-
-  to_read = 0;
-  if (ioctl (fd, FIONREAD, &to_read) == -1)
-    report_file_notify_error ("Error while retrieving file system events",
-                              Qnil);
-  buffer = xmalloc (to_read);
-  n = read (fd, buffer, to_read);
-  if (n < 0)
-    {
-      xfree (buffer);
-      report_file_notify_error ("Error while reading file system events", Qnil);
-    }
-
-  EVENT_INIT (event);
-  event.kind = FILE_NOTIFY_EVENT;
-
-  i = 0;
-  while (i < (size_t)n)
-    {
-      struct inotify_event *ev = (struct inotify_event *) &buffer[i];
-
-      watch_object = Fassoc (make_watch_descriptor (ev->wd), watch_list);
-      if (!NILP (watch_object))
-        {
-          event.arg = inotifyevent_to_event (watch_object, ev);
-
-          /* If event was removed automatically: Drop it from watch list.  */
-          if (ev->mask & IN_IGNORED)
-            watch_list = Fdelete (watch_object, watch_list);
-
-          if (!NILP (event.arg))
-            kbd_buffer_store_event (&event);
-        }
-
-      i += sizeof (*ev) + ev->len;
-    }
-
-  xfree (buffer);
-}
-
 static uint32_t
 symbol_to_inotifymask (Lisp_Object symb)
 {
@@ -200,14 +145,6 @@ symbol_to_inotifymask (Lisp_Object symb)
 
   else if (EQ (symb, Qdont_follow))
     return IN_DONT_FOLLOW;
-  else if (EQ (symb, Qexcl_unlink))
-    return IN_EXCL_UNLINK;
-  else if (EQ (symb, Qmask_add))
-    return IN_MASK_ADD;
-  else if (EQ (symb, Qoneshot))
-    return IN_ONESHOT;
-  else if (EQ (symb, Qonlydir))
-    return IN_ONLYDIR;
 
   else if (EQ (symb, Qt) || EQ (symb, Qall_events))
     return IN_ALL_EVENTS;
@@ -221,21 +158,204 @@ symbol_to_inotifymask (Lisp_Object symb)
 static uint32_t
 aspect_to_inotifymask (Lisp_Object aspect)
 {
-  if (CONSP (aspect))
+  if (CONSP (aspect) || NILP (aspect))
     {
       Lisp_Object x = aspect;
       uint32_t mask = 0;
-      while (CONSP (x))
-        {
-          mask |= symbol_to_inotifymask (XCAR (x));
-          x = XCDR (x);
-        }
+      FOR_EACH_TAIL (x)
+        mask |= symbol_to_inotifymask (XCAR (x));
+      CHECK_LIST_END (x, aspect);
       return mask;
     }
   else
     return symbol_to_inotifymask (aspect);
 }
 
+static Lisp_Object
+inotifyevent_to_event (Lisp_Object watch, struct inotify_event const *ev)
+{
+  Lisp_Object name;
+  uint32_t mask;
+  CONS_TO_INTEGER (Fnth (make_number (3), watch), uint32_t, mask);
+
+  if (! (mask & ev->mask))
+    return Qnil;
+
+  if (ev->len > 0)
+    {
+      size_t const len = strlen (ev->name);
+      name = make_unibyte_string (ev->name, min (len, ev->len));
+      name = DECODE_FILE (name);
+    }
+  else
+    name = XCAR (XCDR (watch));
+
+  return list2 (list4 (Fcons (INTEGER_TO_CONS (ev->wd), XCAR (watch)),
+                       mask_to_aspects (ev->mask),
+                       name,
+                       INTEGER_TO_CONS (ev->cookie)),
+                Fnth (make_number (2), watch));
+}
+
+/* Add a new watch to watch-descriptor WD watching FILENAME and using
+   CALLBACK.  Returns a cons (DESCRIPTOR . ID) uniquely identifying the
+   new watch.  */
+static Lisp_Object
+add_watch (int wd, Lisp_Object filename,
+           Lisp_Object aspect, Lisp_Object callback)
+{
+  Lisp_Object descriptor = INTEGER_TO_CONS (wd);
+  Lisp_Object tail = assoc_no_quit (descriptor, watch_list);
+  Lisp_Object watch, watch_id;
+  uint32_t imask = aspect_to_inotifymask (aspect);
+  Lisp_Object mask = INTEGER_TO_CONS (imask);
+
+  EMACS_INT id = 0;
+  if (NILP (tail))
+    {
+      tail = list1 (descriptor);
+      watch_list = Fcons (tail, watch_list);
+    }
+  else
+    {
+      /* Assign a watch ID that is not already in use, by looking
+         for a gap in the existing sorted list.  */
+      for (; ! NILP (XCDR (tail)); tail = XCDR (tail), id++)
+        if (!EQ (XCAR (XCAR (XCDR (tail))), make_number (id)))
+          break;
+      if (MOST_POSITIVE_FIXNUM < id)
+        emacs_abort ();
+    }
+
+  /* Insert the newly-assigned ID into the previously-discovered gap,
+     which is possibly at the end of the list.  Inserting it there
+     keeps the list sorted.  */
+  watch_id = make_number (id);
+  watch = list4 (watch_id, filename, callback, mask);
+  XSETCDR (tail, Fcons (watch, XCDR (tail)));
+
+  return Fcons (descriptor, watch_id);
+}
+
+/* Find the watch list element (if any) matching DESCRIPTOR.  Return
+   nil if not found.  If found, return t if the first element matches
+   DESCRIPTOR; otherwise, return the cons whose cdr matches
+   DESCRIPTOR.  This lets the caller easily remove the element
+   matching DESCRIPTOR without having to search for it again, and
+   without calling Fdelete (which might quit).  */
+
+static Lisp_Object
+find_descriptor (Lisp_Object descriptor)
+{
+  Lisp_Object tail, prevtail = Qt;
+  for (tail = watch_list; !NILP (tail); prevtail = tail, tail = XCDR (tail))
+    if (equal_no_quit (XCAR (XCAR (tail)), descriptor))
+      return prevtail;
+  return Qnil;
+}
+
+/*  Remove all watches associated with the watch list element after
+    PREVTAIL, or after the first element if PREVTAIL is t.  If INVALID_P
+    is true, the descriptor is already invalid, i.e., it received a
+    IN_IGNORED event.  In this case skip calling inotify_rm_watch.  */
+static void
+remove_descriptor (Lisp_Object prevtail, bool invalid_p)
+{
+  Lisp_Object tail = CONSP (prevtail) ? XCDR (prevtail) : watch_list;
+
+  int inotify_errno = 0;
+  if (! invalid_p)
+    {
+      int wd;
+      CONS_TO_INTEGER (XCAR (XCAR (tail)), int, wd);
+      if (inotify_rm_watch (inotifyfd, wd) != 0)
+        inotify_errno = errno;
+    }
+
+  if (CONSP (prevtail))
+    XSETCDR (prevtail, XCDR (tail));
+  else
+    {
+      watch_list = XCDR (tail);
+      if (NILP (watch_list))
+        {
+          delete_read_fd (inotifyfd);
+          emacs_close (inotifyfd);
+          inotifyfd = -1;
+        }
+    }
+
+  if (inotify_errno != 0)
+    {
+      errno = inotify_errno;
+      report_file_notify_error ("Could not rm watch", XCAR (tail));
+    }
+}
+
+/*  Remove watch associated with (descriptor, id).  */
+static void
+remove_watch (Lisp_Object descriptor, Lisp_Object id)
+{
+  Lisp_Object prevtail = find_descriptor (descriptor);
+  if (NILP (prevtail))
+    return;
+
+  Lisp_Object elt = XCAR (CONSP (prevtail) ? XCDR (prevtail) : watch_list);
+  for (Lisp_Object prev = elt; !NILP (XCDR (prev)); prev = XCDR (prev))
+    if (EQ (id, XCAR (XCAR (XCDR (prev)))))
+      {
+        XSETCDR (prev, XCDR (XCDR (prev)));
+        if (NILP (XCDR (elt)))
+          remove_descriptor (prevtail, false);
+        break;
+      }
+}
+
+/* This callback is called when the FD is available for read.  The inotify
+   events are read from FD and converted into input_events.  */
+static void
+inotify_callback (int fd, void *_)
+{
+  int to_read;
+  if (ioctl (fd, FIONREAD, &to_read) < 0)
+    report_file_notify_error ("Error while retrieving file system events",
+                              Qnil);
+  USE_SAFE_ALLOCA;
+  char *buffer = SAFE_ALLOCA (to_read);
+  ssize_t n = read (fd, buffer, to_read);
+  if (n < 0)
+    report_file_notify_error ("Error while reading file system events", Qnil);
+
+  struct input_event event;
+  EVENT_INIT (event);
+  event.kind = FILE_NOTIFY_EVENT;
+
+  for (ssize_t i = 0; i < n; )
+    {
+      struct inotify_event *ev = (struct inotify_event *) &buffer[i];
+      Lisp_Object descriptor = INTEGER_TO_CONS (ev->wd);
+      Lisp_Object prevtail = find_descriptor (descriptor);
+
+      if (! NILP (prevtail))
+        {
+          Lisp_Object tail = CONSP (prevtail) ? XCDR (prevtail) : watch_list;
+          for (Lisp_Object watches = XCDR (XCAR (tail)); ! NILP (watches);
+               watches = XCDR (watches))
+            {
+              event.arg = inotifyevent_to_event (XCAR (watches), ev);
+              if (!NILP (event.arg))
+                kbd_buffer_store_event (&event);
+            }
+          /* If event was removed automatically: Drop it from watch list.  */
+          if (ev->mask & IN_IGNORED)
+            remove_descriptor (prevtail, true);
+        }
+      i += sizeof (*ev) + ev->len;
+    }
+
+  SAFE_FREE ();
+}
+
 DEFUN ("inotify-add-watch", Finotify_add_watch, Sinotify_add_watch, 3, 3, 0,
        doc: /* Add a watch for FILE-NAME to inotify.
 
@@ -264,10 +384,6 @@ close
 The following symbols can also be added to a list of aspects:
 
 dont-follow
-excl-unlink
-mask-add
-oneshot
-onlydir
 
 Watching a directory is not recursive.  CALLBACK is passed a single argument
 EVENT which contains an event structure of the format
@@ -289,47 +405,56 @@ If a directory is watched then NAME is the name of file that caused the event.
 COOKIE is an object that can be compared using `equal' to identify two matching
 renames (moved-from and moved-to).
 
-See inotify(7) and inotify_add_watch(2) for further information.  The inotify fd
-is managed internally and there is no corresponding inotify_init.  Use
-`inotify-rm-watch' to remove a watch.
-             */)
-     (Lisp_Object file_name, Lisp_Object aspect, Lisp_Object callback)
+See inotify(7) and inotify_add_watch(2) for further information.  The
+inotify fd is managed internally and there is no corresponding
+inotify_init.  Use `inotify-rm-watch' to remove a watch.
+
+Also note, that the following inotify bit-masks can not be used, due
+to the fact that descriptors are shared across different callers.
+
+IN_EXCL_UNLINK
+IN_MASK_ADD
+IN_ONESHOT
+IN_ONLYDIR  */)
+     (Lisp_Object filename, Lisp_Object aspect, Lisp_Object callback)
 {
-  uint32_t mask;
-  Lisp_Object watch_object;
   Lisp_Object encoded_file_name;
-  Lisp_Object watch_descriptor;
-  int watchdesc = -1;
+  bool dont_follow = (CONSP (aspect)
+                      ? ! NILP (Fmemq (Qdont_follow, aspect))
+                      : EQ (Qdont_follow, aspect));
+  int wd = -1;
+  uint32_t mask = (INOTIFY_DEFAULT_MASK
+                   | (dont_follow ? IN_DONT_FOLLOW : 0));
 
-  CHECK_STRING (file_name);
+  CHECK_STRING (filename);
 
   if (inotifyfd < 0)
     {
-      inotifyfd = inotify_init1 (IN_NONBLOCK|IN_CLOEXEC);
+      inotifyfd = inotify_init1 (IN_NONBLOCK | IN_CLOEXEC);
       if (inotifyfd < 0)
         report_file_notify_error ("File watching is not available", Qnil);
       watch_list = Qnil;
       add_read_fd (inotifyfd, &inotify_callback, NULL);
     }
 
-  mask = aspect_to_inotifymask (aspect);
-  encoded_file_name = ENCODE_FILE (file_name);
-  watchdesc = inotify_add_watch (inotifyfd, SSDATA (encoded_file_name), mask);
-  if (watchdesc == -1)
-    report_file_notify_error ("Could not add watch for file", file_name);
-
-  watch_descriptor = make_watch_descriptor (watchdesc);
+  encoded_file_name = ENCODE_FILE (filename);
+  wd = inotify_add_watch (inotifyfd, SSDATA (encoded_file_name), mask);
+  if (wd < 0)
+    report_file_notify_error ("Could not add watch for file", filename);
 
-  /* Delete existing watch object.  */
-  watch_object = Fassoc (watch_descriptor, watch_list);
-  if (!NILP (watch_object))
-      watch_list = Fdelete (watch_object, watch_list);
-
-  /* Store watch object in watch list.  */
-  watch_object = list3 (watch_descriptor, encoded_file_name, callback);
-  watch_list = Fcons (watch_object, watch_list);
+  return add_watch (wd, filename, aspect, callback);
+}
 
-  return watch_descriptor;
+static bool
+valid_watch_descriptor (Lisp_Object wd)
+{
+  return (CONSP (wd)
+          && (RANGED_INTEGERP (0, XCAR (wd), INT_MAX)
+              || (CONSP (XCAR (wd))
+                  && RANGED_INTEGERP ((MOST_POSITIVE_FIXNUM >> 16) + 1,
+                                      XCAR (XCAR (wd)), INT_MAX >> 16)
+                  && RANGED_INTEGERP (0, XCDR (XCAR (wd)), (1 << 16) - 1)))
+          && NATNUMP (XCDR (wd)));
 }
 
 DEFUN ("inotify-rm-watch", Finotify_rm_watch, Sinotify_rm_watch, 1, 1, 0,
@@ -337,28 +462,18 @@ DEFUN ("inotify-rm-watch", Finotify_rm_watch, Sinotify_rm_watch, 1, 1, 0,
 
 WATCH-DESCRIPTOR should be an object returned by `inotify-add-watch'.
 
-See inotify_rm_watch(2) for more information.
-             */)
+See inotify_rm_watch(2) for more information.  */)
      (Lisp_Object watch_descriptor)
 {
-  Lisp_Object watch_object;
-  int wd = XINT (watch_descriptor);
 
-  if (inotify_rm_watch (inotifyfd, wd) == -1)
-    report_file_notify_error ("Could not rm watch", watch_descriptor);
+  Lisp_Object descriptor, id;
 
-  /* Remove watch descriptor from watch list.  */
-  watch_object = Fassoc (watch_descriptor, watch_list);
-  if (!NILP (watch_object))
-    watch_list = Fdelete (watch_object, watch_list);
+  if (! valid_watch_descriptor (watch_descriptor))
+    report_file_notify_error ("Invalid descriptor ", watch_descriptor);
 
-  /* Cleanup if no more files are watched.  */
-  if (NILP (watch_list))
-    {
-      emacs_close (inotifyfd);
-      delete_read_fd (inotifyfd);
-      inotifyfd = -1;
-    }
+  descriptor = XCAR (watch_descriptor);
+  id = XCDR (watch_descriptor);
+  remove_watch (descriptor, id);
 
   return Qt;
 }
@@ -374,10 +489,29 @@ reason.  Removing the watch by calling `inotify-rm-watch' also makes
 it invalid.  */)
      (Lisp_Object watch_descriptor)
 {
-  Lisp_Object watch_object = Fassoc (watch_descriptor, watch_list);
-  return NILP (watch_object) ? Qnil : Qt;
+  if (! valid_watch_descriptor (watch_descriptor))
+    return Qnil;
+  Lisp_Object tail = assoc_no_quit (XCAR (watch_descriptor), watch_list);
+  if (NILP (tail))
+    return Qnil;
+  Lisp_Object watch = assq_no_quit (XCDR (watch_descriptor), XCDR (tail));
+  return ! NILP (watch) ? Qt : Qnil;
 }
 
+#ifdef INOTIFY_DEBUG
+DEFUN ("inotify-watch-list", Finotify_watch_list, Sinotify_watch_list, 0, 0, 0,
+       doc: /* Return a copy of the internal watch_list.  */)
+{
+  return Fcopy_sequence (watch_list);
+}
+
+DEFUN ("inotify-allocated-p", Finotify_allocated_p, Sinotify_allocated_p, 0, 0, 0,
+       doc: /* Return non-nil, if a inotify instance is allocated.  */)
+{
+  return inotifyfd < 0 ? Qnil : Qt;
+}
+#endif
+
 void
 syms_of_inotify (void)
 {
@@ -400,10 +534,6 @@ syms_of_inotify (void)
   DEFSYM (Qclose, "close");             /* IN_CLOSE */
 
   DEFSYM (Qdont_follow, "dont-follow"); /* IN_DONT_FOLLOW */
-  DEFSYM (Qexcl_unlink, "excl-unlink"); /* IN_EXCL_UNLINK */
-  DEFSYM (Qmask_add, "mask-add");       /* IN_MASK_ADD */
-  DEFSYM (Qoneshot, "oneshot");         /* IN_ONESHOT */
-  DEFSYM (Qonlydir, "onlydir");         /* IN_ONLYDIR */
 
   DEFSYM (Qignored, "ignored");         /* IN_IGNORED */
   DEFSYM (Qisdir, "isdir");             /* IN_ISDIR */
@@ -414,6 +544,10 @@ syms_of_inotify (void)
   defsubr (&Sinotify_rm_watch);
   defsubr (&Sinotify_valid_p);
 
+#ifdef INOTIFY_DEBUG
+  defsubr (&Sinotify_watch_list);
+  defsubr (&Sinotify_allocated_p);
+#endif
   staticpro (&watch_list);
 
   Fprovide (intern_c_string ("inotify"), Qnil);
diff --git a/src/lisp.h b/src/lisp.h
index 4b9cd3c4702..3125bd2a5dd 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3376,6 +3376,7 @@ extern Lisp_Object merge (Lisp_Object, Lisp_Object, Lisp_Object);
 extern Lisp_Object do_yes_or_no_p (Lisp_Object);
 extern Lisp_Object concat2 (Lisp_Object, Lisp_Object);
 extern Lisp_Object concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
+extern bool equal_no_quit (Lisp_Object, Lisp_Object);
 extern Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
 extern Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object);
 extern Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object);
diff --git a/src/xdisp.c b/src/xdisp.c
index 82668494927..af086d17eb8 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -2716,6 +2716,7 @@ init_iterator (struct it *it, struct window *w,
       if (face_change)
         {
           face_change = false;
+          XFRAME (w->frame)->face_change = 0;
           free_all_realized_faces (Qnil);
         }
       else if (XFRAME (w->frame)->face_change)
@@ -14132,21 +14133,16 @@ redisplay_internal (void)
                      Therefore, we must redisplay this frame.  */
                   if (!f_redisplay_flag && f->redisplay)
                     goto retry_frame;
-
                   /* In some case (e.g., window resize), we notice
                      only during window updating that the window
                      content changed unpredictably (e.g., a GTK
-                     scrollbar moved) and that our previous estimation
-                     of the frame content was garbage.  We have to
-                     start over.  These cases should be rare, so going
-                     all the way back to the top of redisplay should
-                     be good enough.
-
-                     Why FRAME_WINDOW_P? See
-                     https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00957.html
-
-                     */
-                  if (FRAME_GARBAGED_P (f) && FRAME_WINDOW_P (f))
+                     scrollbar moved, or some Lisp hook that winds up
+                     calling adjust_frame_glyphs) and that our
+                     previous estimation of the frame content was
+                     garbage.  We have to start over.  These cases
+                     should be rare, so going all the way back to the
+                     top of redisplay should be good enough.  */
+                  if (FRAME_GARBAGED_P (f))
                     goto retry;
 
                   /* Prevent various kinds of signals during display
diff --git a/src/xterm.c b/src/xterm.c
index 7856793f8dc..4f9eff6c5e6 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -10056,11 +10056,26 @@ x_set_offset (struct frame *f, register int xoff, register int yoff, int change_
         f->size_hint_flags |= YNegative;
       f->win_gravity = NorthWestGravity;
     }
+
   x_calc_absolute_position (f);
 
   block_input ();
   x_wm_set_size_hint (f, 0, false);
 
+#ifdef USE_GTK
+  if (x_gtk_use_window_move)
+    {
+      /* When a position change was requested and the outer GTK widget
+         has been realized already, leave it to gtk_window_move to DTRT
+         and return.  Used for Bug#25851 and Bug#25943.  */
+      if (change_gravity != 0 && FRAME_GTK_OUTER_WIDGET (f))
+        gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
+                         f->left_pos, f->top_pos);
+      unblock_input ();
+      return;
+    }
+#endif /* USE_GTK */
+
   modified_left = f->left_pos;
   modified_top = f->top_pos;
 
@@ -12905,4 +12920,11 @@ state.
 Set this variable only if your window manager cannot handle the
 transition between the various maximization states.  */);
   x_frame_normalize_before_maximize = false;
+
+  DEFVAR_BOOL ("x-gtk-use-window-move", x_gtk_use_window_move,
+    doc: /* Non-nil means rely on gtk_window_move to set frame positions.
+If this variable is t, the GTK build uses the function gtk_window_move
+to set or store frame positions and disables some time consuming frame
+position adjustments.  */);
+  x_gtk_use_window_move = false;
 }