Simplify ‘delete-trailing-whitespace’ by not treating \n as whitespace

[gnu-emacs] / lisp / isearch.el

diff --git a/lisp/isearch.el b/lisp/isearch.el
index 92d7894d2e73e9a6a30391496299b6e3eacae62f..721f2fc31817eae610208df993a6b63607584630 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


@@ -96,8 +96,12 @@ in Isearch mode is always downcased."
 
 (defcustom search-nonincremental-instead t
   "If non-nil, do a nonincremental search instead of exiting immediately.
 
 (defcustom search-nonincremental-instead t
   "If non-nil, do a nonincremental search instead of exiting immediately.

-Actually, `isearch-edit-string' is called to let you enter the search
-string, and RET terminates editing and does a nonincremental search."
+This affects the behavior of `isearch-exit' and any key bound to that
+command: if this variable is nil, `isearch-exit' always exits the search;
+if the value is non-nil, and the search string is empty, `isearch-exit'
+starts a nonincremental search instead.  (Actually, `isearch-edit-string'
+is called to let you enter the search string, and RET terminates editing
+and does a nonincremental search.)"

   :type 'boolean)
 
 (defcustom search-whitespace-regexp (purecopy "\\s-+")
   :type 'boolean)
 
 (defcustom search-whitespace-regexp (purecopy "\\s-+")


@@ -142,9 +146,11 @@ whenever point is in one of them."
 (defcustom isearch-hide-immediately t
   "If non-nil, re-hide an invisible match right away.
 This variable makes a difference when `search-invisible' is set to `open'.
 (defcustom isearch-hide-immediately t
   "If non-nil, re-hide an invisible match right away.
 This variable makes a difference when `search-invisible' is set to `open'.

+If non-nil, invisible matches are re-hidden as soon as the match moves
+off the invisible text surrounding the match.

 If nil then do not re-hide opened invisible text when the match moves.
 Whatever the value, all opened invisible text is hidden again after exiting
 If nil then do not re-hide opened invisible text when the match moves.
 Whatever the value, all opened invisible text is hidden again after exiting

-the search."
+the search, with the exception of the last successful match, if any."

   :type 'boolean)
 
 (defcustom isearch-resume-in-command-history nil
   :type 'boolean)
 
 (defcustom isearch-resume-in-command-history nil


@@ -171,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,


@@ -221,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.
 


@@ -233,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)


@@ -353,11 +354,7 @@ A value of nil means highlight all matches."
   "Face for lazy highlighting of matches other than the current one."
   :group 'lazy-highlight
   :group 'basic-faces)
   "Face for lazy highlighting of matches other than the current one."
   :group 'lazy-highlight
   :group 'basic-faces)

-(define-obsolete-face-alias 'isearch-lazy-highlight-face 'lazy-highlight "22.1")
-(define-obsolete-variable-alias 'isearch-lazy-highlight-face
-                                'lazy-highlight-face
-                                "22.1")
-(defvar lazy-highlight-face 'lazy-highlight)
+

 \f
 ;; Define isearch help map.
 
 \f
 ;; Define isearch help map.
 


@@ -509,6 +506,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...


@@ -516,8 +514,6 @@ This is like `describe-bindings', but displays only Isearch keys."
     (define-key map "\M-r" 'isearch-toggle-regexp)
     (define-key map "\M-e" 'isearch-edit-string)
 
     (define-key map "\M-r" 'isearch-toggle-regexp)
     (define-key map "\M-e" 'isearch-edit-string)
 

-    (put 'isearch-toggle-case-fold :advertised-binding "\M-sc")
-    (put 'isearch-toggle-regexp    :advertised-binding "\M-sr")

     (put 'isearch-edit-string      :advertised-binding "\M-se")
 
     (define-key map "\M-se" 'isearch-edit-string)
     (put 'isearch-edit-string      :advertised-binding "\M-se")
 
     (define-key map "\M-se" 'isearch-edit-string)


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


@@ -715,7 +715,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


@@ -775,7 +775,8 @@ as a regexp.  See the command `isearch-forward' for more information.
 In incremental searches, a space or spaces normally matches any
 whitespace defined by the variable `search-whitespace-regexp'.
 To search for a literal space and nothing else, enter C-q SPC.
 In incremental searches, a space or spaces normally matches any
 whitespace defined by the variable `search-whitespace-regexp'.
 To search for a literal space and nothing else, enter C-q SPC.

-To toggle whitespace matching, use `isearch-toggle-lax-whitespace'."
+To toggle whitespace matching, use `isearch-toggle-lax-whitespace'.
+This command does not support character folding."

   (interactive "P\np")
   (isearch-mode t (null not-regexp) nil (not no-recursive-edit)))
 
   (interactive "P\np")
   (isearch-mode t (null not-regexp) nil (not no-recursive-edit)))
 


@@ -784,7 +785,9 @@ To toggle whitespace matching, use `isearch-toggle-lax-whitespace'."
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated
 as a sequence of words without regard to how the words are separated.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated
 as a sequence of words without regard to how the words are separated.

-See the command `isearch-forward' for more information."
+See the command `isearch-forward' for more information.
+This command does not support character folding, and lax space matching
+has no effect on it."

   (interactive "P\np")
   (isearch-mode t nil nil (not no-recursive-edit) (null not-word)))
 
   (interactive "P\np")
   (isearch-mode t nil nil (not no-recursive-edit) (null not-word)))
 


@@ -793,7 +796,9 @@ See the command `isearch-forward' for more information."
 The prefix argument is currently unused.
 Like ordinary incremental search except that your input is treated
 as a symbol surrounded by symbol boundary constructs \\_< and \\_>.
 The prefix argument is currently unused.
 Like ordinary incremental search except that your input is treated
 as a symbol surrounded by symbol boundary constructs \\_< and \\_>.

-See the command `isearch-forward' for more information."
+See the command `isearch-forward' for more information.
+This command does not support character folding, and lax space matching
+has no effect on it."

   (interactive "P\np")
   (isearch-mode t nil nil (not no-recursive-edit) 'isearch-symbol-regexp))
 
   (interactive "P\np")
   (isearch-mode t nil nil (not no-recursive-edit) 'isearch-symbol-regexp))
 


@@ -808,7 +813,7 @@ See the command `isearch-forward' for more information."
   "Do incremental search backward for regular expression.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated
   "Do incremental search backward for regular expression.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input is treated

-as a regexp.  See the command `isearch-forward' for more information."
+as a regexp.  See the command `isearch-forward-regexp' for more information."

   (interactive "P\np")
   (isearch-mode nil (null not-regexp) nil (not no-recursive-edit)))
 
   (interactive "P\np")
   (isearch-mode nil (null not-regexp) nil (not no-recursive-edit)))
 


@@ -829,10 +834,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.
 


@@ -864,11 +869,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


@@ -957,15 +962,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))


@@ -974,10 +978,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)


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


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


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


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


@@ -1210,6 +1214,14 @@ If MSG is non-nil, use variable `isearch-message', otherwise `isearch-string'."
          (length succ-msg)
        0))))
 
          (length succ-msg)
        0))))
 

+(defvar isearch-new-regexp-function nil
+  "Holds the next `isearch-regexp-function' inside `with-isearch-suspended'.
+If this is set inside code wrapped by the macro
+`with-isearch-suspended', then the value set will be used as the
+`isearch-regexp-function' once isearch resumes.")
+(define-obsolete-variable-alias 'isearch-new-word
+  'isearch-new-regexp-function "25.1")
+

 (defmacro with-isearch-suspended (&rest body)
   "Exit Isearch mode, run BODY, and reinvoke the pending search.
 You can update the global isearch variables by setting new values to
 (defmacro with-isearch-suspended (&rest body)
   "Exit Isearch mode, run BODY, and reinvoke the pending search.
 You can update the global isearch variables by setting new values to


@@ -1243,6 +1255,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)


@@ -1297,10 +1314,13 @@ 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.
 
            ;; 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)


@@ -1493,17 +1513,18 @@ 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'.
 (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 docstring is auto-generated, the remainder
-may be provided in DOCSTRING.
+The first line of the command's docstring is auto-generated, the
+remainder may be provided in DOCSTRING.

 If FUNCTION is a symbol, this command first toggles the value of
 `isearch-regexp-function' between nil and FUNCTION.  Also set the
 `isearch-message-prefix' property of FUNCTION.
 The command then executes BODY and updates the isearch prompt."
   (declare (indent defun))
 If FUNCTION is a symbol, this command first toggles the value of
 `isearch-regexp-function' between nil and FUNCTION.  Also set the
 `isearch-message-prefix' property of FUNCTION.
 The command then executes BODY and updates the isearch prompt."
   (declare (indent defun))

-  (let ((command-name (intern (format "isearch-toggle-%s" mode))))
+  (let ((command-name (intern (format "isearch-toggle-%s" mode)))
+        (key (concat "\M-s" key)))

     `(progn
        (defun ,command-name ()
          ,(format "Toggle %s searching on or off.%s" mode
     `(progn
        (defun ,command-name ()
          ,(format "Toggle %s searching on or off.%s" mode


@@ -1513,22 +1534,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))
          ,@body
          (setq isearch-success t isearch-adjusted t)
          (isearch-update))

-       (define-key isearch-mode-map ,(concat "\M-s" key) #',command-name)
-       ,@(when (symbolp function)
+       (define-key isearch-mode-map ,key #',command-name)
+       ,@(when (and function (symbolp function))

            `((put ',function 'isearch-message-prefix ,(format "%s " mode))
            `((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))))
              (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)
-(isearch-define-mode-toggle symbol "_" isearch-symbol-regexp)
-(isearch-define-mode-toggle character-fold "'" character-fold-to-regexp)
-(put 'character-fold-to-regexp 'isearch-message-prefix "char-fold ")
+(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 char-fold "'" char-fold-to-regexp "\
+Turning on character-folding turns off regexp mode.")
+(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))


@@ -1610,7 +1635,9 @@ Optional fourth argument is repeat count--search for successive occurrences.
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard

-to punctuation."
+to punctuation.
+This command does not support character folding, and lax space matching
+has no effect on it."

   (interactive "sWord search backward: ")
   (re-search-backward (word-search-regexp string nil) bound noerror count))
 
   (interactive "sWord search backward: ")
   (re-search-backward (word-search-regexp string nil) bound noerror count))
 


@@ -1625,7 +1652,9 @@ Optional fourth argument is repeat count--search for successive occurrences.
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard

-to punctuation."
+to punctuation.
+This command does not support character folding, and lax space matching
+has no effect on it."

   (interactive "sWord search: ")
   (re-search-forward (word-search-regexp string nil) bound noerror count))
 
   (interactive "sWord search: ")
   (re-search-forward (word-search-regexp string nil) bound noerror count))
 


@@ -1644,7 +1673,9 @@ Optional fourth argument is repeat count--search for successive occurrences.
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard

-to punctuation."
+to punctuation.
+This command does not support character folding, and lax space matching
+has no effect on it."

   (interactive "sWord search backward: ")
   (re-search-backward (word-search-regexp string t) bound noerror count))
 
   (interactive "sWord search backward: ")
   (re-search-backward (word-search-regexp string t) bound noerror count))
 


@@ -1663,7 +1694,9 @@ Optional fourth argument is repeat count--search for successive occurrences.
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard
 
 Relies on the function `word-search-regexp' to convert a sequence
 of words in STRING to a regexp used to search words without regard

-to punctuation."
+to punctuation.
+This command does not support character folding, and lax space matching
+has no effect on it."

   (interactive "sWord search: ")
   (re-search-forward (word-search-regexp string t) bound noerror count))
 
   (interactive "sWord search: ")
   (re-search-forward (word-search-regexp string t) bound noerror count))
 


@@ -1834,7 +1867,13 @@ characters in that string."
                 isearch-regexp-lax-whitespace
               isearch-lax-whitespace)
             search-whitespace-regexp)))
                 isearch-regexp-lax-whitespace
               isearch-lax-whitespace)
             search-whitespace-regexp)))

-    (occur regexp nlines)))
+    (occur (if isearch-regexp-function
+              (propertize regexp
+                          'isearch-string isearch-string
+                          'isearch-regexp-function-descr
+                           (isearch--describe-regexp-mode isearch-regexp-function))
+            regexp)
+          nlines)))

 
 (declare-function hi-lock-read-face-name "hi-lock" ())
 
 
 (declare-function hi-lock-read-face-name "hi-lock" ())
 


@@ -1901,7 +1940,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,


@@ -1966,6 +2006,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


@@ -2078,7 +2125,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


@@ -2245,12 +2293,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))


@@ -2277,15 +2325,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)


@@ -2432,7 +2480,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))


@@ -2536,16 +2584,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)


@@ -2613,10 +2675,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.


@@ -2641,21 +2705,34 @@ Can be changed via `isearch-search-fun-function' for special needs."
                                        (isearch-regexp isearch-regexp-lax-whitespace)
                                        (t isearch-lax-whitespace))
                                   search-whitespace-regexp)))
                                        (isearch-regexp isearch-regexp-lax-whitespace)
                                        (t isearch-lax-whitespace))
                                   search-whitespace-regexp)))

-      (funcall
-       (if isearch-forward #'re-search-forward #'re-search-backward)
-       (cond (isearch-regexp-function
-              (let ((lax (isearch--lax-regexp-function-p)))
-                (if (functionp isearch-regexp-function)
-                    (funcall isearch-regexp-function string lax)
-                  (word-search-regexp string lax))))
-             (isearch-regexp string)
-             (t (regexp-quote string)))
-       bound noerror count))))
+      (condition-case er
+          (funcall
+           (if isearch-forward #'re-search-forward #'re-search-backward)
+           (cond (isearch-regexp-function
+                  (let ((lax (isearch--lax-regexp-function-p)))
+                    (if (functionp isearch-regexp-function)
+                        (funcall isearch-regexp-function string lax)
+                      (word-search-regexp string lax))))
+                 (isearch-regexp string)
+                 (t (regexp-quote string)))
+           bound noerror count)
+        (search-failed
+         (signal (car er)
+                 (let ((prefix (get isearch-regexp-function 'isearch-message-prefix)))
+                   (if (and isearch-regexp-function (stringp prefix))
+                       (list (format "%s   [using %ssearch]" string prefix))
+                     (cdr er)))))))))

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


@@ -3028,21 +3105,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


@@ -3063,9 +3126,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))


@@ -3078,10 +3141,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)


@@ -3100,7 +3165,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.


@@ -3123,13 +3190,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


@@ -3173,12 +3240,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)))
 


@@ -3188,7 +3255,7 @@ Attempt to do the search exactly the way the pending Isearch would."
                          ;; 1000 is higher than ediff's 100+,
                          ;; but lower than isearch main overlay's 1001
                          (overlay-put ov 'priority 1000)
                          ;; 1000 is higher than ediff's 100+,
                          ;; but lower than isearch main overlay's 1001
                          (overlay-put ov 'priority 1000)

-                         (overlay-put ov 'face lazy-highlight-face)))
+                         (overlay-put ov 'face 'lazy-highlight)))

                          ;(overlay-put ov 'window (selected-window))))
                      ;; Remember the current position of point for
                      ;; the next call of `isearch-lazy-highlight-update'
                          ;(overlay-put ov 'window (selected-window))))
                      ;; Remember the current position of point for
                      ;; the next call of `isearch-lazy-highlight-update'


@@ -3205,12 +3272,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