Merge from origin/emacs-25

d08afa1 * etc/AUTHORS: Update the AUTHORS file
2668500 ;; * ChangeLog.2: ChangeLog update.
7acfaea ; ChangeLog fixes
97d28b4 * admin/authors.el (authors-valid-file-names): Addition.
9ab52f6 * admin/authors.el: Additions.
0e646c7 Warn about Cairo-related problems
bc4c07f Don't let completion break `declare' handling
66f95e0 Adjust match data before calling after-change-funs
52cf0d5 Do not show string-rectangle preview if minibuffer is empty
6a3d031 * etc/PROBLEMS: Add entry about selection problems under Plas...

# Conflicts:
#	ChangeLog.2
#	src/lisp.h

5 files changed, 47 insertions, 31 deletions

diff --git a/src/cmds.c b/src/cmds.c
index 1e44dddfbf6..4003d8bfa47 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -447,7 +447,7 @@ internal_self_insert (int c, EMACS_INT n)
           string = concat2 (string, tem);
         }
 
-      replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
+      replace_range (PT, PT + chars_to_delete, string, 1, 1, 1, 0);
       Fforward_char (make_number (n));
     }
   else if (n > 1)
diff --git a/src/editfns.c b/src/editfns.c
index 61b2a871b73..732306af868 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -3244,7 +3244,7 @@ Both characters must have the same length of multi-byte form.  */)
               /* replace_range is less efficient, because it moves the gap,
                  but it handles combining correctly.  */
               replace_range (pos, pos + 1, string,
-                             0, 0, 1);
+                             0, 0, 1, 0);
               pos_byte_next = CHAR_TO_BYTE (pos);
               if (pos_byte_next > pos_byte)
                 /* Before combining happened.  We should not increment
@@ -3457,7 +3457,7 @@ It returns the number of characters changed.  */)
                   /* This is less efficient, because it moves the gap,
                      but it should handle multibyte characters correctly.  */
                   string = make_multibyte_string ((char *) str, 1, str_len);
-                  replace_range (pos, pos + 1, string, 1, 0, 1);
+                  replace_range (pos, pos + 1, string, 1, 0, 1, 0);
                   len = str_len;
                 }
               else
@@ -3498,7 +3498,7 @@ It returns the number of characters changed.  */)
                 {
                   string = Fmake_string (make_number (1), val);
                 }
-              replace_range (pos, pos + len, string, 1, 0, 1);
+              replace_range (pos, pos + len, string, 1, 0, 1, 0);
               pos_byte += SBYTES (string);
               pos += SCHARS (string);
               cnt += SCHARS (string);
diff --git a/src/insdel.c b/src/insdel.c
index ec7bbb3e715..5d3884b4059 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1340,7 +1340,9 @@ adjust_after_insert (ptrdiff_t from, ptrdiff_t from_byte,
 /* Replace the text from character positions FROM to TO with NEW,
    If PREPARE, call prepare_to_modify_buffer.
    If INHERIT, the newly inserted text should inherit text properties
-   from the surrounding non-deleted text.  */
+   from the surrounding non-deleted text.
+   If ADJUST_MATCH_DATA, then adjust the match data before calling
+   signal_after_change.  */
 
 /* Note that this does not yet handle markers quite right.
    Also it needs to record a single undo-entry that does a replacement
@@ -1351,7 +1353,8 @@ adjust_after_insert (ptrdiff_t from, ptrdiff_t from_byte,
 
 void
 replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
-               bool prepare, bool inherit, bool markers)
+               bool prepare, bool inherit, bool markers,
+               bool adjust_match_data)
 {
   ptrdiff_t inschars = SCHARS (new);
   ptrdiff_t insbytes = SBYTES (new);
@@ -1508,6 +1511,9 @@ replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
   MODIFF++;
   CHARS_MODIFF = MODIFF;
 
+  if (adjust_match_data)
+    update_search_regs (from, to, from + SCHARS (new));
+
   signal_after_change (from, nchars_del, GPT - from);
   update_compositions (from, GPT, CHECK_BORDER);
 }
diff --git a/src/lisp.h b/src/lisp.h
index 089f3977cd2..8ac9cc1d2a9 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3530,7 +3530,7 @@ extern void adjust_markers_for_delete (ptrdiff_t, ptrdiff_t,
                                        ptrdiff_t, ptrdiff_t);
 extern void adjust_markers_bytepos (ptrdiff_t, ptrdiff_t,
                                     ptrdiff_t, ptrdiff_t, int);
-extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object, bool, bool, bool);
+extern void replace_range (ptrdiff_t, ptrdiff_t, Lisp_Object, bool, bool, bool, bool);
 extern void replace_range_2 (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
                              const char *, ptrdiff_t, ptrdiff_t, bool);
 extern void syms_of_insdel (void);
@@ -4019,6 +4019,8 @@ extern Lisp_Object make_temp_name (Lisp_Object, bool);
 /* Defined in search.c.  */
 extern void shrink_regexp_cache (void);
 extern void restore_search_regs (void);
+extern void update_search_regs (ptrdiff_t oldstart,
+                                ptrdiff_t oldend, ptrdiff_t newend);
 extern void record_unwind_save_match_data (void);
 struct re_registers;
 extern struct re_pattern_buffer *compile_pattern (Lisp_Object,
diff --git a/src/search.c b/src/search.c
index 3d4846644ee..5dc4d355304 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2712,16 +2712,23 @@ since only regular expressions have distinguished subexpressions.  */)
 
   /* The functions below modify the buffer, so they could trigger
      various modification hooks (see signal_before_change and
-     signal_after_change), which might clobber the match data we need
-     to adjust after the replacement.  If that happens, we error out.  */
+     signal_after_change).  If these hooks clobber the match data we
+     error out since otherwise this will result in confusing bugs.  */
   ptrdiff_t sub_start = search_regs.start[sub];
   ptrdiff_t sub_end = search_regs.end[sub];
   unsigned  num_regs = search_regs.num_regs;
+  newpoint = search_regs.start[sub] + SCHARS (newtext);
 
   /* Replace the old text with the new in the cleanest possible way.  */
   replace_range (search_regs.start[sub], search_regs.end[sub],
-                 newtext, 1, 0, 1);
-  newpoint = search_regs.start[sub] + SCHARS (newtext);
+                 newtext, 1, 0, 1, 1);
+  /* Update saved data to match adjustment made by replace_range.  */
+  {
+    ptrdiff_t change = newpoint - sub_end;
+    if (sub_start >= sub_end)
+      sub_start += change;
+    sub_end += change;
+  }
 
   if (case_action == all_caps)
     Fupcase_region (make_number (search_regs.start[sub]),
@@ -2736,26 +2743,6 @@ since only regular expressions have distinguished subexpressions.  */)
       || search_regs.num_regs != num_regs)
     error ("Match data clobbered by buffer modification hooks");
 
-  /* Adjust search data for this change.  */
-  {
-    ptrdiff_t oldend = search_regs.end[sub];
-    ptrdiff_t oldstart = search_regs.start[sub];
-    ptrdiff_t change = newpoint - search_regs.end[sub];
-    ptrdiff_t i;
-
-    for (i = 0; i < search_regs.num_regs; i++)
-      {
-        if (search_regs.start[i] >= oldend)
-          search_regs.start[i] += change;
-        else if (search_regs.start[i] > oldstart)
-          search_regs.start[i] = oldstart;
-        if (search_regs.end[i] >= oldend)
-          search_regs.end[i] += change;
-        else if (search_regs.end[i] > oldstart)
-          search_regs.end[i] = oldstart;
-      }
-  }
-
   /* Put point back where it was in the text.  */
   if (opoint <= 0)
     TEMP_SET_PT (opoint + ZV);
@@ -3096,6 +3083,27 @@ restore_search_regs (void)
     }
 }
 
+/* Called from replace-match via replace_range.  */
+void
+update_search_regs (ptrdiff_t oldstart, ptrdiff_t oldend, ptrdiff_t newend)
+{
+  /* Adjust search data for this change.  */
+  ptrdiff_t change = newend - oldend;
+  ptrdiff_t i;
+
+  for (i = 0; i < search_regs.num_regs; i++)
+    {
+      if (search_regs.start[i] >= oldend)
+        search_regs.start[i] += change;
+      else if (search_regs.start[i] > oldstart)
+        search_regs.start[i] = oldstart;
+      if (search_regs.end[i] >= oldend)
+        search_regs.end[i] += change;
+      else if (search_regs.end[i] > oldstart)
+        search_regs.end[i] = oldstart;
+    }
+}
+
 static void
 unwind_set_match_data (Lisp_Object list)
 {