Merge from origin/emacs-25

[gnu-emacs] / lisp / isearch.el

diff --git a/lisp/isearch.el b/lisp/isearch.el
index 39d573cc01f0b1933bfe23dd8037e18d9d71d6a7..b2223e7b3081c2cf874d64be96fc39adae6d0b66 100644 (file)
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1,6 +1,6 @@
 ;;; isearch.el --- incremental search minor mode
 
 ;;; isearch.el --- incremental search minor mode
 

-;; Copyright (C) 1992-1997, 1999-2015 Free Software Foundation, Inc.
+;; Copyright (C) 1992-1997, 1999-2016 Free Software Foundation, Inc.

 
 ;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
 ;; Maintainer: emacs-devel@gnu.org
 
 ;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
 ;; Maintainer: emacs-devel@gnu.org


@@ -177,11 +177,6 @@ is non-nil if the user quits the search.")
   "Function to call to display the search prompt.
 If nil, use function `isearch-message'.")
 
   "Function to call to display the search prompt.
 If nil, use function `isearch-message'.")
 

-(defmacro isearch-call-message (&optional cqh ellip)
-  `(if isearch-message-function
-       (funcall isearch-message-function ,cqh ,ellip)
-     (isearch-message ,cqh ,ellip)))
-

 (defvar isearch-wrap-function nil
   "Function to call to wrap the search when search is failed.
 If nil, move point to the beginning of the buffer for a forward search,
 (defvar isearch-wrap-function nil
   "Function to call to wrap the search when search is failed.
 If nil, move point to the beginning of the buffer for a forward search,


@@ -229,7 +224,7 @@ Default value, nil, means edit the string instead."
 
 (autoload 'character-fold-to-regexp "character-fold")
 
 
 (autoload 'character-fold-to-regexp "character-fold")
 

-(defcustom search-default-regexp-mode #'character-fold-to-regexp
+(defcustom search-default-mode nil

   "Default mode to use when starting isearch.
 Value is nil, t, or a function.
 
   "Default mode to use when starting isearch.
 Value is nil, t, or a function.
 


@@ -239,9 +234,9 @@ If t, default to regexp searches (as if typing `\\[isearch-toggle-regexp]' durin
 isearch).
 
 If a function, use that function as an `isearch-regexp-function'.
 isearch).
 
 If a function, use that function as an `isearch-regexp-function'.

-Example functions are `word-search-regexp' \(`\\[isearch-toggle-word]'),
-`isearch-symbol-regexp' \(`\\[isearch-toggle-symbol]'), and
-`character-fold-to-regexp' \(`\\[isearch-toggle-character-fold]')."
+Example functions (and the keys to toggle them during isearch)
+are `word-search-regexp' \(`\\[isearch-toggle-word]'), `isearch-symbol-regexp'
+\(`\\[isearch-toggle-symbol]'), and `character-fold-to-regexp' \(`\\[isearch-toggle-character-fold]')."

   ;; :type is set below by `isearch-define-mode-toggle'.
   :type '(choice (const :tag "Literal search" nil)
                  (const :tag "Regexp search" t)
   ;; :type is set below by `isearch-define-mode-toggle'.
   :type '(choice (const :tag "Literal search" nil)
                  (const :tag "Regexp search" t)


@@ -563,7 +558,11 @@ If the value is a function (e.g. `isearch-symbol-regexp'), it is
 called to convert a plain search string to a regexp used by
 regexp search functions.
 The symbol property `isearch-message-prefix' put on this function
 called to convert a plain search string to a regexp used by
 regexp search functions.
 The symbol property `isearch-message-prefix' put on this function

-specifies the prefix string displayed in the search message.")
+specifies the prefix string displayed in the search message.
+
+This variable is set and changed during isearch.  To change the
+default behaviour used for searches, see `search-default-mode'
+instead.")

 ;; We still support setting this to t for backwards compatibility.
 (define-obsolete-variable-alias 'isearch-word
   'isearch-regexp-function "25.1")
 ;; We still support setting this to t for backwards compatibility.
 (define-obsolete-variable-alias 'isearch-word
   'isearch-regexp-function "25.1")


@@ -841,7 +840,6 @@ See the command `isearch-forward-symbol' for more information."
       (isearch-update)))))
 
 \f
       (isearch-update)))))
 
 \f

-(defvar cursor-sensor-inhibit)

 ;; isearch-mode only sets up incremental search for the minor mode.
 ;; All the work is done by the isearch-mode commands.
 
 ;; isearch-mode only sets up incremental search for the minor mode.
 ;; All the work is done by the isearch-mode commands.
 


@@ -873,11 +871,11 @@ used to set the value of `isearch-regexp-function'."
   (setq isearch-forward forward
        isearch-regexp (or regexp
                            (and (not regexp-function)
   (setq isearch-forward forward
        isearch-regexp (or regexp
                            (and (not regexp-function)

-                                (eq search-default-regexp-mode t)))
+                                (eq search-default-mode t)))

        isearch-regexp-function (or regexp-function
        isearch-regexp-function (or regexp-function

-                                    (and (functionp search-default-regexp-mode)
+                                    (and (functionp search-default-mode)

                                          (not regexp)
                                          (not regexp)

-                                         search-default-regexp-mode))
+                                         search-default-mode))

        isearch-op-fun op-fun
        isearch-last-case-fold-search isearch-case-fold-search
        isearch-case-fold-search case-fold-search
        isearch-op-fun op-fun
        isearch-last-case-fold-search isearch-case-fold-search
        isearch-case-fold-search case-fold-search


@@ -966,15 +964,14 @@ used to set the value of `isearch-regexp-function'."
 
 (defun isearch-update ()
   "This is called after every isearch command to update the display.
 
 (defun isearch-update ()
   "This is called after every isearch command to update the display.

-The last thing it does is to run `isearch-update-post-hook'."
+The second last thing it does is to run `isearch-update-post-hook'.
+The last thing is to trigger a new round of lazy highlighting."

   (unless (eq (current-buffer) isearch--current-buffer)
     (when (buffer-live-p isearch--current-buffer)
       (with-current-buffer isearch--current-buffer
         (setq cursor-sensor-inhibit (delq 'isearch cursor-sensor-inhibit))))
     (setq isearch--current-buffer (current-buffer))
     (make-local-variable 'cursor-sensor-inhibit)
   (unless (eq (current-buffer) isearch--current-buffer)
     (when (buffer-live-p isearch--current-buffer)
       (with-current-buffer isearch--current-buffer
         (setq cursor-sensor-inhibit (delq 'isearch cursor-sensor-inhibit))))
     (setq isearch--current-buffer (current-buffer))
     (make-local-variable 'cursor-sensor-inhibit)

-    (unless (boundp 'cursor-sensor-inhibit)
-      (setq cursor-sensor-inhibit nil))

     ;; Suspend things like cursor-intangible during Isearch so we can search
     ;; even within intangible text.
     (push 'isearch cursor-sensor-inhibit))
     ;; Suspend things like cursor-intangible during Isearch so we can search
     ;; even within intangible text.
     (push 'isearch cursor-sensor-inhibit))


@@ -983,10 +980,10 @@ The last thing it does is to run `isearch-update-post-hook'."
           (null executing-kbd-macro))
       (progn
         (if (not (input-pending-p))
           (null executing-kbd-macro))
       (progn
         (if (not (input-pending-p))

-            (isearch-call-message))
+          (funcall (or isearch-message-function #'isearch-message)))

         (if (and isearch-slow-terminal-mode
                  (not (or isearch-small-window
         (if (and isearch-slow-terminal-mode
                  (not (or isearch-small-window

-                          (pos-visible-in-window-p nil nil nil t))))
+                          (pos-visible-in-window-group-p))))

             (let ((found-point (point)))
               (setq isearch-small-window t)
               (move-to-window-line 0)
             (let ((found-point (point)))
               (setq isearch-small-window t)
               (move-to-window-line 0)


@@ -1007,10 +1004,10 @@ The last thing it does is to run `isearch-update-post-hook'."
          (let ((current-scroll (window-hscroll))
                visible-p)
            (set-window-hscroll (selected-window) isearch-start-hscroll)
          (let ((current-scroll (window-hscroll))
                visible-p)
            (set-window-hscroll (selected-window) isearch-start-hscroll)

-           (setq visible-p (pos-visible-in-window-p nil nil t t))
+           (setq visible-p (pos-visible-in-window-group-p nil nil t))

            (if (or (not visible-p)
                    ;; When point is not visible because of hscroll,
            (if (or (not visible-p)
                    ;; When point is not visible because of hscroll,

-                   ;; pos-visible-in-window-p returns non-nil, but
+                   ;; pos-visible-in-window-group-p returns non-nil, but

                    ;; the X coordinate it returns is 1 pixel beyond
                    ;; the last visible one.
                    (>= (car visible-p) (window-body-width nil t)))
                    ;; the X coordinate it returns is 1 pixel beyond
                    ;; the last visible one.
                    (>= (car visible-p) (window-body-width nil t)))


@@ -1023,12 +1020,12 @@ The last thing it does is to run `isearch-update-post-hook'."
   (setq ;; quit-flag nil  not for isearch-mode
    isearch-adjusted nil
    isearch-yank-flag nil)
   (setq ;; quit-flag nil  not for isearch-mode
    isearch-adjusted nil
    isearch-yank-flag nil)

-  (when isearch-lazy-highlight
-    (isearch-lazy-highlight-new-loop))

   ;; We must prevent the point moving to the end of composition when a
   ;; part of the composition has just been searched.
   (setq disable-point-adjustment t)
   ;; We must prevent the point moving to the end of composition when a
   ;; part of the composition has just been searched.
   (setq disable-point-adjustment t)

-  (run-hooks 'isearch-update-post-hook))
+  (run-hooks 'isearch-update-post-hook)
+  (when isearch-lazy-highlight
+    (isearch-lazy-highlight-new-loop)))

 
 (defun isearch-done (&optional nopush edit)
   "Exit Isearch mode.
 
 (defun isearch-done (&optional nopush edit)
   "Exit Isearch mode.


@@ -1061,7 +1058,7 @@ NOPUSH is t and EDIT is t."
   (setq minibuffer-message-timeout isearch-original-minibuffer-message-timeout)
   (isearch-dehighlight)
   (lazy-highlight-cleanup lazy-highlight-cleanup)
   (setq minibuffer-message-timeout isearch-original-minibuffer-message-timeout)
   (isearch-dehighlight)
   (lazy-highlight-cleanup lazy-highlight-cleanup)

-  (let ((found-start (window-start nil t))
+  (let ((found-start (window-group-start))

        (found-point (point)))
     (when isearch-window-configuration
       (set-window-configuration isearch-window-configuration)
        (found-point (point)))
     (when isearch-window-configuration
       (set-window-configuration isearch-window-configuration)


@@ -1071,7 +1068,7 @@ NOPUSH is t and EDIT is t."
        ;; This has an annoying side effect of clearing the last_modiff
        ;; field of the window, which can cause unwanted scrolling,
        ;; so don't do it unless truly necessary.
        ;; This has an annoying side effect of clearing the last_modiff
        ;; field of the window, which can cause unwanted scrolling,
        ;; so don't do it unless truly necessary.

-       (set-window-start (selected-window) found-start t t))))
+       (set-window-group-start (selected-window) found-start t))))

 
   (setq isearch-mode nil)
   (if isearch-input-method-local-p
 
   (setq isearch-mode nil)
   (if isearch-input-method-local-p


@@ -1317,7 +1314,7 @@ You can update the global isearch variables by setting new values to
                  isearch-case-fold-search isearch-new-case-fold)
 
            ;; Restore the minibuffer message before moving point.
                  isearch-case-fold-search isearch-new-case-fold)
 
            ;; Restore the minibuffer message before moving point.

-           (isearch-call-message nil t)
+            (funcall (or isearch-message-function #'isearch-message) nil t)

 
            ;; Set point at the start (end) of old match if forward (backward),
            ;; so after exiting minibuffer isearch resumes at the start (end)
 
            ;; Set point at the start (end) of old match if forward (backward),
            ;; so after exiting minibuffer isearch resumes at the start (end)


@@ -1510,7 +1507,7 @@ Use `isearch-exit' to quit without signaling."
   (isearch-repeat 'backward))
 
 \f
   (isearch-repeat 'backward))
 
 \f

-;;; Toggles for `isearch-regexp-function' and `search-default-regexp-mode'.
+;;; Toggles for `isearch-regexp-function' and `search-default-mode'.

 (defmacro isearch-define-mode-toggle (mode key function &optional docstring &rest body)
   "Define a command called `isearch-toggle-MODE' and bind it to `M-s KEY'.
 The first line of the command's docstring is auto-generated, the
 (defmacro isearch-define-mode-toggle (mode key function &optional docstring &rest body)
   "Define a command called `isearch-toggle-MODE' and bind it to `M-s KEY'.
 The first line of the command's docstring is auto-generated, the


@@ -1531,18 +1528,18 @@ The command then executes BODY and updates the isearch prompt."
              `((setq isearch-regexp-function
                      (unless (eq isearch-regexp-function #',function)
                        #',function))
              `((setq isearch-regexp-function
                      (unless (eq isearch-regexp-function #',function)
                        #',function))

-               (when isearch-regexp-function (setq isearch-regexp nil))))
+               (setq isearch-regexp nil)))

          ,@body
          (setq isearch-success t isearch-adjusted t)
          (isearch-update))
        (define-key isearch-mode-map ,key #',command-name)
          ,@body
          (setq isearch-success t isearch-adjusted t)
          (isearch-update))
        (define-key isearch-mode-map ,key #',command-name)

-       ,@(when (symbolp function)
+       ,@(when (and function (symbolp function))

            `((put ',function 'isearch-message-prefix ,(format "%s " mode))
              (put ',function :advertised-binding ,key)
              (cl-callf (lambda (types) (cons 'choice
                                         (cons '(const :tag ,(capitalize (format "%s search" mode)) ,function)
                                               (cdr types))))
            `((put ',function 'isearch-message-prefix ,(format "%s " mode))
              (put ',function :advertised-binding ,key)
              (cl-callf (lambda (types) (cons 'choice
                                         (cons '(const :tag ,(capitalize (format "%s search" mode)) ,function)
                                               (cdr types))))

-                 (get 'search-default-regexp-mode 'custom-type)))))))
+                 (get 'search-default-mode 'custom-type)))))))

 
 (isearch-define-mode-toggle word "w" word-search-regexp "\
 Turning on word search turns off regexp mode.")
 
 (isearch-define-mode-toggle word "w" word-search-regexp "\
 Turning on word search turns off regexp mode.")


@@ -1937,7 +1934,8 @@ If search string is empty, just beep."
                                            (length isearch-string))))
           isearch-message (mapconcat 'isearch-text-char-description
                                      isearch-string "")))
                                            (length isearch-string))))
           isearch-message (mapconcat 'isearch-text-char-description
                                      isearch-string "")))

-  (isearch-call-message nil t)                 ; Do this before moving point.
+  ;; Do the following before moving point.
+  (funcall (or isearch-message-function #'isearch-message) nil t)

   ;; Use the isearch-other-end as new starting point to be able
   ;; to find the remaining part of the search string again.
   ;; This is like what `isearch-search-and-update' does,
   ;; Use the isearch-other-end as new starting point to be able
   ;; to find the remaining part of the search string again.
   ;; This is like what `isearch-search-and-update' does,


@@ -2114,7 +2112,8 @@ With argument, add COUNT copies of the character."
              (setq isearch-case-fold-search
                    (isearch-no-upper-case-p isearch-string isearch-regexp))))
       ;; Not regexp, not reverse, or no match at point.
              (setq isearch-case-fold-search
                    (isearch-no-upper-case-p isearch-string isearch-regexp))))
       ;; Not regexp, not reverse, or no match at point.

-      (isearch-call-message nil t)     ; Do this before moving point.
+      ;; Do the following before moving point.
+      (funcall (or isearch-message-function #'isearch-message) nil t)

       (if (and isearch-other-end (not isearch-adjusted))
          (goto-char (if isearch-forward isearch-other-end
                       (min isearch-opoint
       (if (and isearch-other-end (not isearch-adjusted))
          (goto-char (if isearch-forward isearch-other-end
                       (min isearch-opoint


@@ -2281,12 +2280,12 @@ Return nil if it's completely visible, or if point is visible,
 together with as much of the search string as will fit; the symbol
 `above' if we need to scroll the text downwards; the symbol `below',
 if upwards."
 together with as much of the search string as will fit; the symbol
 `above' if we need to scroll the text downwards; the symbol `below',
 if upwards."

-  (let ((w-start (window-start nil t))
-        (w-end (window-end nil t t))
+  (let ((w-start (window-group-start))
+        (w-end (window-group-end nil t))

         (w-L1 (save-excursion
         (w-L1 (save-excursion

-                (save-selected-window (move-to-window-line 1 t) (point))))
+                (save-selected-window (move-to-window-group-line 1) (point))))

         (w-L-1 (save-excursion
         (w-L-1 (save-excursion

-                 (save-selected-window (move-to-window-line -1 t) (point))))
+                 (save-selected-window (move-to-window-group-line -1) (point))))

         start end)                  ; start and end of search string in buffer
     (if isearch-forward
         (setq end isearch-point  start (or isearch-other-end isearch-point))
         start end)                  ; start and end of search string in buffer
     (if isearch-forward
         (setq end isearch-point  start (or isearch-other-end isearch-point))


@@ -2313,15 +2312,15 @@ the bottom."
     (if above
         (progn
           (goto-char start)
     (if above
         (progn
           (goto-char start)

-          (recenter 0 t)
-          (when (>= isearch-point (window-end nil t t))
+          (recenter-window-group 0)
+          (when (>= isearch-point (window-group-end nil t))

             (goto-char isearch-point)
             (goto-char isearch-point)

-            (recenter -1 t)))
+            (recenter-window-group -1)))

       (goto-char end)
       (goto-char end)

-      (recenter -1 t)
-      (when (< isearch-point (window-start nil t))
+      (recenter-window-group -1)
+      (when (< isearch-point (window-group-start))

         (goto-char isearch-point)
         (goto-char isearch-point)

-        (recenter 0 t))))
+        (recenter-window-group 0))))

   (goto-char isearch-point))
 
 (defvar isearch-pre-scroll-point nil)
   (goto-char isearch-point))
 
 (defvar isearch-pre-scroll-point nil)


@@ -2468,7 +2467,7 @@ Search is updated accordingly."
   (isearch-ring-adjust1 advance)
   (if search-ring-update
       (progn
   (isearch-ring-adjust1 advance)
   (if search-ring-update
       (progn

-       (isearch-call-message nil t)
+        (funcall (or isearch-message-function #'isearch-message) nil t)

        (isearch-search)
        (isearch-push-state)
        (isearch-update))
        (isearch-search)
        (isearch-push-state)
        (isearch-update))


@@ -2572,16 +2571,30 @@ the word mode."
   (when (eq regexp-function t)
     (setq regexp-function #'word-search-regexp))
   (let ((description
   (when (eq regexp-function t)
     (setq regexp-function #'word-search-regexp))
   (let ((description

-         ;; Don't use a description on the default search mode.
-         (cond ((equal regexp-function search-default-regexp-mode) "")
-               (regexp-function
-                (and (symbolp regexp-function)
-                     (or (get regexp-function 'isearch-message-prefix)
-                         "")))
-               (isearch-regexp "regexp ")
-               ;; We're in literal mode. If the default mode is not
-               ;; literal, then describe it.
-               ((functionp search-default-regexp-mode) "literal "))))
+         (cond
+          ;; 1. Do not use a description on the default search mode,
+          ;;    but only if the default search mode is non-nil.
+          ((or (and search-default-mode
+                    (equal search-default-mode regexp-function))
+               ;; Special case where `search-default-mode' is t
+               ;; (defaults to regexp searches).
+               (and (eq search-default-mode t)
+                    (eq search-default-mode isearch-regexp))) "")
+          ;; 2. Use the `isearch-message-prefix' set for
+          ;;    `regexp-function' if available.
+          (regexp-function
+           (and (symbolp regexp-function)
+                (or (get regexp-function 'isearch-message-prefix)
+                    "")))
+          ;; 3. Else if `isearch-regexp' is non-nil, set description
+          ;;    to "regexp ".
+          (isearch-regexp "regexp ")
+          ;; 4. Else if we're in literal mode (and if the default
+          ;;    mode is also not literal), describe it.
+          ((functionp search-default-mode) "literal ")
+          ;; 5. And finally, if none of the above is true, set the
+          ;;    description to an empty string.
+          (t ""))))

     (if space-before
         ;; Move space from the end to the beginning.
         (replace-regexp-in-string "\\(.*\\) \\'" " \\1" description)
     (if space-before
         ;; Move space from the end to the beginning.
         (replace-regexp-in-string "\\(.*\\) \\'" " \\1" description)


@@ -2649,10 +2662,12 @@ the word mode."
   "Non-default value overrides the behavior of `isearch-search-fun-default'.
 This variable's value should be a function, which will be called
 with no arguments, and should return a function that takes three
   "Non-default value overrides the behavior of `isearch-search-fun-default'.
 This variable's value should be a function, which will be called
 with no arguments, and should return a function that takes three

-arguments: STRING, BOUND, and NOERROR.
+arguments: STRING, BOUND, and NOERROR.  STRING is the string to
+be searched for.  See `re-search-forward' for the meaning of
+BOUND and NOERROR arguments.

 
 This returned function will be used by `isearch-search-string' to
 
 This returned function will be used by `isearch-search-string' to

-search for the first occurrence of STRING or its translation.")
+search for the first occurrence of STRING.")

 
 (defun isearch-search-fun ()
   "Return the function to use for the search.
 
 (defun isearch-search-fun ()
   "Return the function to use for the search.


@@ -2697,8 +2712,14 @@ Can be changed via `isearch-search-fun-function' for special needs."
 
 (defun isearch-search-string (string bound noerror)
   "Search for the first occurrence of STRING or its translation.
 
 (defun isearch-search-string (string bound noerror)
   "Search for the first occurrence of STRING or its translation.

+STRING's characters are translated using `translation-table-for-input'
+if that is non-nil.

 If found, move point to the end of the occurrence,
 If found, move point to the end of the occurrence,

-update the match data, and return point."
+update the match data, and return point.
+An optional second argument bounds the search; it is a buffer position.
+The match found must not extend after that position.
+Optional third argument, if t, means if fail just return nil (no error).
+  If not nil and not t, move to limit of search and return nil."

   (let* ((func (isearch-search-fun))
          (pos1 (save-excursion (funcall func string bound noerror)))
          pos2)
   (let* ((func (isearch-search-fun))
          (pos1 (save-excursion (funcall func string bound noerror)))
          pos2)


@@ -3071,21 +3092,7 @@ is nil.  This function is called when exiting an incremental search if
                                 "22.1")
 
 (defun isearch-lazy-highlight-new-loop (&optional beg end)
                                 "22.1")
 
 (defun isearch-lazy-highlight-new-loop (&optional beg end)

-  "Set an idle timer, which will trigger a new `lazy-highlight' loop.
-BEG and END specify the bounds within which highlighting should
-occur.  This is called when `isearch-update' is invoked (which
-can cause the search string to change or the window(s) to
-scroll).  It is also used by other Emacs features.  Do not start
-the loop when we are executing a keyboard macro."
-  (setq isearch-lazy-highlight-start-limit beg
-        isearch-lazy-highlight-end-limit end)
-  (when (null executing-kbd-macro)
-    (setq isearch-lazy-highlight-timer
-          (run-with-idle-timer lazy-highlight-initial-delay nil
-                               'isearch-lazy-highlight-maybe-new-loop))))
-
-(defun isearch-lazy-highlight-maybe-new-loop ()
-  "If needed cleanup any previous `lazy-highlight' loop and begin a new one.
+  "Cleanup any previous `lazy-highlight' loop and begin a new one.

 BEG and END specify the bounds within which highlighting should occur.
 This is called when `isearch-update' is invoked (which can cause the
 search string to change or the window to scroll).  It is also used
 BEG and END specify the bounds within which highlighting should occur.
 This is called when `isearch-update' is invoked (which can cause the
 search string to change or the window to scroll).  It is also used


@@ -3106,9 +3113,9 @@ by other Emacs features."
                          isearch-lax-whitespace))
                 (not (eq isearch-lazy-highlight-regexp-lax-whitespace
                          isearch-regexp-lax-whitespace))
                          isearch-lax-whitespace))
                 (not (eq isearch-lazy-highlight-regexp-lax-whitespace
                          isearch-regexp-lax-whitespace))

-                 (not (= (window-start nil t)
+                 (not (= (window-group-start)

                          isearch-lazy-highlight-window-start))
                          isearch-lazy-highlight-window-start))

-                 (not (= (window-end nil nil t) ; Window may have been split/joined.
+                 (not (= (window-group-end) ; Window may have been split/joined.

                         isearch-lazy-highlight-window-end))
                 (not (eq isearch-forward
                          isearch-lazy-highlight-forward))
                         isearch-lazy-highlight-window-end))
                 (not (eq isearch-forward
                          isearch-lazy-highlight-forward))


@@ -3121,10 +3128,12 @@ by other Emacs features."
     ;; It used to check for `(not isearch-error)' here, but actually
     ;; lazy-highlighting might find matches to highlight even when
     ;; `isearch-error' is non-nil.  (Bug#9918)
     ;; It used to check for `(not isearch-error)' here, but actually
     ;; lazy-highlighting might find matches to highlight even when
     ;; `isearch-error' is non-nil.  (Bug#9918)

+    (setq isearch-lazy-highlight-start-limit beg
+         isearch-lazy-highlight-end-limit end)

     (setq isearch-lazy-highlight-window       (selected-window)
           isearch-lazy-highlight-window-group (selected-window-group)
     (setq isearch-lazy-highlight-window       (selected-window)
           isearch-lazy-highlight-window-group (selected-window-group)

-         isearch-lazy-highlight-window-start (window-start nil t)
-         isearch-lazy-highlight-window-end   (window-end nil nil t)
+         isearch-lazy-highlight-window-start (window-group-start)
+         isearch-lazy-highlight-window-end   (window-group-end)

          ;; Start lazy-highlighting at the beginning of the found
          ;; match (`isearch-other-end').  If no match, use point.
          ;; One of the next two variables (depending on search direction)
          ;; Start lazy-highlighting at the beginning of the found
          ;; match (`isearch-other-end').  If no match, use point.
          ;; One of the next two variables (depending on search direction)


@@ -3143,7 +3152,9 @@ by other Emacs features."
          isearch-lazy-highlight-regexp-function  isearch-regexp-function
          isearch-lazy-highlight-forward      isearch-forward)
     (unless (equal isearch-string "")
          isearch-lazy-highlight-regexp-function  isearch-regexp-function
          isearch-lazy-highlight-forward      isearch-forward)
     (unless (equal isearch-string "")

-      (isearch-lazy-highlight-update))))
+      (setq isearch-lazy-highlight-timer
+            (run-with-idle-timer lazy-highlight-initial-delay nil
+                                 'isearch-lazy-highlight-update)))))

 
 (defun isearch-lazy-highlight-search ()
   "Search ahead for the next or previous match, for lazy highlighting.
 
 (defun isearch-lazy-highlight-search ()
   "Search ahead for the next or previous match, for lazy highlighting.


@@ -3166,13 +3177,13 @@ Attempt to do the search exactly the way the pending Isearch would."
                                (+ isearch-lazy-highlight-start
                                   ;; Extend bound to match whole string at point
                                   (1- (length isearch-lazy-highlight-last-string)))
                                (+ isearch-lazy-highlight-start
                                   ;; Extend bound to match whole string at point
                                   (1- (length isearch-lazy-highlight-last-string)))

-                             (window-end nil nil t)))
+                             (window-group-end)))

                     (max (or isearch-lazy-highlight-start-limit (point-min))
                          (if isearch-lazy-highlight-wrapped
                              (- isearch-lazy-highlight-end
                                 ;; Extend bound to match whole string at point
                                 (1- (length isearch-lazy-highlight-last-string)))
                     (max (or isearch-lazy-highlight-start-limit (point-min))
                          (if isearch-lazy-highlight-wrapped
                              (- isearch-lazy-highlight-end
                                 ;; Extend bound to match whole string at point
                                 (1- (length isearch-lazy-highlight-last-string)))

-                           (window-start nil t))))))
+                           (window-group-start))))))

        ;; Use a loop like in `isearch-search'.
        (while retry
          (setq success (isearch-search-string
        ;; Use a loop like in `isearch-search'.
        (while retry
          (setq success (isearch-search-string


@@ -3216,12 +3227,12 @@ Attempt to do the search exactly the way the pending Isearch would."
                          (if isearch-lazy-highlight-forward
                              (if (= mb (if isearch-lazy-highlight-wrapped
                                            isearch-lazy-highlight-start
                          (if isearch-lazy-highlight-forward
                              (if (= mb (if isearch-lazy-highlight-wrapped
                                            isearch-lazy-highlight-start

-                                         (window-end nil nil t)))
+                                         (window-group-end)))

                                  (setq found nil)
                                (forward-char 1))
                            (if (= mb (if isearch-lazy-highlight-wrapped
                                          isearch-lazy-highlight-end
                                  (setq found nil)
                                (forward-char 1))
                            (if (= mb (if isearch-lazy-highlight-wrapped
                                          isearch-lazy-highlight-end

-                                       (window-start nil t)))
+                                       (window-group-start)))

                                (setq found nil)
                              (forward-char -1)))
 
                                (setq found nil)
                              (forward-char -1)))
 


@@ -3248,12 +3259,12 @@ Attempt to do the search exactly the way the pending Isearch would."
                      (setq isearch-lazy-highlight-wrapped t)
                      (if isearch-lazy-highlight-forward
                          (progn
                      (setq isearch-lazy-highlight-wrapped t)
                      (if isearch-lazy-highlight-forward
                          (progn

-                           (setq isearch-lazy-highlight-end (window-start nil t))
+                           (setq isearch-lazy-highlight-end (window-group-start))

                            (goto-char (max (or isearch-lazy-highlight-start-limit (point-min))
                            (goto-char (max (or isearch-lazy-highlight-start-limit (point-min))

-                                           (window-start nil t))))
-                       (setq isearch-lazy-highlight-start (window-end nil nil t))
+                                           (window-group-start))))
+                       (setq isearch-lazy-highlight-start (window-group-end))

                        (goto-char (min (or isearch-lazy-highlight-end-limit (point-max))
                        (goto-char (min (or isearch-lazy-highlight-end-limit (point-max))

-                                       (window-end nil nil t))))))))
+                                       (window-group-end))))))))

            (unless nomore
              (setq isearch-lazy-highlight-timer
                    (run-at-time lazy-highlight-interval nil
            (unless nomore
              (setq isearch-lazy-highlight-timer
                    (run-at-time lazy-highlight-interval nil