;;; 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, 2003, 2004 Free Software Foundation, Inc.
;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
;; Maintainer: FSF
;; 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.
-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 `]+'."
+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)
: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)
(defvar isearch-mode-end-hook nil
"Function(s) to call after terminating an incremental 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 nil
(defvar isearch-mode-map
(let* ((i 0)
(map (make-keymap)))
- (or (vectorp (nth 1 map))
- (char-table-p (nth 1 map))
+ (or (char-table-p (nth 1 map))
(error "The initialization of isearch-mode-map must be updated"))
;; Make all multibyte characters search for themselves.
- (let ((l (generic-character-list))
- (table (nth 1 map)))
- (while l
- (set-char-table-default table (car l) 'isearch-printing-char)
- (setq l (cdr l))))
- ;; Make function keys, etc, exit the search.
+ (set-char-table-range (nth 1 map) (cons #x100 (max-char))
+ 'isearch-printing-char)
+ ;; Make function keys, etc, which aren't bound to a scrolling-function
+ ;; exit the search.
(define-key map [t] 'isearch-other-control-char)
;; Control chars, by default, end isearch mode transparently.
;; We need these explicit definitions because, in a dense keymap,
(define-key map " " 'isearch-whitespace-chars)
(define-key map [?\S-\ ] 'isearch-whitespace-chars)
- (define-key map "\C-w" 'isearch-yank-word-or-char)
- (define-key map "\C-y" 'isearch-yank-line)
+ (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 * ? |.
+ ;; 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.
(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-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)
+ (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
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\
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.
Type \\[isearch-yank-kill] to yank last killed text onto end of search string\
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.
(setq disable-point-adjustment t))
(defun isearch-done (&optional nopush edit)
- (if isearch-resume-enabled
+ (if isearch-resume-in-command-history
(let ((command `(isearch-resume ,isearch-string ,isearch-regexp
,isearch-word ,isearch-forward
,isearch-message
;; (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-invalid-regexp-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-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))
+(defsubst isearch-pop-fun-state (frame)
+ "Return the function restoring the mode-specific isearch state in FRAME."
+ (aref frame 12))
+
+(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-invalid-regexp (isearch-invalid-regexp-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))
+ (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-invalid-regexp isearch-wrapped isearch-barrier
+ isearch-within-brackets 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.
(defun isearch-exit ()
(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)
;; If already have what to search for, repeat it.
(or isearch-success
(progn
- (goto-char (if isearch-forward (point-min) (point-max)))
+ (if isearch-wrap-function
+ (funcall isearch-wrap-function)
+ (goto-char (if isearch-forward (point-min) (point-max))))
(setq isearch-wrapped t))))
;; C-s in reverse or C-r in forward, change direction.
(setq isearch-forward (not isearch-forward)))
(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 (point))
+ (not (and transient-mark-mode mark-active
+ (< isearch-opoint (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-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.
(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-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-invalid-regexp)
+ (not (isearch-invalid-regexp-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-invalid-regexp-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 (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 ()
- "Handle * and ? specially in regexps."
+ "Maybe back up to 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))
+ (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."
+ "If in regexp search, jump to the barrier unless in a group."
(interactive)
- (if isearch-regexp
- (progn
- (setq isearch-adjusted t)
- (goto-char isearch-barrier)))
- (isearch-process-search-char last-command-char))
+ (isearch-fallback t nil t))
+
+(defun isearch-unread-key-sequence (keylist)
+ "Unread the given key-sequence KEYLIST.
+Scroll-bar or mode-line events are processed appropriately."
+ (cancel-kbd-macro-events)
+ (apply 'isearch-unread keylist)
+ ;; If the event was a scroll-bar or mode-line click, the event will have
+ ;; been prefixed by a symbol such as vertical-scroll-bar. We must remove
+ ;; it here, because this symbol will be attached to the event again next
+ ;; time it gets read by read-key-sequence.
+ ;;
+ ;; (Old comment from isearch-other-meta-char: "Note that we don't have to
+ ;; modify the event anymore in 21 because read_key_sequence no longer
+ ;; modifies events to produce fake prefix keys.")
+ (if (and (> (length keylist) 1)
+ (symbolp (car keylist))
+ (listp (cadr keylist))
+ (not (numberp (posn-point
+ (event-start (cadr keylist) )))))
+ (pop unread-command-events)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; scrolling within Isearch mode. Alan Mackenzie (acm@muc.de), 2003/2/24
+;;
+;; The idea here is that certain vertical scrolling commands (like C-l
+;; `recenter') should be usable WITHIN Isearch mode. For a command to be
+;; suitable, it must NOT alter the buffer, swap to another buffer or frame,
+;; tamper with isearch's state, or move point. It is unacceptable for the
+;; search string to be scrolled out of the current window. If a command
+;; attempts this, we scroll the text back again.
+;;
+;; We implement this feature with a property called `isearch-scroll'.
+;; If a command's symbol has the value t for this property it is a
+;; scrolling command. The feature needs to be enabled by setting the
+;; customizable variable `isearch-allow-scroll' to a non-nil value.
+;;
+;; The universal argument commands (e.g. C-u) in simple.el are marked
+;; as scrolling commands, and isearch.el has been amended to allow
+;; prefix arguments to be passed through to scrolling commands. Thus
+;; M-0 C-l will scroll point to the top of the window.
+;;
+;; Horizontal scrolling commands are currently not catered for.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Set the isearch-scroll property on some standard functions:
+;; Scroll-bar functions:
+(if (fboundp 'scroll-bar-toolkit-scroll)
+ (put 'scroll-bar-toolkit-scroll 'isearch-scroll t))
+(if (fboundp 'mac-handle-scroll-bar-event)
+ (put 'mac-handle-scroll-bar-event 'isearch-scroll t))
+(if (fboundp 'w32-handle-scroll-bar-event)
+ (put 'w32-handle-scroll-bar-event 'isearch-scroll t))
+
+;; Commands which scroll the window:
+(put 'recenter 'isearch-scroll t)
+(put 'reposition-window 'isearch-scroll t)
+(put 'scroll-up 'isearch-scroll t)
+(put 'scroll-down 'isearch-scroll t)
+
+;; Commands which act on the other window
+(put 'list-buffers 'isearch-scroll t)
+(put 'scroll-other-window 'isearch-scroll t)
+(put 'scroll-other-window-down 'isearch-scroll t)
+(put 'beginning-of-buffer-other-window 'isearch-scroll t)
+(put 'end-of-buffer-other-window 'isearch-scroll t)
+
+;; Commands which change the window layout
+(put 'delete-other-windows 'isearch-scroll t)
+(put 'balance-windows 'isearch-scroll t)
+(put 'split-window-vertically 'isearch-scroll t)
+(put 'enlarge-window 'isearch-scroll t)
+
+;; Universal argument commands
+(put 'universal-argument 'isearch-scroll t)
+(put 'negative-argument 'isearch-scroll t)
+(put 'digit-argument 'isearch-scroll t)
+
+(defcustom isearch-allow-scroll nil
+ "If non-nil, scrolling commands are allowed during incremental search."
+ :type 'boolean
+ :group 'isearch)
+(defun isearch-string-out-of-window (isearch-point)
+ "Test whether the search string is currently outside of the window.
+Return nil if it's completely visible, or if point is visible,
+together with as much of the search string as will fit; the symbol
+`above' if we need to scroll the text downwards; the symbol `below',
+if upwards."
+ (let ((w-start (window-start))
+ (w-end (window-end nil t))
+ (w-L1 (save-excursion (move-to-window-line 1) (point)))
+ (w-L-1 (save-excursion (move-to-window-line -1) (point)))
+ start end) ; start and end of search string in buffer
+ (if isearch-forward
+ (setq end isearch-point start (or isearch-other-end isearch-point))
+ (setq start isearch-point end (or isearch-other-end isearch-point)))
+ (cond ((or (and (>= start w-start) (<= end w-end))
+ (if isearch-forward
+ (and (>= isearch-point w-L-1) (< isearch-point w-end)) ; point on Line -1
+ (and (>= isearch-point w-start) (< isearch-point w-L1)))) ; point on Line 0
+ nil)
+ ((and (< start w-start)
+ (< isearch-point w-L-1))
+ 'above)
+ (t 'below))))
+
+(defun isearch-back-into-window (above isearch-point)
+ "Scroll the window to bring the search string back into view.
+Restore point to ISEARCH-POINT in the process. ABOVE is t when the
+search string is above the top of the window, nil when it is beneath
+the bottom."
+ (let (start end)
+ (if isearch-forward
+ (setq end isearch-point start (or isearch-other-end isearch-point))
+ (setq start isearch-point end (or isearch-other-end isearch-point)))
+ (if above
+ (progn
+ (goto-char start)
+ (recenter 0)
+ (when (>= isearch-point (window-end nil t))
+ (goto-char isearch-point)
+ (recenter -1)))
+ (goto-char end)
+ (recenter -1)
+ (when (< isearch-point (window-start))
+ (goto-char isearch-point)
+ (recenter 0))))
+ (goto-char isearch-point))
+
+(defun isearch-reread-key-sequence-naturally (keylist)
+ "Reread key sequence KEYLIST with Isearch mode's keymap deactivated.
+Return the key sequence as a string/vector."
+ (isearch-unread-key-sequence keylist)
+ (let (overriding-terminal-local-map)
+ (read-key-sequence nil))) ; This will go through function-key-map, if nec.
+
+(defun isearch-lookup-scroll-key (key-seq)
+ "If KEY-SEQ is bound to a scrolling command, return it as a symbol.
+Otherwise return nil."
+ (let* ((overriding-terminal-local-map nil)
+ (binding (key-binding key-seq)))
+ (and binding (symbolp binding) (commandp binding)
+ (eq (get binding 'isearch-scroll) t)
+ binding)))
(defalias 'isearch-other-control-char 'isearch-other-meta-char)
-(defun isearch-other-meta-char ()
- "Exit the search normally and reread this key sequence.
-But only if `search-exit-option' is non-nil, the default.
-If it is the symbol `edit', the search string is edited in the minibuffer
-and the meta character is unread so that it applies to editing the string."
- (interactive)
- (let* ((key (this-command-keys))
+(defun isearch-other-meta-char (&optional arg)
+ "Process a miscellaneous key sequence in Isearch mode.
+
+Try to convert the current key-sequence to something usable in Isearch
+mode, either by converting it with `function-key-map', downcasing a
+key with C-<upper case>, or finding a \"scrolling command\" bound to
+it. \(In the last case, we may have to read more events.) If so,
+either unread the converted sequence or execute the command.
+
+Otherwise, if `search-exit-option' is non-nil (the default) unread the
+key-sequence and exit the search normally. If it is the symbol
+`edit', the search string is edited in the minibuffer and the meta
+character is unread so that it applies to editing the string.
+
+ARG is the prefix argument. It will be transmitted through to the
+scrolling command or to the command whose key-sequence exits
+Isearch mode."
+ (interactive "P")
+ (let* ((key (if current-prefix-arg ; not nec the same as ARG
+ (substring (this-command-keys) universal-argument-num-events)
+ (this-command-keys)))
(main-event (aref key 0))
- (keylist (listify-key-sequence key)))
+ (keylist (listify-key-sequence key))
+ scroll-command isearch-point)
(cond ((and (= (length key) 1)
(let ((lookup (lookup-key function-key-map key)))
(not (or (null lookup) (integerp lookup)
((eq search-exit-option 'edit)
(apply 'isearch-unread keylist)
(isearch-edit-string))
+ ;; Handle a scrolling function.
+ ((and isearch-allow-scroll
+ (progn (setq key (isearch-reread-key-sequence-naturally keylist))
+ (setq keylist (listify-key-sequence key))
+ (setq main-event (aref key 0))
+ (setq scroll-command (isearch-lookup-scroll-key key))))
+ ;; From this point onwards, KEY, KEYLIST and MAIN-EVENT hold a
+ ;; complete key sequence, possibly as modified by function-key-map,
+ ;; not merely the one or two event fragment which invoked
+ ;; isearch-other-meta-char in the first place.
+ (setq isearch-point (point))
+ (setq prefix-arg arg)
+ (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)
+ (goto-char isearch-point)))
+ (isearch-update))
(search-exit-option
(let (window)
- (cancel-kbd-macro-events)
- (apply 'isearch-unread keylist)
-
- ;; Properly handle scroll-bar and mode-line clicks for
- ;; which a dummy prefix event was generated as (aref key
- ;; 0). Note that we don't have to modify the event
- ;; anymore in 21 because read_key_sequence no longer modifies
- ;; events to produce fake prefix keys.
- (when (and (> (length key) 1)
- (symbolp (aref key 0))
- (listp (aref key 1))
- (not (numberp (posn-point
- (event-start (aref key 1))))))
- (pop unread-command-events)
- (setq main-event (car unread-command-events)))
+ (isearch-unread-key-sequence keylist)
+ (setq main-event (car unread-command-events))
;; If we got a mouse click event, that event contains the
;; window clicked on. maybe it was read with the buffer
(isearch-done)
(isearch-clean-overlays))
(isearch-done)
- (isearch-clean-overlays))))
- (t;; otherwise nil
+ (isearch-clean-overlays)
+ (setq prefix-arg arg))))
+ (t;; otherwise nil
(isearch-process-search-string key key)))))
(defun isearch-quote-char ()
(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
(defun isearch-message (&optional c-q-hack ellipsis)
(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 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)))
\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.
(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.
:group 'isearch)
(defface isearch
- '((((type tty pc) (class color))
- (:background "magenta4" :foreground "cyan1"))
- (((class color) (background light))
+ '((((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) (background dark))
+ (((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
- '((((type tty pc) (class color))
- (:background "turquoise3"))
- (((class color) (background light))
+ '((((class color) (min-colors 88) (background light))
(:background "paleturquoise"))
- (((class color) (background dark))
+ (((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-last-string nil)
(defvar isearch-lazy-highlight-window nil)
(defvar isearch-lazy-highlight-window-start nil)
+(defvar isearch-lazy-highlight-window-end nil)
(defvar isearch-lazy-highlight-case-fold-search nil)
(defvar isearch-lazy-highlight-regexp nil)
(not (eq isearch-lazy-highlight-regexp
isearch-regexp))
(not (= (window-start)
- isearch-lazy-highlight-window-start))))
+ isearch-lazy-highlight-window-start))
+ (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)
(setq isearch-lazy-highlight-window (selected-window)
isearch-lazy-highlight-window-start (window-start)
+ isearch-lazy-highlight-window-end (window-end)
isearch-lazy-highlight-start (point)
isearch-lazy-highlight-end (point)
isearch-lazy-highlight-last-string isearch-string
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 isearch-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.
(let ((mb (match-beginning 0))
(me (match-end 0)))
(if (= mb me) ;zero-length match
- (forward-char 1)
+ (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)))
(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)))))))
+ (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-case-fold-search case-fold)
(isearch-search))
+;; arch-tag: 74850515-f7d8-43a6-8a2c-ca90a4c1e675
;;; isearch.el ends here
HCoop / bpt / emacs.git / blobdiff