X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/00098b0131e6906b8b03df35576c2cb6c3b035e5..640ad75b3c4549394eec314b3305ca576d185965:/lisp/isearch.el diff --git a/lisp/isearch.el b/lisp/isearch.el index 117d1bfdc1..69ffcdd55f 100644 --- a/lisp/isearch.el +++ b/lisp/isearch.el @@ -1,7 +1,7 @@ ;;; isearch.el --- incremental search minor mode -;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1999, -;; 2000, 2001, 2003, 2004 Free Software Foundation, Inc. +;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, +;; 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. ;; Author: Daniel LaLiberte ;; Maintainer: FSF @@ -21,8 +21,8 @@ ;; You should have received a copy of the GNU General Public License ;; along with GNU Emacs; see the file COPYING. If not, write to the -;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, -;; Boston, MA 02111-1307, USA. +;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +;; Boston, MA 02110-1301, USA. ;;; Commentary: @@ -109,24 +109,24 @@ string, and RET terminates editing and does a nonincremental search." :type 'boolean :group 'isearch) -(defcustom search-whitespace-regexp "\\(?:\\s-+\\)" +(defcustom search-whitespace-regexp "\\s-+" "*If non-nil, regular expression to match a sequence of whitespace chars. This applies to regular expression incremental search. -You might want to use something like \"\\\\(?:[ \\t\\r\\n]+\\\\)\" instead. -In the Customization buffer, that is `\\(?:[' followed by a space, -a tab, a carriage return (control-M), a newline, and `]+\\)'." - :type 'regexp - :group 'isearch) - -(defcustom search-highlight t - "*Non-nil means incremental search highlights the current match." - :type 'boolean +When you put a space or spaces in the incremental regexp, it stands for +this, unless it is inside of a regexp construct such as [...] or *, + or ?. +You might want to use something like \"[ \\t\\r\\n]+\" instead. +In the Customization buffer, that is `[' followed by a space, +a tab, a carriage return (control-M), a newline, and `]+'. + +When this is nil, each space you type matches literally, against one space." + :type '(choice (const :tag "Find Spaces Literally" nil) + regexp) :group 'isearch) (defcustom search-invisible 'open "If t incremental search can match hidden text. -nil means don't match invisible text. -If the value is `open', if the text matched is made invisible by +A nil value means don't match invisible text. +When the value is `open', if the text matched is made invisible by an overlay having an `invisible' property and that overlay has a property `isearch-open-invisible', then incremental search will show the contents. \(This applies when using `outline.el' and `hideshow.el'.) @@ -157,7 +157,12 @@ command history." "Function(s) to call after starting up an incremental search.") (defvar isearch-mode-end-hook nil - "Function(s) to call after terminating an incremental search.") + "Function(s) to call after terminating an incremental search. +When these functions are called, `isearch-mode-end-hook-quit' +is non-nil if the user quit the search.") + +(defvar isearch-mode-end-hook-quit nil + "Non-nil while running `isearch-mode-end-hook' if user quit the search.") (defvar isearch-wrap-function nil "Function to call to wrap the search when search is failed. @@ -186,10 +191,10 @@ to the search status stack.") (defvar search-ring-yank-pointer nil "Index in `search-ring' of last string reused. -nil if none yet.") +It is nil if none yet.") (defvar regexp-search-ring-yank-pointer nil "Index in `regexp-search-ring' of last string reused. -nil if none yet.") +It is nil if none yet.") (defcustom search-ring-update nil "*Non-nil if advancing or retreating in the search ring should cause search. @@ -197,6 +202,105 @@ Default value, nil, means edit the string instead." :type 'boolean :group 'isearch) +;;; isearch highlight customization. + +(defcustom search-highlight t + "*Non-nil means incremental search highlights the current match." + :type 'boolean + :group 'isearch) + +(defface isearch + '((((class color) (min-colors 88) (background light)) + ;; The background must not be too dark, for that means + ;; the character is hard to see when the cursor is there. + (:background "magenta3" :foreground "lightskyblue1")) + (((class color) (min-colors 88) (background dark)) + (:background "palevioletred2" :foreground "brown4")) + (((class color) (min-colors 16)) + (:background "magenta4" :foreground "cyan1")) + (((class color) (min-colors 8)) + (:background "magenta4" :foreground "cyan1")) + (t (:inverse-video t))) + "Face for highlighting Isearch matches." + :group 'isearch + :group 'basic-faces) +(defvar isearch 'isearch) + +(defcustom isearch-lazy-highlight t + "*Controls the lazy-highlighting during incremental search. +When non-nil, all text in the buffer matching the current search +string is highlighted lazily (see `lazy-highlight-initial-delay' +and `lazy-highlight-interval')." + :type 'boolean + :group 'lazy-highlight + :group 'isearch) + +;;; Lazy highlight customization. + +(defgroup lazy-highlight nil + "Lazy highlighting feature for matching strings." + :prefix "lazy-highlight-" + :version "21.1" + :group 'isearch + :group 'matching) + +(defcustom lazy-highlight-cleanup t + "*Controls whether to remove extra highlighting after a search. +If this is nil, extra highlighting can be \"manually\" removed with +\\[lazy-highlight-cleanup]." + :type 'boolean + :group 'lazy-highlight) +(define-obsolete-variable-alias 'isearch-lazy-highlight-cleanup + 'lazy-highlight-cleanup + "22.1") + +(defcustom lazy-highlight-initial-delay 0.25 + "*Seconds to wait before beginning to lazily highlight all matches." + :type 'number + :group 'lazy-highlight) +(define-obsolete-variable-alias 'isearch-lazy-highlight-initial-delay + 'lazy-highlight-initial-delay + "22.1") + +(defcustom lazy-highlight-interval 0 ; 0.0625 + "*Seconds between lazily highlighting successive matches." + :type 'number + :group 'lazy-highlight) +(define-obsolete-variable-alias 'isearch-lazy-highlight-interval + 'lazy-highlight-interval + "22.1") + +(defcustom lazy-highlight-max-at-a-time 20 + "*Maximum matches to highlight at a time (for `lazy-highlight'). +Larger values may reduce isearch's responsiveness to user input; +smaller values make matches highlight slowly. +A value of nil means highlight all matches." + :type '(choice (const :tag "All" nil) + (integer :tag "Some")) + :group 'lazy-highlight) +(define-obsolete-variable-alias 'isearch-lazy-highlight-max-at-a-time + 'lazy-highlight-max-at-a-time + "22.1") + +(defface lazy-highlight + '((((class color) (min-colors 88) (background light)) + (:background "paleturquoise")) + (((class color) (min-colors 88) (background dark)) + (:background "paleturquoise4")) + (((class color) (min-colors 16)) + (:background "turquoise3")) + (((class color) (min-colors 8)) + (:background "turquoise3")) + (t (:underline t))) + "Face for lazy highlighting of matches other than the current one." + :group 'lazy-highlight + :group 'basic-faces) +(put 'isearch-lazy-highlight-face 'face-alias 'lazy-highlight) +(defvar lazy-highlight-face 'lazy-highlight) +(define-obsolete-variable-alias 'isearch-lazy-highlight-face + 'lazy-highlight-face + "22.1") + ;; Define isearch-mode keymap. (defvar isearch-mode-map @@ -218,12 +322,12 @@ Default value, nil, means edit the string instead." ;; We need these explicit definitions because, in a dense keymap, ;; the binding for t does not affect characters. ;; We use a dense keymap to save space. - (while (< i ?\ ) + (while (< i ?\s) (define-key map (make-string 1 i) 'isearch-other-control-char) (setq i (1+ i))) ;; Single-byte printing chars extend the search string by default. - (setq i ?\ ) + (setq i ?\s) (while (< i 256) (define-key map (vector i) 'isearch-printing-char) (setq i (1+ i))) @@ -260,21 +364,13 @@ Default value, nil, means edit the string instead." (define-key map "\r" 'isearch-exit) (define-key map "\C-j" 'isearch-printing-char) (define-key map "\t" 'isearch-printing-char) - (define-key map " " 'isearch-whitespace-chars) - (define-key map [?\S-\ ] 'isearch-whitespace-chars) + (define-key map [?\S-\ ] 'isearch-printing-char) (define-key map "\C-w" 'isearch-yank-word-or-char) (define-key map "\M-\C-w" 'isearch-del-char) (define-key map "\M-\C-y" 'isearch-yank-char) (define-key map "\C-y" 'isearch-yank-line) - ;; Define keys for regexp chars * ? } |. - ;; Nothing special for + because it matches at least once. - (define-key map "*" 'isearch-*-char) - (define-key map "?" 'isearch-*-char) - (define-key map "}" 'isearch-}-char) - (define-key map "|" 'isearch-|-char) - ;; Turned off because I find I expect to get the global definition--rms. ;; ;; Instead bind C-h to special help command for isearch-mode. ;; (define-key map "\C-h" 'isearch-mode-help) @@ -293,6 +389,8 @@ Default value, nil, means edit the string instead." (define-key map [iconify-frame] nil) (define-key map [make-frame-visible] nil) (define-key map [mouse-movement] nil) + (define-key map [language-change] nil) + ;; For searching multilingual text. (define-key map "\C-\\" 'isearch-toggle-input-method) (define-key map "\C-^" 'isearch-toggle-specified-input-method) @@ -317,12 +415,6 @@ Default value, nil, means edit the string instead." (let ((map (make-sparse-keymap))) (set-keymap-parent map minibuffer-local-map) (define-key map "\r" 'isearch-nonincremental-exit-minibuffer) - (define-key map "\M-n" 'isearch-ring-advance-edit) - (define-key map [next] 'isearch-ring-advance-edit) - (define-key map [down] 'isearch-ring-advance-edit) - (define-key map "\M-p" 'isearch-ring-retreat-edit) - (define-key map [prior] 'isearch-ring-retreat-edit) - (define-key map [up] 'isearch-ring-retreat-edit) (define-key map "\M-\t" 'isearch-complete-edit) (define-key map "\C-s" 'isearch-forward-exit-minibuffer) (define-key map "\C-r" 'isearch-reverse-exit-minibuffer) @@ -349,9 +441,8 @@ Each set is a vector of the form: (defvar isearch-string "") ; The current search string. (defvar isearch-message "") ; text-char-description version of isearch-string -(defvar isearch-success t) ; Searching is currently successful. -(defvar isearch-invalid-regexp nil) ; Regexp not well formed. -(defvar isearch-within-brackets nil) ; Regexp has unclosed [. +(defvar isearch-success t) ; Searching is currently successful. +(defvar isearch-error nil) ; Error message for failed search. (defvar isearch-other-end nil) ; Start (end) of match if forward (backward). (defvar isearch-wrapped nil) ; Searching restarted from the top (bottom). (defvar isearch-barrier 0) @@ -433,8 +524,8 @@ Type \\[isearch-exit] to exit, leaving point at location found. Type LFD (C-j) to match end of line. Type \\[isearch-repeat-forward] to search again forward,\ \\[isearch-repeat-backward] to search again backward. -Type \\[isearch-yank-word-or-char] to yank word from buffer onto end of search\ - string and search for it. +Type \\[isearch-yank-word-or-char] to yank next word or character in buffer + onto the end of the search string, and search for it. Type \\[isearch-del-char] to delete character from end of search string. Type \\[isearch-yank-char] to yank char from buffer onto end of search\ string and search for it. @@ -449,6 +540,14 @@ Type \\[isearch-quote-char] to quote control character to search for it. \\[isearch-abort] when search is successful aborts and moves point to\ starting point. +If you try to exit with the search string still empty, it invokes + nonincremental search. + +Type \\[isearch-query-replace] to start `query-replace' with string to\ + replace from last search string. +Type \\[isearch-query-replace-regexp] to start `query-replace-regexp'\ + with string to replace from last search string. + Type \\[isearch-toggle-case-fold] to toggle search case-sensitivity. Type \\[isearch-toggle-regexp] to toggle regular-expression mode. Type \\[isearch-edit-string] to edit the search string in the minibuffer. @@ -485,7 +584,12 @@ the calling function until the search is done." Do incremental search forward 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 \\[isearch-forward] for more info." +is treated as a regexp. See \\[isearch-forward] for more info. + +In regexp incremental searches, a space or spaces normally matches +any whitespace (the variable `search-whitespace-regexp' controls +precisely what that means). If you want to search for a literal space +and nothing else, enter C-q SPC." (interactive "P\np") (isearch-mode t (null not-regexp) nil (not no-recursive-edit))) @@ -542,8 +646,7 @@ is treated as a regexp. See \\[isearch-forward] for more info." isearch-barrier (point) isearch-adjusted nil isearch-yank-flag nil - isearch-invalid-regexp nil - isearch-within-brackets nil + isearch-error nil isearch-slow-terminal-mode (and (<= baud-rate search-slow-speed) (> (window-height) (* 4 @@ -642,17 +745,24 @@ is treated as a regexp. See \\[isearch-forward] for more info." (if (< isearch-other-end (point)) ; isearch-forward? (isearch-highlight isearch-other-end (point)) (isearch-highlight (point) isearch-other-end)) - (isearch-dehighlight nil)) + (isearch-dehighlight)) )) (setq ;; quit-flag nil not for isearch-mode isearch-adjusted nil isearch-yank-flag nil) - (isearch-lazy-highlight-new-loop) + (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)) (defun isearch-done (&optional nopush edit) + "Exit Isearch mode. +For successful search, pass no args. +For a failing search, NOPUSH is t. +For going to the minibuffer to edit the search string, +NOPUSH is t and EDIT is t." + (if isearch-resume-in-command-history (let ((command `(isearch-resume ,isearch-string ,isearch-regexp ,isearch-word ,isearch-forward @@ -670,8 +780,8 @@ is treated as a regexp. See \\[isearch-forward] for more info." (setq overriding-terminal-local-map nil) ;; (setq pre-command-hook isearch-old-pre-command-hook) ; for lemacs (setq minibuffer-message-timeout isearch-original-minibuffer-message-timeout) - (isearch-dehighlight t) - (isearch-lazy-highlight-cleanup isearch-lazy-highlight-cleanup) + (isearch-dehighlight) + (lazy-highlight-cleanup lazy-highlight-cleanup) (let ((found-start (window-start (selected-window))) (found-point (point))) (if isearch-window-configuration @@ -680,16 +790,7 @@ is treated as a regexp. See \\[isearch-forward] for more info." (if isearch-small-window (goto-char found-point) ;; Exiting the save-window-excursion clobbers window-start; restore it. - (set-window-start (selected-window) found-start t)) - - ;; If there was movement, mark the starting position. - ;; Maybe should test difference between and set mark iff > threshold. - (if (/= (point) isearch-opoint) - (or (and transient-mark-mode mark-active) - (progn - (push-mark isearch-opoint t) - (or executing-kbd-macro (> (minibuffer-depth) 0) - (message "Mark saved where search started")))))) + (set-window-start (selected-window) found-start t))) (setq isearch-mode nil) (if isearch-input-method-local-p @@ -713,26 +814,38 @@ is treated as a regexp. See \\[isearch-forward] for more info." ;; Update the ring data. (isearch-update-ring isearch-string isearch-regexp)) - (run-hooks 'isearch-mode-end-hook) + (let ((isearch-mode-end-hook-quit (and nopush (not edit)))) + (run-hooks 'isearch-mode-end-hook)) + + ;; If there was movement, mark the starting position. + ;; Maybe should test difference between and set mark iff > threshold. + (if (/= (point) isearch-opoint) + (or (and transient-mark-mode mark-active) + (progn + (push-mark isearch-opoint t) + (or executing-kbd-macro (> (minibuffer-depth) 0) + (message "Mark saved where search started"))))) + (and (not edit) isearch-recursive-edit (exit-recursive-edit))) (defun isearch-update-ring (string &optional regexp) "Add STRING to the beginning of the search ring. -REGEXP says which ring to use." +REGEXP if non-nil says use the regexp search ring." (if regexp - (if (or (null regexp-search-ring) - (not (string= string (car regexp-search-ring)))) - (progn - (push string regexp-search-ring) - (if (> (length regexp-search-ring) regexp-search-ring-max) - (setcdr (nthcdr (1- search-ring-max) regexp-search-ring) - nil)))) - (if (or (null search-ring) - (not (string= string (car search-ring)))) - (progn - (push string search-ring) - (if (> (length search-ring) search-ring-max) - (setcdr (nthcdr (1- search-ring-max) search-ring) nil)))))) + (when (or (null regexp-search-ring) + (not (string= string (car regexp-search-ring)))) + (when history-delete-duplicates + (setq regexp-search-ring (delete string regexp-search-ring))) + (push string regexp-search-ring) + (when (> (length regexp-search-ring) regexp-search-ring-max) + (setcdr (nthcdr (1- search-ring-max) regexp-search-ring) nil))) + (when (or (null search-ring) + (not (string= string (car search-ring)))) + (when history-delete-duplicates + (setq search-ring (delete string search-ring))) + (push string search-ring) + (when (> (length search-ring) search-ring-max) + (setcdr (nthcdr (1- search-ring-max) search-ring) nil))))) ;; Switching buffers should first terminate isearch-mode. ;; ;; For Emacs 19, the frame switch event is handled. @@ -767,7 +880,7 @@ REGEXP says which ring to use." (defsubst isearch-word-state (frame) "Return the search-by-word flag in FRAME." (aref frame 6)) -(defsubst isearch-invalid-regexp-state (frame) +(defsubst isearch-error-state (frame) "Return the regexp error message in FRAME, or nil if its regexp is valid." (aref frame 7)) (defsubst isearch-wrapped-state (frame) @@ -776,15 +889,12 @@ REGEXP says which ring to use." (defsubst isearch-barrier-state (frame) "Return the barrier value in FRAME." (aref frame 9)) -(defsubst isearch-within-brackets-state (frame) - "Return the in-character-class flag in FRAME." - (aref frame 10)) (defsubst isearch-case-fold-search-state (frame) "Return the case-folding flag in FRAME." - (aref frame 11)) + (aref frame 10)) (defsubst isearch-pop-fun-state (frame) "Return the function restoring the mode-specific isearch state in FRAME." - (aref frame 12)) + (aref frame 11)) (defun isearch-top-state () (let ((cmd (car isearch-cmds))) @@ -794,10 +904,9 @@ REGEXP says which ring to use." isearch-forward (isearch-forward-state cmd) isearch-other-end (isearch-other-end-state cmd) isearch-word (isearch-word-state cmd) - isearch-invalid-regexp (isearch-invalid-regexp-state cmd) + isearch-error (isearch-error-state cmd) isearch-wrapped (isearch-wrapped-state cmd) isearch-barrier (isearch-barrier-state cmd) - isearch-within-brackets (isearch-within-brackets-state cmd) isearch-case-fold-search (isearch-case-fold-search-state cmd)) (if (functionp (isearch-pop-fun-state cmd)) (funcall (isearch-pop-fun-state cmd) cmd)) @@ -812,8 +921,8 @@ REGEXP says which ring to use." (cons (vector isearch-string isearch-message (point) isearch-success isearch-forward isearch-other-end isearch-word - isearch-invalid-regexp isearch-wrapped isearch-barrier - isearch-within-brackets isearch-case-fold-search + isearch-error isearch-wrapped isearch-barrier + isearch-case-fold-search (if isearch-push-state-function (funcall isearch-push-state-function))) isearch-cmds))) @@ -843,8 +952,6 @@ The following additional command keys are active while editing. \\[isearch-nonincremental-exit-minibuffer] to do one nonincremental search. \\[isearch-forward-exit-minibuffer] to resume isearching forward. \\[isearch-reverse-exit-minibuffer] to resume isearching backward. -\\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring. -\\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring. \\[isearch-complete-edit] to complete the search string using the search ring. \\ If first char entered is \\[isearch-yank-word-or-char], then do word search instead." @@ -876,8 +983,7 @@ If first char entered is \\[isearch-yank-word-or-char], then do word search inst (isearch-barrier isearch-barrier) (isearch-adjusted isearch-adjusted) (isearch-yank-flag isearch-yank-flag) - (isearch-invalid-regexp isearch-invalid-regexp) - (isearch-within-brackets isearch-within-brackets) + (isearch-error isearch-error) ;;; 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) @@ -921,7 +1027,7 @@ If first char entered is \\[isearch-yank-word-or-char], then do word search inst ;; read a key the normal way. ;; Word search does not apply (yet) to regexp searches, ;; no check is made here. - (message (isearch-message-prefix nil nil t)) + (message "%s" (isearch-message-prefix nil nil t)) (if (memq (lookup-key isearch-mode-map (vector e)) '(isearch-yank-word isearch-yank-word-or-char)) @@ -931,12 +1037,12 @@ If first char entered is \\[isearch-yank-word-or-char], then do word search inst (isearch-unread e)) (setq cursor-in-echo-area nil) (setq isearch-new-string - (let (junk-ring) - (read-from-minibuffer - (isearch-message-prefix nil nil isearch-nonincremental) - isearch-string - minibuffer-local-isearch-map nil - 'junk-ring)) + (read-from-minibuffer + (isearch-message-prefix nil nil isearch-nonincremental) + isearch-string + minibuffer-local-isearch-map nil + (if isearch-regexp 'regexp-search-ring 'search-ring) + nil t) isearch-new-message (mapconcat 'isearch-text-char-description isearch-new-string ""))) @@ -977,7 +1083,11 @@ If first char entered is \\[isearch-yank-word-or-char], then do word search inst (if isearch-nonincremental (progn ;; (sit-for 1) ;; needed if isearch-done does: (message "") - (isearch-done)))) + (isearch-done) + ;; The search done message is confusing when the string + ;; is empty, so erase it. + (if (equal isearch-string "") + (message ""))))) (quit ; handle abort-recursive-edit (isearch-abort) ;; outside of let to restore outside global values @@ -1024,7 +1134,7 @@ Use `isearch-exit' to quit without signaling." (isearch-cancel)) ;; If search is failing, or has an incomplete regexp, ;; rub out until it is once more successful. - (while (or (not isearch-success) isearch-invalid-regexp) + (while (or (not isearch-success) isearch-error) (isearch-pop-state)) (isearch-update))) @@ -1034,24 +1144,27 @@ Use `isearch-exit' to quit without signaling." ;; C-s in forward or C-r in reverse. (if (equal isearch-string "") ;; If search string is empty, use last one. - (setq isearch-string - (or (if isearch-regexp - (car regexp-search-ring) - (car search-ring)) - (error "No previous search string")) - isearch-message - (mapconcat 'isearch-text-char-description - isearch-string "") - isearch-case-fold-search isearch-last-case-fold-search) + (if (null (if isearch-regexp regexp-search-ring search-ring)) + (setq isearch-error "No previous search string") + (setq isearch-string + (if isearch-regexp + (car regexp-search-ring) + (car search-ring)) + isearch-message + (mapconcat 'isearch-text-char-description + isearch-string "") + isearch-case-fold-search isearch-last-case-fold-search)) ;; If already have what to search for, repeat it. (or isearch-success (progn + ;; Set isearch-wrapped before calling isearch-wrap-function + (setq isearch-wrapped t) (if isearch-wrap-function (funcall isearch-wrap-function) - (goto-char (if isearch-forward (point-min) (point-max)))) - (setq isearch-wrapped t)))) + (goto-char (if isearch-forward (point-min) (point-max))))))) ;; C-s in reverse or C-r in forward, change direction. - (setq isearch-forward (not isearch-forward))) + (setq isearch-forward (not isearch-forward) + isearch-success t)) (setq isearch-barrier (point)) ; For subsequent \| if regexp. @@ -1115,9 +1228,10 @@ Use `isearch-exit' to quit without signaling." (let ((case-fold-search isearch-case-fold-search)) (isearch-done) (isearch-clean-overlays) - (if (and (< isearch-other-end (point)) + (if (and isearch-other-end + (< isearch-other-end (point)) (not (and transient-mark-mode mark-active - (< isearch-opoint (point))))) + (< (mark) (point))))) (goto-char isearch-other-end)) (set query-replace-from-history-variable (cons isearch-string @@ -1253,8 +1367,8 @@ might return the position of the end of the line." (defun isearch-yank-line () "Pull rest of line from buffer into search string." (interactive) - (isearch-yank-internal 'line-end-position)) - + (isearch-yank-internal + (lambda () (line-end-position (if (eolp) 2 1))))) (defun isearch-search-and-update () ;; Do the search and update the display. @@ -1284,8 +1398,7 @@ might return the position of the end of the line." (min isearch-opoint isearch-barrier)))) (progn (setq isearch-success t - isearch-invalid-regexp nil - isearch-within-brackets nil + isearch-error nil isearch-other-end (match-end 0)) (if (and (eq isearch-case-fold-search t) search-upper-case) (setq isearch-case-fold-search @@ -1319,21 +1432,21 @@ might return the position of the end of the line." Respects \\[isearch-repeat-forward] and \\[isearch-repeat-backward] by stopping at `isearch-barrier' as needed. -Do nothing if a backslash is escaping the liberalizing character. If -WANT-BACKSLASH is non-nil, invert this behavior (for \\} and \\|). +Do nothing if a backslash is escaping the liberalizing character. +If WANT-BACKSLASH is non-nil, invert this behavior (for \\} and \\|). -Do nothing if regexp has recently been invalid unless optional ALLOW-INVALID -non-nil. +Do nothing if regexp has recently been invalid unless optional +ALLOW-INVALID non-nil. -If optional TO-BARRIER non-nil, ignore previous matches and go exactly to the -barrier." +If optional TO-BARRIER non-nil, ignore previous matches and go exactly +to the barrier." ;; (eq (not a) (not b)) makes all non-nil values equivalent (when (and isearch-regexp (eq (not (isearch-backslash isearch-string)) (not want-backslash)) ;; We have to check 2 stack frames because the last might be ;; invalid just because of a backslash. - (or (not isearch-invalid-regexp) - (not (isearch-invalid-regexp-state (cadr isearch-cmds))) + (or (not isearch-error) + (not (isearch-error-state (cadr isearch-cmds))) allow-invalid)) (if to-barrier (progn (goto-char isearch-barrier) @@ -1348,7 +1461,7 @@ barrier." ;; Also skip over postfix operators -- though horrid, ;; 'ab?\{5,6\}+\{1,2\}*' is perfectly legal. (while (and previous - (or (isearch-invalid-regexp-state frame) + (or (isearch-error-state frame) (let* ((string (isearch-string-state frame)) (lchar (aref string (1- (length string))))) ;; The operators aren't always operators; check @@ -1365,31 +1478,14 @@ barrier." ;; `stack' now refers the most recent valid regexp that is not at ;; all optional in its last term. Now dig one level deeper and find ;; what matched before that. - (let ((last-other-end (or (isearch-other-end-state (car previous)) - isearch-barrier))) + (let ((last-other-end + (or (and (car previous) + (isearch-other-end-state (car previous))) + isearch-barrier))) (goto-char (if isearch-forward (max last-other-end isearch-barrier) (min last-other-end isearch-barrier))) - (setq isearch-adjusted t)))))) - (isearch-process-search-char last-command-char)) - -;; * and ? are special when not preceded by \. -(defun isearch-*-char () - "Maybe back up to handle * and ? specially in regexps." - (interactive) - (isearch-fallback nil)) - -;; } is special when it is preceded by \. -(defun isearch-}-char () - "Handle \\} specially in regexps." - (interactive) - (isearch-fallback t t)) - -;; | is special when it is preceded by \. -(defun isearch-|-char () - "If in regexp search, jump to the barrier unless in a group." - (interactive) - (isearch-fallback t nil t)) + (setq isearch-adjusted t))))))) (defun isearch-unread-key-sequence (keylist) "Unread the given key-sequence KEYLIST. @@ -1460,6 +1556,7 @@ Scroll-bar or mode-line events are processed appropriately." (put 'delete-other-windows 'isearch-scroll t) (put 'balance-windows 'isearch-scroll t) (put 'split-window-vertically 'isearch-scroll t) +(put 'split-window-horizontally 'isearch-scroll t) (put 'enlarge-window 'isearch-scroll t) ;; Universal argument commands @@ -1583,7 +1680,7 @@ Isearch mode." ;; directly to avoid the input method and keyboard ;; coding system translating it. (if (and (integerp key) - (>= key ?\ ) (/= key 127) (< key 256)) + (>= key ?\s) (/= key 127) (< key 256)) (progn (isearch-process-search-char key) (setq keylist (cdr keylist))) @@ -1600,12 +1697,15 @@ Isearch mode." (and (integerp main-event) (memq 'shift mods) (memq 'control mods) - (lookup-key isearch-mode-map - (let ((copy (copy-sequence key))) - (aset copy 0 - (- main-event (- ?\C-\S-a ?\C-a))) - copy) - nil))) + (not (memq (lookup-key isearch-mode-map + (let ((copy (copy-sequence key))) + (aset copy 0 + (- main-event + (- ?\C-\S-a ?\C-a))) + copy) + nil) + '(nil + isearch-other-control-char))))) (setcar keylist (- main-event (- ?\C-\S-a ?\C-a))) (cancel-kbd-macro-events) (apply 'isearch-unread keylist)) @@ -1675,24 +1775,28 @@ Isearch mode." ;; Assume character codes 0200 - 0377 stand for characters in some ;; single-byte character set, and convert them to Emacs ;; characters. - (and enable-multibyte-characters - (>= char ?\200) - (<= char ?\377) - (setq char (unibyte-char-to-multibyte char))) - (isearch-process-search-char char))) + (if (and isearch-regexp (= char ?\s)) + (if (subregexp-context-p isearch-string (length isearch-string)) + (isearch-process-search-string "[ ]" " ") + (isearch-process-search-char char)) + (and enable-multibyte-characters + (>= char ?\200) + (<= char ?\377) + (setq char (unibyte-char-to-multibyte char))) + (isearch-process-search-char char)))) (defun isearch-return-char () - "Convert return into newline for incremental search. -Obsolete." + "Convert return into newline for incremental search." (interactive) (isearch-process-search-char ?\n)) +(make-obsolete 'isearch-return-char 'isearch-printing-char) (defun isearch-printing-char () "Add this ordinary printing character to the search string and search." (interactive) (let ((char last-command-char)) (if (= char ?\S-\ ) - (setq char ?\ )) + (setq char ?\s)) (if (and enable-multibyte-characters (>= char ?\200) (<= char ?\377)) @@ -1703,24 +1807,18 @@ Obsolete." (isearch-process-search-multibyte-characters char) (isearch-process-search-char char))))) -(defun isearch-whitespace-chars () - "Match all whitespace chars, if in regexp mode. -If you want to search for just a space, type \\\\[isearch-quote-char] SPC." - (interactive) - (if isearch-regexp - (if (and search-whitespace-regexp (not isearch-within-brackets) - (not isearch-invalid-regexp)) - (isearch-process-search-string search-whitespace-regexp " ") - (isearch-printing-char)) - (progn - ;; This way of doing word search doesn't correctly extend current search. - ;; (setq isearch-word t) - ;; (setq isearch-adjusted t) - ;; (goto-char isearch-barrier) - (isearch-printing-char)))) - (defun isearch-process-search-char (char) + ;; * and ? are special in regexps when not preceded by \. + ;; } and | are special in regexps when preceded by \. + ;; Nothing special for + because it matches at least once. + (cond + ((memq char '(?* ??)) (isearch-fallback nil)) + ((eq char ?\}) (isearch-fallback t t)) + ((eq char ?|) (isearch-fallback t nil t))) + ;; Append the char to the search string, update the message and re-search. + (if (char-table-p translation-table-for-input) + (setq char (or (aref translation-table-for-input char) char))) (isearch-process-search-string (char-to-string char) (if (>= char ?\200) @@ -1776,49 +1874,6 @@ If you want to search for just a space, type \\\\[isearch-quot (interactive) (isearch-ring-adjust nil)) -(defun isearch-ring-advance-edit (n) - "Insert the next element of the search history into the minibuffer. -With prefix arg N, insert the Nth element." - (interactive "p") - (let* ((yank-pointer-name (if isearch-regexp - 'regexp-search-ring-yank-pointer - 'search-ring-yank-pointer)) - (yank-pointer (eval yank-pointer-name)) - (ring (if isearch-regexp regexp-search-ring search-ring)) - (length (length ring))) - (if (zerop length) - () - (set yank-pointer-name - (setq yank-pointer - (mod (- (or yank-pointer 0) n) - length))) - - (delete-field) - (insert (nth yank-pointer ring)) - (goto-char (point-max))))) - -(defun isearch-ring-retreat-edit (n) - "Insert the previous element of the search history into the minibuffer. -With prefix arg N, insert the Nth element." - (interactive "p") - (isearch-ring-advance-edit (- n))) - -;;(defun isearch-ring-adjust-edit (advance) -;; "Use the next or previous search string in the ring while in minibuffer." -;; (isearch-ring-adjust1 advance) -;; (erase-buffer) -;; (insert isearch-string)) - -;;(defun isearch-ring-advance-edit () -;; (interactive) -;; (isearch-ring-adjust-edit 'advance)) - -;;(defun isearch-ring-retreat-edit () -;; "Retreat to the previous search string in the ring while in the minibuffer." -;; (interactive) -;; (isearch-ring-adjust-edit nil)) - - (defun isearch-complete1 () ;; Helper for isearch-complete and isearch-complete-edit ;; Return t if completion OK, nil if no completion exists. @@ -1893,11 +1948,10 @@ If there is no completion possible, say so and continue searching." ;; If about to search, and previous search regexp was invalid, ;; check that it still is. If it is valid now, ;; let the message we display while searching say that it is valid. - (and isearch-invalid-regexp ellipsis + (and isearch-error ellipsis (condition-case () (progn (re-search-forward isearch-string (point) t) - (setq isearch-invalid-regexp nil - isearch-within-brackets nil)) + (setq isearch-error nil)) (error nil))) ;; If currently failing, display no ellipsis. (or isearch-success (setq ellipsis nil)) @@ -1923,8 +1977,8 @@ If there is no completion possible, say so and continue searching." (defun isearch-message-suffix (&optional c-q-hack ellipsis) (concat (if c-q-hack "^Q" "") - (if isearch-invalid-regexp - (concat " [" isearch-invalid-regexp "]") + (if isearch-error + (concat " [" isearch-error "]") ""))) @@ -1959,9 +2013,9 @@ Can be changed via `isearch-search-fun-function' for special needs." (let ((inhibit-point-motion-hooks search-invisible) (inhibit-quit nil) (case-fold-search isearch-case-fold-search) + (search-spaces-regexp search-whitespace-regexp) (retry t)) - (if isearch-regexp (setq isearch-invalid-regexp nil)) - (setq isearch-within-brackets nil) + (setq isearch-error nil) (while retry (setq isearch-success (funcall @@ -1985,16 +2039,19 @@ Can be changed via `isearch-search-fun-function' for special needs." (setq isearch-success nil)) (invalid-regexp - (setq isearch-invalid-regexp (car (cdr lossage))) - (setq isearch-within-brackets (string-match "\\`Unmatched \\[" - isearch-invalid-regexp)) + (setq isearch-error (car (cdr lossage))) (if (string-match "\\`Premature \\|\\`Unmatched \\|\\`Invalid " - isearch-invalid-regexp) - (setq isearch-invalid-regexp "incomplete input"))) + isearch-error) + (setq isearch-error "incomplete input"))) + + (search-failed + (setq isearch-success nil) + (setq isearch-error (nth 2 lossage))) + (error ;; stack overflow in regexp search. - (setq isearch-invalid-regexp (format "%s" lossage)))) + (setq isearch-error (format "%s" lossage)))) (if isearch-success nil @@ -2150,31 +2207,8 @@ Can be changed via `isearch-search-fun-function' for special needs." (setq isearch-hidden t))))))) -;; Highlighting - -(defvar isearch-overlay nil) - -(defun isearch-highlight (beg end) - (unless (null search-highlight) - (cond (isearch-overlay - ;; Overlay already exists, just move it. - (move-overlay isearch-overlay beg end (current-buffer))) - - (t - ;; Overlay doesn't exist, create it. - (setq isearch-overlay (make-overlay beg end)) - (overlay-put isearch-overlay 'face isearch) - (overlay-put isearch-overlay 'priority 1) ;higher than lazy overlays - )))) - -(defun isearch-dehighlight (totally) - (when isearch-overlay - (delete-overlay isearch-overlay))) - - ;; General utilities - (defun isearch-no-upper-case-p (string regexp-flag) "Return t if there are no upper case chars in STRING. If REGEXP-FLAG is non-nil, disregard letters preceded by `\\' (but not `\\\\') @@ -2194,7 +2228,7 @@ since they have special meaning in a regexp." (defun isearch-text-char-description (c) (cond - ((< c ?\ ) (format "^%c" (+ c 64))) + ((< c ?\s) (format "^%c" (+ c 64))) ((= c ?\^?) "^?") (t (char-to-string c)))) @@ -2206,12 +2240,31 @@ since they have special meaning in a regexp." (append char-or-events unread-command-events))) +;; Highlighting + +(defvar isearch-overlay nil) + +(defun isearch-highlight (beg end) + (if search-highlight + (if isearch-overlay + ;; Overlay already exists, just move it. + (move-overlay isearch-overlay beg end (current-buffer)) + ;; Overlay doesn't exist, create it. + (setq isearch-overlay (make-overlay beg end)) + ;; 1001 is higher than lazy's 1000 and ediff's 100+ + (overlay-put isearch-overlay 'priority 1001) + (overlay-put isearch-overlay 'face isearch)))) + +(defun isearch-dehighlight () + (when isearch-overlay + (delete-overlay isearch-overlay))) + ;; isearch-lazy-highlight feature ;; by Bob Glickstein ;; When active, *every* match for the current search string is ;; highlighted: the current one using the normal isearch match color -;; and all the others using `isearch-lazy-highlight-face'. The extra +;; and all the others using `isearch-lazy-highlight'. The extra ;; highlighting makes it easier to anticipate where the cursor will ;; land each time you press C-s or C-r to repeat a pending search. ;; Highlighting of these additional matches happens in a deferred @@ -2228,86 +2281,13 @@ since they have special meaning in a regexp." ;; `isearch-word' and `isearch-regexp'; ;; - the direction of the current search is expected to be given by ;; `isearch-forward'; -;; - the variable `isearch-invalid-regexp' is expected to be true +;; - the variable `isearch-error' is expected to be true ;; iff `isearch-string' is an invalid regexp. -(defgroup isearch-lazy-highlight nil - "Lazy highlighting feature for incremental search." - :prefix "isearch-lazy-highlight-" - :version "21.1" - :group 'isearch) - -(defcustom isearch-lazy-highlight t - "*Controls the lazy-highlighting during incremental searches. -When non-nil, all text in the buffer matching the current search -string is highlighted lazily (see `isearch-lazy-highlight-initial-delay' -and `isearch-lazy-highlight-interval')." - :type 'boolean - :group 'isearch-lazy-highlight) - -(defcustom isearch-lazy-highlight-cleanup t - "*Controls whether to remove extra highlighting after a search. -If this is nil, extra highlighting can be \"manually\" removed with -\\[isearch-lazy-highlight-cleanup]." - :type 'boolean - :group 'isearch-lazy-highlight) - -(defcustom isearch-lazy-highlight-initial-delay 0.25 - "*Seconds to wait before beginning to lazily highlight all matches." - :type 'number - :group 'isearch-lazy-highlight) - -(defcustom isearch-lazy-highlight-interval 0 ; 0.0625 - "*Seconds between lazily highlighting successive matches." - :type 'number - :group 'isearch-lazy-highlight) - -(defcustom isearch-lazy-highlight-max-at-a-time 20 - "*Maximum matches to highlight at a time (for `isearch-lazy-highlight'). -Larger values may reduce isearch's responsiveness to user input; -smaller values make matches highlight slowly. -A value of nil means highlight all matches." - :type '(choice (const :tag "All" nil) - (integer :tag "Some")) - :group 'isearch-lazy-highlight) - -(defgroup isearch-faces nil - "Lazy highlighting feature for incremental search." - :version "21.1" - :group 'isearch) - -(defface isearch - '((((class color) (min-colors 88) (background light)) - ;; The background must not be too dark, for that means - ;; the character is hard to see when the cursor is there. - (:background "magenta2" :foreground "lightskyblue1")) - (((class color) (min-colors 88) (background dark)) - (:background "palevioletred2" :foreground "brown4")) - (((class color) (min-colors 16)) - (:background "magenta4" :foreground "cyan1")) - (((class color) (min-colors 8)) - (:background "magenta4" :foreground "cyan1")) - (t (:inverse-video t))) - "Face for highlighting Isearch matches." - :group 'isearch-faces) -(defvar isearch 'isearch) - -(defface isearch-lazy-highlight-face - '((((class color) (min-colors 88) (background light)) - (:background "paleturquoise")) - (((class color) (min-colors 88) (background dark)) - (:background "paleturquoise4")) - (((class color) (min-colors 16)) - (:background "turquoise3")) - (((class color) (min-colors 8)) - (:background "turquoise3")) - (t (:underline t))) - "Face for lazy highlighting of Isearch matches other than the current one." - :group 'isearch-faces) -(defvar isearch-lazy-highlight-face 'isearch-lazy-highlight-face) - (defvar isearch-lazy-highlight-overlays nil) (defvar isearch-lazy-highlight-wrapped nil) +(defvar isearch-lazy-highlight-start-limit nil) +(defvar isearch-lazy-highlight-end-limit nil) (defvar isearch-lazy-highlight-start nil) (defvar isearch-lazy-highlight-end nil) (defvar isearch-lazy-highlight-timer nil) @@ -2318,13 +2298,13 @@ A value of nil means highlight all matches." (defvar isearch-lazy-highlight-case-fold-search nil) (defvar isearch-lazy-highlight-regexp nil) -(defun isearch-lazy-highlight-cleanup (&optional force) +(defun lazy-highlight-cleanup (&optional force) "Stop lazy highlighting and remove extra highlighting from current buffer. -FORCE non-nil means do it whether or not `isearch-lazy-highlight-cleanup' +FORCE non-nil means do it whether or not `lazy-highlight-cleanup' is nil. This function is called when exiting an incremental search if -`isearch-lazy-highlight-cleanup' is non-nil." +`lazy-highlight-cleanup' is non-nil." (interactive '(t)) - (if (or force isearch-lazy-highlight-cleanup) + (if (or force lazy-highlight-cleanup) (while isearch-lazy-highlight-overlays (delete-overlay (car isearch-lazy-highlight-overlays)) (setq isearch-lazy-highlight-overlays @@ -2333,12 +2313,17 @@ is nil. This function is called when exiting an incremental search if (cancel-timer isearch-lazy-highlight-timer) (setq isearch-lazy-highlight-timer nil))) -(defun isearch-lazy-highlight-new-loop () - "Cleanup any previous `isearch-lazy-highlight' loop and begin a new one. -This happens when `isearch-update' is invoked (which can cause the -search string to change or the window to scroll)." - (when (and isearch-lazy-highlight - (null executing-kbd-macro) +(define-obsolete-function-alias 'isearch-lazy-highlight-cleanup + 'lazy-highlight-cleanup + "22.1") + +(defun isearch-lazy-highlight-new-loop (&optional beg end) + "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 +by other Emacs features." + (when (and (null executing-kbd-macro) (sit-for 0) ;make sure (window-start) is credible (or (not (equal isearch-string isearch-lazy-highlight-last-string)) @@ -2353,8 +2338,10 @@ search string to change or the window to scroll)." (not (= (window-end) ; Window may have been split/joined. isearch-lazy-highlight-window-end)))) ;; something important did indeed change - (isearch-lazy-highlight-cleanup t) ;kill old loop & remove overlays - (when (not isearch-invalid-regexp) + (lazy-highlight-cleanup t) ;kill old loop & remove overlays + (when (not isearch-error) + (setq isearch-lazy-highlight-start-limit beg + isearch-lazy-highlight-end-limit end) (setq isearch-lazy-highlight-window (selected-window) isearch-lazy-highlight-window-start (window-start) isearch-lazy-highlight-window-end (window-end) @@ -2366,82 +2353,97 @@ search string to change or the window to scroll)." isearch-lazy-highlight-wrapped nil) (unless (equal isearch-string "") (setq isearch-lazy-highlight-timer - (run-with-idle-timer isearch-lazy-highlight-initial-delay nil + (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. Attempt to do the search exactly the way the pending isearch would." - (let ((case-fold-search isearch-case-fold-search)) - (funcall (isearch-search-fun) - isearch-string - (if isearch-forward - (if isearch-lazy-highlight-wrapped - isearch-lazy-highlight-start - (window-end)) - (if isearch-lazy-highlight-wrapped - isearch-lazy-highlight-end - (window-start))) - t))) + (let ((case-fold-search isearch-lazy-highlight-case-fold-search) + (isearch-regexp isearch-lazy-highlight-regexp) + (search-spaces-regexp search-whitespace-regexp)) + (condition-case nil + (funcall (isearch-search-fun) + isearch-lazy-highlight-last-string + (if isearch-forward + (min (or isearch-lazy-highlight-end-limit (point-max)) + (if isearch-lazy-highlight-wrapped + isearch-lazy-highlight-start + (window-end))) + (max (or isearch-lazy-highlight-start-limit (point-min)) + (if isearch-lazy-highlight-wrapped + isearch-lazy-highlight-end + (window-start)))) + t) + (error nil)))) (defun isearch-lazy-highlight-update () "Update highlighting of other matches for current search." - (let ((max isearch-lazy-highlight-max-at-a-time) + (let ((max lazy-highlight-max-at-a-time) (looping t) nomore) - (save-excursion - (save-match-data - (goto-char (if isearch-forward - isearch-lazy-highlight-end - isearch-lazy-highlight-start)) - (while looping - (let ((found (isearch-lazy-highlight-search))) - (when max - (setq max (1- max)) - (if (<= max 0) - (setq looping nil))) - (if found - (let ((mb (match-beginning 0)) - (me (match-end 0))) - (if (= mb me) ;zero-length match + (with-local-quit + (save-selected-window + (if (and (window-live-p isearch-lazy-highlight-window) + (not (eq (selected-window) isearch-lazy-highlight-window))) + (select-window isearch-lazy-highlight-window)) + (save-excursion + (save-match-data + (goto-char (if isearch-forward + isearch-lazy-highlight-end + isearch-lazy-highlight-start)) + (while looping + (let ((found (isearch-lazy-highlight-search))) + (when max + (setq max (1- max)) + (if (<= max 0) + (setq looping nil))) + (if found + (let ((mb (match-beginning 0)) + (me (match-end 0))) + (if (= mb me) ;zero-length match + (if isearch-forward + (if (= mb (if isearch-lazy-highlight-wrapped + isearch-lazy-highlight-start + (window-end))) + (setq found nil) + (forward-char 1)) + (if (= mb (if isearch-lazy-highlight-wrapped + isearch-lazy-highlight-end + (window-start))) + (setq found nil) + (forward-char -1))) + + ;; non-zero-length match + (let ((ov (make-overlay mb me))) + (push ov isearch-lazy-highlight-overlays) + ;; 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 'window (selected-window)))) + (if isearch-forward + (setq isearch-lazy-highlight-end (point)) + (setq isearch-lazy-highlight-start (point))))) + + ;; not found or zero-length match at the search bound + (if (not found) + (if isearch-lazy-highlight-wrapped + (setq looping nil + nomore t) + (setq isearch-lazy-highlight-wrapped t) (if isearch-forward - (if (= mb (if isearch-lazy-highlight-wrapped - isearch-lazy-highlight-start - (window-end))) - (setq found nil) - (forward-char 1)) - (if (= mb (if isearch-lazy-highlight-wrapped - isearch-lazy-highlight-end - (window-start))) - (setq found nil) - (forward-char -1))) - - ;; non-zero-length match - (let ((ov (make-overlay mb me))) - (overlay-put ov 'face isearch-lazy-highlight-face) - (overlay-put ov 'priority 0) ;lower than main overlay - (overlay-put ov 'window (selected-window)) - (push ov isearch-lazy-highlight-overlays))) - (if isearch-forward - (setq isearch-lazy-highlight-end (point)) - (setq isearch-lazy-highlight-start (point))))) - - ;; not found or zero-length match at the search bound - (if (not found) - (if isearch-lazy-highlight-wrapped - (setq looping nil - nomore t) - (setq isearch-lazy-highlight-wrapped t) - (if isearch-forward - (progn - (setq isearch-lazy-highlight-end (window-start)) - (goto-char (window-start))) - (setq isearch-lazy-highlight-start (window-end)) - (goto-char (window-end))))))) - (unless nomore - (setq isearch-lazy-highlight-timer - (run-at-time isearch-lazy-highlight-interval nil - 'isearch-lazy-highlight-update))))))) + (progn + (setq isearch-lazy-highlight-end (window-start)) + (goto-char (max (or isearch-lazy-highlight-start-limit (point-min)) + (window-start)))) + (setq isearch-lazy-highlight-start (window-end)) + (goto-char (min (or isearch-lazy-highlight-end-limit (point-max)) + (window-end)))))))) + (unless nomore + (setq isearch-lazy-highlight-timer + (run-at-time lazy-highlight-interval nil + 'isearch-lazy-highlight-update))))))))) (defun isearch-resume (search regexp word forward message case-fold) "Resume an incremental search.