--- /dev/null
+;; Incremental search minor mode.
+;; Copyright (C) 1992 Free Software Foundation, Inc.
+
+;; LCD Archive Entry:
+;; isearch-mode|Daniel LaLiberte|liberte@cs.uiuc.edu
+;; |A minor mode replacement for isearch.el.
+;; |$Date: 92/05/27 11:33:57 $|$Revision: 1.2 $|~/modes/isearch-mode.el
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY. No author or distributor
+;; accepts responsibility to anyone for the consequences of using it
+;; or for whether it serves any particular purpose or works at all,
+;; unless he says so in writing. Refer to the GNU Emacs General Public
+;; License for full details.
+
+;; Everyone is granted permission to copy, modify and redistribute
+;; GNU Emacs, but only under the conditions described in the
+;; GNU Emacs General Public License. A copy of this license is
+;; supposed to have been given to you along with GNU Emacs so you
+;; can know your rights and responsibilities. It should be in a
+;; file named COPYING. Among other things, the copyright notice
+;; and this notice must be preserved on all copies.
+
+;;;====================================================================
+;;; Change History
+
+;;; $Header: /import/kaplan/kaplan/liberte/Isearch/RCS/isearch-mode.el,v 1.2 92/05/27 11:33:57 liberte Exp Locker: liberte $
+;;; $Log: isearch-mode.el,v $
+;;; Revision 1.2 92/05/27 11:33:57 liberte
+;;; Several new commands and features have been added. 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 searching is supported, using a recursive edit. If
+;;; isearching is started non-interactively by calling one of the
+;;; isearch commands (e.g. isearch-forward), it does not return
+;;; until the search is completed. You should still be able switch
+;;; buffers, so be careful not to get things confused.
+;;;
+
+;;; Changes for 1.1
+;;; 3/18/92 Fixed invalid-regexp.
+;;; 3/18/92 Fixed yanking in regexps.
+
+;;;====================================================================
+;; Instructions
+
+;; Searching with isearch-mode.el should work just like isearch.el,
+;; except it is done in a temporary minor mode that terminates when
+;; you finish searching.
+
+;; To use isearch-mode instead of the standard isearch.el, add the
+;; following to your .emacs file. The standard key bindings to
+;; isearch-forward, etc, will then use isearch-mode instead of
+;; isearch.
+
+;; (fset 'isearch 'isearch-mode)
+;; (autoload 'isearch-mode "isearch-mode")
+
+;; The key bindings active within isearch-mode are defined below in
+;; `isearch-mode-map' and `isearch-mode-meta-map' which are given
+;; bindings close to the default characters of isearch.el for
+;; version 19. With `isearch-mode', however, you can bind
+;; multi-character keys and it should be easier to add new commands.
+
+;; Note to epoch and emacs version 19 users: isearch-mode should
+;; work even if you switch windows with the mouse. However, if
+;; you isearch in a buffer that is also displayed in another window,
+;; when you switch to that other window you will still be in
+;; isearch mode but not necessarily in the right state for it to work.
+;; So ... don't do it unless you are in an experimental mood.
+;; You can also experiment with the window-local-variable routines
+;; contained in this package but not yet used.
+;; Also, I am not sure what happens when you return to an isearching
+;; buffer; ideally, the echo area should redisplay the searching status.
+;; A select-window-hook might be useful.
+
+;;;=========================================================================
+;;; The following, defined in loaddefs.el, are still used with isearch-mode.
+
+;(defvar search-last-string ""
+; "Last string search for by a search command.
+;This does not include direct calls to the primitive search functions,
+;and does not include searches that are aborted.")
+
+;(defvar search-last-regexp ""
+; "Last string searched for by a regexp search command.
+;This does not include direct calls to the primitive search functions,
+;and does not include searches that are aborted.")
+
+;(defconst search-exit-option t
+; "Non-nil means random control characters terminate incremental search.")
+
+;(defvar search-slow-window-lines 1
+; "*Number of lines in slow search display windows.")
+
+;(defconst search-slow-speed 1200
+; "*Highest terminal speed at which to use \"slow\" style incremental search.
+;This is the style where a one-line window is created to show the line
+;that the search has reached.")
+
+;;;========================================================================
+;;; Some additional options and constants.
+
+(defvar search-caps-disable-folding t
+ "*If non-nil, upper case chars disable case fold searching.
+This does not yet apply to yanked strings, however.")
+
+(defvar search-nonincremental-instead t
+ "*If non-nil, do a nonincremental search instead if exiting immediately.
+The default value of t reflects the default behavior of old
+isearch.")
+
+(defconst search-whitespace-regexp "\\s-+"
+ "*If non-nil, regular expression to match a sequence of whitespace chars.
+You might want to use something like \"[ \\t\\r\\n]+\" instead.")
+
+;;;==================================================================
+;;; Search ring.
+;;; "regex" == "regexp". One should become the standard term.
+
+(defvar search-ring nil
+ "List of search string sequences.")
+(defvar regex-search-ring nil ;; Is `regex' the new spelling?
+ "List of regular expression search string sequences.")
+
+(defconst search-ring-max 16
+ "*Maximum length of search ring before oldest elements are thrown away.")
+(defconst regex-search-ring-max 16
+ "*Maximum length of regex search ring before oldest elements are thrown away.")
+
+(defvar search-ring-yank-pointer nil
+ "The tail of the search ring whose car is the last thing searched for.")
+(defvar regex-search-ring-yank-pointer nil
+ "The tail of the regular expression search ring whose car is the last
+thing searched for.")
+
+;;;====================================================
+;;; Define isearch-mode keymap.
+
+(defvar isearch-mode-map nil
+ "Keymap for isearch-mode.")
+
+(defvar isearch-mode-meta-map nil
+ "Keymap for isearch-mode for keys with meta char prefix.")
+
+
+;; To handle meta char prefix keys, define another full keymap.
+;; The same must be done for any other prefix keys.
+;; It would be simpler to disable to global keymap, and/or
+;; have a default local key binding for any key not otherwise bound.
+(if isearch-mode-meta-map
+ nil
+ (setq isearch-mode-meta-map
+ (list 'keymap (make-vector 128 'isearch-other-meta-char)))
+ (define-key isearch-mode-meta-map "n" 'isearch-ring-advance)
+ (define-key isearch-mode-meta-map "p" 'isearch-ring-retreat)
+ (define-key isearch-mode-meta-map " " 'isearch-whitespace-chars)
+;for regexps
+
+;; (define-key isearch-mode-meta-map "?" nil) ; my help key is M-?
+ )
+
+(if isearch-mode-map
+ nil
+ (let ((i 0)
+
+ ;; Printing chars extend the selection by default.
+ (array (make-vector 128 'isearch-printing-char)))
+
+ ;; Non-printing chars by default suspend isearch mode transparently
+ (while (< i ?\ )
+ (aset array i 'isearch-other-control-char)
+ (setq i (1+ i)))
+
+ (setq i ?A)
+ (while (<= i ?Z)
+ (aset array i 'isearch-upper-case-char)
+ (setq i (1+ i)))
+
+ (setq isearch-mode-map (list 'keymap array))
+
+ ;; You can reenable global keys by unbinding them locally.
+
+ ;; For the help char this doesnt work quite as expected because
+ ;; isearch-mode is not a major mode, and the echo area is not
+ ;; restored after the help command.
+ ;; Also, we should not assume that the help-command is on C-h.
+ ;; If it is not, and the prefix is not the meta-char, we would
+ ;; have to create another map for its prefix.
+; (define-key isearch-mode-map "\C-h" nil)
+
+ ;; Several non-printing chars change the searching behavior.
+ (define-key isearch-mode-map "\C-s" 'isearch-repeat-forward)
+ (define-key isearch-mode-map "\C-r" 'isearch-repeat-backward)
+ (define-key isearch-mode-map "\177" 'isearch-delete-char)
+ (define-key isearch-mode-map "\C-g" 'isearch-quit)
+
+
+ (define-key isearch-mode-map "\C-q" 'isearch-quote-char)
+
+ ;; (define-key isearch-mode-map "\r" 'isearch-return-char)
+ ;; For version 19, CR (C-m) terminates search and LFD (C-j) matches eol.
+ (define-key isearch-mode-map "\r" 'isearch-exit)
+ (define-key isearch-mode-map "\C-j" 'isearch-printing-char)
+
+
+ (define-key isearch-mode-map "\C-w" 'isearch-yank-word)
+ (define-key isearch-mode-map "\C-y" 'isearch-yank-line)
+
+ (define-key isearch-mode-map "\C-t" 'isearch-toggle-regexp)
+ (define-key isearch-mode-map "\C-^" 'isearch-edit-string)
+
+ ;; define keys for regexp chars * ? |
+ (define-key isearch-mode-map "*" 'isearch-*-char)
+ (define-key isearch-mode-map "?" 'isearch-*-char)
+ (define-key isearch-mode-map "|" 'isearch-|-char)
+
+ ;; Assumes meta-prefix-char is \e.
+ ;; isearch-mode-meta-map must be a keymap before this.
+ (define-key isearch-mode-map "\e" isearch-mode-meta-map)
+ ))
+
+;;;========================================================
+;; Internal variables declared globally for byte-compiler.
+;; These are all made buffer-local during searching.
+
+(defvar isearch-cmds nil
+ "Stack of search status sets.")
+(defvar isearch-string ""
+ "The current search string.")
+(defvar isearch-message ""
+ "The text-char-description version of isearch-string")
+(defvar isearch-success t)
+(defvar isearch-forward nil)
+(defvar isearch-other-end nil
+ "Start of last match if forward, end if backward.")
+(defvar isearch-invalid-regexp nil)
+(defvar isearch-wrapped nil)
+(defvar isearch-barrier 0)
+
+(defvar isearch-regexp nil)
+(defvar isearch-case-fold-search nil
+ "Value of case-fold-search while actually searching.")
+
+(defvar isearch-adjusted nil)
+(defvar isearch-slow-terminal-mode nil)
+(defvar isearch-small-window nil
+ "If t, using a small window.")
+(defvar isearch-found-point nil
+ "to restore point from a small window.")
+
+(defvar isearch-found-start nil
+ "This is the window-start value found by the search.")
+(defvar isearch-opoint 0)
+(defvar isearch-window-configuration nil
+ "The window configuration active at the beginning of the search.")
+(defvar isearch-old-local-map [])
+
+(defvar isearch-yank-flag nil
+ "Flag to indicate a yank occurred, so don't move the cursor.")
+
+(defvar isearch-op-fun nil
+ "A function to be called after each input character is processed.
+(It is not called after characters that exit the search.)
+It is only set from an optional argument to `isearch-mode'.")
+
+;; This is a global variable to avoid byte-compile warnings.
+(defvar isearch-last-command-char -1
+ "Last command char.")
+
+(defvar isearch-mode-hook nil
+ "List of functions to call after starting up an incremental search.
+See `isearch-modal' for an example.
+Set with `(setq isearch-mode-hook (cons 'myhook isearch-mode-hook))
+where myhook can be a function name or lambda expression.")
+
+(defvar isearch-mode-end-hook nil
+ "List of functions to call after terminating an incremental search.
+See `isearch-mode-hook' for more details.")
+
+;;;==============================================================
+;; Minor-mode-alist changes - kind of redundant with the
+;; echo area, but if isearching in multiple windows, it can be useful.
+
+(or (assq 'isearch-mode minor-mode-alist)
+ (nconc minor-mode-alist
+ (list '(isearch-mode isearch-mode))))
+
+(defvar isearch-mode nil)
+(make-variable-buffer-local 'isearch-mode)
+
+;;;===============================================================
+;;; Entry points to isearch-mode.
+;;; These four functions should be moved to loaddefs.el
+
+(defun isearch-forward ()
+ "\
+Do incremental search forward.
+As you type characters, they add to the search string and are found.
+
+\\<isearch-mode-map>
+Type \\[isearch-delete-char] to cancel characters from end of search
+string.
+Type \\[isearch-exit] to exit, leaving point at location found.
+Type \\[isearch-repeat-forward] to search again forward,
+\\[isearch-repeat-backward] to search again backward.
+Type \\[isearch-toggle-regexp] to toggle regular expression with normal searching.
+Type \\[isearch-yank-word] to yank word 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, etc.
+Type \\[isearch-quote-char] to quote control character to search for it.
+Type C-j to match end of line.
+
+Also supported is a search ring of the previous 16 search strings.
+Type \\[isearch-ring-advance] to search for the next item in the search ring.
+Type \\[isearch-ring-retreat] to search for the previous item in the search ring.
+
+Other control and meta characters terminate the search
+ and are then executed normally.
+
+\\[isearch-quit] while searching or when search has failed
+ cancels input back to what has been found successfully.
+\\[isearch-quit] when search is successful aborts and moves point to starting point.
+
+All of these keys are bound in `isearch-mode-map' and
+`isearch-mode-meta-map'. If `isearch-forward' is called
+non-interactively, it does not return to the calling function until
+the search is done."
+ (interactive)
+ (if (interactive-p)
+ (isearch-mode t)
+ (isearch-modal t)))
+
+(defun isearch-forward-regexp ()
+ "\
+Do incremental search forward for regular expression.
+Like ordinary incremental search except that your input
+is treated as a regexp. See \\[isearch-forward] for more info."
+ (interactive)
+ (if (interactive-p)
+ (isearch-mode t t)
+ (isearch-modal t t)))
+
+(defun isearch-backward ()
+ "\
+Do incremental search backward.
+See \\[isearch-forward] for more information."
+ (interactive)
+ (if (interactive-p)
+ (isearch-mode nil)
+ (isearch-modal nil)))
+
+(defun isearch-backward-regexp ()
+ "\
+Do incremental search backward for regular expression.
+Like ordinary incremental search except that your input
+is treated as a regexp. See \\[isearch-forward] for more info."
+ (interactive)
+ (if (interactive-p)
+ (isearch-mode nil t)
+ (isearch-modal nil t)))
+
+
+(defun isearch-modal (forward &optional regexp op-fun)
+ ;; As an example of using the hooks, isearch-mode can be made
+ ;; modal (in the sense of not returning to the calling function
+ ;; until searching is completed) by entering a recursive-edit.
+ ;; This is used if the above functions are called non-interactively.
+ (let ((isearch-mode-hook
+ (cons (function (lambda () (recursive-edit)))
+ isearch-mode-hook))
+ (isearch-mode-end-hook
+ (cons (function (lambda () (exit-recursive-edit)))
+ isearch-mode-end-hook)))
+ (isearch-mode forward regexp op-fun)))
+
+\f
+;;;==================================================================
+;; isearch-mode only sets up incremental search for the minor mode.
+;; All the work is done by the isearch-mode commands.
+
+(defun isearch-mode (forward &optional regexp op-fun)
+ "Start isearch minor mode. Called by isearch-forward, etc."
+ ;; Make buffer-local variables for isearching.
+ ;; We really need window-local variables.
+ (mapcar
+ 'make-local-variable
+ '(isearch-forward
+ isearch-regexp isearch-string isearch-message
+ isearch-case-fold-search
+ isearch-cmds isearch-success isearch-wrapped
+ isearch-barrier isearch-adjusted isearch-invalid-regexp
+ isearch-slow-terminal-mode isearch-other-end isearch-small-window
+ isearch-found-point isearch-found-start isearch-opoint
+ isearch-window-configuration isearch-old-local-map))
+
+ ;; Initialize global vars.
+ (setq isearch-forward forward
+ isearch-regexp regexp
+ isearch-op-fun op-fun
+ isearch-case-fold-search case-fold-search
+ isearch-string ""
+ isearch-message ""
+ isearch-cmds nil
+ isearch-success t
+ isearch-wrapped nil
+ isearch-barrier (point)
+ isearch-adjusted nil
+ isearch-yank-flag nil
+ isearch-invalid-regexp nil
+ isearch-slow-terminal-mode (and (<= (baud-rate) search-slow-speed)
+ (> (window-height)
+ (* 4 search-slow-window-lines)))
+ isearch-other-end nil
+ isearch-small-window nil
+ isearch-found-point nil
+
+ isearch-found-start nil
+ isearch-opoint (point)
+ isearch-window-configuration (current-window-configuration)
+ isearch-old-local-map (current-local-map)
+
+;; inhibit-quit t
+ )
+ (setq isearch-mode " Isearch") ;; forward? regexp?
+ (set-buffer-modified-p (buffer-modified-p)) ; update modeline
+
+ (isearch-push-state)
+
+ (use-local-map isearch-mode-map)
+ (isearch-update)
+ (run-hooks 'isearch-mode-hook)
+ )
+
+
+;;;====================================================
+;; Some high level utilities. Others below.
+
+(defun isearch-update ()
+ ;; Called after each command to update the display.
+ (or unread-command-char
+ (progn
+ (if (not (input-pending-p))
+ (isearch-message))
+ (if (and isearch-slow-terminal-mode
+ (not (or isearch-small-window
+ (pos-visible-in-window-p))))
+ (progn
+ (setq isearch-small-window t)
+ (setq isearch-found-point (point))
+ (move-to-window-line 0)
+ (let ((window-min-height 1))
+ (split-window nil (if (< search-slow-window-lines 0)
+ (1+ (- search-slow-window-lines))
+ (- (window-height)
+ (1+ search-slow-window-lines)))))
+ (if (< search-slow-window-lines 0)
+ (progn (vertical-motion (- 1 search-slow-window-lines))
+ (set-window-start (next-window) (point))
+ (set-window-hscroll (next-window)
+ (window-hscroll))
+ (set-window-hscroll (selected-window) 0))
+ (other-window 1))
+ (goto-char isearch-found-point)))))
+ (setq ;; quit-flag nil not for isearch-mode
+ isearch-adjusted nil
+ isearch-yank-flag nil)
+ )
+
+
+(defun isearch-done ()
+ ;; Called by all commands that terminate isearch-mode.
+ (use-local-map isearch-old-local-map)
+ (setq isearch-found-start (window-start (selected-window)))
+ (setq isearch-found-point (point))
+ (set-window-configuration isearch-window-configuration)
+
+ (if (> (length isearch-string) 0)
+ ;; Update the ring data.
+ (if isearch-regexp
+ (if (not (setq regex-search-ring-yank-pointer
+ (memq isearch-string regex-search-ring)))
+ (progn
+ (setq regex-search-ring (cons isearch-string regex-search-ring)
+ regex-search-ring-yank-pointer regex-search-ring)
+ (if (> (length regex-search-ring) regex-search-ring-max)
+ (setcdr (nthcdr (1- search-ring-max) regex-search-ring)
+ nil))))
+ (if (not (setq search-ring-yank-pointer
+ (memq isearch-string search-ring)))
+ (progn
+ (setq search-ring (cons isearch-string search-ring)
+ search-ring-yank-pointer search-ring)
+ (if (> (length search-ring) search-ring-max)
+ (setcdr (nthcdr (1- search-ring-max) search-ring) nil))))))
+
+ ;; If there was movement, mark the starting position.
+ ;; Maybe should test difference between and set mark iff > threshold.
+ (if (/= (point) isearch-opoint)
+ (push-mark isearch-opoint)
+ (message ""))
+ (if isearch-small-window
+ (goto-char isearch-found-point)
+ ;; Exiting the save-window-excursion clobbers window-start; restore it.
+ (set-window-start (selected-window) isearch-found-start t))
+
+ ;; Kill buffer-local variables for isearching
+ (mapcar
+ 'kill-local-variable
+ '(isearch-forward
+ isearch-regexp isearch-string isearch-message
+ isearch-case-fold-search
+ isearch-cmds isearch-success isearch-wrapped
+ isearch-barrier isearch-adjusted isearch-invalid-regexp
+ isearch-slow-terminal-mode isearch-other-end isearch-small-window
+ isearch-found-point isearch-found-start isearch-opoint
+ isearch-window-configuration isearch-old-local-map))
+
+ (setq isearch-mode nil)
+ (set-buffer-modified-p (buffer-modified-p))
+ (run-hooks 'isearch-mode-end-hook)
+ )
+
+\f
+;;;====================================================
+;; Commands active while inside of the isearch minor mode.
+
+(defun isearch-exit ()
+ "Exit search normally.
+However, if this is the first command after starting incremental
+search and `search-nonincremental-instead' is non-nil, do a
+nonincremental search instead."
+
+ (interactive)
+ (if (and search-nonincremental-instead
+ (= 0 (length isearch-string)))
+ (nonincremental-search isearch-forward isearch-regexp))
+ (isearch-done))
+
+
+(defun isearch-edit-string ()
+ "Edit the search string in the minibuffer and return to incremental search."
+ ;; This doesnt back up the search point.
+ (interactive)
+ (setq isearch-string (read-string (isearch-message-prefix) isearch-string)
+ isearch-message (mapconcat 'text-char-description
+ isearch-string ""))
+ (isearch-push-state)
+ (isearch-search)
+ (isearch-update))
+
+
+(defun isearch-quit ()
+ "Quit incremental search mode if searching is successful.
+Otherwise, revert to previous successful search and continue searching."
+ (interactive)
+ (ding)
+ (discard-input)
+ (if isearch-success
+ ;; If search is successful, move back to starting point
+ ;; and really do quit.
+ (progn (goto-char isearch-opoint)
+ (isearch-done)) ; exit and quit
+ ;; If search is failing, rub out until it is once more
+ ;; successful.
+ (while (not isearch-success) (isearch-pop-state))
+ (isearch-update)))
+
+
+(defun isearch-repeat (direction)
+ ;; Utility for isearch-repeat-forward and -backward.
+ (if (eq isearch-forward (eq direction 'forward))
+ ;; C-s in forward or C-r in reverse.
+ (if (equal isearch-string "")
+ ;; If search string is empty, use last one.
+ (setq isearch-string
+;; (if isearch-regexp
+;; search-last-regexp search-last-string)
+ (or (if isearch-regexp
+ (if regex-search-ring-yank-pointer
+ (car regex-search-ring-yank-pointer)
+ (car regex-search-ring))
+ (if search-ring-yank-pointer
+ (car search-ring-yank-pointer)
+ (car search-ring)))
+ "")
+ isearch-message
+ (mapconcat 'text-char-description
+ isearch-string ""))
+ ;; 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))))
+ ;; C-s in reverse or C-r in forward, change direction.
+ (setq isearch-forward (not isearch-forward)))
+
+ (setq isearch-barrier (point)) ; For subsequent \| if regexp.
+ (setq isearch-success t)
+ (or (equal isearch-string "")
+ (progn
+ ;; If repeating a search that found
+ ;; an empty string, ensure we advance.
+ (if (equal (match-end 0) (match-beginning 0))
+ (forward-char (if isearch-forward 1 -1)))
+ (isearch-search)))
+ (isearch-push-state)
+ (isearch-update))
+
+(defun isearch-repeat-forward ()
+ "Repeat incremental search forwards."
+ (interactive)
+ (isearch-repeat 'forward))
+
+(defun isearch-repeat-backward ()
+ "Repeat incremental search backwards."
+ (interactive)
+ (isearch-repeat 'backward))
+
+(defun isearch-toggle-regexp ()
+ "Toggle regexp searching on or off."
+ ;; The status stack is left unchanged.
+ (interactive)
+ (setq isearch-regexp (not isearch-regexp))
+ (isearch-update))
+
+(defun isearch-delete-char ()
+ "Discard last input item and move point back.
+If no previous match was done, just beep."
+ (interactive)
+ (if (null (cdr isearch-cmds))
+ (ding)
+ (isearch-pop-state))
+ (isearch-update))
+
+
+(defun isearch-yank (chunk)
+ ;; Helper for isearch-yank-word and isearch-yank-line
+ (let ((word (save-excursion
+ (and (not isearch-forward) isearch-other-end
+ (goto-char isearch-other-end))
+ (buffer-substring
+ (point)
+ (save-excursion
+ (cond
+ ((eq chunk 'word)
+ (forward-word 1))
+ ((eq chunk 'line)
+ (end-of-line)))
+ (point))))))
+ (if isearch-regexp (setq word (regexp-quote word)))
+ (setq isearch-string (concat isearch-string word)
+ isearch-message
+ (concat isearch-message
+ (mapconcat 'text-char-description
+ word ""))
+ ;; Don't move cursor in reverse search.
+ isearch-yank-flag t))
+ (isearch-search-and-update))
+
+
+(defun isearch-yank-word ()
+ "Pull next word from buffer into search string."
+ (interactive)
+ (isearch-yank 'word))
+
+(defun isearch-yank-line ()
+ "Pull rest of line from buffer into search string."
+ (interactive)
+ (isearch-yank 'line))
+
+
+(defun isearch-search-and-update ()
+ ;; Do the search and update the display.
+ (if (and (not isearch-success)
+ ;; unsuccessful regexp search may become
+ ;; successful by addition of characters which
+ ;; make isearch-string valid
+ (not isearch-regexp))
+ nil
+ ;; In reverse search, adding stuff at
+ ;; the end may cause zero or many more chars to be
+ ;; matched, in the string following point.
+ ;; Allow all those possibilities without moving point as
+ ;; long as the match does not extend past search origin.
+ (if (and (not isearch-forward) (not isearch-adjusted)
+ (condition-case ()
+ (looking-at (if isearch-regexp isearch-string
+ (regexp-quote isearch-string)))
+ (error nil))
+ (or isearch-yank-flag
+ (<= (match-end 0)
+ (min isearch-opoint isearch-barrier))))
+ (setq isearch-success t
+ isearch-invalid-regexp nil
+ isearch-other-end (match-end 0))
+ ;; Not regexp, not reverse, or no match at point.
+ (if (and isearch-other-end (not isearch-adjusted))
+ (goto-char (if isearch-forward isearch-other-end
+ (min isearch-opoint
+ isearch-barrier
+ (1+ isearch-other-end)))))
+ (isearch-search)
+ ))
+ (isearch-push-state)
+ (if isearch-op-fun (funcall isearch-op-fun))
+ (isearch-update))
+
+
+;; *, ?, 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.
+
+(defun isearch-*-char ()
+ "Handle * and ? specially in regexps."
+ (interactive)
+ (if isearch-regexp
+
+ (progn
+ (setq isearch-adjusted t)
+ (let ((cs (nth (if isearch-forward
+ 5 ; isearch-other-end
+ 2) ; saved (point)
+ (car (cdr isearch-cmds)))))
+ ;; (car isearch-cmds) is after last search;
+ ;; (car (cdr isearch-cmds)) is from before it.
+ (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-other-control-char ()
+ "Any other control char => unread it and exit the search normally.
+But only if `search-exit-option' is non-nil."
+ (interactive)
+ (if search-exit-option
+ (progn
+ (setq unread-command-char last-command-char)
+ (isearch-done))
+ ;; otherwise
+ (isearch-search-and-update)))
+
+
+(defun isearch-other-meta-char ()
+ "Any other meta char => exit the search normally and reexecute the whole key.
+But only if `search-exit-option' is non-nil."
+ ;; This will probably work in place of isearch-other-control-char too,
+ ;; but here we use unwind-protect and command-execute since it is
+ ;; a multi-char key we would want to unread.
+ (interactive)
+ (if search-exit-option
+ (unwind-protect
+ (isearch-done) ;; this exits recursive edit
+ ;; Reexecute the key.
+ (command-execute (this-command-keys)))
+ ;; otherwise
+ (isearch-search-and-update)))
+
+
+(defun isearch-quote-char ()
+ "Quote special characters for incremental search."
+ (interactive)
+ (isearch-process-search-char (read-quoted-char (isearch-message t))))
+
+
+(defun isearch-return-char ()
+ "Convert return into newline for incremental search.
+Obsolete."
+ (interactive)
+ (isearch-process-search-char ?\n))
+
+
+(defun isearch-printing-char ()
+ "Any other printing character => add it to the search string and search."
+ (interactive)
+ (isearch-process-search-char last-command-char))
+
+
+(defun isearch-upper-case-char ()
+ "Any upper case char => turn off case fold search for remainder of search."
+ ;; This feature only applies to interactively entered chars,
+ ;; but not yanked chars, repeat default searches, or search ring searches.
+ ;; Support for these should be easy to add.
+ (interactive)
+ (if search-caps-disable-folding
+ (setq isearch-case-fold-search nil))
+ (isearch-printing-char))
+
+(defun isearch-whitespace-chars ()
+ "Match all whitespace chars, if in regexp mode."
+ (interactive)
+ (if (and isearch-regexp search-whitespace-regexp)
+ (isearch-process-search-string search-whitespace-regexp " ")
+ (isearch-other-meta-char)))
+
+(defun isearch-process-search-char (char)
+ ;; Append the char to the search string, update the message and re-search.
+ (isearch-process-search-string (char-to-string char)
+
+ (text-char-description char)))
+
+(defun isearch-process-search-string (string message)
+ (setq isearch-string (concat isearch-string string)
+ isearch-message (concat isearch-message message))
+ (isearch-search-and-update))
+
+\f
+;;===========================================================
+;; Search Ring
+
+(defun isearch-ring-adjust (advance)
+ ;; helper for isearch-ring-advance and isearch-ring-retreat
+ (if (cdr isearch-cmds)
+ (isearch-pop-state))
+ (let* ((ring (if isearch-regexp regex-search-ring search-ring))
+ (length (length ring))
+ (yank-pointer-name (if isearch-regexp
+ 'regex-search-ring-yank-pointer
+ 'search-ring-yank-pointer))
+ (yank-pointer (eval yank-pointer-name)))
+ (if (zerop length)
+ ()
+ (set yank-pointer-name
+ (setq yank-pointer
+ (nthcdr (% (+ (- length (length yank-pointer))
+ (if advance (1- length) 1))
+ length) ring)))
+ (setq isearch-string (car yank-pointer)
+ isearch-message (mapconcat 'text-char-description
+ isearch-string ""))))
+ (isearch-push-state)
+ (isearch-search)
+ (isearch-update))
+
+(defun isearch-ring-advance ()
+ "Advance to the next search string in the ring."
+ (interactive)
+ (isearch-ring-adjust 'advance))
+
+(defun isearch-ring-retreat ()
+ "Retreat to the previous search string in the ring."
+ (interactive)
+ (isearch-ring-adjust nil))
+
+\f
+;;;=============================================================
+;; Window-local variables
+;; (not used yet - and maybe never)
+
+(defvar window-local-variable-alist nil
+ "An alist of windows associated with window local variables and values.
+The cdr of each item is another alist of variables and values.")
+
+(defvar last-local-window nil)
+(defvar last-window-local-vars nil)
+
+(defun kill-window-local-variables ()
+ "Remove the old variable list, if any."
+ (setq window-local-variable-alist
+ (delq window-local-variable-alist
+ (assq (selected-window)
+ window-local-variable-alist))))
+
+;; Assume that window-local variables are not buffer-local
+;; so we can delay storing until absolutely necessary.
+
+(defun store-window-local-variables (&rest vars-and-vals)
+ "Store the window local variables for selected window."
+ (setq last-local-window (selected-window))
+ (setq last-window-local-vars vars-and-vals))
+
+
+(defun fetch-window-local-variables ()
+ "Fetch the window local variables for selected window.
+Does nothing if the last store was for the same window."
+ (if (not (eq (selected-window) last-local-window))
+ (progn
+ ;; First store the previous values.
+ (setq window-local-variable-alist
+ (cons (cons last-local-window
+ last-window-local-vars)
+ (delq window-local-variable-alist
+ (assq last-local-window
+ window-local-variable-alist))))
+ ;; Now fetch the values for the selected-window.
+ (setq last-local-window (selected-window))
+ (setq last-window-local-vars
+ (cdr (assq last-local-window window-local-variable-alist)))
+ (let ((vars-and-vals last-window-local-vars))
+ (while vars-and-vals
+ (set (car vars-and-vals) (car (cdr vars-and-vals)))
+ (setq vars-and-vals (cdr (cdr vars-and-vals))))))))
+
+
+\f
+;;;==============================================================
+;; The search status stack (and isearch window-local variables, not used).
+
+(defun isearch-top-state ()
+;; (fetch-window-local-variables)
+ (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-invalid-regexp (nth 6 cmd)
+ isearch-wrapped (nth 7 cmd)
+ isearch-barrier (nth 8 cmd))
+ (goto-char (car (cdr (cdr cmd))))))
+
+(defun isearch-pop-state ()
+;; (fetch-window-local-variables)
+ (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-invalid-regexp isearch-wrapped isearch-barrier)
+ isearch-cmds)))
+
+(defun isearch-store-variables ()
+ (store-window-local-variables
+ 'isearch-cmds isearch-cmds
+ 'isearch-regexp isearch-regexp
+ 'isearch-adjusted isearch-adjusted
+ 'isearch-slow-terminal-mode isearch-slow-terminal-mode
+ 'isearch-small-window isearch-small-window
+ 'isearch-found-point isearch-found-point
+ 'isearch-found-start isearch-found-start
+ 'isearch-opoint isearch-opoint
+ 'isearch-window-configuration isearch-window-configuration
+ 'isearch-old-local-map isearch-old-local-map
+ ))
+
+\f
+;;;==================================================================
+;; Message string
+
+(defun isearch-message (&optional c-q-hack ellipsis)
+ ;; Generate and print the message string.
+ (let ((cursor-in-echo-area ellipsis)
+ (m (concat
+ (isearch-message-prefix c-q-hack ellipsis)
+ isearch-message
+ (isearch-message-suffix c-q-hack ellipsis)
+ )))
+ (if c-q-hack m (message "%s" m))))
+
+(defun isearch-message-prefix (&optional c-q-hack ellipsis)
+ ;; 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
+ (condition-case ()
+ (progn (re-search-forward isearch-string (point) t)
+ (setq isearch-invalid-regexp nil))
+ (error nil)))
+ ;; If currently failing, display no ellipsis.
+ (or isearch-success (setq ellipsis nil))
+ (let ((m (concat (if isearch-success "" "failing ")
+ (if isearch-wrapped "wrapped ")
+ (if isearch-regexp "regexp " "")
+ "I-search"
+ (if isearch-forward ": " " backward: ")
+ )))
+ (aset m 0 (upcase (aref m 0)))
+ m))
+
+
+(defun isearch-message-suffix (&optional c-q-hack ellipsis)
+ (concat (if c-q-hack "^Q" "")
+ (if isearch-invalid-regexp
+ (concat " [" isearch-invalid-regexp "]")
+ "")))
+
+\f
+;;;========================================================
+;;; Searching
+
+(defun isearch-search ()
+ ;; Do the search with the current search string.
+ (isearch-message nil t)
+ (condition-case lossage
+ (let ((inhibit-quit nil)
+ (case-fold-search isearch-case-fold-search))
+ (if isearch-regexp (setq isearch-invalid-regexp nil))
+ (setq isearch-success
+ (funcall
+ (if isearch-regexp
+ (if isearch-forward 're-search-forward 're-search-backward)
+ (if isearch-forward 'search-forward 'search-backward))
+ isearch-string nil t))
+ (if isearch-success
+ (setq isearch-other-end
+ (if isearch-forward (match-beginning 0) (match-end 0)))))
+
+ (quit (setq unread-command-char ?\C-g)
+ (setq isearch-success nil))
+
+ (invalid-regexp
+ (setq isearch-invalid-regexp (car (cdr lossage)))
+ (if (string-match
+ "\\`Premature \\|\\`Unmatched \\|\\`Invalid "
+ isearch-invalid-regexp)
+ (setq isearch-invalid-regexp "incomplete input"))))
+
+ (if isearch-success
+ nil
+ ;; Ding if failed this time after succeeding last time.
+ (and (nth 3 (car isearch-cmds))
+ (ding))
+ (goto-char (nth 2 (car isearch-cmds)))))
+
+;;;=================================================
+;; This is called from incremental-search
+;; if the first input character is the exit character.
+
+;; We store the search string in `isearch-string'
+;; which has been bound already by `isearch-search'
+;; so that, when we exit, it is copied into `search-last-string'.
+
+(defun nonincremental-search (forward regexp)
+ ;; This may be broken. Anyway, it could be replaced by the
+ ;; isearch-edit-string command instead.
+ (setq isearch-forward forward
+ isearch-regexp regexp)
+ (let (char function
+ inhibit-quit
+ (cursor-in-echo-area t))
+ ;; Prompt assuming not word search,
+ (setq isearch-message
+
+ (if isearch-regexp
+
+ (if isearch-forward "Regexp search: "
+ "Regexp search backward: ")
+ (if isearch-forward "Search: " "Search backward: ")))
+ (message "%s" isearch-message)
+ ;; Read 1 char and switch to word search if it is ^W.
+ (setq char (read-char))
+ (if (eq char search-yank-word-char)
+ (setq isearch-message (if isearch-forward "Word search: "
+
+ "Word search backward: "))
+ ;; Otherwise let that 1 char be part of the search string.
+ (setq unread-command-char char))
+ (setq function
+ (if (eq char search-yank-word-char)
+ (if isearch-forward 'word-search-forward 'word-search-backward)
+ (if isearch-regexp
+ (if isearch-forward 're-search-forward 're-search-backward)
+ (if isearch-forward 'search-forward 'search-backward))))
+ ;; Read the search string with corrected prompt.
+ (setq isearch-string (read-string isearch-message isearch-string))
+ ;; Empty means use default.
+ (if (= 0 (length isearch-string))
+ (setq isearch-string search-last-string)
+ ;; Set last search string now so it is set even if we fail.
+ (setq search-last-string isearch-string))
+ ;; Since we used the minibuffer, we should be available for redo.
+ (setq command-history
+
+ (cons (list function isearch-string) command-history))
+ ;; Go ahead and search.
+ (let ((case-fold-search isearch-case-fold-search))
+ (funcall function isearch-string))))
HCoop / bpt / emacs.git / commitdiff