isearch-edit-string resumes multi isearches

[gnu-emacs] / lisp / isearch.el

diff --git a/lisp/isearch.el b/lisp/isearch.el
index 12ded02345fae2949a041987391c55829fe4cbbc..eabf05b0b17e5fc51b6b43261d2e79dca3f18a2d 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


@@ -222,9 +222,9 @@ It is nil if none yet.")
 Default value, nil, means edit the string instead."
   :type 'boolean)
 
 Default value, nil, means edit the string instead."
   :type 'boolean)
 

-(autoload 'character-fold-to-regexp "character-fold")
+(autoload 'char-fold-to-regexp "char-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.
 


@@ -234,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 `char-fold-to-regexp' \(`\\[isearch-toggle-char-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)


@@ -510,6 +510,7 @@ This is like `describe-bindings', but displays only Isearch keys."
     ;; People expect to be able to paste with the mouse.
     (define-key map [mouse-2] #'isearch-mouse-2)
     (define-key map [down-mouse-2] nil)
     ;; People expect to be able to paste with the mouse.
     (define-key map [mouse-2] #'isearch-mouse-2)
     (define-key map [down-mouse-2] nil)

+    (define-key map [xterm-paste] #'isearch-xterm-paste)

 
     ;; Some bindings you may want to put in your isearch-mode-hook.
     ;; Suggest some alternates...
 
     ;; Some bindings you may want to put in your isearch-mode-hook.
     ;; Suggest some alternates...


@@ -558,7 +559,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")


@@ -714,7 +719,7 @@ Type \\[isearch-toggle-invisible] to toggle search in invisible text.
 Type \\[isearch-toggle-regexp] to toggle regular-expression mode.
 Type \\[isearch-toggle-word] to toggle word mode.
 Type \\[isearch-toggle-symbol] to toggle symbol mode.
 Type \\[isearch-toggle-regexp] to toggle regular-expression mode.
 Type \\[isearch-toggle-word] to toggle word mode.
 Type \\[isearch-toggle-symbol] to toggle symbol mode.

-Type \\[isearch-toggle-character-fold] to toggle character folding.
+Type \\[isearch-toggle-char-fold] to toggle character folding.

 
 Type \\[isearch-toggle-lax-whitespace] to toggle whitespace matching.
 In incremental searches, a space or spaces normally matches any whitespace
 
 Type \\[isearch-toggle-lax-whitespace] to toggle whitespace matching.
 In incremental searches, a space or spaces normally matches any whitespace


@@ -833,10 +838,10 @@ See the command `isearch-forward-symbol' for more information."
        (buffer-substring-no-properties (car bounds) (cdr bounds))))
      (t
       (setq isearch-error "No symbol at point")
        (buffer-substring-no-properties (car bounds) (cdr bounds))))
      (t
       (setq isearch-error "No symbol at point")

+      (isearch-push-state)

       (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.
 


@@ -868,11 +873,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


@@ -961,15 +966,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))


@@ -981,7 +985,7 @@ The last thing it does is to run `isearch-update-post-hook'."
           (funcall (or isearch-message-function #'isearch-message)))
         (if (and isearch-slow-terminal-mode
                  (not (or isearch-small-window
           (funcall (or isearch-message-function #'isearch-message)))
         (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)


@@ -1002,10 +1006,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)))


@@ -1018,12 +1022,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.


@@ -1056,7 +1060,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)


@@ -1066,7 +1070,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


@@ -1255,6 +1259,11 @@ You can update the global isearch variables by setting new values to
              (isearch-adjusted isearch-adjusted)
              (isearch-yank-flag isearch-yank-flag)
              (isearch-error isearch-error)
              (isearch-adjusted isearch-adjusted)
              (isearch-yank-flag isearch-yank-flag)
              (isearch-error isearch-error)

+
+             (multi-isearch-file-list-new multi-isearch-file-list)
+             (multi-isearch-buffer-list-new multi-isearch-buffer-list)
+             (multi-isearch-next-buffer-function multi-isearch-next-buffer-current-function)
+             (multi-isearch-current-buffer-new multi-isearch-current-buffer)

   ;;; Don't bind this.  We want isearch-search, below, to set it.
   ;;; And the old value won't matter after that.
   ;;;      (isearch-other-end isearch-other-end)
   ;;; Don't bind this.  We want isearch-search, below, to set it.
   ;;; And the old value won't matter after that.
   ;;;      (isearch-other-end isearch-other-end)


@@ -1309,7 +1318,10 @@ You can update the global isearch variables by setting new values to
                  isearch-message isearch-new-message
                  isearch-forward isearch-new-forward
                  isearch-regexp-function isearch-new-regexp-function
                  isearch-message isearch-new-message
                  isearch-forward isearch-new-forward
                  isearch-regexp-function isearch-new-regexp-function

-                 isearch-case-fold-search isearch-new-case-fold)
+                 isearch-case-fold-search isearch-new-case-fold
+                 multi-isearch-current-buffer multi-isearch-current-buffer-new
+                 multi-isearch-file-list multi-isearch-file-list-new
+                 multi-isearch-buffer-list multi-isearch-buffer-list-new)

 
            ;; Restore the minibuffer message before moving point.
             (funcall (or isearch-message-function #'isearch-message) nil t)
 
            ;; Restore the minibuffer message before moving point.
             (funcall (or isearch-message-function #'isearch-message) nil t)


@@ -1505,7 +1517,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


@@ -1526,26 +1538,26 @@ 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 symbol "_" isearch-symbol-regexp "\
 Turning on symbol search turns off regexp mode.")
 
 (isearch-define-mode-toggle word "w" word-search-regexp "\
 Turning on word search turns off regexp mode.")
 (isearch-define-mode-toggle symbol "_" isearch-symbol-regexp "\
 Turning on symbol search turns off regexp mode.")

-(isearch-define-mode-toggle character-fold "'" character-fold-to-regexp "\
+(isearch-define-mode-toggle char-fold "'" char-fold-to-regexp "\

 Turning on character-folding turns off regexp mode.")
 Turning on character-folding turns off regexp mode.")

-(put 'character-fold-to-regexp 'isearch-message-prefix "char-fold ")
+(put 'char-fold-to-regexp 'isearch-message-prefix "char-fold ")

 
 (isearch-define-mode-toggle regexp "r" nil nil
   (setq isearch-regexp (not isearch-regexp))
 
 (isearch-define-mode-toggle regexp "r" nil nil
   (setq isearch-regexp (not isearch-regexp))


@@ -1998,6 +2010,13 @@ is bound to outside of Isearch."
       (when (functionp binding)
        (call-interactively binding)))))
 
       (when (functionp binding)
        (call-interactively binding)))))
 

+(declare-function xterm--pasted-text "term/xterm" ())
+
+(defun isearch-xterm-paste ()
+  "Pull terminal paste into search string."
+  (interactive)
+  (isearch-yank-string (xterm--pasted-text)))
+

 (defun isearch-yank-internal (jumpform)
   "Pull the text from point to the point reached by JUMPFORM.
 JUMPFORM is a lambda expression that takes no arguments and returns
 (defun isearch-yank-internal (jumpform)
   "Pull the text from point to the point reached by JUMPFORM.
 JUMPFORM is a lambda expression that takes no arguments and returns


@@ -2278,12 +2297,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))


@@ -2310,15 +2329,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)


@@ -2569,16 +2588,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)


@@ -2646,10 +2679,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.


@@ -2694,8 +2729,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)


@@ -3068,21 +3109,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


@@ -3103,9 +3130,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))


@@ -3118,10 +3145,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)


@@ -3140,7 +3169,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.


@@ -3163,13 +3194,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


@@ -3213,12 +3244,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)))
 


@@ -3245,12 +3276,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