Mercurial > emacs
changeset 725:75e4ec1e938f
Initial revision
| author | Jim Blandy <jimb@redhat.com> |
|---|---|
| date | Wed, 24 Jun 1992 05:05:16 +0000 |
| parents | fb86b8eef4e5 |
| children | 5f08efa38dd0 |
| files | lisp/=iso8859-1.el lisp/isearch.el |
| diffstat | 2 files changed, 1188 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/=iso8859-1.el Wed Jun 24 05:05:16 1992 +0000 @@ -0,0 +1,94 @@ +;; Set up case-conversion and syntax tables for ISO 8859/1 character set. +;; Copyright (C) 1988 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 1, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; 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, 675 Mass Ave, Cambridge, MA 02139, USA. + + +;; Written by Howard Gayle. See case-table.el for details. + +(require 'case-table) + +(let ((table (standard-case-table))) + (standard-case-syntax 160 " " table) ; NBSP (no-break space) + (standard-case-syntax 161 "." table) ; inverted exclamation mark + (standard-case-syntax 162 "w" table) ; cent sign + (standard-case-syntax 163 "w" table) ; pound sign + (standard-case-syntax 164 "w" table) ; general currency sign + (standard-case-syntax 165 "w" table) ; yen sign + (standard-case-syntax 166 "_" table) ; broken vertical line + (standard-case-syntax 167 "w" table) ; section sign + (standard-case-syntax 168 "w" table) ; diaeresis + (standard-case-syntax 169 "_" table) ; copyright sign + (standard-case-syntax 170 "w" table) ; ordinal indicator, feminine + (standard-case-syntax-delims 171 187 table) ; angle quotation marks + (standard-case-syntax 172 "_" table) ; not sign + (standard-case-syntax 173 "_" table) ; soft hyphen + (standard-case-syntax 174 "_" table) ; registered sign + (standard-case-syntax 175 "w" table) ; macron + (standard-case-syntax 176 "_" table) ; degree sign + (standard-case-syntax 177 "_" table) ; plus or minus sign + (standard-case-syntax 178 "w" table) ; superscript two + (standard-case-syntax 179 "w" table) ; superscript three + (standard-case-syntax 180 "w" table) ; acute accent + (standard-case-syntax 181 "_" table) ; micro sign + (standard-case-syntax 182 "w" table) ; pilcrow + (standard-case-syntax 183 "_" table) ; middle dot + (standard-case-syntax 184 "w" table) ; cedilla + (standard-case-syntax 185 "w" table) ; superscript one + (standard-case-syntax 186 "w" table) ; ordinal indicator, masculine + ;; 187 ; See 171 above. + (standard-case-syntax 188 "_" table) ; fraction one-quarter + (standard-case-syntax 189 "_" table) ; fraction one-half + (standard-case-syntax 190 "_" table) ; fraction three-quarters + (standard-case-syntax 191 "." table) ; inverted question mark + (standard-case-syntax-pair 192 224 table) ; A with grave accent + (standard-case-syntax-pair 193 225 table) ; A with acute accent + (standard-case-syntax-pair 194 226 table) ; A with circumflex accent + (standard-case-syntax-pair 195 227 table) ; A with tilde + (standard-case-syntax-pair 196 228 table) ; A with diaeresis or umlaut mark + (standard-case-syntax-pair 197 229 table) ; A with ring + (standard-case-syntax-pair 198 230 table) ; AE diphthong + (standard-case-syntax-pair 199 231 table) ; C with cedilla + (standard-case-syntax-pair 200 232 table) ; E with grave accent + (standard-case-syntax-pair 201 233 table) ; E with acute accent + (standard-case-syntax-pair 202 234 table) ; E with circumflex accent + (standard-case-syntax-pair 203 235 table) ; E with diaeresis or umlaut mark + (standard-case-syntax-pair 204 236 table) ; I with grave accent + (standard-case-syntax-pair 205 237 table) ; I with acute accent + (standard-case-syntax-pair 206 238 table) ; I with circumflex accent + (standard-case-syntax-pair 207 239 table) ; I with diaeresis or umlaut mark + (standard-case-syntax-pair 208 240 table) ; D with stroke, Icelandic eth + (standard-case-syntax-pair 209 241 table) ; N with tilde + (standard-case-syntax-pair 210 242 table) ; O with grave accent + (standard-case-syntax-pair 211 243 table) ; O with acute accent + (standard-case-syntax-pair 212 244 table) ; O with circumflex accent + (standard-case-syntax-pair 213 245 table) ; O with tilde + (standard-case-syntax-pair 214 246 table) ; O with diaeresis or umlaut mark + (standard-case-syntax 215 "_" table) ; multiplication sign + (standard-case-syntax-pair 216 248 table) ; O with slash + (standard-case-syntax-pair 217 249 table) ; U with grave accent + (standard-case-syntax-pair 218 250 table) ; U with acute accent + (standard-case-syntax-pair 219 251 table) ; U with circumflex accent + (standard-case-syntax-pair 220 252 table) ; U with diaeresis or umlaut mark + (standard-case-syntax-pair 221 253 table) ; Y with acute accent + (standard-case-syntax-pair 222 254 table) ; thorn, Icelandic + (standard-case-syntax 223 "w" table) ; small sharp s, German + (standard-case-syntax 247 "_" table) ; division sign + (standard-case-syntax 255 "w" table) ; small y with diaeresis or umlaut mark + (set-standard-case-table (list (car table)))) + +(provide 'iso8859-1)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/isearch.el Wed Jun 24 05:05:16 1992 +0000 @@ -0,0 +1,1094 @@ +;; 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))) + + +;;;================================================================== +;; 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) + ) + + +;;;==================================================== +;; 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)) + + +;;=========================================================== +;; 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)) + + +;;;============================================================= +;; 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)))))))) + + + +;;;============================================================== +;; 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 + )) + + +;;;================================================================== +;; 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 "]") + ""))) + + +;;;======================================================== +;;; 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))))