From b3aad29e4699da1f3b8d3bb05eb7f3ca695af7bf Mon Sep 17 00:00:00 2001
From: Chong Yidong <cyd@stupidchicken.com>
Date: Wed, 28 Feb 2007 18:54:43 +0000
Subject: (perform-replace): Undo forward-char immediately if non-adjacent
 search fails.

---
 lisp/replace.el | 56 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 27 deletions(-)

(limited to 'lisp/replace.el')

diff --git a/lisp/replace.el b/lisp/replace.el
index 9790dacd82..20f38aec32 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -1466,27 +1466,35 @@ make, or the user didn't cancel the call."
 		    ;; otherwise, search for a match after moving forward
 		    ;; one char if progress is required.
 		    (setq real-match-data
-			  (if (consp match-again)
-			      (progn (goto-char (nth 1 match-again))
-				     (replace-match-data t
-				      real-match-data
-				      match-again))
-			    (and (or match-again
-				     ;; MATCH-AGAIN non-nil means we
-				     ;; accept an adjacent match.  If
-				     ;; we don't, move one char to the
-				     ;; right.  This takes us a
-				     ;; character too far at the end,
-				     ;; but this is undone after the
-				     ;; while-loop.
-				     (progn
-				       (forward-char 1)
-				       (not (or (eobp)
-						(and limit (>= (point) limit))))))
-				 (funcall search-function search-string limit t)
-				 ;; For speed, use only integers and
-				 ;; reuse the list used last time.
-				 (replace-match-data t real-match-data)))))
+			  (cond ((consp match-again)
+				 (goto-char (nth 1 match-again))
+				 (replace-match-data
+				  t real-match-data match-again))
+				;; MATCH-AGAIN non-nil means accept an
+				;; adjacent match.
+				(match-again
+				 (and
+				  (funcall search-function search-string
+					   limit t)
+				  ;; For speed, use only integers and
+				  ;; reuse the list used last time.
+				  (replace-match-data t real-match-data)))
+				((and (< (1+ (point)) (point-max))
+				      (or (null limit)
+					  (< (1+ (point)) limit)))
+				 ;; If not accepting adjacent matches,
+				 ;; move one char to the right before
+				 ;; searching again.  Undo the motion
+				 ;; if the search fails.
+				 (let ((opoint (point)))
+				   (forward-char 1)
+				   (if (funcall
+					search-function search-string
+					limit t)
+				       (replace-match-data
+					t real-match-data)
+				     (goto-char opoint)
+				     nil))))))
 
 	  ;; Record whether the match is nonempty, to avoid an infinite loop
 	  ;; repeatedly matching the same empty string.
@@ -1702,12 +1710,6 @@ make, or the user didn't cancel the call."
 			      (match-data t)))
 		      stack)))))
 
-      ;; The code preventing adjacent regexp matches in the condition
-      ;; of the while-loop above will haven taken us one character
-      ;; beyond the last replacement.  Undo that.
-      (when (and regexp-flag (not match-again) (> replace-count 0))
-	(backward-char 1))
-
       (replace-dehighlight))
     (or unread-command-events
 	(message "Replaced %d occurrence%s"
-- 
cgit v1.2.3