;; 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:
:type 'regexp
:group 'isearch)
-(defcustom search-highlight t
- "*Non-nil means incremental search highlights the current match."
- :type 'boolean
- :group 'isearch)
-
(defcustom search-invisible 'open
"If t incremental search can match hidden text.
nil means don't match invisible text.
:type 'boolean
:group '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)
-
(defvar isearch-mode-hook nil
"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.
: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 "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)
+(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 'replace)
+ :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
-\\[isearch-lazy-highlight-cleanup]."
+\\[lazy-highlight-cleanup]."
:type 'boolean
:group 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-cleanup 'lazy-highlight-cleanup)
+(make-obsolete-variable '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)
+(defvaralias 'isearch-lazy-highlight-initial-delay 'lazy-highlight-initial-delay)
+(make-obsolete-variable '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)
+(defvaralias 'isearch-lazy-highlight-interval 'lazy-highlight-interval)
+(make-obsolete-variable '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').
:type '(choice (const :tag "All" nil)
(integer :tag "Some"))
:group 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-max-at-a-time 'lazy-highlight-max-at-a-time)
+(make-obsolete-variable '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 "turquoise3"))
(t (:underline t)))
"Face for lazy highlighting of matches other than the current one."
- :group 'isearch-faces
:group 'lazy-highlight)
+(put 'isearch-lazy-highlight-face 'face-alias 'lazy-highlight)
+(defvar lazy-highlight-face 'lazy-highlight)
+(defvaralias 'isearch-lazy-highlight-face 'lazy-highlight-face)
+(make-obsolete-variable 'isearch-lazy-highlight-face 'lazy-highlight-face "22.1")
\f
;; Define isearch-mode keymap.
(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)
(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)
(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)
\\[isearch-abort] when search is successful aborts and moves point to\
starting point.
+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.
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
(setq ;; quit-flag nil not for isearch-mode
isearch-adjusted nil
isearch-yank-flag nil)
- (if isearch-lazy-highlight (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
;; (setq pre-command-hook isearch-old-pre-command-hook) ; for lemacs
(setq minibuffer-message-timeout isearch-original-minibuffer-message-timeout)
(isearch-dehighlight)
- (isearch-lazy-highlight-cleanup lazy-highlight-cleanup)
+ (lazy-highlight-cleanup lazy-highlight-cleanup)
(let ((found-start (window-start (selected-window)))
(found-point (point)))
(if isearch-window-configuration
;; 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.
(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)
(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)))
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))
(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)))
\\[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.
\\<isearch-mode-map>
If first char entered is \\[isearch-yank-word-or-char], then do word search instead."
(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)
(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 nil t))
+ (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 "")))
(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)))
;; 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)))
(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
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)
;; 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
;; `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.
(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
(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."
(isearch-process-search-char 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.
(isearch-process-search-string
(char-to-string char)
(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.
;; 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))
(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 "]")
"")))
\f
(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
(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
(setq isearch-hidden t)))))))
\f
-;; 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 ()
- (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 `\\\\')
(append char-or-events unread-command-events)))
\f
+;; 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 ()
+ (when isearch-overlay
+ (delete-overlay isearch-overlay)))
+\f
;; isearch-lazy-highlight feature
;; by Bob Glickstein <http://www.zanshin.com/~bobg/>
;; `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-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)
-
-(defvar isearch-lazy-highlight-face 'lazy-highlight)
-
(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)
(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 `lazy-highlight-cleanup'
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 ()
+(defalias 'isearch-lazy-highlight-cleanup 'lazy-highlight-cleanup)
+(make-obsolete '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.
-This happens when `isearch-update' is invoked (which can cause the
-search string to change or the window to scroll)."
+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
(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)
(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)
+ (let ((case-fold-search isearch-lazy-highlight-case-fold-search)
+ (isearch-regexp isearch-lazy-highlight-regexp)
(search-spaces-regexp search-whitespace-regexp))
- (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)))
+ (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."
;; non-zero-length match
(let ((ov (make-overlay mb me)))
(push ov isearch-lazy-highlight-overlays)
- (overlay-put ov 'face isearch-lazy-highlight-face)
+ (overlay-put ov 'face lazy-highlight-face)
(overlay-put ov 'priority 0) ;lower than main overlay
(overlay-put ov 'window (selected-window))))
(if isearch-forward
(if isearch-forward
(progn
(setq isearch-lazy-highlight-end (window-start))
- (goto-char (window-start)))
+ (goto-char (max (or isearch-lazy-highlight-start-limit (point-min))
+ (window-start))))
(setq isearch-lazy-highlight-start (window-end))
- (goto-char (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 isearch-lazy-highlight-interval nil
+ (run-at-time lazy-highlight-interval nil
'isearch-lazy-highlight-update)))))))))
(defun isearch-resume (search regexp word forward message case-fold)