X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/1a3a6707240ac01920c578693969d4d96c0d1059..d49b6338aa54b1e627f1a08432ee1340ac76871a:/lisp/isearch.el

diff --git a/lisp/isearch.el b/lisp/isearch.el
index b5c47ede4f..77ce1aeb6b 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1,10 +1,10 @@
-;; Incremental search minor mode.
-;; Copyright (C) 1992 Free Software Foundation, Inc.
+;;; isearch.el --- incremental search minor mode.
 
-;; LCD Archive Entry:
-;; isearch-mode|Daniel LaLiberte|liberte@cs.uiuc.edu
-;; |A minor mode replacement for isearch.el.
-;; |$Date: 1992/11/01 22:10:59 $|$Revision: 1.14 $|~/modes/isearch-mode.el
+;; Copyright (C) 1992, 1993 Free Software Foundation, Inc.
+
+;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
+
+;; |$Date: 1993/07/15 03:46:02 $|$Revision: 1.46 $
 
 ;; This file is not yet part of GNU Emacs, but it is based almost
 ;; entirely on isearch.el which is part of GNU Emacs.
@@ -24,6 +24,8 @@
 ;; file named COPYING.  Among other things, the copyright notice
 ;; and this notice must be preserved on all copies.
 
+;;; Commentary:
+
 ;;;====================================================================
 ;; Instructions
 
@@ -36,7 +38,7 @@
 ;; isearch-forward, etc, will then use isearch-mode instead of
 ;; isearch.
 
-;; (fset 'isearch 'isearch-mode)
+;; (defalias 'isearch 'isearch-mode)
 ;; (autoload 'isearch-mode "isearch-mode")
 
 ;; For programmed use of isearch-mode, e.g. calling (isearch-forward),
@@ -49,7 +51,7 @@
 ;; of isearch-forward, etc. found in this file instead of those in
 ;; loaddefs.el.  The simplest way to ensure this is to just load
 ;; isearch-mode explicitly in your .emacs instead of using the above
-;; fset and autoload.
+;; defalias and autoload.
 
 ;; (load "isearch-mode")
 
@@ -81,32 +83,14 @@
 ;; the last possible moment.
 
 ;; TODO
-;; - Integrate the emacs 19 generalized commmand history.
+;; - Integrate the emacs 19 generalized command history.
 ;; - Think about incorporating query-replace.
 ;; - Hooks and options for failed search.
 
-;;;====================================================================
-;;; Change History
-
-;;; $Header: /gd/gnu/emacs/19.0/lisp/RCS/isearch-mode.el,v 1.14 1992/11/01 22:10:59 rms Exp $
-;;; $Log: isearch-mode.el,v $
-; Revision 1.14  1992/11/01  22:10:59  rms
-; (isearch-search): Handle all sorts of errors from regexp search.
-;
-; Revision 1.13  1992/10/27  04:11:46  rms
-; (isearch-edit-string):
-; Bind cursor-in-echo-area only around read-char/allocate-event.
-;
-; Revision 1.12  1992/10/20  21:21:47  rms
-; (isearch-mode-map): Make the top-level keymap dense.
-; Explicitly bind control characters at that level.
-;
-; Revision 1.11  1992/10/11  05:25:11  rms
-; (isearch-ring-advance-edit): Delete spurious `)'.
-;
-; Revision 1.10  1992/09/21  08:28:43  rms
-; entered into RCS
-;
+;;; 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.
@@ -140,6 +124,7 @@
 ;;; 3/18/92 Fixed invalid-regexp.
 ;;; 3/18/92 Fixed yanking in regexps.
 
+;;; Code:
 
 
 ;;;=========================================================================
@@ -172,7 +157,7 @@ that the search has reached.")
 ;;;========================================================================
 ;;; Some additional options and constants.
 
-(defvar search-upper-case t
+(defvar search-upper-case 'not-yanks
   "*If non-nil, upper case chars disable case fold searching.
 That is, upper and lower case chars must match exactly.
 This applies no matter where the chars come from, but does not
@@ -192,9 +177,7 @@ You might want to use something like \"[ \\t\\r\\n]+\" instead.")
 ;; currently a clean thing to do.  Once highlighting is made clean, 
 ;; this feature can be re-enabled and advertised.
 (defvar search-highlight nil
-  "Whether isearch and query-replace should highlight the text which 
-currently matches the search-string.")
-
+  "*Non-nil means incremental search highlights the current match.")
 
 (defvar isearch-mode-hook nil
   "Function(s) to call after starting up an incremental search.")
@@ -235,6 +218,11 @@ Default value, nil, means edit the string instead.")
 (or isearch-mode-map
     (let* ((i 0)
 	   (map (make-keymap)))
+      (or (vectorp (nth 1 map))
+	  (error "The initialization of isearch-mode-map must be updated"))
+      ;; Give this map a vector 256 long, for dense binding
+      ;; of a larger range of ordinary characters.
+      (setcar (cdr map) (make-vector 256 nil))
 
       ;; Make function keys, etc, exit the search.
       (define-key map [t] 'isearch-other-control-char)
@@ -246,10 +234,10 @@ Default value, nil, means edit the string instead.")
 	(define-key map (make-string 1 i) 'isearch-other-control-char)
 	(setq i (1+ i)))
 
-      ;; Printing chars extend the selection by default.
+      ;; Printing chars extend the search string by default.
       (setq i ?\ )
-      (while (< i 128)
-	(define-key map (make-string 1 i) 'isearch-printing-char)
+      (while (< i (length (nth 1 map)))
+	(define-key map (vector i) 'isearch-printing-char)
 	(setq i (1+ i)))
 
       ;; Several non-printing chars change the searching behavior.
@@ -260,9 +248,6 @@ Default value, nil, means edit the string instead.")
     
       (define-key map "\C-q" 'isearch-quote-char)
 
-      ;;  (define-key map "\r" 'isearch-return-char)
-      ;; For version 19, RET (C-m) terminates search and LFD (C-j) matches eol.
-      ;; We could make this conditional.
       (define-key map "\r" 'isearch-exit)
       (define-key map "\C-j" 'isearch-printing-char)
       (define-key map "\t" 'isearch-printing-char)
@@ -271,35 +256,35 @@ Default value, nil, means edit the string instead.")
       (define-key map "\C-w" 'isearch-yank-word)
       (define-key map "\C-y" 'isearch-yank-line)
 
+      ;; Bind the ASCII-equivalent "function keys" explicitly
+      ;; if we bind their equivalents, 
+      ;; since otherwise the default binding would override.
+      ;; We bind [escape] below.
+      (define-key map [tab] 'isearch-printing-char)
+      (define-key map [delete] 'isearch-delete-char)
+      (define-key map [backspace] 'isearch-delete-char)
+      (define-key map [return] 'isearch-exit)
+      (define-key map [newline] 'isearch-printing-char)
+
       ;; 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)
 
-      ;; You can reenable global keys by binding them locally to nil.
-      ;; For the help char this doesnt work quite as expected because
-      ;; isearch-mode is not a major mode.  Also the echo area is not
-      ;; restored after the help command while isearch-mode is
-      ;; still active.  Furthermore, we should not assume that the
-      ;; help-command is on C-h.  But here is how it would be done:
-      ;; (define-key map "\C-h" nil)
-
-      ;; Instead bind C-h to special help command for isearch-mode.
-      (define-key map "\C-h" 'isearch-mode-help)
+;;; Turned off because I find I expect to get the global definition--rms.
+;;;      ;; Instead bind C-h to special help command for isearch-mode.
+;;;      (define-key map "\C-h" 'isearch-mode-help)
 
       ;; To handle local bindings with meta char prefix keys, define
       ;; another full keymap.  This must be done for any other prefix
       ;; keys as well, one full keymap per char of the prefix key.  It
       ;; would be simpler to disable the global keymap, and/or have a
       ;; default local key binding for any key not otherwise bound.
-      (define-key map (char-to-string meta-prefix-char) (make-sparse-keymap))
+      (let ((meta-map (make-sparse-keymap)))
+	(define-key map (char-to-string meta-prefix-char) meta-map)
+	(define-key map [escape] meta-map))
       (define-key map (vector meta-prefix-char t) 'isearch-other-meta-char)
-;;;      (setq i 0)
-;;;      (while (< i 128)
-;;;	(define-key map (char-to-string (+ 128 i));; Needs to be generalized.
-;;;	  'isearch-other-meta-char)
-;;;	(setq i (1+ i)))
 
       (define-key map "\M-n" 'isearch-ring-advance)
       (define-key map "\M-p" 'isearch-ring-retreat)
@@ -400,10 +385,10 @@ Default value, nil, means edit the string instead.")
 ;;;===============================================================
 ;;; Entry points to isearch-mode.
 ;;; These four functions should replace those in loaddefs.el
-;;; An alternative is to fset isearch-forward etc to isearch-mode,
+;;; An alternative is to defalias isearch-forward etc to isearch-mode,
 ;;; and look at this-command to set the options accordingly.
 
-(defun isearch-forward (&optional regexp-p)
+(defun isearch-forward (&optional regexp-p no-recursive-edit)
   "\
 Do incremental search forward.
 With a prefix argument, do an incremental regular expression search instead.
@@ -421,7 +406,6 @@ Type \\[isearch-yank-word] to yank word from buffer onto end of search\
 Type \\[isearch-yank-line] to yank rest of line onto end of search string\
  and search for it.
 Type \\[isearch-quote-char] to quote control character to search for it.
-Type \\[isearch-whitespace-chars] to match all whitespace chars in regexp.
 \\[isearch-abort] while searching or when search has failed cancels input\
  back to what has
  been found successfully.
@@ -442,34 +426,34 @@ Other control and meta characters terminate the search
 If this function is called non-interactively, it does not return to
 the calling function until the search is done."
 
-  (interactive "P")
-  (isearch-mode t (not (null regexp-p)) nil (not (interactive-p))))
+  (interactive "P\np")
+  (isearch-mode t (not (null regexp-p)) nil (not no-recursive-edit)))
 
-(defun isearch-forward-regexp (&optional regexp-p)
+(defun isearch-forward-regexp (&optional not-regexp no-recursive-edit)
   "\
 Do incremental search forward for regular expression.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input
 is treated as a regexp.  See \\[isearch-forward] for more info."
-  (interactive)
-  (isearch-mode t (null regexp-p) nil (not (interactive-p))))
+  (interactive "P\np")
+  (isearch-mode t (null not-regexp) nil (not no-recursive-edit)))
 
-(defun isearch-backward (&optional regexp-p)
+(defun isearch-backward (&optional regexp-p no-recursive-edit)
   "\
 Do incremental search backward.
 With a prefix argument, do a regular expression search instead.
 See \\[isearch-forward] for more information."
-  (interactive)
-  (isearch-mode nil (not (null regexp-p)) nil (not (interactive-p))))
+  (interactive "P\np")
+  (isearch-mode nil (not (null regexp-p)) nil (not no-recursive-edit)))
 
-(defun isearch-backward-regexp (&optional regexp-p)
+(defun isearch-backward-regexp (&optional not-regexp no-recursive-edit)
   "\
 Do incremental search backward for regular expression.
 With a prefix argument, do a regular string search instead.
 Like ordinary incremental search except that your input
 is treated as a regexp.  See \\[isearch-forward] for more info."
-  (interactive)
-  (isearch-mode nil (null regexp-p) nil (not (interactive-p))))
+  (interactive "P\np")
+  (isearch-mode nil (null not-regexp) nil (not no-recursive-edit)))
 
 
 (defun isearch-mode-help ()
@@ -514,15 +498,23 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
 	isearch-small-window nil
 
 	isearch-opoint (point)
-	isearch-window-configuration (current-window-configuration)
 	isearch-old-local-map (current-local-map)
 	search-ring-yank-pointer nil
 	regexp-search-ring-yank-pointer nil)
-  (if isearch-pre-command-hook-exists
-      (add-hook 'pre-command-hook 'isearch-pre-command-hook))
+  (if isearch-slow-terminal-mode
+      (setq isearch-window-configuration (current-window-configuration)))
+
+;; This was for Lucid Emacs.  But now that we have pre-command-hook,
+;; it causes trouble.
+;;  (if isearch-pre-command-hook-exists
+;;      (add-hook 'pre-command-hook 'isearch-pre-command-hook))
   (setq	isearch-mode " Isearch")  ;; forward? regexp?
   (set-buffer-modified-p (buffer-modified-p)) ; update modeline
 
+  ;; It is ugly to show region highlighting while the search
+  ;; is going on.  And we don't want the mark active at the end either.
+  (setq deactivate-mark t)      
+
   (isearch-push-state)
 
   (use-local-map isearch-mode-map)
@@ -532,7 +524,9 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
   ;; 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 and exiting it when done isearching.
-  (if recursive-edit (recursive-edit))
+  (if recursive-edit
+      (let ((isearch-recursive-edit t))
+	(recursive-edit)))
   )
 
 
@@ -544,7 +538,7 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
   (if (if isearch-event-data-type
 	  (null unread-command-event)
 	(if isearch-gnu-emacs-events
-	    (null unread-command-char)
+	    (null unread-command-events)
 	  (< unread-command-char 0)))
       (progn
 	(if (not (input-pending-p))
@@ -587,18 +581,24 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
   (isearch-dehighlight t)
   (let ((found-start (window-start (selected-window)))
 	(found-point (point)))
-    (set-window-configuration isearch-window-configuration)
+    (if isearch-window-configuration
+	(set-window-configuration isearch-window-configuration))
+
+    (if isearch-small-window
+	(goto-char found-point)
+      ;; Exiting the save-window-excursion clobbers window-start; restore it.
+      (set-window-start (selected-window) found-start t)))
 
     ;; If there was movement, mark the starting position.
     ;; Maybe should test difference between and set mark iff > threshold.
     (if (/= (point) isearch-opoint)
-	(push-mark isearch-opoint)
+	(progn
+	  (push-mark isearch-opoint t)
+	  (deactivate-mark)
+	  (or executing-macro (> (minibuffer-depth) 0)
+	      (message "Mark saved where search started")))
       ;; (message "") why is this needed?
       )
-    (if isearch-small-window
-	(goto-char found-point)
-      ;; Exiting the save-window-excursion clobbers window-start; restore it.
-      (set-window-start (selected-window) found-start t)))
 
   (setq isearch-mode nil)
   (set-buffer-modified-p (buffer-modified-p))  ;; update modeline
@@ -626,7 +626,7 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
 
 ;;;=======================================================
 ;;; Switching buffers should first terminate isearch-mode.
-;;; This is done quite differently for each varient of emacs.
+;;; This is done quite differently for each variant of emacs.
 ;;; For lemacs, see Exiting in lemacs below
 
 ;; For Emacs 19, the frame switch event is handled.
@@ -634,7 +634,7 @@ is treated as a regexp.  See \\[isearch-forward] for more info."
   (interactive) ;; Is this necessary?
   ;; First terminate isearch-mode.
   (isearch-done)
-  (select-frame (car (cdr (isearch-last-command-char)))))
+  (handle-switch-frame (car (cdr (isearch-last-command-char)))))
 
 ;;;========================================================
 
@@ -664,7 +664,7 @@ The following additional command keys are active while editing.
 \\[isearch-forward-exit-minibuffer] to resume isearching forward.
 \\[isearch-backward-exit-minibuffer] to resume isearching backward.
 \\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
-\\[isearch-ring-retreat-edit] to replace the search string with the previou item in the search ring.
+\\[isearch-ring-retreat-edit] to replace the search string with the previous item in the search ring.
 \\[isearch-complete-edit] to complete the search string using the search ring.
 
 If first char entered is \\[isearch-yank-word], then do word search instead."
@@ -673,10 +673,10 @@ If first char entered is \\[isearch-yank-word], then do word search instead."
   ;; Mainly, isearch-mode must be terminated while editing and then restarted.
   ;; If there were a way to catch any change of buffer from the minibuffer,
   ;; this could be simplified greatly.
-  ;; Editing doesnt back up the search point.  Should it?
+  ;; Editing doesn't back up the search point.  Should it?
   (interactive)
   (condition-case err
-      (let (isearch-nonincremental	; should search nonincrementally?
+      (let ((isearch-nonincremental isearch-nonincremental)
 
 	    ;; Locally bind all isearch global variables to protect them
 	    ;; from recursive isearching.
@@ -804,7 +804,7 @@ If first char entered is \\[isearch-yank-word], then do word search instead."
 Otherwise, revert to previous successful search and continue searching.
 Use `isearch-exit' to quit without signalling."
   (interactive)
-;;  (ding)  signal instead below, if quiting
+;;  (ding)  signal instead below, if quitting
   (discard-input)
   (if isearch-success
       ;; If search is successful, move back to starting point
@@ -994,41 +994,44 @@ If no previous match was done, just beep."
   (isearch-process-search-char (isearch-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, the default.
-If it is the symbol `edit', the search string is edited in the minibuffer
-and the control char is unread so that it applies to editing the string."
-  (interactive)
-  (cond ((eq search-exit-option 'edit)
-	 (isearch-unread (isearch-last-command-char))
-	 (isearch-edit-string))
-	(search-exit-option;; any other non-nil value
-	 (isearch-unread (isearch-last-command-char))
-	 (isearch-done))
-	(t;; search-exit-option is nil
-	 (isearch-process-search-char (isearch-last-command-char)))))
-
+(defalias 'isearch-other-control-char 'isearch-other-meta-char)
 
 (defun isearch-other-meta-char ()
-  "Any other meta char => exit the search normally and reread the character.
+  "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)
   (cond ((eq search-exit-option 'edit)
 	 (let ((key (this-command-keys)))
-	   (isearch-unread (+ 128 (aref key (1- (length key))))))
+	   (apply 'isearch-unread (listify-key-sequence key)))
 	 (isearch-edit-string))
 	(search-exit-option
-	 (let ((key (this-command-keys)))
-	   (isearch-unread (+ 128 (aref key (1- (length key))))))
-	 (isearch-done))
+	 (let ((key (this-command-keys))
+	       (index 0)
+	       window)
+	   (apply 'isearch-unread (listify-key-sequence key))
+	   ;; Properly handle scroll-bar and mode-line clicks
+	   ;; for which a dummy prefix event was generated as (aref key 0).
+	   (and (> (length key) 1)
+		(symbolp (aref key 0))
+		(listp (aref key 1))
+		(consp (posn-point (event-start (aref key 1))))
+		(setq index 1))
+	   ;; If we got a mouse click, maybe it was read with the buffer
+	   ;; it was clicked on.  If so, that buffer, not the current one,
+	   ;; is in isearch mode.  So end the search in that buffer.
+	   (if (and (listp (aref key index))
+		    (setq window (posn-window (event-start (aref key index))))
+		    (windowp window))
+	       (save-excursion
+		 (set-buffer (window-buffer window))
+		 (isearch-done))
+	     (isearch-done))))
 	(t;; otherwise nil
 	 (isearch-process-search-string (this-command-keys)
 					(this-command-keys)))))
 
-
 (defun isearch-quote-char ()
   "Quote special characters for incremental search."
   (interactive)
@@ -1041,20 +1044,20 @@ Obsolete."
   (isearch-process-search-char ?\n))
 
 (defun isearch-printing-char ()
-  "Any other printing character => add it to the search string and search."
+  "Add this ordinary printing character to the search string and search."
   (interactive)
   (isearch-process-search-char (isearch-last-command-char)))
 
 (defun isearch-whitespace-chars ()
   "Match all whitespace chars, if in regexp mode.
-If not in regexp mode, activate word search."
+If you want to search for just a space, type C-q SPC."
   (interactive)
   (if isearch-regexp 
       (if search-whitespace-regexp
 	  (isearch-process-search-string search-whitespace-regexp " ")
 	(isearch-printing-char))
     (progn
-      ;; This way of doing word search doesnt correctly extend current search.
+      ;; This way of doing word search doesn't correctly extend current search.
       ;;      (setq isearch-word t)
       ;;      (setq isearch-adjusted t)
       ;;      (goto-char isearch-barrier)
@@ -1286,8 +1289,9 @@ If there is no completion possible, say so and continue searching."
 (defun isearch-search ()
   ;; Do the search with the current search string.
   (isearch-message nil t)
-  (if search-upper-case
-      (setq isearch-case-fold-search (isearch-no-upper-case-p isearch-string)))
+  (if (and isearch-case-fold-search search-upper-case)
+      (setq isearch-case-fold-search
+	    (isearch-no-upper-case-p isearch-string isearch-regexp)))
   (condition-case lossage
       (let ((inhibit-quit nil)
 	    (case-fold-search isearch-case-fold-search))
@@ -1332,89 +1336,67 @@ If there is no completion possible, say so and continue searching."
 ;;;========================================================
 ;;; Highlighting
 
-(defun isearch-highlight (begin end))
-(defun isearch-dehighlight (totally))
+(defvar isearch-overlay nil)
 
-;; lemacs uses faces
-'(progn
-(defvar isearch-extent nil)
-
-(or (find-face 'isearch)	;; this face is initialized by x-faces.el
-    (make-face 'isearch))	;; since isearch is preloaded
-
-(defun isearch-lemacs-highlight (begin end)
-  (if (null isearch-highlight)
+(defun isearch-highlight (beg end)
+  (if (null search-highlight)
       nil
-    (if (and (extentp isearch-extent)
-	     (eq (extent-buffer isearch-extent) (current-buffer)))
-	(set-extent-endpoints isearch-extent begin end)
-      (if (and (extentp isearch-extent)
-	       (bufferp (extent-buffer isearch-extent))
-	       (buffer-name (extent-buffer isearch-extent)))
-	  (delete-extent isearch-extent))
-      (setq isearch-extent (make-extent begin end (current-buffer))))
-    (set-extent-face isearch-extent 'isearch)))
-
-(defun isearch-lemacs-dehighlight (totally)
-  (if (and isearch-highlight isearch-extent)
-      (if totally
-	  (let ((inhibit-quit t))
-	    (if (and (extentp isearch-extent)
-		     (bufferp (extent-buffer isearch-extent))
-		     (buffer-name (extent-buffer isearch-extent)))
-		(delete-extent isearch-extent))
-	    (setq isearch-extent nil))
-	(if (and (extentp isearch-extent)
-		 (bufferp (extent-buffer isearch-extent))
-		 (buffer-name (extent-buffer isearch-extent)))
-	    (set-extent-face isearch-extent 'default)
-	  (isearch-dehighlight t)))))
-
-(fset 'isearch-highlight (symbol-function 'isearch-lemacs-highlight))
-(fset 'isearch-dehighlight (symbol-function 'isearch-lemacs-dehighlight))
-)
+    (or isearch-overlay (setq isearch-overlay (make-overlay beg end)))
+    (move-overlay isearch-overlay beg end (current-buffer))
+    (overlay-put isearch-overlay 'face
+		 (if (internal-find-face 'isearch nil)
+		     'isearch 'region))))
+
+(defun isearch-dehighlight (totally)
+  (if isearch-overlay
+      (delete-overlay isearch-overlay)))
 
 ;;;===========================================================
 ;;; General utilities
 
-;; (fset 'isearch-member-equal (symbol-function 'member)) ; for emacs 19
-
-(defun isearch-member-equal (item list)
-  "Return non-nil if ITEM is `equal' to some item in LIST.
-Actually return the list whose car is that item."
-  (while (and list (not (equal item (car list))))
-    (setq list (cdr list)))
-  list)
-
 
-(defun isearch-no-upper-case-p (string)
-  "Return t if there are no upper case chars in string.
-But upper case chars preceeded by \\ (but not \\\\) do not count since they
-have special meaning in a regexp."
+(defun isearch-no-upper-case-p (string regexp-flag)
+  "Return t if there are no upper case chars in STRING.
+If REGEXP-FLAG is non-nil, disregard letters preceeded by `\\' (but not `\\\\')
+since they have special meaning in a regexp."
   (let ((case-fold-search nil))
-    (not (string-match "\\(^\\|\\\\\\\\\\|[^\\]\\)[A-Z]" string))))
+    (not (string-match (if regexp-flag "\\(^\\|\\\\\\\\\\|[^\\]\\)[A-Z]"
+			 "[A-Z]")
+		       string))))
 
 
 ;;;=================================================
-;;; Special functions for lemacs events.
+;; Portability functions to support various Emacs versions.
 
 ;; To quiet the byte-compiler.
 (defvar unread-command-event)
+(defvar unread-command-events)
 (defvar last-command-event)
 
 (defun isearch-char-to-string (c)
   (if (integerp c)
       (make-string 1 c)
-   (make-string 1 (event-to-character c))))
+    (if (and (symbolp c) (get c 'ascii-character))
+	(make-string 1 (get c 'ascii-character))
+      (make-string 1 (event-to-character c)))))
 
 (defun isearch-text-char-description (c)
   (isearch-char-to-string c))
 
-(defun isearch-unread (char-or-event)
-  ;; General function to unread a character or event.
-  (if isearch-event-data-type
-      (setq unread-command-event char-or-event)
-    (setq unread-command-char char-or-event)))
+(defun isearch-unread (&rest char-or-events)
+  ;; General function to unread characters or events.
+  (if isearch-gnu-emacs-events
+      (setq unread-command-events
+	    (append char-or-events unread-command-events))
+    (let ((char (if (cdr char-or-events)
+		    (progn
+		      (while (cdr char-or-events)
+			(setq char-or-events (cdr char-or-events)))
+		      (+ 128 (car char-or-events)))
+		  (car char-or-events))))
+      (if isearch-event-data-type
+	  (setq unread-command-event char)
+	(setq unread-command-char char)))))
 
 (defun isearch-last-command-char ()
   ;; General function to return the last command character.
@@ -1422,106 +1404,4 @@ have special meaning in a regexp."
       last-command-event
     last-command-char))
 
-
-
-
-;;;========================================================
-;;; Exiting in lemacs
-
-;; This is a large amount of code to support automatic termination of
-;; isearch-mode when a command (however it is invoked) is not an
-;; isearch command, or the buffer is switched out from under
-;; isearch-mode.   Only later versions of lemacs have the pre-command-hook.
-
-;;(if isearch-pre-command-hook-exists
-;;(progn
-
-;;;; This list must be modified whenever the available commands are modified.
-;;(mapcar (function (lambda (command)
-;;		    (put command 'isearch-command t)))
-;;	'(isearch-printing-char
-;;	  isearch-return-char
-;;	  isearch-repeat-forward
-;;	  isearch-repeat-backward
-;;	  isearch-delete-char
-;;	  isearch-abort	
-;;	  isearch-quote-char
-;;	  isearch-exit	
-;;	  isearch-printing-char
-;;	  isearch-printing-char
-;;	  isearch-yank-word	
-;;	  isearch-yank-line	
-;;	  isearch-*-char	
-;;	  isearch-*-char	
-;;	  isearch-|-char	
-;;	  isearch-toggle-regexp
-;;	  isearch-edit-string
-;;	  isearch-mode-help	
-;;	  isearch-ring-advance
-;;	  isearch-ring-retreat
-;;	  isearch-ring-advance-edit
-;;	  isearch-ring-retreat-edit
-;;	  isearch-whitespace-chars
-;;	  isearch-complete	
-;;	  isearch-complete-edit
-;;	  isearch-edit-string
-;;	  isearch-toggle-regexp
-;;	  ;; The following may not be needed since isearch-mode is off already.
-;;	  isearch-forward-exit-minibuffer
-;;	  isearch-reverse-exit-minibuffer
-;;	  isearch-nonincremental-exit-minibuffer))
-
-;;(defun isearch-pre-command-hook ()
-;;  ;;
-;;  ;; For use as the value of `pre-command-hook' when isearch-mode is active.
-;;  ;; If the command about to be executed is not one of the isearch commands,
-;;  ;; then isearch-mode is turned off before that command is executed.
-;;  ;;
-;;  ;; If the command about to be executed is self-insert-command, or is a
-;;  ;; keyboard macro of a single key sequence which is bound to self-insert-
-;;  ;; command, then we add those chars to the search ring instead of inserting
-;;  ;; them in the buffer.  In this way, the set of self-searching characters
-;;  ;; need not be exhaustively enumerated, but is derived from other maps.
-;;  ;;
-;;  (isearch-maybe-frob-keyboard-macros)
-;;  (if (and (symbolp this-command)
-;;	   (get this-command 'isearch-command))
-;;      nil
-;;    (isearch-done)))
-
-;;(defun isearch-maybe-frob-keyboard-macros ()
-;;  ;;
-;;  ;; If the command about to be executed is `self-insert-command' then change
-;;  ;; the command to `isearch-printing-char' instead, meaning add the last-
-;;  ;; typed character to the search string.
-;;  ;;
-;;  ;; If `this-command' is a string or a vector (that is, a keyboard macro)
-;;  ;; and it contains only one command, which is bound to self-insert-command,
-;;  ;; then do the same thing as for self-inserting commands: arrange for that
-;;  ;; character to be added to the search string.  If we didn't do this, then
-;;  ;; typing a compose sequence (a la x-compose.el) would terminate the search
-;;  ;; and insert the character, instead of searching for that character.
-;;  ;;
-;;  (cond ((eq this-command 'self-insert-command)
-;;	 (setq this-command 'isearch-printing-char))
-;;	((and (stringp this-command)
-;;	      (eq (key-binding this-command) 'self-insert-command))
-;;	 (setq last-command-char (aref this-command 0)
-;;	       last-command-event (character-to-event last-command-char)
-;;	       this-command 'isearch-printing-char))
-;;	((and (vectorp this-command)
-;;	      (eq (key-binding this-command) 'self-insert-command))
-;;	 (let* ((desc (aref this-command 0))
-;;		(code (cond ((integerp desc) desc)
-;;			    ((symbolp desc) (get desc character-set-property))
-;;			    ((consp desc)
-;;			     (and (null (cdr desc))
-;;				  (get (car desc) character-set-property)))
-;;			    (t nil))))
-;;	   (if code
-;;	       (setq last-command-char code
-;;		     last-command-event (character-to-event last-command-char)
-;;		     this-command 'isearch-printing-char))))
-;;	))
-
-;;))
+;;; isearch.el ends here