Merge master into feature/improved-locked-narrowing.

57 files changed, 1911 insertions, 988 deletions

diff --git a/src/ChangeLog.10 b/src/ChangeLog.10
index ba1cea18d4b..1b18ae5ec5d 100644
--- a/src/ChangeLog.10
+++ b/src/ChangeLog.10
@@ -7899,7 +7899,7 @@
         * buffer.c (scroll-up-aggressively, scroll-down-aggressively):
         * keymap.c (Fminor_mode_key_binding):
         * macterm.c (mac-emulate-three-button-mouse):
-        Delete duplicate duplicate words.
+        Delete duplicate words.
 
 2005-07-18  Ken Raeburn  <raeburn@gnu.org>
 
diff --git a/src/ChangeLog.11 b/src/ChangeLog.11
index 15ab2271718..a00ca453ca4 100644
--- a/src/ChangeLog.11
+++ b/src/ChangeLog.11
@@ -7503,7 +7503,7 @@
 2010-05-28  Kenichi Handa  <handa@m17n.org>
 
         * font.c (font_delete_unmatched): Check Vface_ignored_fonts.
-        Don't sheck SPEC if it is nil.
+        Don't check SPEC if it is nil.
         (font_list_entities): Call font_delete_unmatched if
         Vface_ignored_fonts is non-nil.  (Bug#6287)
 
@@ -8639,7 +8639,7 @@
 
         * keyboard.c: QClabel is new.
         (parse_tool_bar_item): Take out QClabel from tool bar items.
-        Try to construct a label if ther is no QClabel.
+        Try to construct a label if there is no QClabel.
         (syms_of_keyboard): Intern :label as QClabel.
 
         * dispextern.h (tool_bar_item_idx): TOOL_BAR_ITEM_LABEL is new.
@@ -11988,7 +11988,7 @@
 
         * cmds.c (nonundocount): New global variable.
         (keys_of_cmds): Initialize it.
-        (Fself_insert_command): Use it to combine upto 20 sequential chars
+        (Fself_insert_command): Use it to combine up to 20 sequential chars
         into a single undo entry, just like the Qself_insert_command code in
         keyboard.c does.
         Call frame_make_pointer_invisible, also like the Qself_insert_command
diff --git a/src/ChangeLog.12 b/src/ChangeLog.12
index 18618bbfb25..7f77c0ca077 100644
--- a/src/ChangeLog.12
+++ b/src/ChangeLog.12
@@ -73,7 +73,7 @@
 
         * lisp.h (adjust_after_replace): Extern it.
 
-        * coding.c (detect_coding): Cound the heading ASCII bytes in the
+        * coding.c (detect_coding): Count the heading ASCII bytes in the
         case of detection for coding_category_utf_8_auto.
         (decode_coding_gap) [not CODING_DISABLE_ASCII_OPTIMIZATION]:
         Skip decoding if all bytes are ASCII.
@@ -1809,7 +1809,7 @@
 
         * nsfns.m (Fns_do_applescript): Run event loop until script has
         been executed (Bug#12969).
-        (ns_run_ascript): Chech as_script for nil, set to nil after
+        (ns_run_ascript): Check as_script for nil, set to nil after
         executing script.
 
 2012-12-22  Martin Rudalics  <rudalics@gmx.at>
@@ -14132,7 +14132,7 @@
         (coding_set_destination): Return how many bytes
         coding->destination was relocated.
         (CODING_DECODE_CHAR, CODING_ENCODE_CHAR, CODING_CHAR_CHARSET)
-        (CODING_CHAR_CHARSET_P): Adjust for the avove changes.
+        (CODING_CHAR_CHARSET_P): Adjust for the above changes.
 
 2011-12-05  Kazuhiro Ito  <kzhr@d1.dion.ne.jp>  (tiny change)
 
@@ -19967,7 +19967,7 @@
 2011-05-05  Eli Zaretskii  <eliz@gnu.org>
 
         * w32heap.c (allocate_heap) [USE_LISP_UNION_TYPE || USE_LSB_TAG]:
-        New version that can reserve upto 2GB of heap space.
+        New version that can reserve up to 2GB of heap space.
 
 2011-05-05  Chong Yidong  <cyd@stupidchicken.com>
 
diff --git a/src/ChangeLog.13 b/src/ChangeLog.13
index 268a59219c4..91f8005ac51 100644
--- a/src/ChangeLog.13
+++ b/src/ChangeLog.13
@@ -1459,11 +1459,11 @@
         (frame_default_tool_bar_height): Extern.
         * gtkutil.c (xg_frame_set_char_size): Pass Qxg_frame_set_char_size
         to adjust_frame_size.
-        * nsfns.m (Fx_create_frame): Pass Pass Qx_create_frame_1 and
+        * nsfns.m (Fx_create_frame): Pass Qx_create_frame_1 and
         Qx_create_frame_2 to adjust_frame_size.
         * w32fns.c (x_change_tool_bar_height): Call adjust_frame_size with
         inhibit 1 when we have not redisplayed the tool bar yet.
-        (Fx_create_frame): Pass Pass Qx_create_frame_1 and
+        (Fx_create_frame): Pass Qx_create_frame_1 and
         Qx_create_frame_2 to adjust_frame_size.
         * w32menu.c (set_frame_menubar): Simplify adjust_frame_size
         call.
@@ -1476,7 +1476,7 @@
         frame size accordingly.
         * xfns.c (x_change_tool_bar_height): Call adjust_frame_size with
         inhibit 1 when we have not redisplayed the tool bar yet.
-        (Fx_create_frame): Pass Pass Qx_create_frame_1 and
+        (Fx_create_frame): Pass Qx_create_frame_1 and
         Qx_create_frame_2 to adjust_frame_size.
 
 2015-01-12  Paul Eggert  <eggert@cs.ucla.edu>
@@ -7498,7 +7498,7 @@
 2014-04-16  Eli Zaretskii  <eliz@gnu.org>
 
         * insdel.c (invalidate_buffer_caches): When deleting or replacing
-        text, invalidate the bidi_paragraph_cache upto and including the
+        text, invalidate the bidi_paragraph_cache up to and including the
         preceding newline.
 
 2014-04-16  Paul Eggert  <eggert@cs.ucla.edu>
@@ -10183,7 +10183,7 @@
         (w32_wnd_proc): Handle bottom divider width.
         For WM_WINDOWPOSCHANGING return zero if we resize pixelwise.
         (Fx_create_frame): Default divider width parameters.
-        Caclulate sizes pixelwise.  Add vertical drag cursor support.
+        Calculate sizes pixelwise.  Add vertical drag cursor support.
         (x_create_tip_frame): Default divider widths to zero.
         Pixelize call to change_frame_size.
         (Fx_show_tip): Add handling of divider widths.  Pixelize window
@@ -10868,7 +10868,7 @@
 
         * xdisp.c (syms_of_xdisp): New vars redisplay--all-windows-cause and
         redisplay--mode-lines-cause.
-        (redisplay_internal): Keep them uptodate.  Remove redundant check of
+        (redisplay_internal): Keep them up-to-date.  Remove redundant check of
         buffer_shared_and_changed.
         * *.[chm]: Number every assignment to update_mode_lines so we
         can track why it is set.
@@ -12566,7 +12566,7 @@
 2013-09-16  Dmitry Antipov  <dmantipov@yandex.ru>
 
         Do not copy X event in handle_one_xevent except KeyPress case.
-        Wnen XEvent is processed, it is unlikely to be changed except
+        When XEvent is processed, it is unlikely to be changed except
         KeyPress case, so we can avoid copying and use const pointer to
         const data to make sure that an event is not changed elsewhere.
         * xterm.c (handle_one_xevent): Change 2nd arg to 'const XEvent *
diff --git a/src/ChangeLog.5 b/src/ChangeLog.5
index c74e44d7a2f..408a934ce2e 100644
--- a/src/ChangeLog.5
+++ b/src/ChangeLog.5
@@ -2316,7 +2316,7 @@
 
 1995-02-15  Paul Reilly  <pmr@geech.gnu.ai.mit.edu>
 
-        * s/dgux.h (LIB_MOTIF): Add -lgen to provide provide the symbols
+        * s/dgux.h (LIB_MOTIF): Add -lgen to provide the symbols
         `regcmp' and `regex'.
 
 1995-02-15  Richard Stallman  <rms@pogo.gnu.ai.mit.edu>
diff --git a/src/ChangeLog.6 b/src/ChangeLog.6
index fc7cc5e4d48..f5653efd91e 100644
--- a/src/ChangeLog.6
+++ b/src/ChangeLog.6
@@ -2225,7 +2225,7 @@
 
 1996-02-08  Eli Zaretskii  <eliz@is.elta.co.il>
 
-        * fileio.c (Fmake_temp_name) [MS-DOS]: Allow upto 8 characters in
+        * fileio.c (Fmake_temp_name) [MS-DOS]: Allow up to 8 characters in
         the prefix of the temporary file name.
 
 1996-02-07  Richard Stallman  <rms@mole.gnu.ai.mit.edu>
diff --git a/src/ChangeLog.7 b/src/ChangeLog.7
index e893a2a6d82..9c6fd810d34 100644
--- a/src/ChangeLog.7
+++ b/src/ChangeLog.7
@@ -1215,19 +1215,19 @@
 
         * ccl.c: Change term translation to code conversion, then change
         terms unify/unification to translate/translation respectively
-        throughtout the file.
+        throughout the file.
 
         * charset.c: Change terms unify/unification to
-        translate/translation respectively throughtout the file.
+        translate/translation respectively throughout the file.
         (ONE_BYTE_CHAR_WIDTH): Delete unnecessary continuation line at the
         tail.
 
         * charset.h: Change terms unify/unification to
-        translate/translation respectively throughtout the file.
+        translate/translation respectively throughout the file.
         (GET_TRANSLATION_TABLE): Name changed from UNIFICATION_ID_TABLE.
 
         * coding.c: Change terms unify/unification to
-        translate/translation respectively throughtout the file.
+        translate/translation respectively throughout the file.
         (encode_coding_iso2022): Fix bug in encoding a text ending by a
         composite character.
         (check_composing_code): If we are decoding the last block of data,
diff --git a/src/ChangeLog.8 b/src/ChangeLog.8
index ef2472a0f33..c0e3523c648 100644
--- a/src/ChangeLog.8
+++ b/src/ChangeLog.8
@@ -1272,7 +1272,7 @@
 
         * xdisp.c (display_line): Set charpos of first glyph in blank
         lines not corresponding to any text to -1, even if no glyphs are
-        filled in in that line.
+        filled in on that line.
 
 1999-11-01  Gerd Moellmann  <gerd@gnu.org>
 
@@ -3155,7 +3155,7 @@
 
         * xdisp.c (resize_mini_window): Don't resize if
         Vmax_mini_window_height is nil.  Otherwise, use a default if
-        Vmax_mini_window_height is not ot a number.
+        Vmax_mini_window_height is not a number.
         (syms_of_xdisp): Extend documentation of Vmax_mini_window_height.
 
 1999-08-25  Alexandre Oliva  <oliva@dcc.unicamp.br>
@@ -5704,7 +5704,7 @@
         (x_scroll_bar_expose): Make no-op for toolkit scroll bars.
         (x_scroll_bar_create): Create and show a scroll bar widget
         if using toolkit scroll bars.
-        (x_scroll_bar_move): Handle tookit scroll bars.
+        (x_scroll_bar_move): Handle toolkit scroll bars.
 
         * Makefile.in (LIBW): Use Xaw3d if present.
 
diff --git a/src/alloc.c b/src/alloc.c
index f69c65dedc1..d3f696d5ade 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -6279,11 +6279,6 @@ garbage_collect (void)
   image_prune_animation_caches (false);
 #endif
 
-  /* ELisp code run by `gc-post-hook' could result in itree iteration,
-     which must not happen while the itree is already busy.  See
-     bug#58639.  */
-  eassert (!itree_iterator_busy_p ());
-
   if (!NILP (Vpost_gc_hook))
     {
       specpdl_ref gc_count = inhibit_garbage_collection ();
@@ -6508,7 +6503,7 @@ mark_char_table (struct Lisp_Vector *ptr, enum pvec_type pvectype)
 static void
 mark_overlay (struct Lisp_Overlay *ov)
 {
-  /* We don't mark the `interval_node` object, because it is managed manually
+  /* We don't mark the `itree_node` object, because it is managed manually
      rather than by the GC.  */
   eassert (BASE_EQ (ov->interval->data, make_lisp_ptr (ov, Lisp_Vectorlike)));
   set_vectorlike_marked (&ov->header);
@@ -7780,13 +7775,23 @@ allocated since the last garbage collection.  All data types count.
 Garbage collection happens automatically only when `eval' is called.
 
 By binding this temporarily to a large number, you can effectively
-prevent garbage collection during a part of the program.
+prevent garbage collection during a part of the program.  But be
+sure to get back to the normal value soon enough, to avoid system-wide
+memory pressure, and never use a too-high value for prolonged periods
+of time.
 See also `gc-cons-percentage'.  */);
 
   DEFVAR_LISP ("gc-cons-percentage", Vgc_cons_percentage,
                doc: /* Portion of the heap used for allocation.
 Garbage collection can happen automatically once this portion of the heap
 has been allocated since the last garbage collection.
+
+By binding this temporarily to a large number, you can effectively
+prevent garbage collection during a part of the program.  But be
+sure to get back to the normal value soon enough, to avoid system-wide
+memory pressure, and never use a too-high value for prolonged periods
+of time.
+
 If this portion is smaller than `gc-cons-threshold', this is ignored.  */);
   Vgc_cons_percentage = make_float (0.1);
 
diff --git a/src/buffer.c b/src/buffer.c
index b67b989326e..d948aaa2662 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -937,19 +937,16 @@ delete_all_overlays (struct buffer *b)
   if (! b->overlays)
     return;
 
-  /* FIXME: This loop sets the overlays' `buffer` field to NULL but
-     doesn't set the itree_nodes' `parent`, `left` and `right`
-     fields accordingly.  I believe it's harmless, but a bit untidy since
-     other parts of the code are careful to set those fields to NULL when
-     the overlay is deleted.
-     Of course, we can't set them to NULL from within the iteration
-     because the iterator may need them (tho we could if we added
-     an ITREE_POST_ORDER iteration order).  */
-  ITREE_FOREACH (node, b->overlays, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING)
+  /* The general rule is that the tree cannot be modified from within
+     ITREE_FOREACH, but here we bend this rule a little because we know
+     that the POST_ORDER iterator will not need to look at `node` again.  */
+  ITREE_FOREACH (node, b->overlays, PTRDIFF_MIN, PTRDIFF_MAX, POST_ORDER)
     {
       modify_overlay (b, node->begin, node->end);
-      /* Where are the nodes freed ? --ap */
       XOVERLAY (node->data)->buffer = NULL;
+      node->parent = NULL;
+      node->left = NULL;
+      node->right = NULL;
     }
   itree_clear (b->overlays);
 }
@@ -982,7 +979,7 @@ set_overlays_multibyte (bool multibyte)
   struct itree_tree *tree = current_buffer->overlays;
   const intmax_t size = itree_size (tree);
 
-  /* We can't use `interval_node_set_region` at the same time
+  /* We can't use `itree_node_set_region` at the same time
      as we iterate over the itree, so we need an auxiliary storage
      to keep the list of nodes.  */
   USE_SAFE_ALLOCA;
@@ -2985,17 +2982,13 @@ overlays_in (ptrdiff_t beg, ptrdiff_t end, bool extend,
       if (node->begin > end)
         {
           next = min (next, node->begin);
-          ITREE_FOREACH_ABORT ();
           break;
         }
       else if (node->begin == end)
         {
           next = node->begin;
           if ((! empty || end < ZV) && beg < end)
-            {
-              ITREE_FOREACH_ABORT ();
-              break;
-            }
+            break;
           if (empty && node->begin != node->end)
             continue;
         }
@@ -3050,7 +3043,6 @@ next_overlay_change (ptrdiff_t pos)
              of pos, because the search is limited to [pos,next) . */
           eassert (node->begin < next);
           next = node->begin;
-          ITREE_FOREACH_ABORT ();
           break;
         }
       else if (node->begin < node->end && node->end < next)
@@ -3155,10 +3147,7 @@ overlay_touches_p (ptrdiff_t pos)
      pos. */
   ITREE_FOREACH (node, current_buffer->overlays, pos - 1, pos + 1, DESCENDING)
     if (node->begin == pos || node->end == pos)
-      {
-        ITREE_FOREACH_ABORT ();
-        return true;
-      }
+      return true;
   return false;
 }
 
@@ -3454,21 +3443,66 @@ overlay_strings (ptrdiff_t pos, struct window *w, unsigned char **pstr)
 
 
 void
-adjust_overlays_for_insert (ptrdiff_t pos, ptrdiff_t length)
+adjust_overlays_for_insert (ptrdiff_t pos, ptrdiff_t length, bool before_markers)
 {
-  /* After an insertion, the lists are still sorted properly,
-     but we may need to update the value of the overlay center.  */
-  if (! current_buffer->overlays)
-    return;
-  itree_insert_gap (current_buffer->overlays, pos, length);
+  if (!current_buffer->indirections)
+    itree_insert_gap (current_buffer->overlays, pos, length, before_markers);
+  else
+    {
+      struct buffer *base = current_buffer->base_buffer
+                            ? current_buffer->base_buffer
+                            : current_buffer;
+      Lisp_Object tail, other;
+      itree_insert_gap (base->overlays, pos, length, before_markers);
+      FOR_EACH_LIVE_BUFFER (tail, other)
+        if (XBUFFER (other)->base_buffer == base)
+          itree_insert_gap (XBUFFER (other)->overlays, pos, length,
+                            before_markers);
+    }
+}
+
+static void
+adjust_overlays_for_delete_in_buffer (struct buffer * buf,
+                                      ptrdiff_t pos, ptrdiff_t length)
+{
+  Lisp_Object hit_list = Qnil;
+  struct itree_node *node;
+
+  /* Ideally, the evaporate check would be done directly within
+     `itree_delete_gap`, but that code isn't supposed to know about overlays,
+     only about `itree_node`s, so it would break an abstraction boundary.  */
+  itree_delete_gap (buf->overlays, pos, length);
+
+  /* Delete any zero-sized overlays at position POS, if the `evaporate'
+     property is set.  */
+
+  ITREE_FOREACH (node, buf->overlays, pos, pos, ASCENDING)
+    {
+      if (node->end == pos && node->begin == pos
+          && ! NILP (Foverlay_get (node->data, Qevaporate)))
+        hit_list = Fcons (node->data, hit_list);
+    }
+
+  for (; CONSP (hit_list); hit_list = XCDR (hit_list))
+    Fdelete_overlay (XCAR (hit_list));
 }
 
 void
 adjust_overlays_for_delete (ptrdiff_t pos, ptrdiff_t length)
 {
-  if (! current_buffer->overlays)
-    return;
-  itree_delete_gap (current_buffer->overlays, pos, length);
+  if (!current_buffer->indirections)
+    adjust_overlays_for_delete_in_buffer (current_buffer, pos, length);
+  else
+    {
+      struct buffer *base = current_buffer->base_buffer
+                            ? current_buffer->base_buffer
+                            : current_buffer;
+      Lisp_Object tail, other;
+      adjust_overlays_for_delete_in_buffer (base, pos, length);
+      FOR_EACH_LIVE_BUFFER (tail, other)
+        if (XBUFFER (other)->base_buffer == base)
+          adjust_overlays_for_delete_in_buffer (XBUFFER (other), pos, length);
+    }
 }
 
 
@@ -3601,7 +3635,7 @@ buffer.  */)
       o_end = OVERLAY_END (overlay);
     }
 
-  if (! EQ (buffer, obuffer))
+  if (! BASE_EQ (buffer, obuffer))
     {
       if (! NILP (obuffer))
         remove_buffer_overlay (XBUFFER (obuffer), XOVERLAY (overlay));
@@ -3790,7 +3824,9 @@ and also contained within the specified region.
 
 Empty overlays are included in the result if they are located at BEG,
 between BEG and END, or at END provided END denotes the position at the
-end of the accessible part of the buffer.  */)
+end of the accessible part of the buffer.
+
+The resulting list of overlays is in an arbitrary unpredictable order.  */)
   (Lisp_Object beg, Lisp_Object end)
 {
   ptrdiff_t len, noverlays;
@@ -4080,25 +4116,6 @@ call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay, bool after,
     }
 }
 
-/* Delete any zero-sized overlays at position POS, if the `evaporate'
-   property is set.  */
-void
-evaporate_overlays (ptrdiff_t pos)
-{
-  Lisp_Object hit_list = Qnil;
-  struct itree_node *node;
-
-  ITREE_FOREACH (node, current_buffer->overlays, pos, pos, ASCENDING)
-    {
-      if (node->end == pos
-          && ! NILP (Foverlay_get (node->data, Qevaporate)))
-        hit_list = Fcons (node->data, hit_list);
-    }
-
-  for (; CONSP (hit_list); hit_list = XCDR (hit_list))
-    Fdelete_overlay (XCAR (hit_list));
-}
-
 /***********************************************************************
                          Allocation with mmap
  ***********************************************************************/
diff --git a/src/buffer.h b/src/buffer.h
index 3ea4125645d..2e80c8a7b04 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1170,7 +1170,6 @@ extern EMACS_INT fix_position (Lisp_Object);
 extern void delete_all_overlays (struct buffer *);
 extern void reset_buffer (struct buffer *);
 extern void compact_buffer (struct buffer *);
-extern void evaporate_overlays (ptrdiff_t);
 extern ptrdiff_t overlays_at (ptrdiff_t, bool, Lisp_Object **, ptrdiff_t *, ptrdiff_t *);
 extern ptrdiff_t overlays_in (ptrdiff_t, ptrdiff_t, bool, Lisp_Object **,
                               ptrdiff_t *,  bool, bool, ptrdiff_t *);
diff --git a/src/callproc.c b/src/callproc.c
index 4d4b86629cf..f9f840e5440 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -648,6 +648,7 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 
 #ifndef MSDOS
 
+  child_signal_init ();
   block_input ();
   block_child_signal (&oldset);
 
diff --git a/src/comp.c b/src/comp.c
index 14012634ccc..b6072a866e6 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -947,7 +947,7 @@ obj_to_reloc (Lisp_Object obj)
     }
 
   xsignal1 (Qnative_ice,
-            build_string ("cant't find data in relocation containers"));
+            build_string ("can't find data in relocation containers"));
   assume (false);
 
  found:
@@ -5609,7 +5609,7 @@ file_in_eln_sys_dir (Lisp_Object filename)
 /* Load related routines.  */
 DEFUN ("native-elisp-load", Fnative_elisp_load, Snative_elisp_load, 1, 2, 0,
        doc: /* Load native elisp code FILENAME.
-LATE_LOAD has to be non-nil when loading for deferred compilation.  */)
+LATE-LOAD has to be non-nil when loading for deferred compilation.  */)
   (Lisp_Object filename, Lisp_Object late_load)
 {
   CHECK_STRING (filename);
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 1c74180f15c..440142757ec 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -422,7 +422,7 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
-      /* We dont check the syntax of signature.  This will be done by
+      /* We don't check the syntax of signature.  This will be done by
          libdbus.  */
       if (dtype == DBUS_TYPE_OBJECT_PATH)
         XD_DBUS_VALIDATE_PATH (object)
@@ -748,7 +748,7 @@ xd_append_arg (int dtype, Lisp_Object object, DBusMessageIter *iter)
       case DBUS_TYPE_STRING:
       case DBUS_TYPE_OBJECT_PATH:
       case DBUS_TYPE_SIGNATURE:
-        /* We dont check the syntax of signature.  This will be done
+        /* We don't check the syntax of signature.  This will be done
            by libdbus.  */
         if (dtype == DBUS_TYPE_OBJECT_PATH)
           XD_DBUS_VALIDATE_PATH (object)
diff --git a/src/dispextern.h b/src/dispextern.h
index 2f5f4335fe5..2afbdeabaab 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -3495,7 +3495,8 @@ extern bool cursor_in_mouse_face_p (struct window *w);
 extern void tty_draw_row_with_mouse_face (struct window *, struct glyph_row *,
                                           int, int, enum draw_glyphs_face);
 extern void display_tty_menu_item (const char *, int, int, int, int, bool);
-
+extern struct glyph *x_y_to_hpos_vpos (struct window *, int, int, int *, int *,
+                                       int *, int *, int *);
 /* Flags passed to try_window.  */
 #define TRY_WINDOW_CHECK_MARGINS        (1 << 0)
 #define TRY_WINDOW_IGNORE_FONTS_CHANGE  (1 << 1)
diff --git a/src/emacs-module.c b/src/emacs-module.c
index fcdf103c19b..35d6e9e0d7a 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -561,7 +561,7 @@ static struct Lisp_Module_Function *
 allocate_module_function (void)
 {
   return ALLOCATE_PSEUDOVECTOR (struct Lisp_Module_Function,
-                                interactive_form, PVEC_MODULE_FUNCTION);
+                                command_modes, PVEC_MODULE_FUNCTION);
 }
 
 #define XSET_MODULE_FUNCTION(var, ptr) \
diff --git a/src/emacs.c b/src/emacs.c
index 8ad70fecd41..85102acd28e 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -82,6 +82,7 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #endif /* HAVE_WINDOW_SYSTEM */
 
 #include "bignum.h"
+#include "itree.h"
 #include "intervals.h"
 #include "character.h"
 #include "buffer.h"
@@ -431,9 +432,9 @@ terminate_due_to_signal (int sig, int backtrace_limit)
           if (sig == SIGTERM || sig == SIGHUP || sig == SIGINT)
             {
               /* Avoid abort in shut_down_emacs if we were interrupted
-                 by SIGINT in noninteractive usage, as in that case we
-                 don't care about the message stack.  */
-              if (sig == SIGINT && noninteractive)
+                 in noninteractive usage, as in that case we don't
+                 care about the message stack.  */
+              if (noninteractive)
                 clear_message_stack ();
               Fkill_emacs (make_fixnum (sig), Qnil);
             }
diff --git a/src/eval.c b/src/eval.c
index ea238299488..7327d681f9a 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1329,7 +1329,7 @@ Then the value of the last BODY form is returned from the `condition-case'
 expression.
 
 The special handler (:success BODY...) is invoked if BODYFORM terminated
-without signalling an error.  BODY is then evaluated with VAR bound to
+without signaling an error.  BODY is then evaluated with VAR bound to
 the value returned by BODYFORM.
 
 See also the function `signal' for more info.
@@ -1716,7 +1716,6 @@ signal_or_quit (Lisp_Object error_symbol, Lisp_Object data, bool keyboard_quit)
   Lisp_Object clause = Qnil;
   struct handler *h;
 
-  eassert (!itree_iterator_busy_p ());
   if (gc_in_progress || waiting_for_input)
     emacs_abort ();
 
@@ -1810,7 +1809,7 @@ signal_or_quit (Lisp_Object error_symbol, Lisp_Object data, bool keyboard_quit)
       unbind_to (count, Qnil);
     }
 
-  /* If an error is signalled during a Lisp hook in redisplay, write a
+  /* If an error is signaled during a Lisp hook in redisplay, write a
      backtrace into the buffer *Redisplay-trace*.  */
   if (!debugger_called && !NILP (error_symbol)
       && backtrace_on_redisplay_error
diff --git a/src/font.h b/src/font.h
index 3475189206f..d36c45a53c4 100644
--- a/src/font.h
+++ b/src/font.h
@@ -220,13 +220,13 @@ enum font_property_index
 #define FONT_WIDTH_FOR_FACE(font)       \
   font_style_symbolic (font, FONT_WIDTH_INDEX, true)
 
-/* Return the numeric weight value corresponding ot the symbol NAME.  */
+/* Return the numeric weight value corresponding to the symbol NAME.  */
 #define FONT_WEIGHT_NAME_NUMERIC(name)  \
   (font_style_to_value (FONT_WEIGHT_INDEX, (name), false) >> 8)
-/* Return the numeric slant value corresponding ot the symbol NAME.  */
+/* Return the numeric slant value corresponding to the symbol NAME.  */
 #define FONT_SLANT_NAME_NUMERIC(name)   \
   (font_style_to_value (FONT_SLANT_INDEX, (name), false) >> 8)
-/* Return the numeric width value corresponding ot the symbol NAME.  */
+/* Return the numeric width value corresponding to the symbol NAME.  */
 #define FONT_WIDTH_NAME_NUMERIC(name)   \
   (font_style_to_value (FONT_WIDTH_INDEX, (name), false) >> 8)
 
diff --git a/src/fontset.c b/src/fontset.c
index 4b91eff2ef6..b82737d005a 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -1663,7 +1663,17 @@ overwrites the previous settings.  */)
             {
               update_auto_fontset_alist (font_object, fontset_obj);
               AUTO_FRAME_ARG (arg, Qfont, Fcons (fontset, font_object));
-              Fmodify_frame_parameters (fr, arg);
+
+#ifdef HAVE_WINDOW_SYSTEM
+              if (FRAME_WINDOW_P (f))
+                /* This is a window-system frame.  Prevent changes of
+                   the `font' parameter here from messing with the
+                   `font-parameter' frame property, as the frame
+                   parameter is not being changed by the user.  */
+                gui_set_frame_parameters_1 (f, arg, true);
+              else
+#endif
+                Fmodify_frame_parameters (fr, arg);
             }
         }
     }
diff --git a/src/frame.c b/src/frame.c
index f076a5ba54e..b57b296be54 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -4119,10 +4119,17 @@ frame_float (struct frame *f, Lisp_Object val, enum frame_float_type what,
    If a parameter is not specially recognized, do nothing special;
    otherwise call the `gui_set_...' function for that parameter.
    Except for certain geometry properties, always call store_frame_param
-   to store the new value in the parameter alist.  */
+   to store the new value in the parameter alist.
+
+   DEFAULT_PARAMETER should be set if the alist was not specified by
+   the user, or by the face code to set the `font' parameter.  In that
+   case, the `font-parameter' frame parameter should not be changed,
+   so dynamic-setting.el can restore the user's selected font
+   correctly.  */
 
 void
-gui_set_frame_parameters (struct frame *f, Lisp_Object alist)
+gui_set_frame_parameters_1 (struct frame *f, Lisp_Object alist,
+                            bool default_parameter)
 {
   Lisp_Object tail, frame;
 
@@ -4249,7 +4256,7 @@ gui_set_frame_parameters (struct frame *f, Lisp_Object alist)
         }
       else
         {
-          register Lisp_Object param_index, old_value;
+          Lisp_Object param_index, old_value;
 
           old_value = get_frame_param (f, prop);
 
@@ -4260,6 +4267,12 @@ gui_set_frame_parameters (struct frame *f, Lisp_Object alist)
               && XFIXNAT (param_index) < ARRAYELTS (frame_parms)
               && FRAME_RIF (f)->frame_parm_handlers[XFIXNUM (param_index)])
             (*(FRAME_RIF (f)->frame_parm_handlers[XFIXNUM (param_index)])) (f, val, old_value);
+
+          if (!default_parameter && EQ (prop, Qfont))
+            /* The user manually specified the `font' frame parameter.
+               Save that parameter for future use by the
+               dynamic-setting code.  */
+            store_frame_param (f, Qfont_parameter, val);
         }
     }
 
@@ -4410,6 +4423,11 @@ gui_set_frame_parameters (struct frame *f, Lisp_Object alist)
   SAFE_FREE ();
 }
 
+void
+gui_set_frame_parameters (struct frame *f, Lisp_Object alist)
+{
+  gui_set_frame_parameters_1 (f, alist, false);
+}
 
 /* Insert a description of internally-recorded parameters of frame F
    into the parameter alist *ALISTPTR that is to be given to the user.
@@ -4586,9 +4604,6 @@ gui_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   Lisp_Object font_object;
   int fontset = -1;
-#ifdef HAVE_X_WINDOWS
-  Lisp_Object font_param = arg;
-#endif
 
   /* Set the frame parameter back to the old value because we may
      fail to use ARG as the new parameter value.  */
@@ -4627,16 +4642,10 @@ gui_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
         error ("Unknown fontset: %s", SDATA (XCAR (arg)));
       font_object = XCDR (arg);
       arg = AREF (font_object, FONT_NAME_INDEX);
-#ifdef HAVE_X_WINDOWS
-      font_param = Ffont_get (font_object, QCname);
-#endif
     }
   else if (FONT_OBJECT_P (arg))
     {
       font_object = arg;
-#ifdef HAVE_X_WINDOWS
-      font_param = Ffont_get (font_object, QCname);
-#endif
       /* This is to store the XLFD font name in the frame parameter for
          backward compatibility.  We should store the font-object
          itself in the future.  */
@@ -4667,9 +4676,7 @@ gui_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   if (FRAME_TERMINAL (f)->set_new_font_hook)
     FRAME_TERMINAL (f)->set_new_font_hook (f, font_object, fontset);
   store_frame_param (f, Qfont, arg);
-#ifdef HAVE_X_WINDOWS
-  store_frame_param (f, Qfont_parameter, font_param);
-#endif
+
   /* Recalculate tabbar height.  */
   f->n_tab_bar_rows = 0;
   /* Recalculate toolbar height.  */
@@ -4749,7 +4756,7 @@ gui_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_va
   if (FRAME_FONT (f))
     {
       /* Reconsider default font after backend(s) change (Bug#23386).  */
-      FRAME_RIF(f)->default_font_parameter (f, Qnil);
+      FRAME_RIF (f)->default_font_parameter (f, Qnil);
       face_change = true;
       windows_or_buffers_changed = 18;
     }
@@ -5451,12 +5458,20 @@ gui_default_parameter (struct frame *f, Lisp_Object alist, Lisp_Object prop,
                        enum resource_types type)
 {
   Lisp_Object tem;
+  bool was_unbound;
 
   tem = gui_frame_get_arg (f, alist, prop, xprop, xclass, type);
+
   if (BASE_EQ (tem, Qunbound))
-    tem = deflt;
+    {
+      tem = deflt;
+      was_unbound = true;
+    }
+  else
+    was_unbound = false;
+
   AUTO_FRAME_ARG (arg, prop, tem);
-  gui_set_frame_parameters (f, arg);
+  gui_set_frame_parameters_1 (f, arg, was_unbound);
   return tem;
 }
 
@@ -5946,6 +5961,67 @@ This function is for internal use only.  */)
 
   return f->was_invisible ? Qt : Qnil;
 }
+
+#ifdef HAVE_WINDOW_SYSTEM
+
+DEFUN ("reconsider-frame-fonts", Freconsider_frame_fonts,
+       Sreconsider_frame_fonts, 1, 1, 0,
+       doc: /* Recreate FRAME's default font using updated font parameters.
+Signal an error if FRAME is not a window system frame.  This should be
+called after a `config-changed' event is received, signaling that the
+parameters (such as pixel density) used by the system to open fonts
+have changed.  */)
+  (Lisp_Object frame)
+{
+  struct frame *f;
+  Lisp_Object params, font_parameter;
+
+  f = decode_window_system_frame (frame);
+
+  /* Kludge: if a `font' parameter was already specified,
+     create an alist containing just that parameter.  (bug#59371)
+
+     This sounds so simple, right?  Well, read on below: */
+  params = Qnil;
+
+  /* The difference between Qfont and Qfont_parameter is that the
+     latter is not set automatically by the likes of x_new_font, and
+     implicitly as the default face is realized.  It is only set when
+     the user specifically specifies a `font' frame parameter, and is
+     cleared the moment the frame's font becomes defined by a face
+     attribute, instead of through the `font' frame parameter.  */
+  font_parameter = get_frame_param (f, Qfont_parameter);
+
+  if (!NILP (font_parameter))
+    params = list1 (Fcons (Qfont, font_parameter));
+
+  /* First, call this to reinitialize any font backend specific
+     stuff.  */
+
+  if (FRAME_RIF (f)->default_font_parameter)
+    FRAME_RIF (f)->default_font_parameter (f, params);
+
+  /* For a mysterious reason, x_default_font_parameter sets Qfont to
+     nil in the alist!  */
+
+  if (!NILP (font_parameter))
+    params = list1 (Fcons (Qfont, font_parameter));
+
+  /* Now call this to apply the existing value(s) of the `default'
+     face.  */
+  call2 (Qface_set_after_frame_default, frame, params);
+
+  /* Restore the value of the `font-parameter' parameter, as
+     `face-set-after-frame-default' will have changed it through its
+     calls to `set-face-attribute'.  */
+  if (!NILP (font_parameter))
+    store_frame_param (f, Qfont_parameter, font_parameter);
+
+  return Qnil;
+}
+
+#endif
+
 
 /***********************************************************************
                         Multimonitor data
@@ -6201,6 +6277,7 @@ syms_of_frame (void)
   DEFSYM (Qiconify_top_level, "iconify-top-level");
   DEFSYM (Qmake_invisible, "make-invisible");
   DEFSYM (Quse_frame_synchronization, "use-frame-synchronization");
+  DEFSYM (Qfont_parameter, "font-parameter");
 
   {
     int i;
@@ -6634,6 +6711,6 @@ iconify the top level frame instead.  */);
 #ifdef HAVE_WINDOW_SYSTEM
   defsubr (&Sx_get_resource);
   defsubr (&Sx_parse_geometry);
+  defsubr (&Sreconsider_frame_fonts);
 #endif
-
 }
diff --git a/src/frame.h b/src/frame.h
index 458b6257e49..d6fd62b2ac2 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1670,6 +1670,7 @@ IMAGE_OPT_FROM_ID (struct frame *f, int id)
 /* The class of this X application.  */
 #define EMACS_CLASS "Emacs"
 
+extern void gui_set_frame_parameters_1 (struct frame *, Lisp_Object, bool);
 extern void gui_set_frame_parameters (struct frame *, Lisp_Object);
 extern void gui_set_fullscreen (struct frame *, Lisp_Object, Lisp_Object);
 extern void gui_set_line_spacing (struct frame *, Lisp_Object, Lisp_Object);
diff --git a/src/ftcrfont.c b/src/ftcrfont.c
index dc765e5aee4..ede8f1323cd 100644
--- a/src/ftcrfont.c
+++ b/src/ftcrfont.c
@@ -737,7 +737,7 @@ struct font_driver const ftcrfont_driver =
   .filter_properties = ftfont_filter_properties,
   .combining_capability = ftfont_combining_capability,
 #ifdef HAVE_PGTK
-  .cached_font_ok = ftcrfont_cached_font_ok
+  .cached_font_ok = ftcrfont_cached_font_ok,
 #endif
   };
 #ifdef HAVE_HARFBUZZ
@@ -755,6 +755,42 @@ syms_of_ftcrfont (void)
   pdumper_do_now_and_after_load (syms_of_ftcrfont_for_pdumper);
 }
 
+#ifdef HAVE_X_WINDOWS
+
+/* Place the default font options used by Cairo on the given display
+   in OPTIONS.  */
+
+void
+ftcrfont_get_default_font_options (struct x_display_info *dpyinfo,
+                                   cairo_font_options_t *options)
+{
+  Pixmap drawable;
+  cairo_surface_t *surface;
+
+  /* Cairo doesn't allow fetching the default font options for a
+     display, so the only option is to create a drawable, and an Xlib
+     surface for that drawable, and to get the font options from there
+     instead.  */
+
+  drawable = XCreatePixmap (dpyinfo->display, dpyinfo->root_window,
+                            1, 1, dpyinfo->n_planes);
+  surface = cairo_xlib_surface_create (dpyinfo->display, drawable,
+                                       dpyinfo->visual, 1, 1);
+
+  if (!surface)
+    {
+      XFreePixmap (dpyinfo->display, drawable);
+      return;
+    }
+
+  cairo_surface_get_font_options (surface, options);
+  XFreePixmap (dpyinfo->display, drawable);
+  cairo_surface_destroy (surface);
+  return;
+}
+
+#endif
+
 static void
 syms_of_ftcrfont_for_pdumper (void)
 {
diff --git a/src/ftfont.h b/src/ftfont.h
index cfab8d3154f..ee56e2d7608 100644
--- a/src/ftfont.h
+++ b/src/ftfont.h
@@ -84,4 +84,11 @@ struct font_info
 #endif
 };
 
+#if defined USE_CAIRO && defined HAVE_X_WINDOWS
+
+extern void ftcrfont_get_default_font_options (struct x_display_info *,
+                                               cairo_font_options_t *);
+
+#endif /* USE_CAIRO && HAVE_X_WINDOWS */
+
 #endif  /* EMACS_FTFONT_H */
diff --git a/src/gnutls.c b/src/gnutls.c
index a0de0238c47..7f0aaf85a41 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -2790,6 +2790,10 @@ Any GnuTLS extension with ID up to 100
 
   capabilities = Fcons (intern("gnutls"), capabilities);
 
+#  ifdef HAVE_GNUTLS_EXT__DUMBFW
+  capabilities = Fcons (intern("ClientHello Padding"), capabilities);
+#  endif
+
 # ifdef HAVE_GNUTLS3
   capabilities = Fcons (intern("gnutls3"), capabilities);
   capabilities = Fcons (intern("digests"), capabilities);
@@ -2807,16 +2811,14 @@ Any GnuTLS extension with ID up to 100
       const char* name = gnutls_ext_get_name(ext);
       if (name != NULL)
         {
-          capabilities = Fcons (intern(name), capabilities);
+          Lisp_Object cap = intern (name);
+          if (NILP (Fmemq (cap, capabilities)))
+            capabilities = Fcons (cap, capabilities);
         }
     }
 #  endif
 # endif   /* HAVE_GNUTLS3 */
 
-#  ifdef HAVE_GNUTLS_EXT__DUMBFW
-  capabilities = Fcons (intern("ClientHello Padding"), capabilities);
-#  endif
-
 # ifdef WINDOWSNT
   Vlibrary_cache = Fcons (Fcons (Qgnutls, capabilities), Vlibrary_cache);
 # endif /* WINDOWSNT */
diff --git a/src/haiku_support.cc b/src/haiku_support.cc
index 0f8e26d0db4..3a982856777 100644
--- a/src/haiku_support.cc
+++ b/src/haiku_support.cc
@@ -653,6 +653,24 @@ public:
       Quit ();
     else if (msg->what == B_CLIPBOARD_CHANGED)
       haiku_write (CLIPBOARD_CHANGED_EVENT, &rq);
+    else if (msg->what == B_KEY_MAP_LOADED)
+      {
+        /* Install the new keymap.  Or rather, clear key_map -- Emacs
+           will fetch it again from the main thread the next time it
+           is needed.  */
+        if (key_map_lock.Lock ())
+          {
+            if (key_map)
+              free (key_map);
+
+            if (key_chars)
+              free (key_chars);
+
+            key_map = NULL;
+            key_chars = NULL;
+            key_map_lock.Unlock ();
+          }
+      }
     else
       BApplication::MessageReceived (msg);
   }
diff --git a/src/haiku_support.h b/src/haiku_support.h
index e940e69bf11..2605a75b400 100644
--- a/src/haiku_support.h
+++ b/src/haiku_support.h
@@ -383,7 +383,7 @@ struct haiku_font_pattern
   /* The number of characters in `wanted_chars'.  */
   int want_chars_len;
 
-  /* List of characters.  The font must fullfill at least one of
+  /* List of characters.  The font must fulfill at least one of
      them for the match to succeed.  */
   int *need_one_of;
 
diff --git a/src/haikufns.c b/src/haikufns.c
index 711202c5df3..5717d0354f8 100644
--- a/src/haikufns.c
+++ b/src/haikufns.c
@@ -175,10 +175,19 @@ haiku_change_tool_bar_height (struct frame *f, int height)
 void
 haiku_change_tab_bar_height (struct frame *f, int height)
 {
-  int unit = FRAME_LINE_HEIGHT (f);
-  int old_height = FRAME_TAB_BAR_HEIGHT (f);
-  int lines = (height + unit - 1) / unit;
-  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
+  int unit, old_height, lines;
+  Lisp_Object fullscreen;
+
+  unit = FRAME_LINE_HEIGHT (f);
+  old_height = FRAME_TAB_BAR_HEIGHT (f);
+  fullscreen = get_frame_param (f, Qfullscreen);
+
+  /* This differs from the tool bar code in that the tab bar height is
+     not rounded up.  Otherwise, if redisplay_tab_bar decides to grow
+     the tab bar by even 1 pixel, FRAME_TAB_BAR_LINES will be changed,
+     leading to the tab bar height being incorrectly set upon the next
+     call to x_set_font.  (bug#59285) */
+  lines = height / unit;
 
   /* Make sure we redisplay all windows in this frame.  */
   fset_redisplay (f);
diff --git a/src/haikuselect.c b/src/haikuselect.c
index bd004f4900a..e8d3b5f0f7f 100644
--- a/src/haikuselect.c
+++ b/src/haikuselect.c
@@ -1260,7 +1260,7 @@ syms_of_haikuselect (void)
 {
   DEFVAR_BOOL ("haiku-signal-invalid-refs", haiku_signal_invalid_refs,
     doc: /* If nil, silently ignore invalid file names in system messages.
-Otherwise, an error will be signalled if adding a file reference to a
+Otherwise, an error will be signaled if adding a file reference to a
 system message failed.  */);
   haiku_signal_invalid_refs = true;
 
diff --git a/src/haikuterm.c b/src/haikuterm.c
index 4e32b747160..496480cbc09 100644
--- a/src/haikuterm.c
+++ b/src/haikuterm.c
@@ -3007,9 +3007,11 @@ haiku_default_font_parameter (struct frame *f, Lisp_Object parms)
     font = font_open_by_spec (f, Ffont_get_system_font ());
 
   if (NILP (font))
-      font = !NILP (font_param) ? font_param
-      : gui_display_get_arg (dpyinfo, parms, Qfont, "font", "Font",
-                             RES_TYPE_STRING);
+    font = (!NILP (font_param)
+            ? font_param
+            : gui_display_get_arg (dpyinfo, parms, Qfont,
+                                   "font", "Font",
+                                   RES_TYPE_STRING));
 
   if (! FONTP (font) && ! STRINGP (font))
     {
@@ -3029,13 +3031,6 @@ haiku_default_font_parameter (struct frame *f, Lisp_Object parms)
       if (NILP (font))
         error ("No suitable font was found");
     }
-  else if (!NILP (font_param))
-    {
-      /* Remember the explicit font parameter, so we can re-apply it
-         after we've applied the `default' face settings.  */
-      AUTO_FRAME_ARG (arg, Qfont_parameter, font_param);
-      gui_set_frame_parameters (f, arg);
-    }
 
   gui_default_parameter (f, parms, Qfont, font, "font", "Font",
                          RES_TYPE_STRING);
diff --git a/src/image.c b/src/image.c
index 1e323ba66a0..600c32571e1 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1843,7 +1843,9 @@ image_clear_image (struct frame *f, struct image *img)
 {
   block_input ();
   image_clear_image_1 (f, img,
-                   CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_MASK | CLEAR_IMAGE_COLORS);
+                       (CLEAR_IMAGE_PIXMAP
+                        | CLEAR_IMAGE_MASK
+                        | CLEAR_IMAGE_COLORS));
   unblock_input ();
 }
 
@@ -2980,7 +2982,8 @@ lookup_image (struct frame *f, Lisp_Object spec, int face_id)
       unblock_input ();
     }
 
-  /* We're using IMG, so set its timestamp to `now'.  */
+  /* IMG is now being used, so set its timestamp to the current
+     time.  */
   img->timestamp = current_timespec ();
 
   /* Value is the image id.  */
@@ -3238,12 +3241,13 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
 static void
 x_destroy_x_image (XImage *ximg)
 {
-  eassert (input_blocked_p ());
   if (ximg)
     {
       xfree (ximg->data);
       ximg->data = NULL;
     }
+
+  XDestroyImage (ximg);
 }
 
 # if !defined USE_CAIRO && defined HAVE_XRENDER
@@ -6224,26 +6228,28 @@ static void
 image_from_emacs_colors (struct frame *f, struct image *img, Emacs_Color *colors)
 {
   int x, y;
-  Emacs_Pix_Container oimg = NULL;
+  Emacs_Pix_Container ximage;
   Emacs_Color *p;
 
+  ximage = NULL;
+
   init_color_table ();
 
   image_clear_image_1 (f, img, CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_COLORS);
   image_create_x_image_and_pixmap (f, img, img->width, img->height, 0,
-                                   &oimg, 0);
+                                   &ximage, 0);
   p = colors;
   for (y = 0; y < img->height; ++y)
     for (x = 0; x < img->width; ++x, ++p)
       {
         unsigned long pixel;
         pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
-        PUT_PIXEL (oimg, x, y, pixel);
+        PUT_PIXEL (ximage, x, y, pixel);
       }
 
   xfree (colors);
 
-  image_put_x_image (f, img, oimg, 0);
+  image_put_x_image (f, img, ximage, false);
 #ifdef COLOR_TABLE_SUPPORT
   img->colors = colors_in_color_table (&img->ncolors);
   free_color_table ();
@@ -12207,7 +12213,15 @@ non-numeric, there is no explicit limit on the size of images.  */);
 # endif
   DEFSYM (Qgobject, "gobject");
 #endif /* HAVE_NTGUI  */
-#endif /* HAVE_RSVG  */
+#elif defined HAVE_NATIVE_IMAGE_API                     \
+  && ((defined HAVE_NS && defined NS_IMPL_COCOA)        \
+      || defined HAVE_HAIKU)
+  DEFSYM (Qsvg, "svg");
+
+  /* On Haiku, the SVG translator may not be installed.  */
+  if (image_can_use_native_api (Qsvg))
+    add_image_type (Qsvg);
+#endif
 
 #ifdef HAVE_NS
   DEFSYM (Qheic, "heic");
diff --git a/src/insdel.c b/src/insdel.c
index 6d56a76c77a..03ce59b3409 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -268,6 +268,7 @@ adjust_markers_for_delete (ptrdiff_t from, ptrdiff_t from_byte,
           m->bytepos = from_byte;
         }
     }
+  adjust_overlays_for_delete (from, to - from);
 }
 
 
@@ -307,6 +308,7 @@ adjust_markers_for_insert (ptrdiff_t from, ptrdiff_t from_byte,
           m->charpos += nchars;
         }
     }
+  adjust_overlays_for_insert (from, to - from, before_markers);
 }
 
 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
@@ -343,6 +345,11 @@ adjust_markers_for_replace (ptrdiff_t from, ptrdiff_t from_byte,
   ptrdiff_t diff_bytes = new_bytes - old_bytes;
 
   adjust_suspend_auto_hscroll (from, from + old_chars);
+
+  /* FIXME: When OLD_CHARS is 0, this "replacement" is really just an
+     insertion, but the behavior we provide here in that case is that of
+     `insert-before-markers` rather than that of `insert`.
+     Maybe not a bug, but not a feature either.  */
   for (m = BUF_MARKERS (current_buffer); m; m = m->next)
     {
       if (m->bytepos >= prev_to_byte)
@@ -358,6 +365,10 @@ adjust_markers_for_replace (ptrdiff_t from, ptrdiff_t from_byte,
     }
 
   check_markers ();
+
+  adjust_overlays_for_insert (from + old_chars, new_chars, true);
+  if (old_chars)
+    adjust_overlays_for_delete (from, old_chars);
 }
 
 /* Starting at POS (BYTEPOS), find the byte position corresponding to
@@ -917,7 +928,6 @@ insert_1_both (const char *string,
   if (Z - GPT < END_UNCHANGED)
     END_UNCHANGED = Z - GPT;
 
-  adjust_overlays_for_insert (PT, nchars);
   adjust_markers_for_insert (PT, PT_BYTE,
                              PT + nchars, PT_BYTE + nbytes,
                              before_markers);
@@ -1043,7 +1053,6 @@ insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
   if (Z - GPT < END_UNCHANGED)
     END_UNCHANGED = Z - GPT;
 
-  adjust_overlays_for_insert (PT, nchars);
   adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
                              PT_BYTE + outgoing_nbytes,
                              before_markers);
@@ -1115,9 +1124,8 @@ insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes, bool text_at_gap_tail)
 
   insert_from_gap_1 (nchars, nbytes, text_at_gap_tail);
 
-  adjust_overlays_for_insert (ins_charpos, nchars);
   adjust_markers_for_insert (ins_charpos, ins_bytepos,
-                             ins_charpos + nchars, ins_bytepos + nbytes, 0);
+                             ins_charpos + nchars, ins_bytepos + nbytes, false);
 
   if (buffer_intervals (current_buffer))
     {
@@ -1257,10 +1265,9 @@ insert_from_buffer_1 (struct buffer *buf,
   if (Z - GPT < END_UNCHANGED)
     END_UNCHANGED = Z - GPT;
 
-  adjust_overlays_for_insert (PT, nchars);
   adjust_markers_for_insert (PT, PT_BYTE, PT + nchars,
                              PT_BYTE + outgoing_nbytes,
-                             0);
+                             false);
 
   offset_intervals (current_buffer, PT, nchars);
 
@@ -1316,17 +1323,12 @@ adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte,
                                 len, len_byte);
   else
     adjust_markers_for_insert (from, from_byte,
-                               from + len, from_byte + len_byte, 0);
+                               from + len, from_byte + len_byte, false);
 
   if (nchars_del > 0)
     record_delete (from, prev_text, false);
   record_insert (from, len);
 
-  if (len > nchars_del)
-    adjust_overlays_for_insert (from, len - nchars_del);
-  else if (len < nchars_del)
-    adjust_overlays_for_delete (from, nchars_del - len);
-
   offset_intervals (current_buffer, from, len - nchars_del);
 
   if (from < PT)
@@ -1338,8 +1340,6 @@ adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte,
 
   check_markers ();
 
-  if (len == 0)
-    evaporate_overlays (from);
   modiff_incr (&MODIFF, nchars_del + len);
   CHARS_MODIFF = MODIFF;
 }
@@ -1507,14 +1507,9 @@ replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
          which make the original byte positions of the markers
          invalid.  */
       adjust_markers_bytepos (from, from_byte, from + inschars,
-                              from_byte + outgoing_insbytes, 1);
+                              from_byte + outgoing_insbytes, true);
     }
 
-  /* Adjust the overlay center as needed.  This must be done after
-     adjusting the markers that bound the overlays.  */
-  adjust_overlays_for_delete (from, nchars_del);
-  adjust_overlays_for_insert (from, inschars);
-
   offset_intervals (current_buffer, from, inschars - nchars_del);
 
   /* Get the intervals for the part of the string we are inserting--
@@ -1530,9 +1525,6 @@ replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
                   (from_byte + outgoing_insbytes
                    - (PT_BYTE < to_byte ? PT_BYTE : to_byte)));
 
-  if (outgoing_insbytes == 0)
-    evaporate_overlays (from);
-
   check_markers ();
 
   modiff_incr (&MODIFF, nchars_del + inschars);
@@ -1640,18 +1632,10 @@ replace_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
              sequences which make the original byte positions of the
              markers invalid.  */
           adjust_markers_bytepos (from, from_byte, from + inschars,
-                                  from_byte + insbytes, 1);
+                                  from_byte + insbytes, true);
         }
     }
 
-  /* Adjust the overlay center as needed.  This must be done after
-     adjusting the markers that bound the overlays.  */
-  if (nchars_del != inschars)
-    {
-      adjust_overlays_for_insert (from, inschars);
-      adjust_overlays_for_delete (from + inschars, nchars_del);
-    }
-
   offset_intervals (current_buffer, from, inschars - nchars_del);
 
   /* Relocate point as if it were a marker.  */
@@ -1664,9 +1648,6 @@ replace_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
         adjust_point (inschars - nchars_del, insbytes - nbytes_del);
     }
 
-  if (insbytes == 0)
-    evaporate_overlays (from);
-
   check_markers ();
 
   modiff_incr (&MODIFF, nchars_del + inschars);
@@ -1854,10 +1835,6 @@ del_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
 
   offset_intervals (current_buffer, from, - nchars_del);
 
-  /* Adjust the overlay center as needed.  This must be done after
-     adjusting the markers that bound the overlays.  */
-  adjust_overlays_for_delete (from, nchars_del);
-
   GAP_SIZE += nbytes_del;
   ZV_BYTE -= nbytes_del;
   Z_BYTE -= nbytes_del;
@@ -1879,8 +1856,6 @@ del_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
 
   check_markers ();
 
-  evaporate_overlays (from);
-
   return deletion;
 }
 
diff --git a/src/itree.c b/src/itree.c
index 3b10802ff09..04fa9e827a2 100644
--- a/src/itree.c
+++ b/src/itree.c
@@ -70,7 +70,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    but not the END.  The previous/next overlay change operations need
    to find the nearest point where there is *either* an interval BEG
    or END point, but there is no efficient way to narrow the search
-   space over END postions.
+   space over END positions.
 
    Consider the case where next-overlay-change is called at POS, all
    interval BEG positions are less than pos POS and all interval END
@@ -111,7 +111,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    In order to avoid this, we introduce yet another node attribute,
    called OFFSET.
 
-   The OFFSET of some some subtree, represented by its root, is the
+   The OFFSET of some subtree, represented by its root, is the
    amount of shift that needs to be applied to its BEGIN, END and
    LIMIT values, in order to get to the actual buffer positions.
    Coming back to the example, all we would need to do in this case,
@@ -131,43 +131,20 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  * | Stack
  * +=======================================================================+ */
 
-typedef uintptr_t nodeptr_and_flag;
-
-static inline nodeptr_and_flag
-make_nav (struct itree_node *ptr, bool flag)
-{
-  uintptr_t v = (uintptr_t) ptr;
-  /* We assume alignment imposes the LSB is clear for us to use it.  */
-  eassert (!(v & 1));
-  return v | !!flag;
-}
-
-static inline struct itree_node *
-nav_nodeptr (nodeptr_and_flag nav)
-{
-  return (struct itree_node *) (nav & (~(uintptr_t)1));
-}
-
-static inline bool
-nav_flag (nodeptr_and_flag nav)
-{
-  return (bool) (nav & 1);
-}
-
 /* Simple dynamic array. */
-struct interval_stack
+struct itree_stack
 {
-  nodeptr_and_flag *nodes;
+  struct itree_node **nodes;
   size_t size;
   size_t length;
 };
 
 /* This is just a simple dynamic array with stack semantics. */
 
-static struct interval_stack*
-interval_stack_create (intmax_t initial_size)
+static struct itree_stack*
+itree_stack_create (intmax_t initial_size)
 {
-  struct interval_stack *stack = xmalloc (sizeof (struct interval_stack));
+  struct itree_stack *stack = xmalloc (sizeof (struct itree_stack));
   stack->size = max (0, initial_size);
   stack->nodes = xmalloc (stack->size * sizeof (struct itree_node*));
   stack->length = 0;
@@ -175,7 +152,7 @@ interval_stack_create (intmax_t initial_size)
 }
 
 static void
-interval_stack_destroy (struct interval_stack *stack)
+itree_stack_destroy (struct itree_stack *stack)
 {
   if (! stack)
     return;
@@ -184,14 +161,8 @@ interval_stack_destroy (struct interval_stack *stack)
   xfree (stack);
 }
 
-static void
-interval_stack_clear (struct interval_stack *stack)
-{
-  stack->length = 0;
-}
-
 static inline void
-interval_stack_ensure_space (struct interval_stack *stack, intmax_t nelements)
+itree_stack_ensure_space (struct itree_stack *stack, uintmax_t nelements)
 {
   if (nelements > stack->size)
     {
@@ -204,95 +175,32 @@ interval_stack_ensure_space (struct interval_stack *stack, intmax_t nelements)
 /* Push NODE on the STACK, while settings its visited flag to FLAG. */
 
 static inline void
-interval_stack_push_flagged (struct interval_stack *stack,
-                             struct itree_node *node, bool flag)
+itree_stack_push (struct itree_stack *stack, struct itree_node *node)
 {
-  eassert (node && node != NULL);
-
-  /* FIXME: While the stack used in the iterator is bounded by the tree
-     depth and could be easily pre-allocated to a large enough size to avoid
-     this "ensure" check, `interval_stack_push` is also used elsewhere to
-     simply collect some subset of the overlays, where it's only bounded by
-     the total number of overlays in the buffer (which can be large and thus
-     preferably not pre-allocated needlessly).  */
-  interval_stack_ensure_space (stack, stack->length + 1);
+  eassert (node);
+  itree_stack_ensure_space (stack, stack->length + 1);
 
-  stack->nodes[stack->length] = make_nav (node, flag);
+  stack->nodes[stack->length] = node;
   stack->length++;
 }
 
-static inline void
-interval_stack_push (struct interval_stack *stack, struct itree_node *node)
-{
-  interval_stack_push_flagged (stack, node, false);
-}
-
-static inline nodeptr_and_flag
-interval_stack_pop (struct interval_stack *stack)
+static inline struct itree_node *
+itree_stack_pop (struct itree_stack *stack)
 {
   if (stack->length == 0)
-    return make_nav (NULL, false);
+    return NULL;
   return stack->nodes[--stack->length];
 }
 
 
 /* +-----------------------------------------------------------------------+ */
 
-/* State used when iterating interval. */
-struct itree_iterator
-{
-  struct interval_stack *stack;
-  ptrdiff_t begin;
-  ptrdiff_t end;
-
-  /* A copy of the tree's `otick`.  */
-  uintmax_t otick;
-  enum itree_order order;
-  bool running;
-  const char *file;
-  int line;
-};
-
-/* Ideally, every iteration would use its own `iter` object, so we could
-   have several iterations active at the same time.  In practice, iterations
-   are limited by the fact we don't allow modifying the tree at the same
-   time, making the use of nested iterations quite rare anyway.
-   So we just use a single global iterator instead for now.  */
-static struct itree_iterator *iter;
-
 static int
-interval_tree_max_height (const struct itree_tree *tree)
+itree_max_height (const struct itree_tree *tree)
 {
   return 2 * log (tree->size + 1) / log (2) + 0.5;
 }
 
-/* Allocate a new iterator for TREE. */
-
-static struct itree_iterator *
-itree_iterator_create (struct itree_tree *tree)
-{
-  struct itree_iterator *g = xmalloc (sizeof *g);
-  /* 19 here just avoids starting with a silly-small stack.
-     FIXME: Since this stack only needs to be about 2*max_depth
-     in the worst case, we could completely pre-allocate it to something
-     like word-bit-size * 2 and then never worry about growing it.  */
-  const int size = (tree ? interval_tree_max_height (tree) : 19) + 1;
-
-  g->stack = interval_stack_create (size);
-  g->running = false;
-  g->begin = 0;
-  g->end = 0;
-  g->file = NULL;
-  g->line = 0;
-  return g;
-}
-
-static void
-itree_init (void)
-{
-  iter = itree_iterator_create (NULL);
-}
-
 struct check_subtree_result
 {
   /* Node count of the tree.  */
@@ -325,7 +233,7 @@ check_subtree (struct itree_node *node,
      and <= to its parent's otick.
 
      Note: we cannot assert that (NODE.otick == NODE.parent.otick)
-     implies (NODE.offset == 0) because interval_tree_inherit_offset()
+     implies (NODE.offset == 0) because itree_inherit_offset()
      doesn't always update otick.  It could, but it is not clear there
      is a need.  */
   eassert (node->otick <= tree_otick);
@@ -429,7 +337,7 @@ itree_newlimit (struct itree_node *node)
 /* Update NODE's limit attribute according to its children. */
 
 static void
-interval_tree_update_limit (struct itree_node *node)
+itree_update_limit (struct itree_node *node)
 {
   if (node == NULL)
     return;
@@ -444,7 +352,7 @@ interval_tree_update_limit (struct itree_node *node)
 */
 
 static void
-interval_tree_inherit_offset (uintmax_t otick, struct itree_node *node)
+itree_inherit_offset (uintmax_t otick, struct itree_node *node)
 {
   eassert (node->parent == NULL || node->parent->otick >= node->otick);
   if (node->otick == otick)
@@ -481,7 +389,7 @@ interval_tree_inherit_offset (uintmax_t otick, struct itree_node *node)
    stable, i.e. new_limit = old_limit.  */
 
 static void
-interval_tree_propagate_limit (struct itree_node *node)
+itree_propagate_limit (struct itree_node *node)
 {
   ptrdiff_t newlimit;
 
@@ -502,15 +410,15 @@ interval_tree_propagate_limit (struct itree_node *node)
 }
 
 static struct itree_node*
-interval_tree_validate (struct itree_tree *tree, struct itree_node *node)
+itree_validate (struct itree_tree *tree, struct itree_node *node)
 {
 
   if (tree->otick == node->otick || node == NULL)
     return node;
   if (node != tree->root)
-    interval_tree_validate (tree, node->parent);
+    itree_validate (tree, node->parent);
 
-  interval_tree_inherit_offset (tree->otick, node);
+  itree_inherit_offset (tree->otick, node);
   return node;
 }
 
@@ -541,7 +449,7 @@ ptrdiff_t
 itree_node_begin (struct itree_tree *tree,
                   struct itree_node *node)
 {
-  interval_tree_validate (tree, node);
+  itree_validate (tree, node);
   return node->begin;
 }
 
@@ -551,20 +459,15 @@ ptrdiff_t
 itree_node_end (struct itree_tree *tree,
                 struct itree_node *node)
 {
-  interval_tree_validate (tree, node);
+  itree_validate (tree, node);
   return node->end;
 }
 
-/* Allocate an interval_tree. Free with interval_tree_destroy. */
+/* Allocate an itree_tree.  Free with itree_destroy.  */
 
 struct itree_tree *
 itree_create (void)
 {
-  /* FIXME?  Maybe avoid the initialization of itree_null in the same
-     way that is used to call mem_init in alloc.c?  It's not really
-     important though.  */
-  itree_init ();
-
   struct itree_tree *tree = xmalloc (sizeof (*tree));
   itree_clear (tree);
   return tree;
@@ -584,10 +487,9 @@ itree_clear (struct itree_tree *tree)
 /* Initialize a pre-allocated tree (presumably on the stack).  */
 
 static void
-interval_tree_init (struct interval_tree *tree)
+itree_init (struct itree_tree *tree)
 {
-  interval_tree_clear (tree);
-  /* tree->iter = itree_iterator_create (tree); */
+  itree_clear (tree);
 }
 #endif
 
@@ -596,8 +498,6 @@ void
 itree_destroy (struct itree_tree *tree)
 {
   eassert (tree->root == NULL);
-  /* if (tree->iter)
-   *   itree_iterator_destroy (tree->iter); */
   xfree (tree);
 }
 
@@ -612,15 +512,15 @@ itree_size (struct itree_tree *tree)
 /* Perform the familiar left-rotation on node NODE.  */
 
 static void
-interval_tree_rotate_left (struct itree_tree *tree,
+itree_rotate_left (struct itree_tree *tree,
                            struct itree_node *node)
 {
   eassert (node->right != NULL);
 
   struct itree_node *right = node->right;
 
-  interval_tree_inherit_offset (tree->otick, node);
-  interval_tree_inherit_offset (tree->otick, right);
+  itree_inherit_offset (tree->otick, node);
+  itree_inherit_offset (tree->otick, right);
 
   /* Turn right's left subtree into node's right subtree.  */
   node->right = right->left;
@@ -648,22 +548,22 @@ interval_tree_rotate_left (struct itree_tree *tree,
     node->parent = right;
 
   /* Order matters here.  */
-  interval_tree_update_limit (node);
-  interval_tree_update_limit (right);
+  itree_update_limit (node);
+  itree_update_limit (right);
 }
 
 /* Perform the familiar right-rotation on node NODE.  */
 
 static void
-interval_tree_rotate_right (struct itree_tree *tree,
+itree_rotate_right (struct itree_tree *tree,
                             struct itree_node *node)
 {
   eassert (tree && node && node->left != NULL);
 
   struct itree_node *left = node->left;
 
-  interval_tree_inherit_offset (tree->otick, node);
-  interval_tree_inherit_offset (tree->otick, left);
+  itree_inherit_offset (tree->otick, node);
+  itree_inherit_offset (tree->otick, left);
 
   node->left = left->right;
   if (left->right != NULL)
@@ -685,8 +585,8 @@ interval_tree_rotate_right (struct itree_tree *tree,
   if (node != NULL)
     node->parent = left;
 
-  interval_tree_update_limit (left);
-  interval_tree_update_limit (node);
+  itree_update_limit (left);
+  itree_update_limit (node);
 }
 
 /* Repair the tree after an insertion.
@@ -694,7 +594,7 @@ interval_tree_rotate_right (struct itree_tree *tree,
    Rebalance the parents as needed to re-establish the RB invariants.  */
 
 static void
-interval_tree_insert_fix (struct itree_tree *tree,
+itree_insert_fix (struct itree_tree *tree,
                           struct itree_node *node)
 {
   eassert (tree->root->red == false);
@@ -728,12 +628,12 @@ interval_tree_insert_fix (struct itree_tree *tree,
               if (node == node->parent->right) /* case 2.a */
                 {
                   node = node->parent;
-                  interval_tree_rotate_left (tree, node);
+                  itree_rotate_left (tree, node);
                 }
               /* case 3.a */
               node->parent->red = false;
               node->parent->parent->red = true;
-              interval_tree_rotate_right (tree, node->parent->parent);
+              itree_rotate_right (tree, node->parent->parent);
             }
         }
       else
@@ -753,12 +653,12 @@ interval_tree_insert_fix (struct itree_tree *tree,
               if (node == node->parent->left) /* case 2.b */
                 {
                   node = node->parent;
-                  interval_tree_rotate_right (tree, node);
+                  itree_rotate_right (tree, node);
                 }
               /* case 3.b */
               node->parent->red = false;
               node->parent->parent->red = true;
-              interval_tree_rotate_left (tree, node->parent->parent);
+              itree_rotate_left (tree, node->parent->parent);
             }
         }
     }
@@ -770,22 +670,20 @@ interval_tree_insert_fix (struct itree_tree *tree,
 }
 
 /* Insert a NODE into the TREE.
-   Note, that inserting a node twice results in undefined behaviour.  */
+   Note, that inserting a node twice results in undefined behavior.  */
 
 static void
-interval_tree_insert (struct itree_tree *tree, struct itree_node *node)
+itree_insert_node (struct itree_tree *tree, struct itree_node *node)
 {
-  eassert (node->begin <= node->end && node != NULL);
-  /* FIXME: The assertion below fails because `delete_all_overlays`
-     doesn't set left/right/parent to NULL.  */
-  /* eassert (node->left == NULL && node->right == NULL
-             && node->parent == NULL) */;
+  eassert (node && node->begin <= node->end);
+  eassert (node->left == NULL && node->right == NULL
+           && node->parent == NULL);
   eassert (check_tree (tree, true)); /* FIXME: Too expensive.  */
 
   struct itree_node *parent = NULL;
   struct itree_node *child = tree->root;
   uintmax_t otick = tree->otick;
-  /* It's the responsability of the caller to set `otick` on the node,
+  /* It's the responsibility of the caller to set `otick` on the node,
      to "confirm" that the begin/end fields are up to date.  */
   eassert (node->otick == otick);
 
@@ -793,7 +691,7 @@ interval_tree_insert (struct itree_tree *tree, struct itree_node *node)
      ancestors limit values.  */
   while (child != NULL)
     {
-      interval_tree_inherit_offset (otick, child);
+      itree_inherit_offset (otick, child);
       parent = child;
       eassert (child->offset == 0);
       child->limit = max (child->limit, node->end);
@@ -826,7 +724,7 @@ interval_tree_insert (struct itree_tree *tree, struct itree_node *node)
     {
       node->red = true;
       eassert (check_tree (tree, false)); /* FIXME: Too expensive.  */
-      interval_tree_insert_fix (tree, node);
+      itree_insert_fix (tree, node);
     }
 }
 
@@ -837,7 +735,7 @@ itree_insert (struct itree_tree *tree, struct itree_node *node,
   node->begin = begin;
   node->end = end;
   node->otick = tree->otick;
-  interval_tree_insert (tree, node);
+  itree_insert_node (tree, node);
 }
 
 /* Safely modify a node's interval. */
@@ -847,35 +745,32 @@ itree_node_set_region (struct itree_tree *tree,
                        struct itree_node *node,
                        ptrdiff_t begin, ptrdiff_t end)
 {
-  interval_tree_validate (tree, node);
+  itree_validate (tree, node);
   if (begin != node->begin)
     {
       itree_remove (tree, node);
       node->begin = min (begin, PTRDIFF_MAX - 1);
       node->end = max (node->begin, end);
-      interval_tree_insert (tree, node);
+      itree_insert_node (tree, node);
     }
   else if (end != node->end)
     {
       node->end = max (node->begin, end);
       eassert (node != NULL);
-      interval_tree_propagate_limit (node);
+      itree_propagate_limit (node);
     }
 }
 
 /* Return true, if NODE is a member of TREE. */
 
 static bool
-interval_tree_contains (struct itree_tree *tree, struct itree_node *node)
+itree_contains (struct itree_tree *tree, struct itree_node *node)
 {
   eassert (node);
   struct itree_node *other;
   ITREE_FOREACH (other, tree, node->begin, PTRDIFF_MAX, ASCENDING)
     if (other == node)
-      {
-        ITREE_FOREACH_ABORT ();
-        return true;
-      }
+      return true;
 
   return false;
 }
@@ -890,11 +785,11 @@ itree_limit_is_stable (struct itree_node *node)
 }
 
 static struct itree_node*
-interval_tree_subtree_min (uintmax_t otick, struct itree_node *node)
+itree_subtree_min (uintmax_t otick, struct itree_node *node)
 {
   if (node == NULL)
     return node;
-  while ((interval_tree_inherit_offset (otick, node),
+  while ((itree_inherit_offset (otick, node),
           node->left != NULL))
     node = node->left;
   return node;
@@ -905,14 +800,14 @@ interval_tree_subtree_min (uintmax_t otick, struct itree_node *node)
    so re-balance the parents to re-establish the RB invariants.  */
 
 static void
-interval_tree_remove_fix (struct itree_tree *tree,
+itree_remove_fix (struct itree_tree *tree,
                           struct itree_node *node,
                           struct itree_node *parent)
 {
   if (parent == NULL)
     eassert (node == tree->root);
   else
-  eassert (node == NULL || node->parent == parent);
+    eassert (node == NULL || node->parent == parent);
 
   while (parent != NULL && null_safe_is_black (node))
     {
@@ -926,7 +821,7 @@ interval_tree_remove_fix (struct itree_tree *tree,
             {
               other->red = false;
               parent->red = true;
-              interval_tree_rotate_left (tree, parent);
+              itree_rotate_left (tree, parent);
               other = parent->right;
             }
           eassume (other != NULL);
@@ -945,13 +840,13 @@ interval_tree_remove_fix (struct itree_tree *tree,
                 {
                   other->left->red = false;
                   other->red = true;
-                  interval_tree_rotate_right (tree, other);
+                  itree_rotate_right (tree, other);
                   other = parent->right;
                 }
               other->red = parent->red; /* 4.a */
               parent->red = false;
               other->right->red = false;
-              interval_tree_rotate_left (tree, parent);
+              itree_rotate_left (tree, parent);
               node = tree->root;
               parent = NULL;
             }
@@ -964,7 +859,7 @@ interval_tree_remove_fix (struct itree_tree *tree,
             {
               other->red = false;
               parent->red = true;
-              interval_tree_rotate_right (tree, parent);
+              itree_rotate_right (tree, parent);
               other = parent->left;
             }
           eassume (other != NULL);
@@ -983,14 +878,14 @@ interval_tree_remove_fix (struct itree_tree *tree,
                 {
                   other->right->red = false;
                   other->red = true;
-                  interval_tree_rotate_left (tree, other);
+                  itree_rotate_left (tree, other);
                   other = parent->left;
                 }
 
               other->red = parent->red; /* 4.b */
               parent->red = false;
               other->left->red = false;
-              interval_tree_rotate_right (tree, parent);
+              itree_rotate_right (tree, parent);
               node = tree->root;
               parent = NULL;
             }
@@ -1023,7 +918,7 @@ itree_total_offset (struct itree_node *node)
    unchanged.  Caller is responsible for recalculation of `limit`.
    Requires both nodes to be using the same effective `offset`.  */
 static void
-interval_tree_replace_child (struct itree_tree *tree,
+itree_replace_child (struct itree_tree *tree,
                              struct itree_node *source,
                              struct itree_node *dest)
 {
@@ -1049,11 +944,11 @@ interval_tree_replace_child (struct itree_tree *tree,
    recalculation of `limit`.  Requires both nodes to be using the same
    effective `offset`. */
 static void
-interval_tree_transplant (struct itree_tree *tree,
+itree_transplant (struct itree_tree *tree,
                           struct itree_node *source,
                           struct itree_node *dest)
 {
-  interval_tree_replace_child (tree, source, dest);
+  itree_replace_child (tree, source, dest);
   source->left = dest->left;
   if (source->left != NULL)
     source->left->parent = source;
@@ -1068,17 +963,17 @@ interval_tree_transplant (struct itree_tree *tree,
 struct itree_node*
 itree_remove (struct itree_tree *tree, struct itree_node *node)
 {
-  eassert (interval_tree_contains (tree, node));
+  eassert (itree_contains (tree, node));
   eassert (check_tree (tree, true)); /* FIXME: Too expensive.  */
 
   /* Find `splice`, the leaf node to splice out of the tree.  When
      `node` has at most one child this is `node` itself.  Otherwise,
      it is the in order successor of `node`.  */
-  interval_tree_inherit_offset (tree->otick, node);
+  itree_inherit_offset (tree->otick, node);
   struct itree_node *splice
     = (node->left == NULL || node->right == NULL)
         ? node
-        : interval_tree_subtree_min (tree->otick, node->right);
+        : itree_subtree_min (tree->otick, node->right);
 
   /* Find `subtree`, the only child of `splice` (may be NULL).  Note:
      `subtree` will not be modified other than changing its parent to
@@ -1099,7 +994,7 @@ itree_remove (struct itree_tree *tree, struct itree_node *node)
      `splice` is black, this creates a red-red violation, so remember
      this now as the field can be overwritten when splice is
      transplanted below.  */
-  interval_tree_replace_child (tree, subtree, splice);
+  itree_replace_child (tree, subtree, splice);
   bool removed_black = !splice->red;
 
   /* Replace `node` with `splice` in the tree and propagate limit
@@ -1108,18 +1003,18 @@ itree_remove (struct itree_tree *tree, struct itree_node *node)
      has a new child.  */
   if (splice != node)
     {
-      interval_tree_transplant (tree, splice, node);
-      interval_tree_propagate_limit (subtree_parent);
+      itree_transplant (tree, splice, node);
+      itree_propagate_limit (subtree_parent);
       if (splice != subtree_parent)
-        interval_tree_update_limit (splice);
+        itree_update_limit (splice);
     }
-  interval_tree_propagate_limit (splice->parent);
+  itree_propagate_limit (splice->parent);
 
   --tree->size;
 
   /* Fix any black height violation caused by removing a black node.  */
   if (removed_black)
-    interval_tree_remove_fix (tree, subtree, subtree_parent);
+    itree_remove_fix (tree, subtree, subtree_parent);
 
   eassert ((tree->size == 0) == (tree->root == NULL));
   eassert (check_tree (tree, true)); /* FIXME: Too expensive.  */
@@ -1137,52 +1032,6 @@ itree_remove (struct itree_tree *tree, struct itree_node *node)
   return node;
 }
 
-bool
-itree_iterator_busy_p (void)
-{
-  return (iter && iter->running);
-}
-
-/* Start a iterator enumerating all intervals in [BEGIN,END) in the
-   given ORDER.  Only one iterator per tree can be running at any time.  */
-
-struct itree_iterator *
-itree_iterator_start (struct itree_tree *tree, ptrdiff_t begin,
-                      ptrdiff_t end, enum itree_order order,
-                      const char *file, int line)
-{
-  /* struct itree_iterator *iter = tree->iter; */
-  if (iter->running)
-    {
-      fprintf (stderr,
-               "Detected nested iteration!\nOuter: %s:%d\nInner: %s:%d\n",
-               iter->file, iter->line, file, line);
-      emacs_abort ();
-    }
-  iter->begin = begin;
-  iter->end = end;
-  iter->otick = tree->otick;
-  iter->order = order;
-  interval_stack_clear (iter->stack);
-  if (begin <= end && tree->root != NULL)
-    interval_stack_push_flagged (iter->stack, tree->root, false);
-  iter->file = file;
-  iter->line = line;
-  iter->running = true;
-  /* interval_stack_ensure_space (iter->stack,
-                                  2 * interval_tree_max_height (tree)); */
-  return iter;
-}
-
-/* Stop using the iterator. */
-
-void
-itree_iterator_finish (struct itree_iterator *iter)
-{
-  eassert (iter->running);
-  iter->running = false;
-}
-
 
 /* +=======================================================================+
  * | Insert/Delete Gaps
@@ -1190,113 +1039,125 @@ itree_iterator_finish (struct itree_iterator *iter)
 
 /* Insert a gap at POS of length LENGTH expanding all intervals
    intersecting it, while respecting their rear_advance and
-   front_advance setting. */
+   front_advance setting.
+
+   If BEFORE_MARKERS is non-zero, all overlays beginning/ending at POS
+   are treated as if their front_advance/rear_advance was true. */
 
 void
 itree_insert_gap (struct itree_tree *tree,
-                  ptrdiff_t pos, ptrdiff_t length)
+                  ptrdiff_t pos, ptrdiff_t length, bool before_markers)
 {
-  if (length <= 0 || tree->root == NULL)
+  if (!tree || length <= 0 || tree->root == NULL)
     return;
   uintmax_t ootick = tree->otick;
 
   /* FIXME: Don't allocate iterator/stack anew every time. */
 
   /* Nodes with front_advance starting at pos may mess up the tree
-     order, so we need to remove them first. */
-  struct interval_stack *saved = interval_stack_create (0);
+     order, so we need to remove them first.  This doesn't apply for
+     `before_markers` since in that case, all positions move identically
+     regardless of `front_advance` or `rear_advance`.  */
+  struct itree_stack *saved = itree_stack_create (0);
   struct itree_node *node = NULL;
-  ITREE_FOREACH (node, tree, pos, pos + 1, PRE_ORDER)
+  if (!before_markers)
     {
-      if (node->begin == pos && node->front_advance
-          && (node->begin != node->end || node->rear_advance))
-        interval_stack_push (saved, node);
+      /* Actually any order would do.  */
+      ITREE_FOREACH (node, tree, pos, pos + 1, PRE_ORDER)
+        {
+          if (node->begin == pos && node->front_advance
+              /* If we have front_advance and !rear_advance and
+                 the overlay is empty, make sure we don't move
+                 begin past end by pretending it's !front_advance.  */
+              && (node->begin != node->end || node->rear_advance))
+            itree_stack_push (saved, node);
+        }
     }
-  for (int i = 0; i < saved->length; ++i)
-    itree_remove (tree, nav_nodeptr (saved->nodes[i]));
+  for (size_t i = 0; i < saved->length; ++i)
+    itree_remove (tree, saved->nodes[i]);
 
   /* We can't use an iterator here, because we can't effectively
-     narrow AND shift some subtree at the same time. */
+     narrow AND shift some subtree at the same time.  */
   if (tree->root != NULL)
     {
-      const int size = interval_tree_max_height (tree) + 1;
-      struct interval_stack *stack = interval_stack_create (size);
-      interval_stack_push (stack, tree->root);
-      nodeptr_and_flag nav;
-      while ((nav = interval_stack_pop (stack),
-              node = nav_nodeptr (nav)))
+      const int size = itree_max_height (tree) + 1;
+      struct itree_stack *stack = itree_stack_create (size);
+      itree_stack_push (stack, tree->root);
+      while ((node = itree_stack_pop (stack)))
         {
           /* Process in pre-order. */
-          interval_tree_inherit_offset (tree->otick, node);
+          itree_inherit_offset (tree->otick, node);
+          if (pos > node->limit)
+            continue;
           if (node->right != NULL)
             {
               if (node->begin > pos)
                 {
-                  /* All nodes in this subtree are shifted by length. */
+                  /* All nodes in this subtree are shifted by length.  */
                   node->right->offset += length;
                   ++tree->otick;
                 }
               else
-                interval_stack_push (stack, node->right);
+                itree_stack_push (stack, node->right);
             }
-          if (node->left != NULL
-              && pos <= node->left->limit + node->left->offset)
-            interval_stack_push (stack, node->left);
+          if (node->left != NULL)
+            itree_stack_push (stack, node->left);
 
-          /* node->begin == pos implies no front-advance. */
-          if (node->begin > pos)
+          if (before_markers
+              ? node->begin >= pos
+              : node->begin > pos) /* node->begin == pos => !front-advance  */
             node->begin += length;
-          if (node->end > pos || (node->end == pos && node->rear_advance))
+          if (node->end > pos
+              || (node->end == pos && (before_markers || node->rear_advance)))
             {
               node->end += length;
               eassert (node != NULL);
-              interval_tree_propagate_limit (node);
+              itree_propagate_limit (node);
             }
         }
-      interval_stack_destroy (stack);
+      itree_stack_destroy (stack);
     }
 
-  /* Reinsert nodes starting at POS having front-advance. */
+  /* Reinsert nodes starting at POS having front-advance.  */
   uintmax_t notick = tree->otick;
-  nodeptr_and_flag nav;
-  while ((nav = interval_stack_pop (saved),
-          node = nav_nodeptr (nav)))
+  while ((node = itree_stack_pop (saved)))
     {
       eassert (node->otick == ootick);
+      eassert (node->begin == pos);
+      eassert (node->end > pos || node->rear_advance);
       node->begin += length;
-      if (node->end != pos || node->rear_advance)
-        node->end += length;
+      node->end += length;
       node->otick = notick;
-      interval_tree_insert (tree, node);
+      itree_insert_node (tree, node);
     }
 
-  interval_stack_destroy (saved);
+  itree_stack_destroy (saved);
 }
 
 /* Delete a gap at POS of length LENGTH, contracting all intervals
-   intersecting it. */
+   intersecting it.  */
 
 void
 itree_delete_gap (struct itree_tree *tree,
                   ptrdiff_t pos, ptrdiff_t length)
 {
-  if (length <= 0 || tree->root == NULL)
+  if (!tree || length <= 0 || tree->root == NULL)
     return;
 
-  /* FIXME: Don't allocate stack anew every time. */
+  /* FIXME: Don't allocate stack anew every time.  */
 
   /* Can't use the iterator here, because by decrementing begin, we
-     might unintentionally bring shifted nodes back into our search space. */
-  const int size = interval_tree_max_height (tree) + 1;
-  struct interval_stack *stack = interval_stack_create (size);
+     might unintentionally bring shifted nodes back into our search space.  */
+  const int size = itree_max_height (tree) + 1;
+  struct itree_stack *stack = itree_stack_create (size);
   struct itree_node *node;
 
-  interval_stack_push (stack, tree->root);
-  nodeptr_and_flag nav;
-  while ((nav = interval_stack_pop (stack)))
+  itree_stack_push (stack, tree->root);
+  while ((node = itree_stack_pop (stack)))
     {
-      node = nav_nodeptr (nav);
-      interval_tree_inherit_offset (tree->otick, node);
+      itree_inherit_offset (tree->otick, node);
+      if (pos > node->limit)
+        continue;
       if (node->right != NULL)
         {
           if (node->begin > pos + length)
@@ -1306,11 +1167,10 @@ itree_delete_gap (struct itree_tree *tree,
               ++tree->otick;
             }
           else
-            interval_stack_push (stack, node->right);
+            itree_stack_push (stack, node->right);
         }
-      if (node->left != NULL
-          && pos <= node->left->limit + node->left->offset)
-        interval_stack_push (stack, node->left);
+      if (node->left != NULL)
+        itree_stack_push (stack, node->left);
 
       if (pos < node->begin)
         node->begin = max (pos, node->begin - length);
@@ -1318,10 +1178,10 @@ itree_delete_gap (struct itree_tree *tree,
         {
           node->end = max (pos , node->end - length);
           eassert (node != NULL);
-          interval_tree_propagate_limit (node);
+          itree_propagate_limit (node);
         }
     }
-  interval_stack_destroy (stack);
+  itree_stack_destroy (stack);
 }
 
 
@@ -1339,81 +1199,217 @@ itree_delete_gap (struct itree_tree *tree,
    a NODE2 strictly bigger than NODE1 should also be included).  */
 
 static inline bool
-interval_node_intersects (const struct itree_node *node,
-                          ptrdiff_t begin, ptrdiff_t end)
+itree_node_intersects (const struct itree_node *node,
+                       ptrdiff_t begin, ptrdiff_t end)
 {
   return (begin < node->end && node->begin < end)
     || (node->begin == node->end && begin == node->begin);
 }
 
-/* Return the next node of the iterator in the order given when it was
-   started; or NULL if there are no more nodes. */
+/* Return the "next" node in the current traversal order.
 
-struct itree_node *
-itree_iterator_next (struct itree_iterator *g)
-{
-  eassert (g->running);
+   Note that this should return all the nodes that we need to traverse
+   in order to traverse the nodes selected by the current narrowing (i.e.
+   `ITER->begin..ITER->end`) so it will also return some nodes which aren't in
+   that narrowing simply because they may have children which are.
 
-  struct itree_node *const null = NULL;
-  struct itree_node *node;
+   The code itself is very unsatifactory because the code of each one
+   of the supported traversals seems completely different from the others.
+   If someone knows how to make it more uniform and "obviously correct",
+   please make yourself heard.  */
 
-  /* The `visited` flag stored in each node is used here (and only here):
-     We keep a "workstack" of nodes we need to consider.  This stack
-     consist of nodes of two types: nodes that we have decided
-     should be returned by the iterator, and nodes which we may
-     need to consider (including checking their children).
-     We start an iteration with a stack containing just the root
-     node marked as "not visited" which means that it (and its children)
-     needs to be considered but we haven't yet decided whether it's included
-     in the iterator's output.  */
-
-  do
+static struct itree_node *
+itree_iter_next_in_subtree (struct itree_node *node,
+                            struct itree_iterator *iter)
+{
+  /* FIXME: Like in the previous version of the iterator, we
+     prune based on `limit` only when moving to a left child,
+     but `limit` can also get smaller when moving to a right child
+     It's actually fairly common, so maybe it would be worthwhile
+     to prune a bit more aggressively here.  */
+  struct itree_node *next;
+  switch (iter->order)
     {
-      nodeptr_and_flag nav;
-      bool visited;
-      while ((nav = interval_stack_pop (g->stack),
-              node = nav_nodeptr (nav),
-              visited = nav_flag (nav),
-              node && !visited))
-        {
-          struct itree_node *const left = node->left;
-          struct itree_node *const right = node->right;
+    case ITREE_ASCENDING:
+      next = node->right;
+      if (!next)
+        {
+          while ((next = node->parent)
+                 && next->right == node)
+            node = next;
+          if (!next)
+            return NULL;   /* No more nodes to visit. */
+          node = next;
+        }
+      else
+        {
+          node = next;
+          itree_inherit_offset (iter->otick, node);
+          while ((next = node->left)
+                 && (itree_inherit_offset (iter->otick, next),
+                     iter->begin <= next->limit))
+            node = next;
+        }
+      if (node->begin > iter->end)
+        return NULL;  /* No more nodes within begin..end.  */
+      return node;
+
+    case ITREE_DESCENDING:
+      next = node->left;
+      if (!next
+          || (itree_inherit_offset (iter->otick, next),
+              next->limit < iter->begin))
+        {
+          while ((next = node->parent)
+                 && next->left == node)
+            node = next;
+          if (!next)
+            return NULL;   /* No more nodes to visit. */
+          node = next;
+        }
+      else
+        {
+          node = next;
+          while (node->begin <= iter->end
+                 && (next = node->right))
+            {
+              itree_inherit_offset (iter->otick, next),
+              node = next;
+            }
+        }
+      return node;
+
+    case ITREE_PRE_ORDER:
+      next = node->left;
+      if (next
+          && (itree_inherit_offset (iter->otick, next),
+              !(next->limit < iter->begin)))
+        return next;
+      next = node->right;
+      if (node->begin <= iter->end && next)
+        {
+          itree_inherit_offset (iter->otick, next);
+          return next;
+        }
+      while ((next = node->parent))
+        {
+          if (next->right == node)
+            node = next;
+          else
+            {
+              eassert (next->left == node);
+              node = next;
+              next = node->right;
+              if (node->begin <= iter->end && next)
+                {
+                  itree_inherit_offset (iter->otick, next);
+                  return next;
+                }
+            }
+          }
+      return NULL;
+
+    case ITREE_POST_ORDER:
+      next = node->parent;
+      if (!next || next->right == node)
+        return next;
+      eassert (next->left == node);
+      node = next;
+      next = node->right;
+      if (!(node->begin <= iter->end && next))
+        return node;
+      node = next;
+      itree_inherit_offset (iter->otick, node);
+      while (((next = node->left)
+              && (itree_inherit_offset (iter->otick, next),
+                  iter->begin <= next->limit))
+             || (node->begin <= iter->end
+                 && (next = node->right)
+                 && (itree_inherit_offset (iter->otick, next), true)))
+        node = next;
+      return node;
+
+    default:
+    emacs_abort ();
+    }
+}
 
-          interval_tree_inherit_offset (g->otick, node);
-          eassert (itree_limit_is_stable (node));
-          switch (g->order)
-            {
-            case ITREE_ASCENDING:
-              if (right != null && node->begin <= g->end)
-                interval_stack_push_flagged (g->stack, right, false);
-              if (interval_node_intersects (node, g->begin, g->end))
-                interval_stack_push_flagged (g->stack, node, true);
-              /* Node's children may still be off-set and we need to add it.  */
-              if (left != null && g->begin <= left->limit + left->offset)
-                interval_stack_push_flagged (g->stack, left, false);
-              break;
-            case ITREE_DESCENDING:
-              if (left != null && g->begin <= left->limit + left->offset)
-                interval_stack_push_flagged (g->stack, left, false);
-              if (interval_node_intersects (node, g->begin, g->end))
-                interval_stack_push_flagged (g->stack, node, true);
-              if (right != null && node->begin <= g->end)
-                interval_stack_push_flagged (g->stack, right, false);
-              break;
-            case ITREE_PRE_ORDER:
-              if (right != null && node->begin <= g->end)
-                interval_stack_push_flagged (g->stack, right, false);
-              if (left != null && g->begin <= left->limit + left->offset)
-                interval_stack_push_flagged (g->stack, left, false);
-              if (interval_node_intersects (node, g->begin, g->end))
-                interval_stack_push_flagged (g->stack, node, true);
-              break;
-            }
-        }
-      /* Node may have been invalidated by itree_iterator_narrow
-         after it was pushed: Check if it still intersects. */
-    } while (node && ! interval_node_intersects (node, g->begin, g->end));
+static struct itree_node *
+itree_iterator_first_node (struct itree_tree *tree,
+                           struct itree_iterator *iter)
+{
+  struct itree_node *node = tree->root;
+  if (node)
+    {
+      struct itree_node dummy;
+      dummy.left = NULL;
+      dummy.parent = NULL;
+      dummy.right = NULL;
+      itree_inherit_offset (iter->otick, node);
+      switch (iter->order)
+        {
+        case ITREE_ASCENDING:
+          dummy.right = node;
+          dummy.begin = PTRDIFF_MIN;
+          node = itree_iter_next_in_subtree (&dummy, iter);
+          break;
+
+        case ITREE_DESCENDING:
+          dummy.left = node;
+          node = itree_iter_next_in_subtree (&dummy, iter);
+          break;
+
+        case ITREE_PRE_ORDER:
+          break;
+
+        case ITREE_POST_ORDER:
+          dummy.parent = &dummy;
+          dummy.left = &dummy;
+          dummy.right = node;
+          dummy.begin = PTRDIFF_MIN;
+          node = itree_iter_next_in_subtree (&dummy, iter);
+          break;
+        default:
+          emacs_abort ();
+        }
+    }
+  return node;
+}
+
+/* Start a iterator enumerating all intervals in [BEGIN,END) in the
+   given ORDER.  */
+
+struct itree_iterator *
+itree_iterator_start (struct itree_iterator *iter,
+                      struct itree_tree *tree,
+                      ptrdiff_t begin, ptrdiff_t end, enum itree_order order)
+{
+  eassert (iter);
+  iter->begin = begin;
+  iter->end = end;
+  iter->otick = tree->otick;
+  iter->order = order;
+  /* Beware: the `node` field always holds "the next" node to consider.
+     so it's always "one node ahead" of what the iterator loop sees.
+     In most respects this makes no difference, but we depend on this
+     detail in `delete_all_overlays` where this allows us to modify
+     the current node knowing that the iterator will not need it to
+     find the next.  */
+  iter->node = itree_iterator_first_node (tree, iter);
+  return iter;
+}
 
+struct itree_node *
+itree_iterator_next (struct itree_iterator *iter)
+{
+  struct itree_node *node = iter->node;
+  while (node
+         && !itree_node_intersects (node, iter->begin, iter->end))
+    {
+      node = itree_iter_next_in_subtree (node, iter);
+      eassert (itree_limit_is_stable (node));
+    }
+  iter->node = node ? itree_iter_next_in_subtree (node, iter) : NULL;
   return node;
 }
 
@@ -1424,9 +1420,9 @@ void
 itree_iterator_narrow (struct itree_iterator *g,
                        ptrdiff_t begin, ptrdiff_t end)
 {
-  eassert (g->running);
+  eassert (g);
   eassert (begin >= g->begin);
   eassert (end <= g->end);
-  g->begin =  max (begin, g->begin);
-  g->end =  min (end, g->end);
+  g->begin = max (begin, g->begin);
+  g->end = min (end, g->end);
 }
diff --git a/src/itree.h b/src/itree.h
index c6b68d36672..291fa53fd30 100644
--- a/src/itree.h
+++ b/src/itree.h
@@ -104,6 +104,7 @@ enum itree_order
     ITREE_ASCENDING,
     ITREE_DESCENDING,
     ITREE_PRE_ORDER,
+    ITREE_POST_ORDER,
   };
 
 extern void itree_node_init (struct itree_node *, bool, bool, Lisp_Object);
@@ -119,25 +120,33 @@ extern void itree_insert (struct itree_tree *, struct itree_node *,
                           ptrdiff_t, ptrdiff_t);
 extern struct itree_node *itree_remove (struct itree_tree *,
                                         struct itree_node *);
-extern void itree_insert_gap (struct itree_tree *, ptrdiff_t, ptrdiff_t);
+extern void itree_insert_gap (struct itree_tree *, ptrdiff_t, ptrdiff_t, bool);
 extern void itree_delete_gap (struct itree_tree *, ptrdiff_t, ptrdiff_t);
 
 /* Iteration functions.  Almost all code should use ITREE_FOREACH
    instead.  */
-extern bool itree_iterator_busy_p (void);
-extern struct itree_iterator *itree_iterator_start (struct itree_tree *,
+extern struct itree_iterator *itree_iterator_start (struct itree_iterator *,
+                                                    struct itree_tree *,
                                                     ptrdiff_t,
                                                     ptrdiff_t,
-                                                    enum itree_order,
-                                                    const char *, int);
+                                                    enum itree_order);
 extern void itree_iterator_narrow (struct itree_iterator *, ptrdiff_t,
                                    ptrdiff_t);
-extern void itree_iterator_finish (struct itree_iterator *);
 extern struct itree_node *itree_iterator_next (struct itree_iterator *);
 
+/* State used when iterating interval. */
+struct itree_iterator
+  {
+    struct itree_node *node;
+    ptrdiff_t begin;
+    ptrdiff_t end;
+    uintmax_t otick;    /* A copy of the tree's `otick`.  */
+    enum itree_order order;
+  };
+
 /* Iterate over the intervals between BEG and END in the tree T.
    N will hold successive nodes.  ORDER can be one of : `ASCENDING`,
-   `DESCENDING`, or `PRE_ORDER`.
+   `DESCENDING`, `POST_ORDER`, or `PRE_ORDER`.
    It should be used as:
 
       ITREE_FOREACH (n, t, beg, end, order)
@@ -147,34 +156,24 @@ extern struct itree_node *itree_iterator_next (struct itree_iterator *);
 
    BEWARE:
    - The expression T may be evaluated more than once, so make sure
-     it is cheap a pure.
-   - Only a single iteration can happen at a time, so make sure none of the
-     code within the loop can start another tree iteration, i.e. it shouldn't
-     be able to run ELisp code, nor GC since GC can run ELisp by way
-     of `post-gc-hook`.
-   - If you need to exit the loop early, you *have* to call `ITREE_ABORT`
-     just before exiting (e.g. with `break` or `return`).
-   - Non-local exits are not supported within the body of the loop.
+     it is cheap and pure.
    - Don't modify the tree during the iteration.
  */
 #define ITREE_FOREACH(n, t, beg, end, order)                        \
-  /* FIXME: We'd want to declare `x` right here, but I can't figure out
+  /* FIXME: We'd want to declare `n` right here, but I can't figure out
      how to make that work here: the `for` syntax only allows a single
      clause for the var declarations where we need 2 different types.
      We could use the `struct {foo x; bar y; } p;` trick to declare two
      vars `p.x` and `p.y` of unrelated types, but then none of the names
-     of the vars matches the `n` we receive :-(.  */                \
-  if (!t)                                                           \
-    { }                                                             \
-  else                                                              \
-    for (struct itree_iterator *itree_iter_                         \
-            = itree_iterator_start (t, beg, end, ITREE_##order,     \
-                                        __FILE__, __LINE__);        \
-          ((n = itree_iterator_next (itree_iter_))                  \
-           || (itree_iterator_finish (itree_iter_), false));)
-
-#define ITREE_FOREACH_ABORT() \
-  itree_iterator_finish (itree_iter_)
+     of the vars matches the `n` we receive :-(.  */             \
+  if (!t)                                                        \
+    { }                                                          \
+  else                                                           \
+    for (struct itree_iterator itree_local_iter_,                \
+                               *itree_iter_                      \
+            = itree_iterator_start (&itree_local_iter_,          \
+                                    t, beg, end, ITREE_##order); \
+          ((n = itree_iterator_next (itree_iter_)));)
 
 #define ITREE_FOREACH_NARROW(beg, end) \
   itree_iterator_narrow (itree_iter_, beg, end)
diff --git a/src/keyboard.c b/src/keyboard.c
index d8796569cd2..4b35a044eb0 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -503,9 +503,11 @@ echo_add_key (Lisp_Object c)
   if ((NILP (echo_string) || SCHARS (echo_string) == 0)
       && help_char_p (c))
     {
-      AUTO_STRING (str, " (Type ? for further options)");
+      AUTO_STRING (str, " (Type ? for further options, q for quick help)");
       AUTO_LIST2 (props, Qface, Qhelp_key_binding);
       Fadd_text_properties (make_fixnum (7), make_fixnum (8), props, str);
+      Fadd_text_properties (make_fixnum (30), make_fixnum (31), props,
+str);
       new_string = concat2 (new_string, str);
     }
 
@@ -5718,6 +5720,29 @@ make_scroll_bar_position (struct input_event *ev, Lisp_Object type)
                 builtin_lisp_symbol (scroll_bar_parts[ev->part]));
 }
 
+#if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
+
+/* Return whether or not the coordinates X and Y are inside the
+   box of the menu-bar window of frame F.  */
+
+static bool
+coords_in_menu_bar_window (struct frame *f, int x, int y)
+{
+  struct window *window;
+
+  if (!WINDOWP (f->menu_bar_window))
+    return false;
+
+  window = XWINDOW (f->menu_bar_window);
+
+  return (y >= WINDOW_TOP_EDGE_Y (window)
+          && x >= WINDOW_LEFT_EDGE_X (window)
+          && y <= WINDOW_BOTTOM_EDGE_Y (window)
+          && x <= WINDOW_RIGHT_EDGE_X (window));
+}
+
+#endif
+
 /* Given a struct input_event, build the lisp event which represents
    it.  If EVENT is 0, build a mouse movement event from the mouse
    movement buffer, which should have a movement event in it.
@@ -5970,10 +5995,32 @@ make_lispy_event (struct input_event *event)
                and ROW are set to frame relative glyph coordinates
                which are then used to determine whether this click is
                in a menu (non-toolkit version).  */
-            if (!toolkit_menubar_in_use (f))
+            if (!toolkit_menubar_in_use (f)
+#if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
+                /* Don't process events for menu bars if they are not
+                   in the menu bar window.  */
+                && (!FRAME_WINDOW_P (f)
+                    || coords_in_menu_bar_window (f, XFIXNUM (event->x),
+                                                  XFIXNUM (event->y)))
+#endif
+                )
               {
-                pixel_to_glyph_coords (f, XFIXNUM (event->x), XFIXNUM (event->y),
-                                       &column, &row, NULL, 1);
+#if defined HAVE_WINDOW_SYSTEM && !defined HAVE_EXT_MENU_BAR
+                if (FRAME_WINDOW_P (f))
+                  {
+                    struct window *menu_w = XWINDOW (f->menu_bar_window);
+                    int x, y, dummy;
+
+                    x = FRAME_TO_WINDOW_PIXEL_X (menu_w, XFIXNUM (event->x));
+                    y = FRAME_TO_WINDOW_PIXEL_Y (menu_w, XFIXNUM (event->y));
+
+                    x_y_to_hpos_vpos (XWINDOW (f->menu_bar_window), x, y, &column, &row,
+                                      NULL, NULL, &dummy);
+                  }
+                else
+#endif
+                  pixel_to_glyph_coords (f, XFIXNUM (event->x), XFIXNUM (event->y),
+                                         &column, &row, NULL, 1);
 
                 /* In the non-toolkit version, clicks on the menu bar
                    are ordinary button events in the event buffer.
@@ -5983,7 +6030,7 @@ make_lispy_event (struct input_event *event)
                    menu bar and Emacs doesn't know about it until
                    after the user makes a selection.)  */
                 if (row >= 0 && row < FRAME_MENU_BAR_LINES (f)
-                  && (event->modifiers & down_modifier))
+                    && (event->modifiers & down_modifier))
                   {
                     Lisp_Object items, item;
 
diff --git a/src/lisp.h b/src/lisp.h
index 64167856835..8a5b8dad831 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4690,7 +4690,7 @@ extern void syms_of_editfns (void);
 extern bool mouse_face_overlay_overlaps (Lisp_Object);
 extern Lisp_Object disable_line_numbers_overlay_at_eob (void);
 extern AVOID nsberror (Lisp_Object);
-extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
+extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t, bool);
 extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
 extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
 extern void report_overlay_modification (Lisp_Object, Lisp_Object, bool,
@@ -4915,6 +4915,7 @@ extern bool running_asynch_code;
 
 /* Defined in process.c.  */
 struct Lisp_Process;
+extern void child_signal_init (void);
 extern void kill_buffer_processes (Lisp_Object);
 extern int wait_reading_process_output (intmax_t, int, int, bool, Lisp_Object,
                                         struct Lisp_Process *, int);
diff --git a/src/lread.c b/src/lread.c
index dfa4d9afb51..2a57f721943 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1236,7 +1236,8 @@ Return t if the file exists and loads successfully.  */)
   /* If file name is magic, call the handler.  */
   handler = Ffind_file_name_handler (file, Qload);
   if (!NILP (handler))
-    return call5 (handler, Qload, file, noerror, nomessage, nosuffix);
+    return
+      call6 (handler, Qload, file, noerror, nomessage, nosuffix, must_suffix);
 
   /* The presence of this call is the result of a historical accident:
      it used to be in every file-operation and when it got removed
@@ -1740,12 +1741,15 @@ maybe_swap_for_eln (bool no_native, Lisp_Object *filename, int *fd,
                                                Vload_path,
                                                Qnil, Qnil)))
                 return;
-              call2 (intern_c_string ("display-warning"),
-                     Qcomp,
-                     CALLN (Fformat,
-                            build_string ("Cannot look up eln file as "
-                                          "no source file was found for %s"),
-                            *filename));
+              Vdelayed_warnings_list
+                = Fcons (list2
+                         (Qcomp,
+                          CALLN (Fformat,
+                                 build_string ("Cannot look up eln "
+                                               "file as no source file "
+                                               "was found for %s"),
+                                 *filename)),
+                         Vdelayed_warnings_list);
               return;
             }
         }
@@ -5619,7 +5623,8 @@ from the file, and matches them against this regular expression.
 When the regular expression matches, the file is considered to be safe
 to load.  */);
   Vbytecomp_version_regexp
-    = build_pure_c_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
+    = build_pure_c_string
+        ("^;;;.\\(?:in Emacs version\\|bytecomp version FSF\\)");
 
   DEFSYM (Qlexical_binding, "lexical-binding");
   DEFVAR_LISP ("lexical-binding", Vlexical_binding,
diff --git a/src/nsfns.m b/src/nsfns.m
index 2699cf37a5b..d793bcf13ff 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -632,10 +632,19 @@ ns_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 void
 ns_change_tab_bar_height (struct frame *f, int height)
 {
-  int unit = FRAME_LINE_HEIGHT (f);
-  int old_height = FRAME_TAB_BAR_HEIGHT (f);
-  int lines = (height + unit - 1) / unit;
-  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
+  int unit, old_height, lines;
+  Lisp_Object fullscreen;
+
+  unit = FRAME_LINE_HEIGHT (f);
+  old_height = FRAME_TAB_BAR_HEIGHT (f);
+  fullscreen = get_frame_param (f, Qfullscreen);
+
+  /* This differs from the tool bar code in that the tab bar height is
+     not rounded up.  Otherwise, if redisplay_tab_bar decides to grow
+     the tab bar by even 1 pixel, FRAME_TAB_BAR_LINES will be changed,
+     leading to the tab bar height being incorrectly set upon the next
+     call to x_set_font.  (bug#59285) */
+  lines = height / unit;
 
   /* Make sure we redisplay all windows in this frame.  */
   fset_redisplay (f);
diff --git a/src/nsimage.m b/src/nsimage.m
index 9cb5090dd0d..dd8768664a4 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -74,8 +74,10 @@ ns_can_use_native_image_api (Lisp_Object type)
     imageType = @"com.compuserve.gif";
   else if (EQ (type, Qtiff))
     imageType = @"public.tiff";
+#ifndef HAVE_RSVG
   else if (EQ (type, Qsvg))
     imageType = @"public.svg-image";
+#endif
   else if (EQ (type, Qheic))
     imageType = @"public.heic";
 
diff --git a/src/nsterm.m b/src/nsterm.m
index 17f40dc7e37..507f2a9e7da 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -7056,6 +7056,36 @@ ns_create_font_panel_buttons (id target, SEL select, SEL cancel_action)
   processingCompose = NO;
 }
 
+static Lisp_Object
+ns_in_echo_area_1 (void *ptr)
+{
+  Lisp_Object in_echo_area;
+  specpdl_ref count;
+
+  count = SPECPDL_INDEX ();
+  specbind (Qinhibit_quit, Qt);
+  in_echo_area = safe_call (1, Qns_in_echo_area);
+
+  return unbind_to (count, in_echo_area);
+}
+
+static Lisp_Object
+ns_in_echo_area_2 (enum nonlocal_exit exit, Lisp_Object error)
+{
+  return Qnil;
+}
+
+static bool
+ns_in_echo_area (void)
+{
+  Lisp_Object in_echo_area;
+
+  in_echo_area
+    = internal_catch_all (ns_in_echo_area_1, NULL,
+                          ns_in_echo_area_2);
+
+  return !NILP (in_echo_area);
+}
 
 /* Used to position char selection windows, etc.  */
 - (NSRect)firstRectForCharacterRange: (NSRange)theRange
@@ -7069,7 +7099,7 @@ ns_create_font_panel_buttons (id target, SEL select, SEL cancel_action)
   if (NS_KEYLOG)
     NSLog (@"firstRectForCharRange request");
 
-  if (WINDOWP (echo_area_window) && ! NILP (call0 (intern ("ns-in-echo-area"))))
+  if (WINDOWP (echo_area_window) && ns_in_echo_area ())
     win = XWINDOW (echo_area_window);
   else
     win = XWINDOW (FRAME_SELECTED_WINDOW (emacsframe));
@@ -11012,6 +11042,7 @@ respectively.  */);
   DEFSYM (Qcondensed, "condensed");
   DEFSYM (Qreverse_italic, "reverse-italic");
   DEFSYM (Qexpanded, "expanded");
+  DEFSYM (Qns_in_echo_area, "ns-in-echo-area");
 
 #ifdef NS_IMPL_COCOA
   Fprovide (Qcocoa, Qnil);
diff --git a/src/pdumper.c b/src/pdumper.c
index d6ae57afb2e..0a5d96dbb7c 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -2137,8 +2137,8 @@ static dump_off
 dump_interval_node (struct dump_context *ctx, struct itree_node *node,
                     dump_off parent_offset)
 {
-#if CHECK_STRUCTS && !defined (HASH_interval_node_5765524F7E)
-# error "interval_node changed. See CHECK_STRUCTS comment in config.h."
+#if CHECK_STRUCTS && !defined (HASH_itree_node_50DE304F13)
+# error "itree_node changed. See CHECK_STRUCTS comment in config.h."
 #endif
   struct itree_node out;
   dump_object_start (ctx, &out, sizeof (out));
@@ -2179,7 +2179,7 @@ dump_interval_node (struct dump_context *ctx, struct itree_node *node,
 static dump_off
 dump_overlay (struct dump_context *ctx, const struct Lisp_Overlay *overlay)
 {
-#if CHECK_STRUCTS && !defined (HASH_Lisp_Overlay_1CD4249AEC)
+#if CHECK_STRUCTS && !defined (HASH_Lisp_Overlay_EB4C05D8D2)
 # error "Lisp_Overlay changed. See CHECK_STRUCTS comment in config.h."
 #endif
   START_DUMP_PVEC (ctx, &overlay->header, struct Lisp_Overlay, out);
@@ -2748,7 +2748,7 @@ dump_hash_table (struct dump_context *ctx,
 static dump_off
 dump_buffer (struct dump_context *ctx, const struct buffer *in_buffer)
 {
-#if CHECK_STRUCTS && !defined HASH_buffer_F0F08347A5
+#if CHECK_STRUCTS && !defined HASH_buffer_193CAA5E45
 # error "buffer changed. See CHECK_STRUCTS comment in config.h."
 #endif
   struct buffer munged_buffer = *in_buffer;
diff --git a/src/pgtkfns.c b/src/pgtkfns.c
index 9473e14f5cf..a32067af818 100644
--- a/src/pgtkfns.c
+++ b/src/pgtkfns.c
@@ -473,10 +473,19 @@ pgtk_set_tab_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 void
 pgtk_change_tab_bar_height (struct frame *f, int height)
 {
-  int unit = FRAME_LINE_HEIGHT (f);
-  int old_height = FRAME_TAB_BAR_HEIGHT (f);
-  int lines = (height + unit - 1) / unit;
-  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
+  int unit, old_height, lines;
+  Lisp_Object fullscreen;
+
+  unit = FRAME_LINE_HEIGHT (f);
+  old_height = FRAME_TAB_BAR_HEIGHT (f);
+  fullscreen = get_frame_param (f, Qfullscreen);
+
+  /* This differs from the tool bar code in that the tab bar height is
+     not rounded up.  Otherwise, if redisplay_tab_bar decides to grow
+     the tab bar by even 1 pixel, FRAME_TAB_BAR_LINES will be changed,
+     leading to the tab bar height being incorrectly set upon the next
+     call to x_set_font.  (bug#59285) */
+  lines = height / unit;
 
   /* Make sure we redisplay all windows in this frame.  */
   fset_redisplay (f);
@@ -1112,13 +1121,6 @@ pgtk_default_font_parameter (struct frame *f, Lisp_Object parms)
       if (NILP (font))
         error ("No suitable font was found");
     }
-  else if (!NILP (font_param))
-    {
-      /* Remember the explicit font parameter, so we can re-apply it after
-         we've applied the `default' face settings.  */
-      AUTO_FRAME_ARG (arg, Qfont_parameter, font_param);
-      gui_set_frame_parameters (f, arg);
-    }
 
   /* This call will make X resources override any system font setting.  */
   gui_default_parameter (f, parms, Qfont, font, "font", "Font",
diff --git a/src/pgtkterm.c b/src/pgtkterm.c
index 491ba338821..13f6c6c3c4d 100644
--- a/src/pgtkterm.c
+++ b/src/pgtkterm.c
@@ -511,16 +511,16 @@ pgtk_free_frame_resources (struct frame *f)
 
   if (FRAME_X_OUTPUT (f)->scrollbar_foreground_css_provider != NULL)
     {
-      GtkCssProvider *old =
-        FRAME_X_OUTPUT (f)->scrollbar_foreground_css_provider;
+      GtkCssProvider *old
+        = FRAME_X_OUTPUT (f)->scrollbar_foreground_css_provider;
       g_object_unref (old);
       FRAME_X_OUTPUT (f)->scrollbar_foreground_css_provider = NULL;
     }
 
   if (FRAME_X_OUTPUT (f)->scrollbar_background_css_provider != NULL)
     {
-      GtkCssProvider *old =
-        FRAME_X_OUTPUT (f)->scrollbar_background_css_provider;
+      GtkCssProvider *old
+        = FRAME_X_OUTPUT (f)->scrollbar_background_css_provider;
       g_object_unref (old);
       FRAME_X_OUTPUT (f)->scrollbar_background_css_provider = NULL;
     }
@@ -714,40 +714,42 @@ pgtk_set_window_size (struct frame *f, bool change_gravity,
 
 void
 pgtk_iconify_frame (struct frame *f)
-/* --------------------------------------------------------------------------
-     External: Iconify window
-   -------------------------------------------------------------------------- */
 {
+  GtkWindow *window;
+
   /* Don't keep the highlight on an invisible frame.  */
+
   if (FRAME_DISPLAY_INFO (f)->highlight_frame == f)
-    FRAME_DISPLAY_INFO (f)->highlight_frame = 0;
+    FRAME_DISPLAY_INFO (f)->highlight_frame = NULL;
+
+  /* If the frame is already iconified, return.  */
 
   if (FRAME_ICONIFIED_P (f))
     return;
 
-  block_input ();
+  /* Child frames on PGTK have no outer widgets.  In that case, simply
+     refuse to iconify the frame.  */
 
   if (FRAME_GTK_OUTER_WIDGET (f))
     {
       if (!FRAME_VISIBLE_P (f))
         gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
 
-      gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
-      SET_FRAME_VISIBLE (f, 0);
-      SET_FRAME_ICONIFIED (f, true);
-      unblock_input ();
-      return;
-    }
+      window = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
 
-  /* Make sure the X server knows where the window should be positioned,
-     in case the user deiconifies with the window manager.  */
-  if (!FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P (f))
-    pgtk_set_offset (f, f->left_pos, f->top_pos, 0);
+      gtk_window_iconify (window);
 
-  SET_FRAME_ICONIFIED (f, true);
-  SET_FRAME_VISIBLE (f, 0);
+      /* Don't make the frame iconified here.  Doing so will cause it
+         to be skipped by redisplay, until GDK says it is deiconified
+         (see window_state_event for more details).  However, if the
+         window server rejects the iconification request, GDK will
+         never tell Emacs about the iconification not happening,
+         leading to the frame not being redisplayed until the next
+         window state change.  */
 
-  unblock_input ();
+      /* SET_FRAME_VISIBLE (f, 0);
+         SET_FRAME_ICONIFIED (f, true); */
+    }
 }
 
 static gboolean
@@ -1331,8 +1333,8 @@ fill_background_by_face (struct frame *f, struct face *face, int x, int y,
 
   if (face->stipple != 0)
     {
-      cairo_pattern_t *mask =
-        FRAME_DISPLAY_INFO (f)->bitmaps[face->stipple - 1].pattern;
+      cairo_pattern_t *mask
+        = FRAME_DISPLAY_INFO (f)->bitmaps[face->stipple - 1].pattern;
 
       double r = ((face->foreground >> 16) & 0xff) / 255.0;
       double g = ((face->foreground >> 8) & 0xff) / 255.0;
@@ -1604,8 +1606,8 @@ pgtk_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
 
           /* It is assured that all LEN characters in STR is ASCII.  */
           for (j = 0; j < len; j++)
-            char2b[j] =
-              s->font->driver->encode_char (s->font, str[j]) & 0xFFFF;
+            char2b[j]
+              = s->font->driver->encode_char (s->font, str[j]) & 0xFFFF;
           s->font->driver->draw (s, 0, upper_len,
                                  x + glyph->slice.glyphless.upper_xoff,
                                  s->ybase + glyph->slice.glyphless.upper_yoff,
@@ -2956,8 +2958,8 @@ pgtk_draw_window_cursor (struct window *w, struct glyph_row *glyph_row, int x,
 
       if (w == XWINDOW (f->selected_window))
         {
-          int frame_x =
-            WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
+          int frame_x = (WINDOW_TO_FRAME_PIXEL_X (w, x)
+                         + WINDOW_LEFT_FRINGE_WIDTH (w));
           int frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, y);
           pgtk_im_set_cursor_location (f, frame_x, frame_y,
                                        w->phys_cursor_width,
@@ -4516,16 +4518,29 @@ pgtk_free_pixmap (struct frame *f, Emacs_Pixmap pixmap)
 void
 pgtk_focus_frame (struct frame *f, bool noactivate)
 {
-  struct pgtk_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+  struct pgtk_display_info *dpyinfo;
+  GtkWidget *widget;
+  GtkWindow *window;
 
-  GtkWidget *wid = FRAME_WIDGET (f);
+  dpyinfo = FRAME_DISPLAY_INFO (f);
 
-  if (dpyinfo->x_focus_frame != f && wid != NULL)
+  if (FRAME_GTK_OUTER_WIDGET (f) && !noactivate)
     {
-      block_input ();
-      gtk_widget_grab_focus (wid);
-      unblock_input ();
+      /* The user says it is okay to activate the frame.  Call
+         gtk_window_present_with_time.  If the timestamp specified
+         (actually a display serial on Wayland) is new enough, then
+         any Wayland compositor supporting gtk_surface1_present will
+         cause the frame to be activated.  */
+
+      window = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
+      gtk_window_present_with_time (window, dpyinfo->last_user_time);
+      return;
     }
+
+  widget = FRAME_WIDGET (f);
+
+  if (widget)
+    gtk_widget_grab_focus (widget);
 }
 
 static void
@@ -5142,13 +5157,15 @@ static gboolean
 key_press_event (GtkWidget *widget, GdkEvent *event, gpointer *user_data)
 {
   union buffered_input_event inev;
-  ptrdiff_t nbytes = 0;
+  ptrdiff_t nbytes;
   Mouse_HLInfo *hlinfo;
   struct frame *f;
+  struct pgtk_display_info *dpyinfo;
 
   f = pgtk_any_window_to_frame (gtk_widget_get_window (widget));
   EVENT_INIT (inev.ie);
   hlinfo = MOUSE_HL_INFO (f);
+  nbytes = 0;
 
   /* If mouse-highlight is an integer, input clears out
      mouse highlighting.  */
@@ -5179,6 +5196,12 @@ key_press_event (GtkWidget *widget, GdkEvent *event, gpointer *user_data)
       Lisp_Object c;
       guint state;
 
+      dpyinfo = FRAME_DISPLAY_INFO (f);
+
+      /* Set the last user time for pgtk_focus_frame to work
+         correctly.  */
+      dpyinfo->last_user_time = event->key.time;
+
       state = event->key.state;
 
       /* While super is pressed, the input method will always always
@@ -5212,8 +5235,8 @@ key_press_event (GtkWidget *widget, GdkEvent *event, gpointer *user_data)
 
       /* Common for all keysym input events.  */
       XSETFRAME (inev.ie.frame_or_window, f);
-      inev.ie.modifiers =
-        pgtk_gtk_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), modifiers);
+      inev.ie.modifiers
+        = pgtk_gtk_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), modifiers);
       inev.ie.timestamp = event->key.time;
 
       /* First deal with keysyms which have defined
@@ -5361,11 +5384,37 @@ done:
   return TRUE;
 }
 
+static struct pgtk_display_info *
+pgtk_display_info_for_display (GdkDisplay *dpy)
+{
+  struct pgtk_display_info *dpyinfo;
+
+  for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
+    {
+      if (dpyinfo->display == dpy)
+        return dpyinfo;
+    }
+
+  return NULL;
+}
+
 static gboolean
 key_release_event (GtkWidget *widget,
                    GdkEvent *event,
                    gpointer *user_data)
 {
+  GdkDisplay *display;
+  struct pgtk_display_info *dpyinfo;
+
+  display = gtk_widget_get_display (widget);
+  dpyinfo = pgtk_display_info_for_display (display);
+
+  if (dpyinfo)
+    /* This is needed on Wayland because of some brain dead
+       compositors.  Without them, we would not have to keep track of
+       the serial of key release events.  */
+    dpyinfo->last_user_time = event->key.time;
+
   return TRUE;
 }
 
@@ -5420,9 +5469,7 @@ map_event (GtkWidget *widget,
       /* Check if fullscreen was specified before we where mapped the
          first time, i.e. from the command line.  */
       if (!FRAME_X_OUTPUT (f)->has_been_visible)
-        {
-          set_fullscreen_state (f);
-        }
+        set_fullscreen_state (f);
 
       if (!iconified)
         {
@@ -5465,24 +5512,6 @@ window_state_event (GtkWidget *widget,
   inev.ie.kind = NO_EVENT;
   inev.ie.arg = Qnil;
 
-  if (f)
-    {
-      if (new_state & GDK_WINDOW_STATE_FOCUSED)
-        {
-          if (FRAME_ICONIFIED_P (f))
-            {
-              /* Gnome shell does not iconify us when C-z is pressed.
-                 It hides the frame.  So if our state says we aren't
-                 hidden anymore, treat it as deiconified.  */
-              SET_FRAME_VISIBLE (f, 1);
-              SET_FRAME_ICONIFIED (f, false);
-              FRAME_X_OUTPUT (f)->has_been_visible = true;
-              inev.ie.kind = DEICONIFY_EVENT;
-              XSETFRAME (inev.ie.frame_or_window, f);
-            }
-        }
-    }
-
   if (new_state & GDK_WINDOW_STATE_FULLSCREEN)
     store_frame_param (f, Qfullscreen, Qfullboth);
   else if (new_state & GDK_WINDOW_STATE_MAXIMIZED)
@@ -5500,14 +5529,37 @@ window_state_event (GtkWidget *widget,
   else
     store_frame_param (f, Qfullscreen, Qnil);
 
+  /* The Wayland protocol provides no way for the client to know
+     whether or not one of its toplevels has actually been
+     deiconified.  It only provides a request for clients to iconify a
+     toplevel, without even the ability to determine whether or not
+     the iconification request was rejected by the display server.
+
+     GDK computes the iconified state by sending a window state event
+     containing only GDK_WINDOW_STATE_ICONIFIED immediately after
+     gtk_window_iconify is called.  That is error-prone if the request
+     to iconify the frame was rejected by the display server, but is
+     not the main problem here, as Wayland compositors only rarely
+     reject such requests.  GDK also assumes that it can clear the
+     iconified state upon receiving the next toplevel configure event
+     from the display server.  Unfortunately, such events can be sent
+     by Wayland compositors while the frame is iconified, and may also
+     not be sent upon deiconification.  So, no matter what Emacs does,
+     the iconification state of a frame is likely to be wrong under
+     one situation or another.  */
+
   if (new_state & GDK_WINDOW_STATE_ICONIFIED)
-    SET_FRAME_ICONIFIED (f, true);
+    {
+      SET_FRAME_ICONIFIED (f, true);
+      SET_FRAME_VISIBLE (f, false);
+    }
   else
     {
       FRAME_X_OUTPUT (f)->has_been_visible = true;
       inev.ie.kind = DEICONIFY_EVENT;
       XSETFRAME (inev.ie.frame_or_window, f);
       SET_FRAME_ICONIFIED (f, false);
+      SET_FRAME_VISIBLE (f, true);
     }
 
   if (new_state & GDK_WINDOW_STATE_STICKY)
@@ -5899,9 +5951,10 @@ construct_mouse_click (struct input_event *result,
   result->kind = MOUSE_CLICK_EVENT;
   result->code = event->button - 1;
   result->timestamp = event->time;
-  result->modifiers =
-    (pgtk_gtk_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), event->state) |
-     (event->type == GDK_BUTTON_RELEASE ? up_modifier : down_modifier));
+  result->modifiers = (pgtk_gtk_to_emacs_modifiers (FRAME_DISPLAY_INFO (f),
+                                                    event->state)
+                       | (event->type == GDK_BUTTON_RELEASE
+                          ? up_modifier : down_modifier));
 
   XSETINT (result->x, event->x);
   XSETINT (result->y, event->y);
@@ -5966,6 +6019,10 @@ button_event (GtkWidget *widget, GdkEvent *event,
         }
     }
 
+  /* Set the last user time, used to activate the frame in
+     pgtk_focus_frame.  */
+  dpyinfo->last_user_time = event->button.time;
+
   if (f)
     {
       /* Is this in the tab-bar?  */
@@ -5984,10 +6041,7 @@ button_event (GtkWidget *widget, GdkEvent *event,
               (f, x, y, event->type == GDK_BUTTON_PRESS,
                pgtk_gtk_to_emacs_modifiers (dpyinfo, event->button.state));
         }
-    }
 
-  if (f)
-    {
       if (!(tab_bar_p && NILP (tab_bar_arg)) && !tool_bar_p)
         {
           if (ignore_next_mouse_click_timeout)
@@ -6055,8 +6109,8 @@ scroll_event (GtkWidget *widget, GdkEvent *event, gpointer *user_data)
 
   inev.ie.kind = NO_EVENT;
   inev.ie.timestamp = event->scroll.time;
-  inev.ie.modifiers =
-    pgtk_gtk_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), event->scroll.state);
+  inev.ie.modifiers
+    = pgtk_gtk_to_emacs_modifiers (FRAME_DISPLAY_INFO (f), event->scroll.state);
   XSETINT (inev.ie.x, event->scroll.x);
   XSETINT (inev.ie.y, event->scroll.y);
   XSETFRAME (inev.ie.frame_or_window, f);
@@ -6594,6 +6648,44 @@ pgtk_selection_event (GtkWidget *widget, GdkEvent *event,
   return FALSE;
 }
 
+/* Display a warning message if the PGTK port is being used under X;
+   that is not supported.  */
+
+static void
+pgtk_display_x_warning (GdkDisplay *display)
+{
+  GtkWidget *dialog_widget, *label, *content_area;
+  GtkDialog *dialog;
+  GtkWindow *window;
+  GdkScreen *screen;
+
+  /* Do this instead of GDK_IS_X11_DISPLAY because the GDK X header
+     pulls in Xlib, which conflicts with definitions in pgtkgui.h.  */
+  if (strcmp (G_OBJECT_TYPE_NAME (display),
+              "GdkX11Display"))
+    return;
+
+  dialog_widget = gtk_dialog_new ();
+  dialog = GTK_DIALOG (dialog_widget);
+  window = GTK_WINDOW (dialog_widget);
+  screen = gdk_display_get_default_screen (display);
+  content_area = gtk_dialog_get_content_area (dialog);
+
+  gtk_window_set_title (window, "Warning");
+  gtk_window_set_screen (window, screen);
+
+  label = gtk_label_new ("You are trying to run Emacs configured with"
+                          " the \"pure-GTK\" interface under the X Window"
+                          " System.  That configuration is unsupported and"
+                          " will lead to sporadic crashes during transfer of"
+                          " large selection data.  It will also lead to"
+                          " various problems with keyboard input.");
+  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+  gtk_container_add (GTK_CONTAINER (content_area), label);
+  gtk_widget_show (label);
+  gtk_widget_show (dialog_widget);
+}
+
 /* Open a connection to X display DISPLAY_NAME, and return
    the structure that describes the open display.
    If we cannot contact the display, return null.  */
@@ -6697,6 +6789,9 @@ pgtk_term_init (Lisp_Object display_name, char *resource_name)
       return 0;
     }
 
+  /* If the PGTK port is being used under X, complain very loudly, as
+     that isn't supported.  */
+  pgtk_display_x_warning (dpy);
 
   dpyinfo = xzalloc (sizeof *dpyinfo);
   pgtk_initialize_display_info (dpyinfo);
@@ -6940,10 +7035,9 @@ pgtk_parse_color (struct frame *f, const char *color_name,
       color->red = rgba.red * 65535;
       color->green = rgba.green * 65535;
       color->blue = rgba.blue * 65535;
-      color->pixel =
-        (color->red >> 8) << 16 |
-        (color->green >> 8) << 8 |
-        (color->blue >> 8) << 0;
+      color->pixel = ((color->red >> 8) << 16
+                      | (color->green >> 8) << 8
+                      | (color->blue >> 8) << 0);
       return 1;
     }
   return 0;
@@ -7072,10 +7166,9 @@ If set to a non-float value, there will be no wait at all.  */);
   Vpgtk_wait_for_event_timeout = make_float (0.1);
 
   DEFVAR_LISP ("pgtk-keysym-table", Vpgtk_keysym_table,
-               doc: /* Hash table of character codes indexed by X keysym codes.  */);
-  Vpgtk_keysym_table =
-    make_hash_table (hashtest_eql, 900, DEFAULT_REHASH_SIZE,
-                     DEFAULT_REHASH_THRESHOLD, Qnil, false);
+    doc: /* Hash table of character codes indexed by X keysym codes.  */);
+  Vpgtk_keysym_table = make_hash_table (hashtest_eql, 900, DEFAULT_REHASH_SIZE,
+                                        DEFAULT_REHASH_THRESHOLD, Qnil, false);
 
   window_being_scrolled = Qnil;
   staticpro (&window_being_scrolled);
@@ -7113,13 +7206,13 @@ pgtk_begin_cr_clip (struct frame *f)
 
   if (!cr)
     {
-      cairo_surface_t *surface =
-        gdk_window_create_similar_surface (gtk_widget_get_window
-                                           (FRAME_GTK_WIDGET (f)),
-                                           CAIRO_CONTENT_COLOR_ALPHA,
-                                           FRAME_CR_SURFACE_DESIRED_WIDTH (f),
-                                           FRAME_CR_SURFACE_DESIRED_HEIGHT
-                                           (f));
+      cairo_surface_t *surface
+        = gdk_window_create_similar_surface (gtk_widget_get_window
+                                             (FRAME_GTK_WIDGET (f)),
+                                             CAIRO_CONTENT_COLOR_ALPHA,
+                                             FRAME_CR_SURFACE_DESIRED_WIDTH (f),
+                                             FRAME_CR_SURFACE_DESIRED_HEIGHT
+                                             (f));
 
       cr = FRAME_CR_CONTEXT (f) = cairo_create (surface);
       cairo_surface_destroy (surface);
diff --git a/src/pgtkterm.h b/src/pgtkterm.h
index fcc6c5310e9..b6bd10dcb41 100644
--- a/src/pgtkterm.h
+++ b/src/pgtkterm.h
@@ -262,6 +262,13 @@ struct pgtk_output
   unsigned long background_color;
   void *toolbar;
 
+  /* The "time" of the last user interaction on this display.  Set
+     upon button and key press and release events.
+
+     Under the GDK Wayland backend, this is actually an event
+     serial.  */
+  guint32 last_user_time;
+
   /* Cursors */
   Emacs_Cursor current_cursor;
   Emacs_Cursor text_cursor;
@@ -357,8 +364,8 @@ struct pgtk_output
   /* The tool bar in this frame  */
   GtkWidget *toolbar_widget;
   /* True if tool bar is packed into the hbox widget (i.e. vertical).  */
-  bool_bf toolbar_in_hbox:1;
-  bool_bf toolbar_is_packed:1;
+  bool_bf toolbar_in_hbox : 1;
+  bool_bf toolbar_is_packed : 1;
 
   GtkTooltip *ttip_widget;
   GtkWidget *ttip_lbl;
diff --git a/src/print.c b/src/print.c
index 65218084a4c..07560518c46 100644
--- a/src/print.c
+++ b/src/print.c
@@ -2017,8 +2017,8 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
             i = sprintf (buf, " stmt=%p", XSQLITE (obj)->stmt);
             strout (buf, i, i, printcharfun);
           }
-        i = sprintf (buf, " name=%s", XSQLITE (obj)->name);
-        strout (buf, i, i, printcharfun);
+        print_c_string (" name=", printcharfun);
+        print_c_string (XSQLITE (obj)->name, printcharfun);
         printchar ('>', printcharfun);
       }
       break;
diff --git a/src/process.c b/src/process.c
index 358899cdede..5144c5d6c92 100644
--- a/src/process.c
+++ b/src/process.c
@@ -292,7 +292,6 @@ static int child_signal_read_fd = -1;
    descriptor to notify `wait_reading_process_output' of process
    status changes.  */
 static int child_signal_write_fd = -1;
-static void child_signal_init (void);
 #ifndef WINDOWSNT
 static void child_signal_read (int, void *);
 #endif
@@ -7323,7 +7322,7 @@ process has been transmitted to the serial port.  */)
 
 /* Set up `child_signal_read_fd' and `child_signal_write_fd'.  */
 
-static void
+void
 child_signal_init (void)
 {
   /* Either both are initialized, or both are uninitialized.  */
diff --git a/src/search.c b/src/search.c
index b5d6a442c0f..1c5831b6de7 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1558,7 +1558,6 @@ simple_search (EMACS_INT n, unsigned char *pat,
         while (1)
           {
             /* Try matching at position POS.  */
-            ptrdiff_t this_pos = pos;
             ptrdiff_t this_pos_byte = pos_byte;
             ptrdiff_t this_len = len;
             unsigned char *p = pat;
@@ -1580,7 +1579,6 @@ simple_search (EMACS_INT n, unsigned char *pat,
                 p += charlen;
 
                 this_pos_byte += buf_charlen;
-                this_pos++;
               }
 
             if (this_len == 0)
@@ -2824,11 +2822,21 @@ Return value is undefined if the last search failed.  */)
 }
 
 DEFUN ("match-data", Fmatch_data, Smatch_data, 0, 3, 0,
-       doc: /* Return a list describing what the last search matched.
-Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.
-All the elements are markers or nil (nil if the Nth pair didn't match)
-if the last match was on a buffer; integers or nil if a string was matched.
-Use `set-match-data' to reinstate the data in this list.
+       doc: /* Return a list of positions that record text matched by the last search.
+Element 2N of the returned list is the position of the beginning of the
+match of the Nth subexpression; it corresponds to `(match-beginning N)';
+element 2N + 1 is the position of the end of the match of the Nth
+subexpression; it corresponds to `(match-end N)'.  See `match-beginning'
+and `match-end'.
+If the last search was on a buffer, all the elements are by default
+markers or nil (nil when the Nth pair didn't match); they are integers
+or nil if the search was on a string.  But if the optional argument
+INTEGERS is non-nil, the elements that represent buffer positions are
+always integers, not markers, and (if the search was on a buffer) the
+buffer itself is appended to the list as one additional element.
+
+Use `set-match-data' to reinstate the match data from the elements of
+this list.
 
 Note that non-matching optional groups at the end of the regexp are
 elided instead of being represented with two `nil's each.  For instance:
@@ -2838,16 +2846,13 @@ elided instead of being represented with two `nil's each.  For instance:
     (match-data))
   => (0 1 nil nil 0 1)
 
-If INTEGERS (the optional first argument) is non-nil, always use
-integers (rather than markers) to represent buffer positions.  In
-this case, and if the last match was in a buffer, the buffer will get
-stored as one additional element at the end of the list.
-
-If REUSE is a list, reuse it as part of the value.  If REUSE is long
-enough to hold all the values, and if INTEGERS is non-nil, no consing
-is done.
+If REUSE is a list, store the value in REUSE by destructively modifying it.
+If REUSE is long enough to hold all the values, its length remains the
+same, and any unused elements are set to nil.  If REUSE is not long
+enough, it is extended.  Note that if REUSE is long enough and INTEGERS
+is non-nil, no consing is done to make the return value; this minimizes GC.
 
-If optional third arg RESEAT is non-nil, any previous markers on the
+If optional third argument RESEAT is non-nil, any previous markers on the
 REUSE list will be modified to point to nowhere.
 
 Return value is undefined if the last search failed.  */)
diff --git a/src/sqlite.c b/src/sqlite.c
index 08bf696b8ca..ac860f55bcd 100644
--- a/src/sqlite.c
+++ b/src/sqlite.c
@@ -52,7 +52,9 @@ DEF_DLL_FN (SQLITE_API int, sqlite3_bind_null, (sqlite3_stmt*, int));
 DEF_DLL_FN (SQLITE_API int, sqlite3_bind_int, (sqlite3_stmt*, int, int));
 DEF_DLL_FN (SQLITE_API int, sqlite3_extended_errcode, (sqlite3*));
 DEF_DLL_FN (SQLITE_API const char*, sqlite3_errmsg, (sqlite3*));
+#if SQLITE_VERSION_NUMBER >= 3007015
 DEF_DLL_FN (SQLITE_API const char*, sqlite3_errstr, (int));
+#endif
 DEF_DLL_FN (SQLITE_API int, sqlite3_step, (sqlite3_stmt*));
 DEF_DLL_FN (SQLITE_API int, sqlite3_changes, (sqlite3*));
 DEF_DLL_FN (SQLITE_API int, sqlite3_column_count, (sqlite3_stmt*));
@@ -91,7 +93,9 @@ DEF_DLL_FN (SQLITE_API int, sqlite3_load_extension,
 # undef sqlite3_bind_int
 # undef sqlite3_extended_errcode
 # undef sqlite3_errmsg
-# undef sqlite3_errstr
+# if SQLITE_VERSION_NUMBER >= 3007015
+#  undef sqlite3_errstr
+# endif
 # undef sqlite3_step
 # undef sqlite3_changes
 # undef sqlite3_column_count
@@ -117,7 +121,9 @@ DEF_DLL_FN (SQLITE_API int, sqlite3_load_extension,
 # define sqlite3_bind_int fn_sqlite3_bind_int
 # define sqlite3_extended_errcode fn_sqlite3_extended_errcode
 # define sqlite3_errmsg fn_sqlite3_errmsg
-# define sqlite3_errstr fn_sqlite3_errstr
+# if SQLITE_VERSION_NUMBER >= 3007015
+#  define sqlite3_errstr fn_sqlite3_errstr
+# endif
 # define sqlite3_step fn_sqlite3_step
 # define sqlite3_changes fn_sqlite3_changes
 # define sqlite3_column_count fn_sqlite3_column_count
@@ -146,7 +152,9 @@ load_dll_functions (HMODULE library)
   LOAD_DLL_FN (library, sqlite3_bind_int);
   LOAD_DLL_FN (library, sqlite3_extended_errcode);
   LOAD_DLL_FN (library, sqlite3_errmsg);
+#if SQLITE_VERSION_NUMBER >= 3007015
   LOAD_DLL_FN (library, sqlite3_errstr);
+#endif
   LOAD_DLL_FN (library, sqlite3_step);
   LOAD_DLL_FN (library, sqlite3_changes);
   LOAD_DLL_FN (library, sqlite3_column_count);
@@ -428,13 +436,27 @@ row_to_value (sqlite3_stmt *stmt)
 static Lisp_Object
 sqlite_prepare_errdata (int code, sqlite3 *sdb)
 {
-  Lisp_Object errstr = build_string (sqlite3_errstr (code));
   Lisp_Object errcode = make_fixnum (code);
-  /* More details about what went wrong.  */
-  Lisp_Object ext_errcode = make_fixnum (sqlite3_extended_errcode (sdb));
   const char *errmsg = sqlite3_errmsg (sdb);
-  return list4 (errstr, errmsg ? build_string (errmsg) : Qnil,
-                errcode, ext_errcode);
+  Lisp_Object lerrmsg = errmsg ? build_string (errmsg) : Qnil;
+  Lisp_Object errstr, ext_errcode;
+
+#if SQLITE_VERSION_NUMBER >= 3007015
+  errstr = build_string (sqlite3_errstr (code));
+#else
+  /* The internet says this is identical to sqlite3_errstr (code).  */
+  errstr = lerrmsg;
+#endif
+
+  /* More details about what went wrong.  */
+#if SQLITE_VERSION_NUMBER >= 3006005
+  ext_errcode = make_fixnum (sqlite3_extended_errcode (sdb));
+#else
+  /* What value to use here?  */
+  ext_errcode = make_fixnum (0);
+#endif
+
+  return list4 (errstr, lerrmsg, errcode, ext_errcode);
 }
 
 DEFUN ("sqlite-execute", Fsqlite_execute, Ssqlite_execute, 2, 3, 0,
diff --git a/src/w32fns.c b/src/w32fns.c
index 93b7f80f268..887e5a1f7b7 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1717,10 +1717,19 @@ w32_set_tab_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 void
 w32_change_tab_bar_height (struct frame *f, int height)
 {
-  int unit = FRAME_LINE_HEIGHT (f);
-  int old_height = FRAME_TAB_BAR_HEIGHT (f);
-  int lines = (height + unit - 1) / unit;
-  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
+  int unit, old_height, lines;
+  Lisp_Object fullscreen;
+
+  unit = FRAME_LINE_HEIGHT (f);
+  old_height = FRAME_TAB_BAR_HEIGHT (f);
+  fullscreen = get_frame_param (f, Qfullscreen);
+
+  /* This differs from the tool bar code in that the tab bar height is
+     not rounded up.  Otherwise, if redisplay_tab_bar decides to grow
+     the tab bar by even 1 pixel, FRAME_TAB_BAR_LINES will be changed,
+     leading to the tab bar height being incorrectly set upon the next
+     call to x_set_font.  (bug#59285) */
+  lines = height / unit;
 
   /* Make sure we redisplay all windows in this frame.  */
   fset_redisplay (f);
@@ -5785,13 +5794,7 @@ w32_default_font_parameter (struct frame *f, Lisp_Object parms)
       if (NILP (font))
         error ("No suitable font was found");
     }
-  else if (!NILP (font_param))
-    {
-      /* Remember the explicit font parameter, so we can re-apply it after
-         we've applied the `default' face settings.  */
-      gui_set_frame_parameters (f, Fcons (Fcons (Qfont_parameter, font_param),
-                                          Qnil));
-    }
+
   gui_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
 }
 
@@ -8417,7 +8420,7 @@ a ShowWindow flag:
 
   current_dir = ENCODE_FILE (current_dir);
   /* Cannot use filename_to_utf16/ansi with DOCUMENT, since it could
-     be a URL that is not limited to MAX_PATH chararcters.  */
+     be a URL that is not limited to MAX_PATH characters.  */
   doclen = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
                                  SSDATA (document), -1, NULL, 0);
   doc_w = xmalloc (doclen * sizeof (wchar_t));
diff --git a/src/w32inevt.c b/src/w32inevt.c
index 6a1d9afacf7..d13b0521c9a 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -648,7 +648,7 @@ handle_file_notifications (struct input_event *hold_quit)
       ns = NULL;
 
       /* Find out if there is a record available in the linked list of
-         notifications sets.  If so, unlink te set from the linked list.
+         notifications sets.  If so, unlink the set from the linked list.
          Use the critical section.  */
       enter_crit ();
       if (notifications_set_head->next != notifications_set_head)
diff --git a/src/xdisp.c b/src/xdisp.c
index 3b330f315bc..fa5ce84b1c4 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -2330,7 +2330,7 @@ pixel_to_glyph_coords (struct frame *f, int pix_x, int pix_y, int *x, int *y,
    text, or we can't tell because W's current matrix is not up to
    date.  */
 
-static struct glyph *
+struct glyph *
 x_y_to_hpos_vpos (struct window *w, int x, int y, int *hpos, int *vpos,
                   int *dx, int *dy, int *area)
 {
@@ -3342,7 +3342,8 @@ init_iterator (struct it *it, struct window *w,
     {
       /* Mode lines, menu bar in terminal frames.  */
       it->first_visible_x = 0;
-      it->last_visible_x = body_width = WINDOW_PIXEL_WIDTH (w);
+      it->last_visible_x =
+        WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
     }
   else
     {
@@ -3410,8 +3411,13 @@ init_iterator (struct it *it, struct window *w,
       face = FACE_FROM_ID_OR_NULL (it->f, remapped_base_face_id);
       if (face && face->box != FACE_NO_BOX)
         {
+          int box_thickness = face->box_vertical_line_width;
           it->face_box_p = true;
           it->start_of_box_run_p = true;
+          /* Make sure we will have enough horizontal space to add the
+             right box line at the end.  */
+          if (box_thickness > 0)
+            it->last_visible_x -= box_thickness;
         }
     }
 
@@ -5324,6 +5330,8 @@ display_min_width (struct it *it, ptrdiff_t bufpos,
           /* Insert the stretch glyph.  */
           it->object = list3 (Qspace, QCwidth, w);
           produce_stretch_glyph (it);
+          if (it->area == TEXT_AREA)
+            it->current_x += it->pixel_width;
           it->min_width_property = Qnil;
         }
     }
@@ -7036,17 +7044,11 @@ strings_with_newlines (ptrdiff_t startpos, ptrdiff_t endpos, struct window *w)
       str = Foverlay_get (overlay, Qbefore_string);
       if (STRINGP (str) && SCHARS (str)
           && memchr (SDATA (str), '\n', SBYTES (str)))
-        {
-          ITREE_FOREACH_ABORT ();
-          return true;
-        }
+        return true;
       str = Foverlay_get (overlay, Qafter_string);
       if (STRINGP (str) && SCHARS (str)
           && memchr (SDATA (str), '\n', SBYTES (str)))
-        {
-          ITREE_FOREACH_ABORT ();
-          return true;
-        }
+        return true;
     }
 
   /* Check for 'display' properties whose values include strings.  */
@@ -23188,10 +23190,18 @@ extend_face_to_end_of_line (struct it *it)
      this is called when redisplaying a non-selected window, with
      point temporarily moved to window-point.  */
   specbind (Qinhibit_quit, Qt);
-  const int extend_face_id = (it->face_id == DEFAULT_FACE_ID
-                              || it->s != NULL)
-    ? DEFAULT_FACE_ID
-    : face_at_pos (it, LFACE_EXTEND_INDEX);
+  /* The default face, possibly remapped. */
+  struct face *default_face =
+    FACE_FROM_ID_OR_NULL (f, lookup_basic_face (it->w, f, DEFAULT_FACE_ID));
+  if (!default_face)
+    return;
+
+  const int extend_face_id =
+    (it->face_id == default_face->id || it->s != NULL)
+    ? it->face_id
+    : (it->glyph_row->ends_at_zv_p
+       ? default_face->id
+       : face_at_pos (it, LFACE_EXTEND_INDEX));
   unbind_to (count, Qnil);
 
   /* Face extension extends the background and box of IT->extend_face_id
@@ -23228,14 +23238,8 @@ extend_face_to_end_of_line (struct it *it)
   if (!ASCII_CHAR_P (it->c))
     it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
 
-  /* The default face, possibly remapped. */
-  struct face *default_face =
-    FACE_FROM_ID (f, lookup_basic_face (it->w, f, DEFAULT_FACE_ID));
 
 #ifdef HAVE_WINDOW_SYSTEM
-  if (default_face == NULL)
-    error ("extend_face_to_end_of_line: default_face is not set!");
-
   if (FRAME_WINDOW_P (f))
     {
       /* If the row is empty, add a space with the current face of IT,
@@ -26751,7 +26755,17 @@ display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format)
     {
       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
                             + it.glyph_row->used[TEXT_AREA] - 1);
+      int box_thickness = face->box_vertical_line_width;
       last->right_box_line_p = true;
+      /* Add back the space for the right box line we subtracted in
+         init_iterator, since the right_box_line_p flag will make the
+         glyph wider.  We actually add only as much space as is
+         available for the last glyph of the modeline and whatever
+         space is left beyond it, since that glyph could be only
+         partially visible */
+      if (box_thickness > 0)
+        last->pixel_width += max (0, (box_thickness
+                                      - (it.current_x - it.last_visible_x)));
     }
 
   return it.glyph_row->height;
@@ -33597,8 +33611,14 @@ coords_in_mouse_face_p (struct window *w, int hpos, int vpos)
 bool
 cursor_in_mouse_face_p (struct window *w)
 {
-  int hpos = w->phys_cursor.hpos;
   int vpos = w->phys_cursor.vpos;
+
+  /* If the cursor is outside the matrix glyph rows, it cannot be
+     within the mouse face.  */
+  if (!(0 <= vpos && vpos < w->current_matrix->nrows))
+    return false;
+
+  int hpos = w->phys_cursor.hpos;
   struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
 
   /* When the window is hscrolled, cursor hpos can legitimately be out
diff --git a/src/xfaces.c b/src/xfaces.c
index ed76db9adb7..df078227c8a 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -3809,8 +3809,12 @@ set_font_frame_param (Lisp_Object frame, Lisp_Object lface)
           ASET (lface, LFACE_FONT_INDEX, font);
         }
       f->default_face_done_p = false;
-      AUTO_FRAME_ARG (arg, Qfont, font);
-      Fmodify_frame_parameters (frame, arg);
+      AUTO_LIST2 (arg, AUTO_CONS_EXPR (Qfont, font),
+                  /* Clear the `font-parameter' frame property, as the
+                     font is now being specified by a face, not a
+                     frame property.  */
+                  AUTO_CONS_EXPR (Qfont_parameter, Qnil));
+      gui_set_frame_parameters_1 (f, arg, true);
     }
 }
 
@@ -4208,7 +4212,17 @@ Default face attributes override any local face attributes.  */)
             {
               Lisp_Object name = newface->font->props[FONT_NAME_INDEX];
               AUTO_FRAME_ARG (arg, Qfont, name);
-              Fmodify_frame_parameters (frame, arg);
+
+#ifdef HAVE_WINDOW_SYSTEM
+              if (FRAME_WINDOW_P (f))
+                /* This is a window-system frame.  Prevent changes of
+                   the `font' parameter here from messing with the
+                   `font-parameter' frame property, as the frame
+                   parameter is not being changed by the user.  */
+                gui_set_frame_parameters_1 (f, arg, true);
+              else
+#endif
+                Fmodify_frame_parameters (frame, arg);
             }
 
           if (STRINGP (gvec[LFACE_FOREGROUND_INDEX]))
diff --git a/src/xfns.c b/src/xfns.c
index 3ff7a8c2865..95092ce05f4 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1362,13 +1362,21 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       char *xmessage = alloca (1 + message_length);
       memcpy (xmessage, cursor_data.error_string, message_length);
 
-      x_uncatch_errors ();
+      x_uncatch_errors_after_check ();
+
+      /* XFreeCursor can generate BadCursor errors, because
+         XCreateFontCursor is not a request that waits for a reply,
+         and as such can return IDs that will not actually be used by
+         the server.  */
+      x_ignore_errors_for_next_request (FRAME_DISPLAY_INFO (f));
 
       /* Free any successfully created cursors.  */
       for (i = 0; i < mouse_cursor_max; i++)
         if (cursor_data.cursor[i] != 0)
           XFreeCursor (dpy, cursor_data.cursor[i]);
 
+      x_stop_ignoring_errors (FRAME_DISPLAY_INFO (f));
+
       /* This should only be able to fail if the server's serial
          number tracking is broken.  */
       if (cursor_data.error_cursor >= 0)
@@ -1750,10 +1758,19 @@ x_set_tab_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 void
 x_change_tab_bar_height (struct frame *f, int height)
 {
-  int unit = FRAME_LINE_HEIGHT (f);
-  int old_height = FRAME_TAB_BAR_HEIGHT (f);
-  int lines = (height + unit - 1) / unit;
-  Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
+  int unit, old_height, lines;
+  Lisp_Object fullscreen;
+
+  unit = FRAME_LINE_HEIGHT (f);
+  old_height = FRAME_TAB_BAR_HEIGHT (f);
+  fullscreen = get_frame_param (f, Qfullscreen);
+
+  /* This differs from the tool bar code in that the tab bar height is
+     not rounded up.  Otherwise, if redisplay_tab_bar decides to grow
+     the tab bar by even 1 pixel, FRAME_TAB_BAR_LINES will be changed,
+     leading to the tab bar height being incorrectly set upon the next
+     call to x_set_font.  (bug#59285) */
+  lines = height / unit;
 
   /* Make sure we redisplay all windows in this frame.  */
   fset_redisplay (f);
@@ -4506,9 +4523,11 @@ x_default_font_parameter (struct frame *f, Lisp_Object parms)
     }
 
   if (NILP (font))
-      font = !NILP (font_param) ? font_param
-      : gui_display_get_arg (dpyinfo, parms, Qfont, "font", "Font",
-                             RES_TYPE_STRING);
+    font = (!NILP (font_param)
+            ? font_param
+            : gui_display_get_arg (dpyinfo, parms,
+                                   Qfont, "font", "Font",
+                                   RES_TYPE_STRING));
 
   if (! FONTP (font) && ! STRINGP (font))
     {
@@ -4540,13 +4559,6 @@ x_default_font_parameter (struct frame *f, Lisp_Object parms)
       if (NILP (font))
         error ("No suitable font was found");
     }
-  else if (!NILP (font_param))
-    {
-      /* Remember the explicit font parameter, so we can re-apply it after
-         we've applied the `default' face settings.  */
-      AUTO_FRAME_ARG (arg, Qfont_parameter, font_param);
-      gui_set_frame_parameters (f, arg);
-    }
 
   /* This call will make X resources override any system font setting.  */
   gui_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
diff --git a/src/xselect.c b/src/xselect.c
index db5c7853e7f..a381fa23522 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -918,6 +918,13 @@ x_handle_selection_request (struct selection_input_event *event)
         }
       /* Save conversion results */
       lisp_data_to_selection_data (dpyinfo, multprop, &cs);
+
+      /* If cs.type is ATOM, change it to ATOM_PAIR.  This is because
+         the parameters to a MULTIPLE are ATOM_PAIRs.  */
+
+      if (cs.type == XA_ATOM)
+        cs.type = dpyinfo->Xatom_ATOM_PAIR;
+
       XChangeProperty (dpyinfo->display, requestor, property,
                        cs.type, cs.format, PropModeReplace,
                        cs.data, cs.size);
@@ -960,7 +967,7 @@ x_handle_selection_request (struct selection_input_event *event)
    x_reply_selection_request.  If FOR_MULTIPLE, write out
    the data even if conversion fails, using conversion_fail_tag.
 
-   Return true iff successful.  */
+   Return true if successful.  */
 
 static bool
 x_convert_selection (Lisp_Object selection_symbol,
diff --git a/src/xsettings.c b/src/xsettings.c
index 15e7ff54995..00b67539d41 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -56,6 +56,7 @@ typedef unsigned int CARD32;
 
 #ifdef USE_CAIRO
 #include <fontconfig/fontconfig.h>
+#include "ftfont.h"
 #elif defined HAVE_XFT
 #include <X11/Xft/Xft.h>
 #endif
@@ -765,7 +766,7 @@ parse_settings (unsigned char *prop,
 #ifndef HAVE_PGTK
 /* Read settings from the XSettings property window on display for DPYINFO.
    Store settings read in SETTINGS.
-   Return true iff successful.  */
+   Return true if successful.  */
 
 static bool
 read_settings (Display_Info *dpyinfo, struct xsettings *settings)
@@ -826,6 +827,7 @@ apply_xft_settings (Display_Info *dpyinfo,
 #else
   FcConfigSubstitute (NULL, pat, FcMatchPattern);
   options = cairo_font_options_create ();
+  ftcrfont_get_default_font_options (dpyinfo, options);
   cairo_ft_font_options_substitute (options, pat);
   cairo_font_options_destroy (options);
   FcDefaultSubstitute (pat);
@@ -884,6 +886,14 @@ apply_xft_settings (Display_Info *dpyinfo,
     }
 #endif
 
+#ifdef USE_CAIRO
+  /* When Cairo is being used, set oldsettings.dpi to dpyinfo->resx.
+     This is a gross hack, but seeing as Cairo fails to report
+     anything reasonable, just use it to avoid config-changed events
+     being sent at startup.  */
+  oldsettings.dpi = dpyinfo->resx;
+#endif
+
   if ((settings->seen & SEEN_DPI) != 0
       && settings->dpi > 0
       /* The following conjunct avoids setting `changed' to true when
diff --git a/src/xterm.c b/src/xterm.c
index 7dd969b821f..af652a0d856 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -912,11 +912,6 @@ struct x_selection_request_event
 
 struct x_selection_request_event *pending_selection_requests;
 
-/* Compare two request serials A and B with OP, handling
-   wraparound.  */
-#define X_COMPARE_SERIALS(a, op ,b) \
-  (((long) (a) - (long) (b)) op 0)
-
 struct x_atom_ref
 {
   /* Atom name.  */
@@ -1139,6 +1134,7 @@ static void x_clean_failable_requests (struct x_display_info *);
 static struct frame *x_tooltip_window_to_frame (struct x_display_info *,
                                                 Window, bool *);
 static Window x_get_window_below (Display *, Window, int, int, int *, int *);
+static void x_set_input_focus (struct x_display_info *, Window, Time);
 
 #ifndef USE_TOOLKIT_SCROLL_BARS
 static void x_scroll_bar_redraw (struct scroll_bar *);
@@ -5245,7 +5241,9 @@ xi_convert_button_state (XIButtonState *in, unsigned int *out)
     }
 }
 
-/* Return the modifier state in XEV as a standard X modifier mask.  */
+/* Return the modifier state in XEV as a standard X modifier mask.
+   This should be used for non-keyboard events, where the group does
+   not matter.  */
 
 #ifdef USE_GTK
 static
@@ -5263,6 +5261,17 @@ xi_convert_event_state (XIDeviceEvent *xev)
   return mods | buttons;
 }
 
+/* Like the above.  However, buttons are not converted, while the
+   group is.  This should be used for key events being passed to the
+   likes of input methods and Xt.  */
+
+static unsigned int
+xi_convert_event_keyboard_state (XIDeviceEvent *xev)
+{
+  return ((xev->mods.effective & ~(1 << 13 | 1 << 14))
+          | (xev->group.effective << 13));
+}
+
 /* Free all XI2 devices on DPYINFO.  */
 static void
 x_free_xi_devices (struct x_display_info *dpyinfo)
@@ -5301,6 +5310,7 @@ x_free_xi_devices (struct x_display_info *dpyinfo)
 }
 
 #ifdef HAVE_XINPUT2_1
+
 struct xi_known_valuator
 {
   /* The current value of this valuator.  */
@@ -5312,20 +5322,60 @@ struct xi_known_valuator
   /* The next valuator whose value we already know.  */
   struct xi_known_valuator *next;
 };
+
+/* Populate the scroll valuator at INDEX in DEVICE with the scroll
+   valuator information provided in INFO.
+
+   The information consists of:
+
+     - whether or not the valuator is horizontal.
+
+     - whether or not the valuator's value is currently unknown,
+       until the next XI_Motion event is received or the valuator's
+       value is restored by the caller upon encountering valuator
+       class data.
+
+     - what the current value of the valuator is.  This is set to
+       DBL_MIN for debugging purposes, but can be any value, as
+       invalid_p is currently true.
+
+     - the increment, which defines the amount of movement equal to a
+       single unit of scrolling.  For example, if the increment is
+       2.0, then a WHEEL_DOWN or WHEEL_UP event will be sent every
+       time the valuator value changes by 2.0, unless
+       mwheel-coalesce-scroll-events is nil.
+
+     - the number used in XI_Motion events and elsewhere to identify
+       the valuator.  */
+
+static void
+xi_populate_scroll_valuator (struct xi_device_t *device,
+                             int index, XIScrollClassInfo *info)
+{
+  struct xi_scroll_valuator_t *valuator;
+
+  valuator = &device->valuators[index];
+  valuator->horizontal
+    = (info->scroll_type == XIScrollTypeHorizontal);
+  valuator->invalid_p = true;
+  valuator->emacs_value = DBL_MIN;
+  valuator->increment = info->increment;
+  valuator->number = info->number;
+}
+
 #endif
 
 static void
-xi_populate_device_from_info (struct xi_device_t *xi_device,
+xi_populate_device_from_info (struct x_display_info *dpyinfo,
+                              struct xi_device_t *xi_device,
                               XIDeviceInfo *device)
 {
 #ifdef HAVE_XINPUT2_1
-  struct xi_scroll_valuator_t *valuator;
   struct xi_known_valuator *values, *tem;
-  int actual_valuator_count;
+  int actual_valuator_count, c;
   XIScrollClassInfo *info;
-  XIValuatorClassInfo *val_info;
+  XIValuatorClassInfo *valuator_info;
 #endif
-  int c;
 #ifdef HAVE_XINPUT2_2
   XITouchClassInfo *touch_info;
 #endif
@@ -5334,58 +5384,121 @@ xi_populate_device_from_info (struct xi_device_t *xi_device,
   USE_SAFE_ALLOCA;
 #endif
 
+  /* Initialize generic information about the device: its ID, which
+     buttons are currently pressed and thus presumably actively
+     grabbing the device, what kind of device it is (master pointer,
+     master keyboard, slave pointer, slave keyboard, or floating
+     slave), and its attachment.
+
+     Here is a brief description of what device uses and attachments
+     are.  Under XInput 2, user input from individual input devices is
+     multiplexed into specific seats before being delivered, with each
+     seat corresponding to a single on-screen mouse pointer and having
+     its own keyboard focus.  Each seat consists of two virtual
+     devices: the master keyboard and the master pointer, the first of
+     which is used to report all keyboard input, with the other used
+     to report all other input.
+
+     Input from each physical device (mouse, trackpad or keyboard) is
+     then associated with that slave device's paired master device.
+     For example, moving the device "Logitech USB Optical Mouse",
+     enslaved by the master pointer device "Virtual core pointer",
+     will result in movement of the mouse pointer associated with that
+     master device's seat.  If the pointer moves over an Emacs frame,
+     then the frame will receive XI_Enter and XI_Motion events from
+     that master pointer.
+
+     Likewise, keyboard input from the device "AT Translated Set 2
+     keyboard", enslaved by the master keyboard device "Virtual core
+     keyboard", will be reported to its seat's input focus window.
+
+     The device use describes what the device is.  The meanings of
+     MasterPointer, MasterKeyboard, SlavePointer and SlaveKeyboard
+     should be obvious.  FloatingSlave means the device is a slave
+     device that is not associated with any seat, and thus generates
+     no input.
+
+     The device attachment is a device ID whose meaning varies
+     depending on the device use.  If the device is a master device,
+     then the attachment is the device ID of the other device in its
+     seat (the master keyboard for master pointer devices, and vice
+     versa).  Otherwise, it is the ID of the master device the slave
+     device is attached to.  For slave devices not attached to any
+     seat, its value is undefined.  */
+
   xi_device->device_id = device->deviceid;
   xi_device->grab = 0;
-
-#ifdef HAVE_XINPUT2_1
-  actual_valuator_count = 0;
-  xi_device->valuators = xmalloc (sizeof *xi_device->valuators
-                                  * device->num_classes);
-  values = NULL;
-#endif
-
   xi_device->use = device->use;
   xi_device->name = build_string (device->name);
   xi_device->attachment = device->attachment;
 
+  /* Clear the list of active touch points on the device, which are
+     individual touches tracked by a touchscreen.  */
+
 #ifdef HAVE_XINPUT2_2
   xi_device->touchpoints = NULL;
   xi_device->direct_p = false;
 #endif
 
+#ifdef HAVE_XINPUT2_1
+  if (!dpyinfo->xi2_version)
+    {
+      /* Skip everything below as there are no classes of interest on
+         XI 2.0 servers.  */
+      xi_device->valuators = NULL;
+      xi_device->scroll_valuator_count = 0;
+
+      SAFE_FREE ();
+      return;
+    }
+
+  actual_valuator_count = 0;
+  xi_device->valuators = xnmalloc (device->num_classes,
+                                   sizeof *xi_device->valuators);
+  values = NULL;
+
+  /* Initialize device info based on a list of "device classes".
+     Device classes are little pieces of information associated with a
+     device.  Emacs is interested in scroll valuator information and
+     touch handling information, which respectively describe the axes
+     (if any) along which the device's scroll wheel rotates, and how
+     the device reports touch input.  */
+
   for (c = 0; c < device->num_classes; ++c)
     {
       switch (device->classes[c]->type)
         {
-#ifdef HAVE_XINPUT2_1
         case XIScrollClass:
           {
             info = (XIScrollClassInfo *) device->classes[c];
-
-            valuator = &xi_device->valuators[actual_valuator_count++];
-            valuator->horizontal
-              = (info->scroll_type == XIScrollTypeHorizontal);
-            valuator->invalid_p = true;
-            valuator->emacs_value = DBL_MIN;
-            valuator->increment = info->increment;
-            valuator->number = info->number;
-
+            xi_populate_scroll_valuator (xi_device, actual_valuator_count++,
+                                         info);
             break;
           }
 
         case XIValuatorClass:
           {
-            val_info = (XIValuatorClassInfo *) device->classes[c];
+            valuator_info = (XIValuatorClassInfo *) device->classes[c];
             tem = SAFE_ALLOCA (sizeof *tem);
 
+            /* Avoid restoring bogus values if some driver
+               accidentally specifies relative values in scroll
+               valuator classes how the input extension spec says they
+               should be, but allow restoring values when a value is
+               set, which is how the input extension actually
+               behaves.  */
+
+            if (valuator_info->value == 0.0
+                && valuator_info->mode != XIModeAbsolute)
+              continue;
+
             tem->next = values;
-            tem->number = val_info->number;
-            tem->current_value = val_info->value;
+            tem->number = valuator_info->number;
+            tem->current_value = valuator_info->value;
 
             values = tem;
             break;
           }
-#endif
 
 #ifdef HAVE_XINPUT2_2
         case XITouchClass:
@@ -5399,7 +5512,6 @@ xi_populate_device_from_info (struct xi_device_t *xi_device,
         }
     }
 
-#ifdef HAVE_XINPUT2_1
   xi_device->scroll_valuator_count = actual_valuator_count;
 
   /* Now look through all the valuators whose values are already known
@@ -5413,7 +5525,9 @@ xi_populate_device_from_info (struct xi_device_t *xi_device,
           if (xi_device->valuators[c].number == tem->number)
             {
               xi_device->valuators[c].invalid_p = false;
-              xi_device->valuators[c].current_value = tem->current_value;
+              xi_device->valuators[c].current_value
+                = tem->current_value;
+              xi_device->valuators[c].emacs_value = 0.0;
             }
         }
     }
@@ -5475,7 +5589,8 @@ x_cache_xi_devices (struct x_display_info *dpyinfo)
   for (i = 0; i < ndevices; ++i)
     {
       if (infos[i].enabled)
-        xi_populate_device_from_info (&dpyinfo->devices[actual_devices++],
+        xi_populate_device_from_info (dpyinfo,
+                                      &dpyinfo->devices[actual_devices++],
                                       &infos[i]);
     }
 
@@ -5610,8 +5725,11 @@ static void
 xi_reset_scroll_valuators_for_device_id (struct x_display_info *dpyinfo,
                                          int id)
 {
-  struct xi_device_t *device = xi_device_from_id (dpyinfo, id);
+  struct xi_device_t *device;
   struct xi_scroll_valuator_t *valuator;
+  int i;
+
+  device = xi_device_from_id (dpyinfo, id);
 
   if (!device)
     return;
@@ -5619,7 +5737,7 @@ xi_reset_scroll_valuators_for_device_id (struct x_display_info *dpyinfo,
   if (!device->scroll_valuator_count)
     return;
 
-  for (int i = 0; i < device->scroll_valuator_count; ++i)
+  for (i = 0; i < device->scroll_valuator_count; ++i)
     {
       valuator = &device->valuators[i];
       valuator->invalid_p = true;
@@ -11414,15 +11532,18 @@ x_new_focus_frame (struct x_display_info *dpyinfo, struct frame *frame)
   x_frame_rehighlight (dpyinfo);
 }
 
+#ifdef HAVE_XFIXES
+
 /* True if the display in DPYINFO supports a version of Xfixes
    sufficient for pointer blanking.  */
-#ifdef HAVE_XFIXES
+
 static bool
-x_probe_xfixes_extension (struct x_display_info *dpyinfo)
+x_fixes_pointer_blanking_supported (struct x_display_info *dpyinfo)
 {
   return (dpyinfo->xfixes_supported_p
           && dpyinfo->xfixes_major >= 4);
 }
+
 #endif /* HAVE_XFIXES */
 
 /* Toggle mouse pointer visibility on frame F using the XFixes
@@ -11493,7 +11614,7 @@ x_toggle_visible_pointer (struct frame *f, bool invisible)
   /* But if Xfixes is available, try using it instead.  */
   if (dpyinfo->invisible_cursor == None)
     {
-      if (x_probe_xfixes_extension (dpyinfo))
+      if (x_fixes_pointer_blanking_supported (dpyinfo))
         {
           dpyinfo->fixes_pointer_blanking = true;
           xfixes_toggle_visible_pointer (f, invisible);
@@ -11521,7 +11642,7 @@ XTtoggle_invisible_pointer (struct frame *f, bool invisible)
   block_input ();
 #ifdef HAVE_XFIXES
   if (FRAME_DISPLAY_INFO (f)->fixes_pointer_blanking
-      && x_probe_xfixes_extension (FRAME_DISPLAY_INFO (f)))
+      && x_fixes_pointer_blanking_supported (FRAME_DISPLAY_INFO (f)))
     xfixes_toggle_visible_pointer (f, invisible);
   else
 #endif
@@ -11529,13 +11650,16 @@ XTtoggle_invisible_pointer (struct frame *f, bool invisible)
   unblock_input ();
 }
 
-/* Handle FocusIn and FocusOut state changes for FRAME.
-   If FRAME has focus and there exists more than one frame, puts
-   a FOCUS_IN_EVENT into *BUFP.  */
+/* Handle FocusIn and FocusOut state changes for FRAME.  If FRAME has
+   focus and there exists more than one frame, puts a FOCUS_IN_EVENT
+   into *BUFP.  Note that this code is not used to handle focus
+   changes on builds that can use the X Input extension for handling
+   input focus when it is available (currently the no toolkit and GTK
+   3 toolkits).  */
 
 static void
-x_focus_changed (int type, int state, struct x_display_info *dpyinfo, struct frame *frame,
-                 struct input_event *bufp)
+x_focus_changed (int type, int state, struct x_display_info *dpyinfo,
+                 struct frame *frame, struct input_event *bufp)
 {
   if (type == FocusIn)
     {
@@ -13017,121 +13141,181 @@ xi_get_scroll_valuator (struct xi_device_t *device, int number)
   return NULL;
 }
 
-#endif
+/* Check if EVENT, a DeviceChanged event, contains any scroll
+   valuators.  */
 
-/* Handle EVENT, a DeviceChanged event.  Look up the device that
-   changed, and update its information with the data in EVENT.  */
+static bool
+xi_has_scroll_valuators (XIDeviceChangedEvent *event)
+{
+  int i;
+
+  for (i = 0; i < event->num_classes; ++i)
+    {
+      if (event->classes[i]->type == XIScrollClass)
+        return true;
+    }
+
+  return false;
+}
+
+/* Repopulate the information (touchpoint tracking information, scroll
+   valuators, etc) in DEVICE with the device classes provided in
+   CLASSES.  This is called upon receiving a DeviceChanged event.
+
+   This function is not present on XI 2.0 as there are no worthwhile
+   classes there.  */
 
 static void
-xi_handle_device_changed (struct x_display_info *dpyinfo,
-                          struct xi_device_t *device,
-                          XIDeviceChangedEvent *event)
+xi_handle_new_classes (struct x_display_info *dpyinfo, struct xi_device_t *device,
+                       XIAnyClassInfo **classes, int num_classes)
 {
-#ifdef HAVE_XINPUT2_1
-  XIDeviceInfo *info;
   XIScrollClassInfo *scroll;
-  int i, ndevices;
   struct xi_scroll_valuator_t *valuator;
   XIValuatorClassInfo *valuator_info;
-#endif
+  int i;
 #ifdef HAVE_XINPUT2_2
-  struct xi_touch_point_t *tem, *last;
   XITouchClassInfo *touch;
 #endif
 
-#ifdef HAVE_XINPUT2_1
-  /* When a DeviceChange event is received for a master device, we
-     don't get any scroll valuators along with it.  This is possibly
-     an X server bug but I really don't want to dig any further, so
-     fetch the scroll valuators manually.  (bug#57020) */
-
-  x_catch_errors (dpyinfo->display);
-  info = XIQueryDevice (dpyinfo->display, event->deviceid,
-                        /* ndevices is always 1 if a deviceid is
-                           specified.  If the request fails, NULL will
-                           be returned.  */
-                        &ndevices);
-  x_uncatch_errors ();
+  if (dpyinfo->xi2_version < 1)
+    /* Emacs is connected to an XI 2.0 server, which reports no
+       classes of interest.  */
+    return;
 
-  if (info)
-    {
-      device->valuators = xrealloc (device->valuators,
-                                    (info->num_classes
-                                     * sizeof *device->valuators));
-      device->scroll_valuator_count = 0;
+  device->valuators = xnmalloc (num_classes,
+                                sizeof *device->valuators);
+  device->scroll_valuator_count = 0;
 #ifdef HAVE_XINPUT2_2
-      device->direct_p = false;
+  device->direct_p = false;
 #endif
 
-      for (i = 0; i < info->num_classes; ++i)
+  for (i = 0; i < num_classes; ++i)
+    {
+      switch (classes[i]->type)
         {
-          switch (info->classes[i]->type)
-            {
-            case XIScrollClass:
-              scroll = (XIScrollClassInfo *) info->classes[i];
-
-              valuator = &device->valuators[device->scroll_valuator_count++];
-              valuator->horizontal = (scroll->scroll_type
-                                      == XIScrollTypeHorizontal);
-              valuator->invalid_p = true;
-              valuator->emacs_value = DBL_MIN;
-              valuator->increment = scroll->increment;
-              valuator->number = scroll->number;
-              break;
+        case XIScrollClass:
+          scroll = (XIScrollClassInfo *) classes[i];
+
+          xi_populate_scroll_valuator (device,
+                                       device->scroll_valuator_count++,
+                                       scroll);
+          break;
 
 #ifdef HAVE_XINPUT2_2
-            case XITouchClass:
-              touch = (XITouchClassInfo *) info->classes[i];
+        case XITouchClass:
+          touch = (XITouchClassInfo *) classes[i];
 
-              if (touch->mode == XIDirectTouch)
-                device->direct_p = true;
-              break;
+          if (touch->mode == XIDirectTouch)
+            device->direct_p = true;
+          break;
 #endif
-            }
         }
+    }
 
-      /* Restore the values of any scroll valuators that we already
-         know about.  */
+  /* Restore the values of any scroll valuators that we already
+     know about.  */
 
-      for (i = 0; i < info->num_classes; ++i)
-        {
-          switch (info->classes[i]->type)
-            {
-            case XIValuatorClass:
-              valuator_info = (XIValuatorClassInfo *) info->classes[i];
+  for (i = 0; i < num_classes; ++i)
+    {
+      if (classes[i]->type != XIValuatorClass)
+        continue;
 
-              valuator = xi_get_scroll_valuator (device,
-                                                 valuator_info->number);
-              if (valuator)
-                {
-                  valuator->invalid_p = false;
-                  valuator->current_value = valuator_info->value;
-                }
+      valuator_info = (XIValuatorClassInfo *) classes[i];
 
-              break;
-            }
-        }
+      /* Avoid restoring bogus values if some driver accidentally
+         specifies relative values in scroll valuator classes how the
+         input extension spec says they should be, but allow restoring
+         values when a value is set, which is how the input extension
+         actually behaves.  */
+
+      if (valuator_info->value == 0.0
+          && valuator_info->mode != XIModeAbsolute)
+        continue;
+
+      valuator = xi_get_scroll_valuator (device,
+                                         valuator_info->number);
+
+      if (!valuator)
+        continue;
+
+      valuator->invalid_p = false;
+      valuator->current_value = valuator_info->value;
+      valuator->emacs_value = 0;
 
+      break;
+    }
+}
+
+#endif
+
+/* Handle EVENT, a DeviceChanged event.  Look up the device that
+   changed, and update its information with the data in EVENT.  */
+
+static void
+xi_handle_device_changed (struct x_display_info *dpyinfo,
+                          struct xi_device_t *device,
+                          XIDeviceChangedEvent *event)
+{
+#ifdef HAVE_XINPUT2_1
+  int ndevices;
+  XIDeviceInfo *info;
+#endif
 #ifdef HAVE_XINPUT2_2
-      /* The device is no longer a DirectTouch device, so
-         remove any touchpoints that we might have
-         recorded.  */
-      if (!device->direct_p)
-        {
-          tem = device->touchpoints;
+  struct xi_touch_point_t *tem, *last;
+#endif
 
-          while (tem)
-            {
-              last = tem;
-              tem = tem->next;
-              xfree (last);
-            }
+#ifdef HAVE_XINPUT2_1
+  if (xi_has_scroll_valuators (event))
+    /* Scroll valuators are provided by this event.  Use the values
+       provided in this event to populate the device's new scroll
+       valuator list: if this event is a SlaveSwitch event caused by
+       wheel movement, then querying for the device info will probably
+       return the value after the wheel movement, leading to a delta
+       of 0 being computed upon handling the subsequent XI_Motion
+       event.  (bug#58980) */
+    xi_handle_new_classes (dpyinfo, device, event->classes,
+                           event->num_classes);
+  else
+    {
+      /* When a DeviceChange event is received for a master device,
+         the X server sometimes does not send any scroll valuators
+         along with it.  This is possibly an X server bug but I really
+         don't want to dig any further, so fetch the scroll valuators
+         manually.  (bug#57020) */
 
-          device->touchpoints = NULL;
-        }
+      x_catch_errors (dpyinfo->display);
+      info = XIQueryDevice (dpyinfo->display, event->deviceid,
+                            /* ndevices is always 1 if a deviceid is
+                               specified.  If the request fails, NULL will
+                               be returned.  */
+                            &ndevices);
+      x_uncatch_errors ();
+
+      if (!info)
+        return;
+
+      /* info contains the classes currently associated with the
+         event.  Apply them.  */
+      xi_handle_new_classes (dpyinfo, device, info->classes,
+                             info->num_classes);
+    }
 #endif
 
-      XIFreeDeviceInfo (info);
+#ifdef HAVE_XINPUT2_2
+  /* The device is no longer a DirectTouch device, so remove any
+     touchpoints that we might have recorded.  */
+  if (!device->direct_p)
+    {
+      tem = device->touchpoints;
+
+      while (tem)
+        {
+          last = tem;
+          tem = tem->next;
+          xfree (last);
+        }
+
+      device->touchpoints = NULL;
     }
 #endif
 }
@@ -13383,7 +13567,7 @@ x_find_modifier_meanings (struct x_display_info *dpyinfo)
 #ifdef HAVE_XKB
   int i;
   int found_meta_p = false;
-  uint vmodmask;
+  unsigned int vmodmask;
 #endif
 
   dpyinfo->meta_mod_mask = 0;
@@ -14079,6 +14263,136 @@ x_get_window_below (Display *dpy, Window window,
   return value;
 }
 
+/* Like XTmouse_position, but much faster.  */
+
+static void
+x_fast_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
+                       enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
+                       Time *timestamp)
+{
+  int root_x, root_y, win_x, win_y;
+  unsigned int mask;
+  Window dummy;
+  struct scroll_bar *bar;
+  struct x_display_info *dpyinfo;
+  Lisp_Object tail, frame;
+  struct frame *f1;
+
+  dpyinfo = FRAME_DISPLAY_INFO (*fp);
+
+  if (dpyinfo->last_mouse_scroll_bar && !insist)
+    {
+      bar = dpyinfo->last_mouse_scroll_bar;
+
+      if (bar->horizontal)
+        x_horizontal_scroll_bar_report_motion (fp, bar_window, part,
+                                               x, y, timestamp);
+      else
+        x_scroll_bar_report_motion (fp, bar_window, part,
+                                    x, y, timestamp);
+
+      return;
+    }
+
+  if (!EQ (Vx_use_fast_mouse_position, Qreally_fast))
+    {
+      /* This means that Emacs should select a frame and report the
+         mouse position relative to it.  The approach used here avoids
+         making multiple roundtrips to the X server querying for the
+         window beneath the pointer, and was borrowed from
+         haiku_mouse_position in haikuterm.c.  */
+
+      FOR_EACH_FRAME (tail, frame)
+        {
+          if (FRAME_X_P (XFRAME (frame))
+              && (FRAME_DISPLAY_INFO (XFRAME (frame))
+                  == dpyinfo))
+            XFRAME (frame)->mouse_moved = false;
+        }
+
+      if (gui_mouse_grabbed (dpyinfo)
+          && !EQ (track_mouse, Qdropping)
+          && !EQ (track_mouse, Qdrag_source))
+        /* Pick the last mouse frame if dropping.  */
+        f1 = dpyinfo->last_mouse_frame;
+      else
+        /* Otherwise, pick the last mouse motion frame.  */
+        f1 = dpyinfo->last_mouse_motion_frame;
+
+      if (!f1 && (FRAME_X_P (SELECTED_FRAME ())
+                  && (FRAME_DISPLAY_INFO (SELECTED_FRAME ())
+                      == dpyinfo)))
+        f1 = SELECTED_FRAME ();
+
+      if (!f1 || (!FRAME_X_P (f1) && (insist > 0)))
+        FOR_EACH_FRAME (tail, frame)
+          if (FRAME_X_P (XFRAME (frame))
+              && (FRAME_DISPLAY_INFO (XFRAME (frame))
+                  == dpyinfo)
+              && !FRAME_TOOLTIP_P (XFRAME (frame)))
+            f1 = XFRAME (frame);
+
+      if (f1 && FRAME_TOOLTIP_P (f1))
+        f1 = NULL;
+
+      if (f1 && FRAME_X_P (f1) && FRAME_X_WINDOW (f1))
+        {
+          if (!x_query_pointer (dpyinfo->display, FRAME_X_WINDOW (f1),
+                                &dummy, &dummy, &root_x, &root_y,
+                                &win_x, &win_y, &mask))
+            /* The pointer is out of the screen.  */
+            return;
+
+          remember_mouse_glyph (f1, win_x, win_y,
+                                &dpyinfo->last_mouse_glyph);
+          dpyinfo->last_mouse_glyph_frame = f1;
+
+          *bar_window = Qnil;
+          *part = scroll_bar_nowhere;
+
+          /* If track-mouse is `drag-source' and the mouse pointer is
+             certain to not be actually under the chosen frame, return
+             NULL in FP.  */
+          if (EQ (track_mouse, Qdrag_source)
+              && (win_x < 0 || win_y < 0
+                  || win_x >= FRAME_PIXEL_WIDTH (f1)
+                  || win_y >= FRAME_PIXEL_HEIGHT (f1)))
+            *fp = NULL;
+          else
+            *fp = f1;
+
+          *timestamp = dpyinfo->last_mouse_movement_time;
+          XSETINT (*x, win_x);
+          XSETINT (*y, win_y);
+        }
+    }
+  else
+    {
+      /* This means Emacs should only report the coordinates of the
+         last mouse motion.  */
+
+      if (dpyinfo->last_mouse_motion_frame)
+        {
+          *fp = dpyinfo->last_mouse_motion_frame;
+          *timestamp = dpyinfo->last_mouse_movement_time;
+          *x = make_fixnum (dpyinfo->last_mouse_motion_x);
+          *y = make_fixnum (dpyinfo->last_mouse_motion_y);
+          *bar_window = Qnil;
+          *part = scroll_bar_nowhere;
+
+          FOR_EACH_FRAME (tail, frame)
+            {
+              if (FRAME_X_P (XFRAME (frame))
+                  && (FRAME_DISPLAY_INFO (XFRAME (frame))
+                      == dpyinfo))
+                XFRAME (frame)->mouse_moved = false;
+            }
+
+          dpyinfo->last_mouse_motion_frame->mouse_moved = false;
+        }
+    }
+}
+
 /* Return the current position of the mouse.
    *FP should be a frame which indicates which display to ask about.
 
@@ -14105,9 +14419,27 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                   Time *timestamp)
 {
   struct frame *f1, *maybe_tooltip;
-  struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
+  struct x_display_info *dpyinfo;
   bool unrelated_tooltip;
 
+  dpyinfo = FRAME_DISPLAY_INFO (*fp);
+
+  if (!NILP (Vx_use_fast_mouse_position))
+    {
+      /* The user says that Emacs is running over the network, and a
+         fast approximation of `mouse-position' should be used.
+
+         Depending on what the value of `x-use-fast-mouse-position'
+         is, do one of two things: only perform the XQueryPointer to
+         obtain the coordinates from the last mouse frame, or only
+         return the last mouse motion frame and the
+         last_mouse_motion_x and Y.  */
+
+      x_fast_mouse_position (fp, insist, bar_window, part, x,
+                             y, timestamp);
+      return;
+    }
+
   block_input ();
 
   if (dpyinfo->last_mouse_scroll_bar && insist == 0)
@@ -14229,7 +14561,7 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                     break;
                   }
 #ifdef USE_GTK
-                /* We don't wan't to know the innermost window.  We
+                /* We don't want to know the innermost window.  We
                    want the edit window.  For non-Gtk+ the innermost
                    window is the edit window.  For Gtk+ it might not
                    be.  It might be the tool bar for example.  */
@@ -14260,7 +14592,7 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                never use them in that case.)  */
 
 #ifdef USE_GTK
-            /* We don't wan't to know the innermost window.  We
+            /* We don't want to know the innermost window.  We
                want the edit window.  */
             f1 = x_window_to_frame (dpyinfo, win);
 #else
@@ -18620,7 +18952,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
         /* If drag-and-drop or another modal dialog/menu is in
            progress, handle SelectionRequest events immediately, by
-           pushing it onto the selecction queue.  */
+           pushing it onto the selection queue.  */
 
         if (x_use_pending_selection_requests)
           {
@@ -20980,8 +21312,11 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 
             if (FRAME_PARENT_FRAME (f) || (hf && frame_ancestor_p (f, hf)))
               {
+                x_ignore_errors_for_next_request (dpyinfo);
                 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
                                 RevertToParent, event->xbutton.time);
+                x_stop_ignoring_errors (dpyinfo);
+
                 if (FRAME_PARENT_FRAME (f))
                   XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
               }
@@ -21393,6 +21728,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                  related to those grabs arrive.  The only way to
                  remedy this is to never reset scroll valuators on a
                  grab-related crossing event.  (bug#57476) */
+
               if (enter->mode != XINotifyUngrab
                   && enter->mode != XINotifyGrab
                   && enter->mode != XINotifyPassiveGrab
@@ -21522,17 +21858,16 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                  was very complicated and kept running into server
                  bugs.  */
 #ifdef HAVE_XINPUT2_1
-              if (any
-                  /* xfwm4 selects for button events on the frame
-                     window, resulting in passive grabs being
-                     generated along with the delivery of emulated
-                     button events; this then interferes with
-                     scrolling, since device valuators will constantly
-                     be reset as the crossing events related to those
-                     grabs arrive.  The only way to remedy this is to
-                     never reset scroll valuators on a grab-related
-                     crossing event.  (bug#57476) */
-                  && leave->mode != XINotifyUngrab
+              /* xfwm4 selects for button events on the frame window,
+                 resulting in passive grabs being generated along with
+                 the delivery of emulated button events; this then
+                 interferes with scrolling, since device valuators
+                 will constantly be reset as the crossing events
+                 related to those grabs arrive.  The only way to
+                 remedy this is to never reset scroll valuators on a
+                 grab-related crossing event.  (bug#57476) */
+
+              if (leave->mode != XINotifyUngrab
                   && leave->mode != XINotifyGrab
                   && leave->mode != XINotifyPassiveUngrab
                   && leave->mode != XINotifyPassiveGrab)
@@ -21569,19 +21904,6 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                  masks are set on the frame widget's window.  */
               f = x_window_to_frame (dpyinfo, leave->event);
 
-              /* Also do this again here, since the test for `any'
-                 above may not have found a frame, as that usually
-                 just looks up a top window on Xt builds.  */
-
-#ifdef HAVE_XINPUT2_1
-              if (f && leave->mode != XINotifyUngrab
-                  && leave->mode != XINotifyGrab
-                  && leave->mode != XINotifyPassiveUngrab
-                  && leave->mode != XINotifyPassiveGrab)
-                xi_reset_scroll_valuators_for_device_id (dpyinfo,
-                                                         leave->deviceid);
-#endif
-
               if (!f)
                 f = x_top_window_to_frame (dpyinfo, leave->event);
 #endif
@@ -22696,9 +23018,13 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                         }
 #else
                       /* Non-no toolkit builds without GTK 3 use core
-                         events to handle focus.  */
+                         events to handle focus.  Errors are still
+                         caught here in case the window is not
+                         viewable.  */
+                      x_ignore_errors_for_next_request (dpyinfo);
                       XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
                                       RevertToParent, xev->time);
+                      x_stop_ignoring_errors (dpyinfo);
 #endif
                       if (FRAME_PARENT_FRAME (f))
                         XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
@@ -22953,7 +23279,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
               char *copy_bufptr = copy_buffer;
               int copy_bufsiz = sizeof (copy_buffer);
               ptrdiff_t i;
-              uint old_state;
+              unsigned int old_state;
               struct xi_device_t *device, *source;
 
               coding = Qlatin_1;
@@ -22979,8 +23305,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                   copy.xkey.root = xev->root;
                   copy.xkey.subwindow = xev->child;
                   copy.xkey.time = xev->time;
-                  copy.xkey.state = ((xev->mods.effective & ~(1 << 13 | 1 << 14))
-                                     | (xev->group.effective << 13));
+                  copy.xkey.state = xi_convert_event_keyboard_state (xev);
                   xi_convert_button_state (&xev->buttons, &copy.xkey.state);
 
                   copy.xkey.x = lrint (xev->event_x);
@@ -23036,8 +23361,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
               xkey.root = xev->root;
               xkey.subwindow = xev->child;
               xkey.time = xev->time;
-              xkey.state = ((xev->mods.effective & ~(1 << 13 | 1 << 14))
-                            | (xev->group.effective << 13));
+              xkey.state = xi_convert_event_keyboard_state (xev);
 
               xkey.x = lrint (xev->event_x);
               xkey.y = lrint (xev->event_y);
@@ -23101,8 +23425,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #ifdef HAVE_XKB
               if (dpyinfo->xkb_desc)
                 {
-                  uint xkb_state = state;
-                  xkb_state &= ~(1 << 13 | 1 << 14);
+                  unsigned int xkb_state;
+
+                  xkb_state = state & ~(1 << 13 | 1 << 14);
                   xkb_state |= xev->group.effective << 13;
 
                   if (!XkbTranslateKeyCode (dpyinfo->xkb_desc, keycode,
@@ -23455,8 +23780,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
               xkey.root = xev->root;
               xkey.subwindow = xev->child;
               xkey.time = xev->time;
-              xkey.state = ((xev->mods.effective & ~(1 << 13 | 1 << 14))
-                            | (xev->group.effective << 13));
+              xkey.state = xi_convert_event_keyboard_state (xev);
               xkey.x = lrint (xev->event_x);
               xkey.y = lrint (xev->event_y);
               xkey.x_root = lrint (xev->root_x);
@@ -23558,7 +23882,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                               memset (dpyinfo->devices + dpyinfo->num_devices - 1,
                                       0, sizeof *dpyinfo->devices);
                               device = &dpyinfo->devices[dpyinfo->num_devices - 1];
-                              xi_populate_device_from_info (device, info);
+                              xi_populate_device_from_info (dpyinfo, device, info);
                             }
 
                           if (info)
@@ -24939,6 +25263,48 @@ static struct x_error_message_stack *x_error_message;
 /* The amount of items (depth) in that stack.  */
 int x_error_message_count;
 
+/* Compare various request serials while handling wraparound.  Treat a
+   difference of more than X_ULONG_MAX / 2 as wraparound.
+
+   Note that these functions truncate serials to 32 bits before
+   comparison.  */
+
+static bool
+x_is_serial_more_than (unsigned int a, unsigned int b)
+{
+  if (a > b)
+    return true;
+
+  return (b - a > X_ULONG_MAX / 2);
+}
+
+static bool
+x_is_serial_more_than_or_equal_to (unsigned int a, unsigned int b)
+{
+  if (a >= b)
+    return true;
+
+  return (b - a > X_ULONG_MAX / 2);
+}
+
+static bool
+x_is_serial_less_than (unsigned int a, unsigned int b)
+{
+  if (a < b)
+    return true;
+
+  return (a - b > X_ULONG_MAX / 2);
+}
+
+static bool
+x_is_serial_less_than_or_equal_to (unsigned int a, unsigned int b)
+{
+  if (a <= b)
+    return true;
+
+  return (a - b > X_ULONG_MAX / 2);
+}
+
 static struct x_error_message_stack *
 x_find_error_handler (Display *dpy, XErrorEvent *event)
 {
@@ -24948,8 +25314,8 @@ x_find_error_handler (Display *dpy, XErrorEvent *event)
 
   while (stack)
     {
-      if (X_COMPARE_SERIALS (event->serial, >=,
-                             stack->first_request)
+      if (x_is_serial_more_than_or_equal_to (event->serial,
+                                             stack->first_request)
           && dpy == stack->dpy)
         return stack;
 
@@ -25052,11 +25418,11 @@ x_request_can_fail (struct x_display_info *dpyinfo,
        failable_requests < dpyinfo->next_failable_request;
        failable_requests++)
     {
-      if (X_COMPARE_SERIALS (request, >=,
-                             failable_requests->start)
+      if (x_is_serial_more_than_or_equal_to (request,
+                                             failable_requests->start)
           && (!failable_requests->end
-              || X_COMPARE_SERIALS (request, <=,
-                                    failable_requests->end)))
+              || x_is_serial_less_than_or_equal_to (request,
+                                                    failable_requests->end)))
         return failable_requests;
     }
 
@@ -25074,11 +25440,11 @@ x_clean_failable_requests (struct x_display_info *dpyinfo)
 
   for (first = dpyinfo->failable_requests; first < last; first++)
     {
-      if (X_COMPARE_SERIALS (first->start, >,
-                             LastKnownRequestProcessed (dpyinfo->display))
+      if (x_is_serial_more_than (first->start,
+                                 LastKnownRequestProcessed (dpyinfo->display))
           || !first->end
-          || X_COMPARE_SERIALS (first->end, >,
-                                LastKnownRequestProcessed (dpyinfo->display)))
+          || x_is_serial_more_than (first->end,
+                                    LastKnownRequestProcessed (dpyinfo->display)))
         break;
     }
 
@@ -25157,8 +25523,7 @@ x_stop_ignoring_errors (struct x_display_info *dpyinfo)
   /* Abort if no request was made since
      `x_ignore_errors_for_next_request'.  */
 
-  if (X_COMPARE_SERIALS (range->end, <,
-                         range->start))
+  if (x_is_serial_less_than (range->end, range->start))
     emacs_abort ();
 
 #ifdef HAVE_GTK3
@@ -27347,11 +27712,10 @@ x_ewmh_activate_frame (struct frame *f)
             {
               time = x_get_server_time (f);
 
-              x_ignore_errors_for_next_request (dpyinfo);
-              XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
-                              RevertToParent, time);
+              x_set_input_focus (FRAME_DISPLAY_INFO (f),
+                                 FRAME_OUTER_WINDOW (f),
+                                 time);
               XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
-              x_stop_ignoring_errors (dpyinfo);
 
               return;
             }
@@ -27377,6 +27741,76 @@ x_get_focus_frame (struct frame *f)
   return lisp_focus;
 }
 
+/* Return the toplevel parent of F, if it is a child frame.
+   Otherwise, return NULL.  */
+
+static struct frame *
+x_get_toplevel_parent (struct frame *f)
+{
+  struct frame *parent;
+
+  if (!FRAME_PARENT_FRAME (f))
+    return NULL;
+
+  parent = FRAME_PARENT_FRAME (f);
+
+  while (FRAME_PARENT_FRAME (parent))
+    parent = FRAME_PARENT_FRAME (parent);
+
+  return parent;
+}
+
+static void
+x_set_input_focus (struct x_display_info *dpyinfo, Window window,
+                   Time time)
+{
+#ifdef HAVE_XINPUT2
+  struct xi_device_t *device;
+#endif
+
+  /* Do the equivalent of XSetInputFocus with the specified window and
+     time, but use the attachment to the device that Emacs has
+     designated the client pointer on X Input Extension builds.
+     Asynchronously trap errors around the generated XI_SetFocus or
+     SetInputFocus request, in case the device has been destroyed or
+     the window obscured.
+
+     The revert_to will be set to RevertToParent for generated
+     SetInputFocus requests.  */
+
+#ifdef HAVE_XINPUT2
+  if (dpyinfo->supports_xi2
+      && dpyinfo->client_pointer_device != -1)
+    {
+      device = xi_device_from_id (dpyinfo, dpyinfo->client_pointer_device);
+
+      /* The device is a master pointer.  Use its attachment, which
+         should be the master keyboard.  */
+
+      if (device)
+        {
+          eassert (device->use == XIMasterPointer);
+
+          x_ignore_errors_for_next_request (dpyinfo);
+          XISetFocus (dpyinfo->display, device->attachment,
+                      /* Note that the input extension
+                         only supports RevertToParent-type
+                         behavior.  */
+                      window, time);
+          x_stop_ignoring_errors (dpyinfo);
+
+          return;
+        }
+    }
+#endif
+
+  /* Otherwise, use the pointer device that the X server says is the
+     client pointer.  */
+  x_ignore_errors_for_next_request (dpyinfo);
+  XSetInputFocus (dpyinfo->display, window, RevertToParent, time);
+  x_stop_ignoring_errors (dpyinfo);
+}
+
 /* In certain situations, when the window manager follows a
    click-to-focus policy, there seems to be no way around calling
    XSetInputFocus to give another frame the input focus.
@@ -27402,6 +27836,18 @@ x_focus_frame (struct frame *f, bool noactivate)
   else
     {
       if (!noactivate
+          /* If F is override-redirect, use SetInputFocus instead.
+             Override-redirect frames are not subject to window
+             management.  */
+          && !FRAME_OVERRIDE_REDIRECT (f)
+          /* If F is a child frame, use SetInputFocus instead.  This
+             may not work if its parent is not activated.  */
+          && !FRAME_PARENT_FRAME (f)
+          /* If the focus is being transferred from a child frame to
+             its toplevel parent, also use SetInputFocus.  */
+          && (!dpyinfo->x_focus_frame
+              || (x_get_toplevel_parent (dpyinfo->x_focus_frame)
+                  != f))
           && x_wm_supports (f, dpyinfo->Xatom_net_active_window))
         {
           /* When window manager activation is possible, use it
@@ -27413,8 +27859,6 @@ x_focus_frame (struct frame *f, bool noactivate)
           return;
         }
 
-      /* Ignore any BadMatch error this request might result in.  */
-      x_ignore_errors_for_next_request (dpyinfo);
       if (NILP (Vx_no_window_manager))
         {
           /* Use the last user time.  It is invalid to use CurrentTime
@@ -27432,15 +27876,19 @@ x_focus_frame (struct frame *f, bool noactivate)
               && !dpyinfo->x_focus_frame)
             time = x_get_server_time (f);
 
-          XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
-                          RevertToParent, time);
+          /* Ignore any BadMatch error this request might result in.
+             A BadMatch error can occur if the window was obscured
+             after the time of the last user interaction without
+             changing the last-focus-change-time.  */
+          x_set_input_focus (FRAME_DISPLAY_INFO (f), FRAME_OUTER_WINDOW (f),
+                             time);
         }
       else
-        XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
-                        /* But when no window manager is in use, we
-                           don't care.  */
-                        RevertToParent, CurrentTime);
-      x_stop_ignoring_errors (dpyinfo);
+        x_set_input_focus (FRAME_DISPLAY_INFO (f), FRAME_OUTER_WINDOW (f),
+                           /* But when no window manager is in use,
+                              respecting the ICCCM doesn't really
+                              matter.  */
+                           CurrentTime);
     }
 }
 
@@ -28912,10 +29360,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 #endif
   int i;
 
+#if defined HAVE_XFIXES && defined USE_XCB
   USE_SAFE_ALLOCA;
-
-  /* Avoid warnings when SAFE_ALLOCA is not actually used.  */
-  ((void) SAFE_ALLOCA (0));
+#endif
 
   block_input ();
 
@@ -29069,7 +29516,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
       unblock_input ();
 
+#if defined HAVE_XFIXES && defined USE_XCB
       SAFE_FREE ();
+#endif
       return 0;
     }
 
@@ -29089,7 +29538,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
       unblock_input ();
 
+#if defined HAVE_XFIXES && defined USE_XCB
       SAFE_FREE ();
+#endif
       return 0;
     }
 #endif
@@ -29559,11 +30010,10 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
           xi_select_hierarchy_events (dpyinfo);
 #endif
 
+          dpyinfo->xi2_version = minor;
           x_cache_xi_devices (dpyinfo);
         }
     }
-
-  dpyinfo->xi2_version = minor;
  skip_xi_setup:
   ;
 #endif
@@ -29778,21 +30228,30 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
   {
     XrmValue d, fr, to;
     Font font;
+    XFontStruct *query_result;
 
     dpy = dpyinfo->display;
-    d.addr = (XPointer)&dpy;
+    d.addr = (XPointer) &dpy;
     d.size = sizeof (Display *);
     fr.addr = (char *) XtDefaultFont;
     fr.size = sizeof (XtDefaultFont);
     to.size = sizeof (Font *);
-    to.addr = (XPointer)&font;
+    to.addr = (XPointer) &font;
     x_catch_errors (dpy);
     if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
       emacs_abort ();
-    if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
+    query_result = XQueryFont (dpy, font);
+
+    /* Set the dialog font to some fallback (here, 9x15) if the font
+       specified is invalid.  */
+    if (x_had_errors_p (dpy) || !font)
       XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
-    /* Do not free XFontStruct returned by the above call to XQueryFont.
-       This leads to X protocol errors at XtCloseDisplay (Bug#18403).  */
+
+    /* Do not destroy the font struct returned above with XFreeFont;
+       that also destroys the font, leading to X protocol errors at
+       XtCloseDisplay.  Just free the font info structure.
+       (Bug#18403) */
+    XFreeFontInfo (NULL, query_result, 1);
     x_uncatch_errors ();
   }
 #endif
@@ -29966,7 +30425,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
 
   unblock_input ();
 
+#if defined HAVE_XFIXES && defined USE_XCB
   SAFE_FREE ();
+#endif
   return dpyinfo;
 }
 
@@ -30846,6 +31307,7 @@ With MS Windows, Haiku windowing or Nextstep, the value is t.  */);
   DEFSYM (Qimitate_pager, "imitate-pager");
   DEFSYM (Qnewer_time, "newer-time");
   DEFSYM (Qraise_and_focus, "raise-and-focus");
+  DEFSYM (Qreally_fast, "really-fast");
 
   DEFVAR_LISP ("x-ctrl-keysym", Vx_ctrl_keysym,
     doc: /* Which keys Emacs uses for the ctrl modifier.
@@ -31125,4 +31587,19 @@ not bypass window manager focus stealing prevention):
   - The symbol `raise-and-focus', which means to raise the window and
     focus it manually.  */);
   Vx_allow_focus_stealing = Qnewer_time;
+
+  DEFVAR_LISP ("x-use-fast-mouse-position", Vx_use_fast_mouse_position,
+    doc: /* How to make `mouse-position' faster.
+
+`mouse-position' and `mouse-pixel-position' default to querying the X
+server for the window under the mouse pointer.  This results in
+accurate results, but is also very slow when the X connection has
+moderate to high latency.  Setting this variable to a non-nil value
+makes Emacs query only for the position of the pointer, which is
+usually faster.  Doing so improves the performance of dragging to
+select text over slow X connections.
+
+If that is still too slow, setting this variable to the symbol
+`really-fast' will make Emacs return only cached values.  */);
+  Vx_use_fast_mouse_position = Qnil;
 }
diff --git a/src/xterm.h b/src/xterm.h
index 1124dcceb4a..c36920081d3 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -580,7 +580,9 @@ struct x_display_info
   Time last_user_time;
 
   /* Position where the mouse was last time we reported a motion.
-     This is a position on last_mouse_motion_frame.  */
+     This is a position on last_mouse_motion_frame.  It is used in
+     some situations to report the mouse position as well: see
+     XTmouse_position.  */
   int last_mouse_motion_x;
   int last_mouse_motion_y;
 
@@ -1605,22 +1607,15 @@ SELECTION_EVENT_DISPLAY (struct selection_input_event *ev)
 
 extern void x_free_gcs (struct frame *);
 extern void x_relative_mouse_position (struct frame *, int *, int *);
-extern void x_real_pos_and_offsets (struct frame *f,
-                                    int *left_offset_x,
-                                    int *right_offset_x,
-                                    int *top_offset_y,
-                                    int *bottom_offset_y,
-                                    int *x_pixels_diff,
-                                    int *y_pixels_diff,
-                                    int *xptr,
-                                    int *yptr,
-                                    int *outer_border);
-extern void x_default_font_parameter (struct frame* f, Lisp_Object parms);
+extern void x_real_pos_and_offsets (struct frame *, int *, int *, int *,
+                                    int *, int *, int *, int *, int *,
+                                    int *);
+extern void x_default_font_parameter (struct frame *, Lisp_Object);
 
 /* From xrdb.c.  */
 
-XrmDatabase x_load_resources (Display *, const char *, const char *,
-                              const char *);
+extern XrmDatabase x_load_resources (Display *, const char *, const char *,
+                                     const char *);
 extern const char *x_get_string_resource (void *, const char *, const char *);
 
 /* Defined in xterm.c */