;;; isearch.el --- incremental search minor mode
-;; Copyright (C) 1992, 93, 94, 95, 96, 97, 1999, 2000, 01, 2003
-;; 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 <liberte@cs.uiuc.edu>
;; Maintainer: FSF
;; 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:
;; keep the behavior. No point in forcing nonincremental search until
;; the last possible moment.
-;; TODO
-;; - Integrate the emacs 19 generalized command history.
-;; - Think about incorporating query-replace.
-;; - Hooks and options for failed search.
-
-;;; Change Log:
-
-;; Changes before those recorded in ChangeLog:
-
-;; Revision 1.4 92/09/14 16:26:02 liberte
-;; Added prefix args to isearch-forward, etc. to switch between
-;; string and regular expression searching.
-;; Added some support for lemacs.
-;; Added general isearch-highlight option - but only for lemacs so far.
-;; Added support for frame switching in emacs 19.
-;; Added word search option to isearch-edit-string.
-;; Renamed isearch-quit to isearch-abort.
-;; Numerous changes to comments and doc strings.
-;;
-;; Revision 1.3 92/06/29 13:10:08 liberte
-;; Moved modal isearch-mode handling into isearch-mode.
-;; Got rid of buffer-local isearch variables.
-;; isearch-edit-string used by ring adjustments, completion, and
-;; nonincremental searching. C-s and C-r are additional exit commands.
-;; Renamed all regex to regexp.
-;; Got rid of found-start and found-point globals.
-;; Generalized handling of upper-case chars.
-
-;; Revision 1.2 92/05/27 11:33:57 liberte
-;; Emacs version 19 has a search ring, which is supported here.
-;; Other fixes found in the version 19 isearch are included here.
-;;
-;; Also see variables search-caps-disable-folding,
-;; search-nonincremental-instead, search-whitespace-regexp, and
-;; commands isearch-toggle-regexp, isearch-edit-string.
-;;
-;; semi-modal isearching is supported.
-
-;; Changes for 1.1
-;; 3/18/92 Fixed invalid-regexp.
-;; 3/18/92 Fixed yanking in regexps.
-
;;; Code:
\f
: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.
+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 `]+'."
- :type 'regexp
- :group 'isearch)
+a tab, a carriage return (control-M), a newline, and `]+'.
-(defcustom search-highlight t
- "*Non-nil means incremental search highlights the current match."
- :type 'boolean
+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'.)
:type 'boolean
:group 'isearch)
-(defcustom isearch-resume-enabled t
- "*If non-nil, `isearch-resume' commands are added to the command history."
+(defcustom isearch-resume-in-command-history nil
+ "*If non-nil, `isearch-resume' commands are added to the command history.
+This allows you to resume earlier isearch sessions through the
+command history."
:type 'boolean
:group 'isearch)
"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.
+If nil, move point to the beginning of the buffer for a forward search,
+or to the end of the buffer for a backward search.")
+
+(defvar isearch-push-state-function nil
+ "Function to save a function restoring the mode-specific isearch state
+to the search status stack.")
;; Search ring.
(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.
: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")
+\f
;; Define isearch-mode keymap.
(defvar isearch-mode-map
;; 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)))
(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 "\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 "\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)
;; 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 [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)
(define-key map "\M-r" 'isearch-toggle-regexp)
(define-key map "\M-e" 'isearch-edit-string)
+ (define-key map [?\M-%] 'isearch-query-replace)
+ (define-key map [?\C-\M-%] 'isearch-query-replace-regexp)
+
map)
"Keymap for `isearch-mode'.")
(defvar minibuffer-local-isearch-map
(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 "\M-p" 'isearch-ring-retreat-edit)
+ (define-key map "\r" 'isearch-nonincremental-exit-minibuffer)
(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)
+ (define-key map "\C-s" 'isearch-forward-exit-minibuffer)
+ (define-key map "\C-r" 'isearch-reverse-exit-minibuffer)
+ (define-key map "\C-f" 'isearch-yank-char-in-minibuffer)
+ (define-key map [right] 'isearch-yank-char-in-minibuffer)
map)
"Keymap for editing isearch strings in the minibuffer.")
(defvar isearch-cmds nil
"Stack of search status sets.
-Each set is a list of the form:
- (STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD
- INVALID-REGEXP WRAPPED BARRIER WITHIN-BRACKETS CASE-FOLD-SEARCH)")
+Each set is a vector of the form:
+ [STRING MESSAGE POINT SUCCESS FORWARD OTHER-END WORD
+ INVALID-REGEXP WRAPPED BARRIER WITHIN-BRACKETS CASE-FOLD-SEARCH]")
(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)
As you type characters, they add to the search string and are found.
The following non-printing keys are bound in `isearch-mode-map'.
-Type \\[isearch-delete-char] to cancel characters from end of search string.
+Type \\[isearch-delete-char] to cancel last input item from end of search string.
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\
+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.
Type \\[isearch-yank-line] to yank rest of line onto end of search string\
and 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.
you want to use.
The above keys, bound in `isearch-mode-map', are often controlled by
- options; do M-x apropos on search-.* to find them.
+ options; do \\[apropos] on search-.* to find them.
Other control and meta characters terminate the search
and are then executed normally (depending on `search-exit-option').
Likewise for function keys and mouse button events.
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)))
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
(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)
- (if isearch-resume-enabled
+ "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
,isearch-message
(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
(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
;; 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.
;; (isearch-clean-overlays)
;; (handle-switch-frame (car (cdr last-command-char))))
+\f
+;; The search status structure and stack.
+
+(defsubst isearch-string-state (frame)
+ "Return the search string in FRAME."
+ (aref frame 0))
+(defsubst isearch-message-state (frame)
+ "Return the search string to display to the user in FRAME."
+ (aref frame 1))
+(defsubst isearch-point-state (frame)
+ "Return the point in FRAME."
+ (aref frame 2))
+(defsubst isearch-success-state (frame)
+ "Return the success flag in FRAME."
+ (aref frame 3))
+(defsubst isearch-forward-state (frame)
+ "Return the searching-forward flag in FRAME."
+ (aref frame 4))
+(defsubst isearch-other-end-state (frame)
+ "Return the other end of the match in FRAME."
+ (aref frame 5))
+(defsubst isearch-word-state (frame)
+ "Return the search-by-word flag in FRAME."
+ (aref frame 6))
+(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)
+ "Return the search-wrapped flag in FRAME."
+ (aref frame 8))
+(defsubst isearch-barrier-state (frame)
+ "Return the barrier value in FRAME."
+ (aref frame 9))
+(defsubst isearch-case-fold-search-state (frame)
+ "Return the case-folding flag in FRAME."
+ (aref frame 10))
+(defsubst isearch-pop-fun-state (frame)
+ "Return the function restoring the mode-specific isearch state in FRAME."
+ (aref frame 11))
+
+(defun isearch-top-state ()
+ (let ((cmd (car isearch-cmds)))
+ (setq isearch-string (isearch-string-state cmd)
+ isearch-message (isearch-message-state cmd)
+ isearch-success (isearch-success-state cmd)
+ isearch-forward (isearch-forward-state cmd)
+ isearch-other-end (isearch-other-end-state cmd)
+ isearch-word (isearch-word-state cmd)
+ isearch-error (isearch-error-state cmd)
+ isearch-wrapped (isearch-wrapped-state cmd)
+ isearch-barrier (isearch-barrier-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))
+ (goto-char (isearch-point-state cmd))))
+
+(defun isearch-pop-state ()
+ (setq isearch-cmds (cdr isearch-cmds))
+ (isearch-top-state))
+
+(defun isearch-push-state ()
+ (setq isearch-cmds
+ (cons (vector isearch-string isearch-message (point)
+ isearch-success isearch-forward isearch-other-end
+ isearch-word
+ isearch-error isearch-wrapped isearch-barrier
+ isearch-case-fold-search
+ (if isearch-push-state-function
+ (funcall isearch-push-state-function)))
+ isearch-cmds)))
+
\f
;; Commands active while inside of the isearch minor mode.
\\[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)
;; 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))
(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 "")))
(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
(defun isearch-cancel ()
"Terminate the search and go back to the starting point."
(interactive)
+ (if (functionp (isearch-pop-fun-state (car (last isearch-cmds))))
+ (funcall (isearch-pop-fun-state (car (last isearch-cmds)))
+ (car (last isearch-cmds))))
(goto-char isearch-opoint)
- (isearch-done t)
+ (isearch-done t) ; exit isearch
(isearch-clean-overlays)
- (signal 'quit nil)) ; and pass on quit signal
+ (signal 'quit nil)) ; and pass on quit signal
(defun isearch-abort ()
"Abort incremental search mode if searching is successful, signaling quit.
(if isearch-success
;; If search is successful, move back to starting point
;; and really do quit.
- (progn (goto-char isearch-opoint)
- (setq isearch-success nil)
- (isearch-done t) ; exit isearch
- (isearch-clean-overlays)
- (signal 'quit nil)) ; and pass on quit signal
+ (progn
+ (setq isearch-success nil)
+ (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)))
;; 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
- (goto-char (if isearch-forward (point-min) (point-max)))
- (setq isearch-wrapped t))))
+ ;; 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)))))))
;; 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.
(if (equal isearch-string "")
(setq isearch-success t)
- (if (and isearch-success (equal (match-end 0) (match-beginning 0))
+ (if (and isearch-success
+ (equal (point) isearch-other-end)
(not isearch-just-started))
;; If repeating a search that found
;; an empty string, ensure we advance.
(interactive)
(setq isearch-regexp (not isearch-regexp))
(if isearch-regexp (setq isearch-word nil))
+ (setq isearch-success t isearch-adjusted t)
(isearch-update))
(defun isearch-toggle-case-fold ()
(isearch-message-prefix nil nil isearch-nonincremental)
isearch-message
(if isearch-case-fold-search "in" "")))
- (setq isearch-adjusted t)
+ (setq isearch-success t isearch-adjusted t)
(sit-for 1)
(isearch-update))
+(defun isearch-query-replace (&optional regexp-flag)
+ "Start query-replace with string to replace from last search string."
+ (interactive)
+ (barf-if-buffer-read-only)
+ (if regexp-flag (setq isearch-regexp t))
+ (let ((case-fold-search isearch-case-fold-search))
+ (isearch-done)
+ (isearch-clean-overlays)
+ (if (and isearch-other-end
+ (< isearch-other-end (point))
+ (not (and transient-mark-mode mark-active
+ (< (mark) (point)))))
+ (goto-char isearch-other-end))
+ (set query-replace-from-history-variable
+ (cons isearch-string
+ (symbol-value query-replace-from-history-variable)))
+ (perform-replace
+ isearch-string
+ (query-replace-read-to
+ isearch-string
+ (if isearch-regexp "Query replace regexp" "Query replace")
+ isearch-regexp)
+ t isearch-regexp isearch-word nil nil
+ (if (and transient-mark-mode mark-active) (region-beginning))
+ (if (and transient-mark-mode mark-active) (region-end)))))
+
+(defun isearch-query-replace-regexp ()
+ "Start query-replace-regexp with string to replace from last search string."
+ (interactive)
+ (isearch-query-replace t))
+
+\f
(defun isearch-delete-char ()
"Discard last input item and move point back.
If no previous match was done, just beep."
(isearch-pop-state))
(isearch-update))
+(defun isearch-del-char (&optional arg)
+ "Delete character from end of search string and search again.
+If search string is empty, just beep."
+ (interactive "p")
+ (if (= 0 (length isearch-string))
+ (ding)
+ (setq isearch-string (substring isearch-string 0 (- (or arg 1)))
+ isearch-message (mapconcat 'isearch-text-char-description
+ isearch-string "")
+ ;; Don't move cursor in reverse search.
+ isearch-yank-flag t))
+ (isearch-search-and-update))
(defun isearch-yank-string (string)
"Pull STRING into search string."
(goto-char isearch-other-end))
(buffer-substring-no-properties (point) (funcall jumpform)))))
-(defun isearch-yank-char ()
- "Pull next letter from buffer into search string."
- (interactive)
- (isearch-yank-internal (lambda () (forward-char 1) (point))))
+(defun isearch-yank-char-in-minibuffer (&optional arg)
+ "Pull next character from buffer into end of search string in minibuffer."
+ (interactive "p")
+ (if (eobp)
+ (insert
+ (save-excursion
+ (set-buffer (cadr (buffer-list)))
+ (buffer-substring-no-properties
+ (point) (progn (forward-char arg) (point)))))
+ (forward-char arg)))
+
+(defun isearch-yank-char (&optional arg)
+ "Pull next character from buffer into search string."
+ (interactive "p")
+ (isearch-yank-internal (lambda () (forward-char arg) (point))))
(defun isearch-yank-word-or-char ()
"Pull next character or word from buffer into search string."
(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.
(when (or isearch-success
- ;; unsuccessful regexp search may become
- ;; successful by addition of characters which
- ;; make isearch-string valid
+ ;; Unsuccessful regexp search may become successful by
+ ;; addition of characters which make isearch-string valid
isearch-regexp
;; If the string was found but was completely invisible,
;; it might now be partly visible, so try again.
(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
(isearch-update))
-;; *, ?, and | chars can make a regexp more liberal.
+;; *, ?, }, and | chars can make a regexp more liberal.
;; They can make a regexp match sooner or make it succeed instead of failing.
;; So go back to place last successful search started
;; or to the last ^S/^R (barrier), whichever is nearer.
;; + needs no special handling because the string must match at least once.
-(defun isearch-*-char ()
- "Handle * and ? specially in regexps."
- (interactive)
- (if isearch-regexp
- (let ((idx (length isearch-string)))
- (while (and (> idx 0)
- (eq (aref isearch-string (1- idx)) ?\\))
- (setq idx (1- idx)))
- (when (= (mod (- (length isearch-string) idx) 2) 0)
- (setq isearch-adjusted t)
- ;; Get the isearch-other-end from before the last search.
- ;; We want to start from there,
- ;; so that we don't retreat farther than that.
- ;; (car isearch-cmds) is after last search;
- ;; (car (cdr isearch-cmds)) is from before it.
- (let ((cs (nth 5 (car (cdr isearch-cmds)))))
- (setq cs (or cs isearch-barrier))
- (goto-char
- (if isearch-forward
- (max cs isearch-barrier)
- (min cs isearch-barrier)))))))
- (isearch-process-search-char last-command-char))
-
-
-(defun isearch-|-char ()
- "If in regexp search, jump to the barrier."
- (interactive)
- (if isearch-regexp
- (progn
- (setq isearch-adjusted t)
- (goto-char isearch-barrier)))
- (isearch-process-search-char last-command-char))
+(defun isearch-backslash (str)
+ "Return t if STR ends in an odd number of backslashes."
+ (= (mod (- (length str) (string-match "\\\\*\\'" str)) 2) 1))
+
+(defun isearch-fallback (want-backslash &optional allow-invalid to-barrier)
+ "Return point to previous successful match to allow regexp liberalization.
+\\<isearch-mode-map>
+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 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."
+ ;; (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-error)
+ (not (isearch-error-state (cadr isearch-cmds)))
+ allow-invalid))
+ (if to-barrier
+ (progn (goto-char isearch-barrier)
+ (setq isearch-adjusted t))
+ (let* ((stack isearch-cmds)
+ (previous (cdr stack)) ; lookbelow in the stack
+ (frame (car stack)))
+ ;; Walk down the stack looking for a valid regexp (as of course only
+ ;; they can be the previous successful match); this conveniently
+ ;; removes all bracket-sets and groups that might be in the way, as
+ ;; well as partial \{\} constructs that the code below leaves behind.
+ ;; Also skip over postfix operators -- though horrid,
+ ;; 'ab?\{5,6\}+\{1,2\}*' is perfectly legal.
+ (while (and previous
+ (or (isearch-error-state frame)
+ (let* ((string (isearch-string-state frame))
+ (lchar (aref string (1- (length string)))))
+ ;; The operators aren't always operators; check
+ ;; backslashes. This doesn't handle the case of
+ ;; operators at the beginning of the regexp not
+ ;; being special, but then we should fall back to
+ ;; the barrier anyway because it's all optional.
+ (if (isearch-backslash
+ (isearch-string-state (car previous)))
+ (eq lchar ?\})
+ (memq lchar '(?* ?? ?+))))))
+ (setq stack previous previous (cdr previous) frame (car stack)))
+ (when stack
+ ;; `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 (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)))))))
(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
;; 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)))
(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))
(command-execute scroll-command)
(let ((ab-bel (isearch-string-out-of-window isearch-point)))
(if ab-bel
- (isearch-back-into-window (eq ab-bel 'above) isearch-point)))
+ (isearch-back-into-window (eq ab-bel 'above) isearch-point)
+ (goto-char isearch-point)))
(isearch-update))
(search-exit-option
(let (window)
;; 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))
(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-mode-map>\\[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)
(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.
(delete-field)
(insert isearch-string))))
-\f
-;; The search status stack (and isearch window-local variables, not used).
-;; Need a structure for this.
-
-(defun isearch-top-state ()
- (let ((cmd (car isearch-cmds)))
- (setq isearch-string (car cmd)
- isearch-message (car (cdr cmd))
- isearch-success (nth 3 cmd)
- isearch-forward (nth 4 cmd)
- isearch-other-end (nth 5 cmd)
- isearch-word (nth 6 cmd)
- isearch-invalid-regexp (nth 7 cmd)
- isearch-wrapped (nth 8 cmd)
- isearch-barrier (nth 9 cmd)
- isearch-within-brackets (nth 10 cmd)
- isearch-case-fold-search (nth 11 cmd))
- (goto-char (car (cdr (cdr cmd))))))
-
-(defun isearch-pop-state ()
- (setq isearch-cmds (cdr isearch-cmds))
- (isearch-top-state))
-
-(defun isearch-push-state ()
- (setq isearch-cmds
- (cons (list 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-cmds)))
-
\f
;; Message string
(let ((cursor-in-echo-area ellipsis)
(m (concat
(isearch-message-prefix c-q-hack ellipsis isearch-nonincremental)
- isearch-message
+ (if (and (not isearch-success)
+ (string-match " +$" isearch-message))
+ (concat
+ (substring isearch-message 0 (match-beginning 0))
+ (propertize (substring isearch-message (match-beginning 0))
+ 'face 'trailing-whitespace))
+ isearch-message)
(isearch-message-suffix c-q-hack ellipsis)
)))
(if c-q-hack
;; 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))
(let ((m (concat (if isearch-success "" "failing ")
+ (if isearch-adjusted "pending " "")
(if (and isearch-wrapped
+ (not isearch-wrap-function)
(if isearch-forward
(> (point) isearch-opoint)
(< (point) isearch-opoint)))
(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
;; Searching
-(defvar isearch-search-fun-function nil "Override `isearch-function-fun'.")
+(defvar isearch-search-fun-function nil
+ "Override `isearch-search-fun'.
+This function should return the search function for isearch to use.
+It will call this function with three arguments
+as if it were `search-forward'.")
(defun isearch-search-fun ()
"Return the function to use for the search.
(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
(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
;; Ding if failed this time after succeeding last time.
- (and (nth 3 (car isearch-cmds))
+ (and (isearch-success-state (car isearch-cmds))
(ding))
- (goto-char (nth 2 (car isearch-cmds)))))
+ (if (functionp (isearch-pop-fun-state (car isearch-cmds)))
+ (funcall (isearch-pop-fun-state (car isearch-cmds)) (car isearch-cmds)))
+ (goto-char (isearch-point-state (car isearch-cmds)))))
;; Called when opening an overlay, and we are still in isearch.
(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 (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 `\\\\')
(defun isearch-text-char-description (c)
(cond
- ((< c ?\ ) (format "^%c" (+ c 64)))
+ ((< c ?\s) (format "^%c" (+ c 64)))
((= c ?\^?) "^?")
(t (char-to-string c))))
(append char-or-events unread-command-events)))
\f
+;; 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)))
+\f
;; isearch-lazy-highlight feature
;; by Bob Glickstein <http://www.zanshin.com/~bobg/>
;; 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
;; `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
- '((((type tty pc) (class color))
- (:background "magenta4" :foreground "cyan1"))
- (((class color) (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) (background dark))
- (:background "palevioletred2" :foreground "brown4"))
- (t (:inverse-video t)))
- "Face for highlighting Isearch matches."
- :group 'isearch-faces)
-(defvar isearch 'isearch)
-
-(defface isearch-lazy-highlight-face
- '((((type tty pc) (class color))
- (:background "turquoise3"))
- (((class color) (background light))
- (:background "paleturquoise"))
- (((class color) (background dark))
- (:background "paleturquoise4"))
- (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)
(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
(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))
(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)
isearch-lazy-highlight-case-fold-search isearch-case-fold-search
isearch-lazy-highlight-regexp isearch-regexp
isearch-lazy-highlight-wrapped nil)
- (setq isearch-lazy-highlight-timer
- (run-with-idle-timer isearch-lazy-highlight-initial-delay nil
- 'isearch-lazy-highlight-update)))))
+ (unless (equal isearch-string "")
+ (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.
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
- (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
- (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)))))))
+ (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
+ (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.
isearch-case-fold-search case-fold)
(isearch-search))
-;;; arch-tag: 74850515-f7d8-43a6-8a2c-ca90a4c1e675
+;; arch-tag: 74850515-f7d8-43a6-8a2c-ca90a4c1e675
;;; isearch.el ends here