(hippie-expand): Removed bug - don't undo from another buffer.

(he-reset-string): Removed bug - don't move markers.
(he-capitalize-first): New function, defining new "case".
(he-transfer-case): New function.
(he-transfer-case-ok): Function removed.
(he-substitute-string,he-ordinary-case-p,he-string-member): Use the
new functions above, for the new case handling.
(he-file-name-chars): New variable.
(he-file-name-beg): Use `he-file-name-chars'.
(he-file-name-nondirectory,he-file-name-directory,
he-file-directory-p,he-concat-directory-file-name): New functions
to handle VMS and PC filename formats more accurately.
(try-complete-file-name,try-complete-file-name-partially): Use the
new functions above.
(try-expand-line-all-buffers,try-expand-list-all-buffers,
try-expand-dabbrev-all-buffers): Use `case-fold-search' from the
original buffer.
(he-line-beg): Removed bug that made point move.
(try-expand-all-abbrevs): Check that abbrev tables exist before use.
(try-expand-dabbrev-visible): New try function.
(he-search-window): New variable used by `try-expand-dabbrev-visible'.
(he-dab-search-regexp): Function removed.
(he-dab-search): Renamed to `he-dabbrev-search'.
(he-dabbrev-search): Find only whole matching symbols.
(he-dabbrev-skip-space): New variable.
(he-dabbrev-beg): Use `he-dabbrev-skip-space'.
(try-expand-dabbrev-from-kill,he-dabbrev-kill-search): New try
function, with requisites.
(try-expand-whole-kill,he-whole-kill-search,he-kill-beg): New try
function, with requisites.
(he-search-loc2): New variable, used by `try-expand-whole-kill'
and `try-expand-dabbrev-from-kill'.
(hippie-expand-try-functions-list): Added the try functions
`try-complete-file-name-partially', `try-expand-dabbrev-from-kill'
and `try-complete-lisp-symbol-partially'.
(Several functions): Adjusted and corrected use of `he-tried-table'.

1 files changed, 424 insertions, 169 deletions

diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index 9e7334ab569..408b80ee393 100644
--- a/lisp/hippie-exp.el
+++ b/lisp/hippie-exp.el
@@ -1,11 +1,11 @@
 ;;; hippie-exp.el --- expand text trying various ways to find its expansion.
 
 ;; Author: Anders Holst <aho@sans.kth.se>
-;; Last change: 2 September 1993
-;; Version: 1.3
+;; Last change: 6 August 1995
+;; Version: 1.4
 ;; Keywords: abbrev
 
-;; Copyright (C) 1992, 1993 Free Software Foundation, Inc.
+;; Copyright (C) 1992 Free Software Foundation, Inc.
 ;;
 ;; This file is part of GNU Emacs.
 
@@ -79,6 +79,16 @@
 ;;      like `dabbrev-expand' but searches all Emacs buffers (except the
 ;;      current) for matching words.  (No, I don't find this one
 ;;      particularly slow.) 
+;;    `try-expand-dabbrev-visible': Searches the currently visible parts of
+;;      all windows.  Can be put before `try-expand-dabbrev-all-buffers' to
+;;      first try the expansions you can see.
+;;    `try-expand-dabbrev-from-kill': Searches the kill ring for a suitable
+;;      completion of the word.  Good to have, just in case the word was not
+;;      found elsewhere.
+;;    `try-expand-whole-kill' : Tries to complete text with a whole entry
+;;      from the kill ring.  May be good if you don't know how far up in
+;;      the kill-ring the required entry is, and don't want to mess with
+;;      "Choose Next Paste".
 ;;    `try-complete-lisp-symbol' : like `lisp-complete-symbol', but goes
 ;;      through all possibilities instead of completing what is unique.
 ;;      Might be tedious (usually a lot of possible completions) and
@@ -123,7 +133,7 @@
 ;;  There is also a variable: `he-tried-table' which is meant to contain
 ;;  all tried expansions so far.  The try-function can check this 
 ;;  variable to see whether an expansion has already been tried
-;;  (hint: `he-string-member'), and add its own tried expansions to it.
+;;  (hint: `he-string-member').
 ;;
 ;;  Known bugs
 ;;
@@ -131,8 +141,8 @@
 ;;  spite of the use of `he-tried-table' to prevent that.  This is 
 ;;  because different try-functions may try to complete different
 ;;  lengths of text, and thus put different amounts of the
-;;  text in `he-try-table'.  Anyway this seems to occur seldom enough not
-;;  to be too disturbing.  Also it should NOT be possible for the
+;;  text in `he-tried-table'.  Anyway this seems to occur seldom enough
+;;  not to be too disturbing.  Also it should NOT be possible for the
 ;;  opposite situation to occur, that `hippie-expand' misses some
 ;;  suggestion because it thinks it has already tried it.
 ;;
@@ -141,7 +151,7 @@
 ;;  I want to thank Mikael Djurfeldt in discussions with whom the idea
 ;;  of this function took form.
 ;;  I am also grateful to all those who have given me suggestions on
-;;  how to improve it.
+;;  how to improve it, and all those who helped to find and remove bugs.
 ;;
 
 ;;; Code:
@@ -160,19 +170,26 @@
 
 (defvar he-search-loc (make-marker))
 
+(defvar he-search-loc2 ())
+
 (defvar he-search-bw ())
 
 (defvar he-search-bufs ())
 
 (defvar he-searched-n-bufs ())
 
+(defvar he-search-window ())
+
 ;;;###autoload
-(defvar hippie-expand-try-functions-list '(try-complete-file-name
+(defvar hippie-expand-try-functions-list '(try-complete-file-name-partially
+					   try-complete-file-name
 					   try-expand-all-abbrevs
-                                           try-expand-list
+					   try-expand-list
 					   try-expand-line
 					   try-expand-dabbrev
 					   try-expand-dabbrev-all-buffers
+					   try-expand-dabbrev-from-kill
+					   try-complete-lisp-symbol-partially
 					   try-complete-lisp-symbol)
   "The list of expansion functions tried in order by `hippie-expand'.
 To change the behavior of `hippie-expand', remove, change the order of,
@@ -229,16 +246,17 @@ undoes the expansion."
 		  (message "No further expansions found"))
 	      (ding))
 	    (if (and hippie-expand-verbose
-                     (not (window-minibuffer-p (selected-window))))
+		     (not (window-minibuffer-p (selected-window))))
 		(message (concat "Using "
 				 (prin1-to-string (nth he-num 
 				   hippie-expand-try-functions-list)))))))
-      (if (>= he-num 0)
+      (if (and (>= he-num 0)
+	       (eq (marker-buffer he-string-beg) (current-buffer)))
 	  (progn
 	    (setq he-num -1)
 	    (he-reset-string)
 	    (if (and hippie-expand-verbose
-                     (not (window-minibuffer-p (selected-window))))
+		     (not (window-minibuffer-p (selected-window))))
 		(message "Undoing expansions"))))))
 
 ;; Initializes the region to expand (to between BEG and END).
@@ -250,13 +268,10 @@ undoes the expansion."
 ;; Resets the expanded region to its original contents.
 (defun he-reset-string ()
   (let ((newpos (point-marker)))
-    (delete-region he-string-beg he-string-end)
     (goto-char he-string-beg)
     (insert he-search-string)
-    (set-marker he-string-end (point))
-    (if (= newpos he-string-beg)
-	(goto-char he-string-end)
-	(goto-char newpos))))
+    (delete-region (point) he-string-end)
+    (goto-char newpos)))
 
 ;; Substitutes an expansion STR into the correct region (the region
 ;; initialized with `he-init-string'). 
@@ -266,53 +281,66 @@ undoes the expansion."
 (defun he-substitute-string (str &optional trans-case)
   (let ((trans-case (and trans-case
 			 case-replace
-			 case-fold-search
-			 (he-transfer-case-ok str he-search-string)))
-	(newpos (point-marker)))
-    (he-reset-string)
+			 case-fold-search))
+	(newpos (point-marker))
+	(subst ()))
     (goto-char he-string-beg)
-    (search-forward he-search-string)
-    (replace-match (if trans-case (downcase str) str)
-		   (not trans-case)
-		   'literal)
-    (set-marker he-string-end (point))
-    (if (= newpos he-string-beg)
-	(goto-char he-string-end)
-	(goto-char newpos))))
+    (setq subst (if trans-case (he-transfer-case he-search-string str) str))
+    (setq he-tried-table (cons subst he-tried-table))
+    (insert subst)
+    (delete-region (point) he-string-end)
+    (goto-char newpos)))
+
+(defun he-capitalize-first (str)
+  (save-match-data
+    (if (string-match "\\Sw*\\(\\sw\\).*" str)
+	(let ((res (downcase str))
+	      (no (match-beginning 1)))
+	  (aset res no (upcase (aref str no)))
+	  res)
+      str)))
 
 (defun he-ordinary-case-p (str)
   (or (string= str (downcase str))
       (string= str (upcase str))
-      (string= str (capitalize str))))
-
-(defun he-transfer-case-ok (to-str from-str)
-  (and (not (string= from-str (substring to-str 0 (min (length from-str)
-                                                       (length to-str)))))
-         ;; otherwise transfer is not needed (and this also solves
-	 ;; some obscure situations)
-       (he-ordinary-case-p to-str)
-         ;; otherwise case may be significant 
-       (he-ordinary-case-p from-str)
-         ;; otherwise replace-match wont know what to do
-  ))
+      (string= str (capitalize str))
+      (string= str (he-capitalize-first str))))
+
+(defun he-transfer-case (from-str to-str)
+  (cond ((string= from-str (substring to-str 0 (min (length from-str)
+						    (length to-str))))
+	 to-str)
+	((not (he-ordinary-case-p to-str))
+	 to-string)
+	((string= from-str (downcase from-str))
+	 (downcase to-str))
+	((string= from-str (upcase from-str))
+	 (upcase to-str))
+	((string= from-str (he-capitalize-first from-str))
+	 (he-capitalize-first to-str))
+	((string= from-str (capitalize from-str))
+	 (capitalize to-str))
+	(t
+	 to-str)))
+
 
 ;; Check if STR is a member of LST.
-;; Ignore case if `case-replace' and `case-fold-search' are both t.
-(defun he-string-member (str lst)
-  (while (and lst
-	      (not
-	       (if (and case-fold-search case-replace)
-		   (string= (downcase (car lst)) (downcase str))
-		   (string= (car lst) str))))
-    (setq lst (cdr lst)))
-  lst)
+;; Transform to the final case if optional TRANS-CASE is non-NIL.
+(defun he-string-member (str lst &optional trans-case)
+  (if str
+      (member (if (and trans-case
+		       case-replace
+		       case-fold-search)
+		  (he-transfer-case he-search-string str)
+		str)
+	      lst)))
 
 ;; Check if STR matches any regexp in LST.
 ;; Ignore possible non-strings in LST.
 (defun he-regexp-member (str lst)
   (while (and lst
 	      (or (not (stringp (car lst)))
-                  (not (string-match (car lst) str))))
+		  (not (string-match (car lst) str))))
     (setq lst (cdr lst)))
   lst)
 
@@ -334,7 +362,7 @@ Make it use the expansion functions in TRY-LIST.  An optional second
 argument VERBOSE non-nil makes the function verbose."
   (` (function (lambda (arg)
        (, (concat 
-           "Try to expand text before point, using the following functions: \n"
+	   "Try to expand text before point, using the following functions: \n"
 	   (mapconcat 'prin1-to-string (eval try-list) ", ")))
        (interactive "P")
        (let ((hippie-expand-try-functions-list (, try-list))
@@ -344,6 +372,7 @@ argument VERBOSE non-nil makes the function verbose."
 
 ;;;  Here follows the try-functions and their requisites:
 
+
 (defun try-complete-file-name (old)
   "Try to complete text as a file name.
 The argument OLD has to be nil the first call of this function, and t
@@ -352,13 +381,13 @@ string).  It returns t if a new completion is found, nil otherwise."
   (if (not old)
       (progn 
 	(he-init-string (he-file-name-beg) (point))
-	(let ((name-part (file-name-nondirectory he-search-string))
-	      (dir-part (expand-file-name (or (file-name-directory
+	(let ((name-part (he-file-name-nondirectory he-search-string))
+	      (dir-part (expand-file-name (or (he-file-name-directory
 					       he-search-string) ""))))
 	  (if (not (he-string-member name-part he-tried-table))
 	      (setq he-tried-table (cons name-part he-tried-table)))
 	  (if (and (not (equal he-search-string ""))
-		   (file-directory-p dir-part))
+		   (he-file-directory-p dir-part))
 	      (setq he-expand-list (sort (file-name-all-completions 
 					  name-part
 					  dir-part)
@@ -370,12 +399,13 @@ string).  It returns t if a new completion is found, nil otherwise."
     (setq he-expand-list (cdr he-expand-list)))
   (if (null he-expand-list)
       (progn
-        (if old (he-reset-string))
+	(if old (he-reset-string))
 	())
-      (let ((filename (concat (file-name-directory he-search-string)
-			      (car he-expand-list))))
+      (let ((filename (he-concat-directory-file-name
+		       (he-file-name-directory he-search-string)
+		       (car he-expand-list))))
 	(he-substitute-string filename)
-	(setq he-tried-table (cons (car he-expand-list) he-tried-table))
+	(setq he-tried-table (cons (car he-expand-list) (cdr he-tried-table)))
 	(setq he-expand-list (cdr he-expand-list))
 	t)))
 
@@ -388,33 +418,88 @@ otherwise."
     (if (not old)
 	(progn 
 	  (he-init-string (he-file-name-beg) (point))
-	  (let ((name-part (file-name-nondirectory he-search-string))
-		(dir-part (expand-file-name (or (file-name-directory
+	  (let ((name-part (he-file-name-nondirectory he-search-string))
+		(dir-part (expand-file-name (or (he-file-name-directory
 						 he-search-string) ""))))
 	    (if (and (not (equal he-search-string ""))
-		     (file-directory-p dir-part))
+		     (he-file-directory-p dir-part))
 		(setq expansion (file-name-completion name-part
 						      dir-part)))
 	    (if (or (eq expansion t)
-		    (string= expansion name-part))
+		    (string= expansion name-part)
+		    (he-string-member expansion he-tried-table))
 		(setq expansion ())))))
 
     (if (not expansion)
 	(progn
-          (if old (he-reset-string))
+	  (if old (he-reset-string))
 	  ())
-	(let ((filename (concat (file-name-directory he-search-string)
-				expansion)))
+	(let ((filename (he-concat-directory-file-name
+			 (he-file-name-directory he-search-string)
+			 expansion)))
 	  (he-substitute-string filename)
-	  (setq he-tried-table (cons expansion he-tried-table))
+	  (setq he-tried-table (cons expansion (cdr he-tried-table)))
 	  t))))
 
+(defvar he-file-name-chars
+  (cond ((memq system-type '(vax-vms axp-vms))
+	 "-a-zA-Z0-9_/.,~^#$+=:\\[\\]")
+	((memq system-type '(ms-dos ms-windows))
+	 "-a-zA-Z0-9_/.,~^#$+=:\\\\")
+	(t			    ;; More strange file formats ?
+	 "-a-zA-Z0-9_/.,~^#$+="))
+  "Characters that are considered part of the file name to expand.")
+
 (defun he-file-name-beg ()
-  (let ((skips "-a-zA-Z0-9_./~^#$"))
-    (save-excursion
-      (skip-chars-backward skips)
-      (point))))
+  (save-excursion
+    (skip-chars-backward he-file-name-chars)
+    (point)))
 
+;; Thanks go to Richard Levitte <levitte@e.kth.se> who helped to make these
+;; work under VMS, and to David Hughes <ukchugd@ukpmr.cs.philips.nl> who 
+;; helped to make it work on PC.
+(defun he-file-name-nondirectory (file)
+  "Fix to make `file-name-nondirectory' work for hippie-expand under VMS."
+  (if (memq system-type '(axp-vms vax-vms))
+      (let ((n (file-name-nondirectory file)))
+	(if (string-match "^\\(\\[.*\\)\\.\\([^\\.]*\\)$" n)
+	    (concat "[." (substring n (match-beginning 2) (match-end 2)))
+	  n))
+    (file-name-nondirectory file)))
+
+(defun he-file-name-directory (file)
+  "Fix to make `file-name-directory' work for hippie-expand under VMS."
+  (if (memq system-type '(axp-vms vax-vms))
+      (let ((n (file-name-nondirectory file))
+	    (d (file-name-directory file)))
+	(if (string-match "^\\(\\[.*\\)\\.\\([^\\.]*\\)$" n)
+	    (concat d (substring n (match-beginning 1) (match-end 1)) "]")
+	  d))
+    (file-name-directory file)))
+
+(defun he-file-directory-p (file)
+  "Fix to make `file-directory-p' work for hippie-expand under VMS."
+  (if (memq system-type '(vax-vms axp-vms))
+      (or (file-directory-p file)
+	  (file-directory-p (concat file "[000000]")))
+    (file-directory-p dir-part)))
+  
+(defun he-concat-directory-file-name (dir-part name-part)
+  "Try to slam together two parts of a file specification, system dependently."
+  (cond ((memq system-type '(axp-vms vax-vms))
+	 (if (and (string= (substring dir-part -1) "]")
+		  (string= (substring name-part 0 2) "[."))
+	     (concat (substring dir-part 0 -1) (substring name-part 1))
+	   (concat dir-part name-part)))
+	((memq system-type '(ms-dos ms-windows))
+	 (if (and (string-match "\\\\" dir-part)
+		  (not (string-match "/" dir-part))
+		  (= (aref name-part (1- (length name-part))) ?/))
+	     (aset name-part (1- (length name-part)) ?\\))
+	 (concat dir-part name-part))
+	(t 
+	 (concat dir-part name-part))))
+			
 (defun try-complete-lisp-symbol (old)
   "Try to complete word as an Emacs Lisp symbol.
 The argument OLD has to be nil the first call of this function, and t
@@ -438,11 +523,10 @@ string).  It returns t if a new completion is found, nil otherwise."
     (setq he-expand-list (cdr he-expand-list)))
   (if (null he-expand-list)
       (progn
-        (if old (he-reset-string))
+	(if old (he-reset-string))
 	())
       (progn
 	(he-substitute-string (car he-expand-list))
-	(setq he-tried-table (cons (car he-expand-list) he-tried-table))
 	(setq he-expand-list (cdr he-expand-list))
 	t)))
 
@@ -463,16 +547,16 @@ otherwise."
 					  (fboundp sym)
 					  (symbol-plist sym)))))))
 	  (if (or (eq expansion t)
-		  (string= expansion he-search-string))
+		  (string= expansion he-search-string)
+		  (he-string-member expansion he-tried-table))
 	      (setq expansion ()))))
 
   (if (not expansion)
       (progn
-        (if old (he-reset-string))
+	(if old (he-reset-string))
 	())
       (progn
 	(he-substitute-string expansion)
-	(setq he-tried-table (cons expansion he-tried-table))
 	t))))
 
 (defun he-lisp-symbol-beg ()
@@ -518,11 +602,10 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not expansion)
 	(progn
-          (if old (he-reset-string))
+	  (if old (he-reset-string))
 	  ())
 	(progn
 	  (he-substitute-string expansion t)
-	  (setq he-tried-table (cons expansion he-tried-table))
 	  t))))
 
 (defun try-expand-line-all-buffers (old)
@@ -533,43 +616,45 @@ string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ())
 	(strip-prompt (and (get-buffer-process (current-buffer))
 			   comint-prompt-regexp))
-	(buf (current-buffer)))
+	(buf (current-buffer))
+	(orig-case-fold-search case-fold-search))
     (if (not old)
 	(progn
 	  (he-init-string (he-line-beg strip-prompt) (point))
 	  (setq he-search-bufs (buffer-list))
-          (setq he-searched-n-bufs 0)
+	  (setq he-searched-n-bufs 0)
 	  (set-marker he-search-loc 1 (car he-search-bufs))))
 
     (if (not (equal he-search-string ""))
 	(while (and he-search-bufs 
-                    (not expansion)
-                    (or (not hippie-expand-max-buffers)
-                        (< he-searched-n-bufs hippie-expand-max-buffers)))
+		    (not expansion)
+		    (or (not hippie-expand-max-buffers)
+			(< he-searched-n-bufs hippie-expand-max-buffers)))
 	  (set-buffer (car he-search-bufs))
 	  (if (and (not (eq (current-buffer) buf))
 		   (not (memq major-mode hippie-expand-ignore-buffers))
-                   (not (he-regexp-member (buffer-name)
-                                          hippie-expand-ignore-buffers)))
+		   (not (he-regexp-member (buffer-name)
+					  hippie-expand-ignore-buffers)))
 	      (save-excursion
 		(goto-char he-search-loc)
-                (setq strip-prompt (and (get-buffer-process (current-buffer))
-                                        comint-prompt-regexp))
-		(setq expansion (he-line-search he-search-string
-						strip-prompt nil))
+		(setq strip-prompt (and (get-buffer-process (current-buffer))
+					comint-prompt-regexp))
+		(setq expansion (let ((case-fold-search orig-case-fold-search))
+				  (he-line-search he-search-string
+						  strip-prompt nil)))
 		(set-marker he-search-loc (point))
-                (if expansion
-                    (setq he-tried-table (cons expansion he-tried-table))
-                  (setq he-search-bufs (cdr he-search-bufs))
-                  (setq he-searched-n-bufs (1+ he-searched-n-bufs))
-                  (set-marker he-search-loc 1 (car he-search-bufs))))
-            (setq he-search-bufs (cdr he-search-bufs))
-            (set-marker he-search-loc 1 (car he-search-bufs)))))
+		(if (not expansion)
+		    (progn
+		      (setq he-search-bufs (cdr he-search-bufs))
+		      (setq he-searched-n-bufs (1+ he-searched-n-bufs))
+		      (set-marker he-search-loc 1 (car he-search-bufs)))))
+	    (setq he-search-bufs (cdr he-search-bufs))
+	    (set-marker he-search-loc 1 (car he-search-bufs)))))
 
     (set-buffer buf)
     (if (not expansion)
 	(progn
-          (if old (he-reset-string))
+	  (if old (he-reset-string))
 	  ())
 	(progn
 	  (he-substitute-string expansion t)
@@ -586,18 +671,16 @@ string).  It returns t if a new completion is found, nil otherwise."
 		     (he-line-search-regexp str strip-prompt)
 		     nil t)))
       (setq result (buffer-substring (match-beginning 2) (match-end 2)))
-      (if (he-string-member result he-tried-table)
-	  (setq result nil)))	            ; if already in table, ignore
+      (if (he-string-member result he-tried-table t)
+	  (setq result nil)))		    ; if already in table, ignore
     result))
 
 (defun he-line-beg (strip-prompt)
   (save-excursion
-    (end-of-line)
     (if (re-search-backward (he-line-search-regexp "" strip-prompt) 
 			    (save-excursion (beginning-of-line)
 					    (point)) t)
 	(match-beginning 2)
-      (beginning-of-line)
       (point))))
 
 (defun he-line-search-regexp (pat strip-prompt)
@@ -646,7 +729,6 @@ string).  It returns t if a new completion is found, nil otherwise."
 	  ())
 	(progn
 	  (he-substitute-string expansion t)
-	  (setq he-tried-table (cons expansion he-tried-table))
 	  t))))
 
 (defun try-expand-list-all-buffers (old)
@@ -655,40 +737,42 @@ The argument OLD has to be nil the first call of this function, and t
 for subsequent calls (for further possible completions of the same
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ())
-	(buf (current-buffer)))
+	(buf (current-buffer))
+	(orig-case-fold-search case-fold-search))
     (if (not old)
 	(progn
 	  (he-init-string (he-list-beg) (point))
 	  (setq he-search-bufs (buffer-list))
-          (setq he-searched-n-bufs 0)
+	  (setq he-searched-n-bufs 0)
 	  (set-marker he-search-loc 1 (car he-search-bufs))))
 
     (if (not (equal he-search-string ""))
 	(while (and he-search-bufs 
-                    (not expansion)
-                    (or (not hippie-expand-max-buffers)
-                        (< he-searched-n-bufs hippie-expand-max-buffers)))
+		    (not expansion)
+		    (or (not hippie-expand-max-buffers)
+			(< he-searched-n-bufs hippie-expand-max-buffers)))
 	  (set-buffer (car he-search-bufs))
 	  (if (and (not (eq (current-buffer) buf))
 		   (not (memq major-mode hippie-expand-ignore-buffers))
-                   (not (he-regexp-member (buffer-name)
-                                          hippie-expand-ignore-buffers)))
+		   (not (he-regexp-member (buffer-name)
+					  hippie-expand-ignore-buffers)))
 	      (save-excursion
 		(goto-char he-search-loc)
-		(setq expansion (he-list-search he-search-string nil))
+		(setq expansion (let ((case-fold-search orig-case-fold-search))
+				  (he-list-search he-search-string nil)))
 		(set-marker he-search-loc (point))
-                (if expansion
-                    (setq he-tried-table (cons expansion he-tried-table))
-                  (setq he-search-bufs (cdr he-search-bufs))
-                  (setq he-searched-n-bufs (1+ he-searched-n-bufs))
-                  (set-marker he-search-loc 1 (car he-search-bufs))))
-            (setq he-search-bufs (cdr he-search-bufs))
-            (set-marker he-search-loc 1 (car he-search-bufs)))))
+		(if (not expansion)
+		    (progn
+		      (setq he-search-bufs (cdr he-search-bufs))
+		      (setq he-searched-n-bufs (1+ he-searched-n-bufs))
+		      (set-marker he-search-loc 1 (car he-search-bufs)))))
+	    (setq he-search-bufs (cdr he-search-bufs))
+	    (set-marker he-search-loc 1 (car he-search-bufs)))))
 
     (set-buffer buf)
     (if (not expansion)
 	(progn
-          (if old (he-reset-string))
+	  (if old (he-reset-string))
 	  ())
 	(progn
 	  (he-substitute-string expansion t)
@@ -696,7 +780,7 @@ string).  It returns t if a new completion is found, nil otherwise."
 
 (defun he-list-search (str reverse) 
   (let ((result ())
-        beg pos err)
+	beg pos err)
     (while (and (not result)
 		(if reverse
 		    (search-backward str nil t)
@@ -706,23 +790,23 @@ string).  It returns t if a new completion is found, nil otherwise."
       (goto-char beg)
       (setq err ())
       (condition-case ()
-          (forward-list 1)
-        (error (setq err t)))
+	  (forward-list 1)
+	(error (setq err t)))
       (if (and reverse 
-               (> (point) he-string-beg))
-          (setq err t))
+	       (> (point) he-string-beg))
+	  (setq err t))
       (if (not err)
-          (progn
-            (setq result (buffer-substring beg (point)))
-            (if (he-string-member result he-tried-table)
-                (setq result nil))))	       ; if already in table, ignore
+	  (progn
+	    (setq result (buffer-substring beg (point)))
+	    (if (he-string-member result he-tried-table t)
+		(setq result nil))))	       ; if already in table, ignore
       (goto-char pos))
     result))
 
 (defun he-list-beg ()
   (save-excursion
     (condition-case ()
-        (backward-up-list 1)
+	(backward-up-list 1)
       (error ()))
     (point)))
 
@@ -737,22 +821,22 @@ string).  It returns t if a new expansion is found, nil otherwise."
 	(setq he-expand-list 
 	      (and (not (equal he-search-string ""))
 		   (mapcar (function (lambda (sym)
-			     (abbrev-expansion (downcase he-search-string)
-					       (eval sym))))
+			     (if (and (boundp sym) (vectorp (eval sym)))
+				 (abbrev-expansion (downcase he-search-string)
+						   (eval sym)))))
 			   (append '(local-abbrev-table 
 				     global-abbrev-table)
 				   abbrev-table-name-list))))))
   (while (and he-expand-list
 	      (or (not (car he-expand-list))
-		  (he-string-member (car he-expand-list) he-tried-table)))
+		  (he-string-member (car he-expand-list) he-tried-table t)))
     (setq he-expand-list (cdr he-expand-list)))
   (if (null he-expand-list)
       (progn
-        (if old (he-reset-string))
+	(if old (he-reset-string))
 	())
       (progn
 	(he-substitute-string (car he-expand-list) t)
-	(setq he-tried-table (cons (car he-expand-list) he-tried-table))
 	(setq he-expand-list (cdr he-expand-list))
 	t)))
 
@@ -774,7 +858,7 @@ string).  It returns t if a new expansion is found, nil otherwise."
 	  (if he-search-bw
 	      (progn 
 		(goto-char he-search-loc)
-		(setq expansion (he-dab-search he-search-string t))
+		(setq expansion (he-dabbrev-search he-search-string t))
 		(set-marker he-search-loc (point))
 		(if (not expansion)
 		    (progn
@@ -784,16 +868,15 @@ string).  It returns t if a new expansion is found, nil otherwise."
 	  (if (not expansion) ; Then look forward.
 	      (progn 
 		(goto-char he-search-loc)
-		(setq expansion (he-dab-search he-search-string nil))
+		(setq expansion (he-dabbrev-search he-search-string nil))
 		(set-marker he-search-loc (point))))))
 	
     (if (not expansion)
 	(progn
-          (if old (he-reset-string))
+	  (if old (he-reset-string))
 	  ())
 	(progn
 	  (he-substitute-string expansion t)
-	  (setq he-tried-table (cons expansion he-tried-table))
 	  t))))
 
 (defun try-expand-dabbrev-all-buffers (old)
@@ -802,68 +885,240 @@ The argument OLD has to be nil the first call of this function, and t
 for subsequent calls (for further possible expansions of the same
 string).  It returns t if a new expansion is found, nil otherwise."
   (let ((expansion ())
-	(buf (current-buffer)))
+	(buf (current-buffer))
+	(orig-case-fold-search case-fold-search))
     (if (not old)
 	(progn
 	  (he-init-string (he-dabbrev-beg) (point))
 	  (setq he-search-bufs (buffer-list))
-          (setq he-searched-n-bufs 0)
+	  (setq he-searched-n-bufs 0)
 	  (set-marker he-search-loc 1 (car he-search-bufs))))
 
     (if (not (equal he-search-string ""))
 	(while (and he-search-bufs 
-                    (not expansion)
-                    (or (not hippie-expand-max-buffers)
-                        (< he-searched-n-bufs hippie-expand-max-buffers)))
+		    (not expansion)
+		    (or (not hippie-expand-max-buffers)
+			(< he-searched-n-bufs hippie-expand-max-buffers)))
 	  (set-buffer (car he-search-bufs))
 	  (if (and (not (eq (current-buffer) buf))
 		   (not (memq major-mode hippie-expand-ignore-buffers))
-                   (not (he-regexp-member (buffer-name)
-                                          hippie-expand-ignore-buffers)))
+		   (not (he-regexp-member (buffer-name)
+					  hippie-expand-ignore-buffers)))
 	      (save-excursion
 		(goto-char he-search-loc)
-		(setq expansion (he-dab-search he-search-string nil))
+		(setq expansion (let ((case-fold-search orig-case-fold-search))
+				  (he-dabbrev-search he-search-string nil)))
 		(set-marker he-search-loc (point))
-                (if expansion
-                    (setq he-tried-table (cons expansion he-tried-table))
-                  (setq he-search-bufs (cdr he-search-bufs))
-                  (setq he-searched-n-bufs (1+ he-searched-n-bufs))
-                  (set-marker he-search-loc 1 (car he-search-bufs))))
-            (setq he-search-bufs (cdr he-search-bufs))
-            (set-marker he-search-loc 1 (car he-search-bufs)))))
+		(if (not expansion)
+		    (progn
+		      (setq he-search-bufs (cdr he-search-bufs))
+		      (setq he-searched-n-bufs (1+ he-searched-n-bufs))
+		      (set-marker he-search-loc 1 (car he-search-bufs)))))
+	    (setq he-search-bufs (cdr he-search-bufs))
+	    (set-marker he-search-loc 1 (car he-search-bufs)))))
 
     (set-buffer buf)
     (if (not expansion)
 	(progn
-          (if old (he-reset-string))
+	  (if old (he-reset-string))
 	  ())
 	(progn
 	  (he-substitute-string expansion t)
 	  t))))
 
-(defun he-dab-search-regexp (pat)
-  (concat "\\<" (regexp-quote pat) 
-	  "\\(\\sw\\|\\s_\\)+"))
+;; Thanks go to Jeff Dairiki <dairiki@faraday.apl.washington.edu> who
+;; suggested this one.
+(defun try-expand-dabbrev-visible (old)
+  "Try to expand word \"dynamically\", searching visible window parts.
+The argument OLD has to be nil the first call of this function, and t
+for subsequent calls (for further possible expansions of the same
+string).  It returns t if a new expansion is found, nil otherwise."
+  (let ((expansion ())
+	(buf (current-buffer))
+	(flag (if (frame-visible-p (window-frame (selected-window)))
+		  'visible t)))
+    (if (not old)
+	(progn
+	   (he-init-string (he-dabbrev-beg) (point))
+	   (setq he-search-window (selected-window))
+	   (set-marker he-search-loc
+		       (window-start he-search-window)
+		       (window-buffer he-search-window))))
+
+    (while (and (not (equal he-search-string ""))
+		(marker-position he-search-loc)
+		(not expansion))
+      (save-excursion
+	(set-buffer (marker-buffer he-search-loc))
+	(goto-char he-search-loc)
+	(setq expansion (he-dabbrev-search he-search-string ()
+					   (window-end he-search-window)))
+	(if (and expansion
+		 (eq (marker-buffer he-string-beg) (current-buffer))
+		 (eq (marker-position he-string-beg) (match-beginning 0)))
+	    (setq expansion (he-dabbrev-search he-search-string ()
+					       (window-end he-search-window))))
+	(set-marker he-search-loc (point) (current-buffer)))
+      (if (not expansion)
+	  (progn 
+	    (setq he-search-window (next-window he-search-window nil flag))
+	    (if (eq he-search-window (selected-window))
+		(set-marker he-search-loc nil)
+	      (set-marker he-search-loc (window-start he-search-window)
+			  (window-buffer he-search-window))))))
+    
+    (set-buffer buf)
+    (if (not expansion)
+	(progn
+	  (if old (he-reset-string))
+	  ())
+	(progn
+	  (he-substitute-string expansion t)
+	  t))))
 
-(defun he-dab-search (pattern reverse)
-  (let ((result ()))
+(defun he-dabbrev-search (pattern &optional reverse limit)
+  (let ((result ())
+	(regpat (if (eq (char-syntax (aref pattern 0)) ?_)
+		    (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+")
+		  (concat "\\<" (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))))
     (while (and (not result) 
 		(if reverse
-		     (re-search-backward (he-dab-search-regexp pattern)
-					 nil t)
-		     (re-search-forward (he-dab-search-regexp pattern)
-					nil t)))
+		     (re-search-backward regpat limit t)
+		     (re-search-forward regpat limit t)))
       (setq result (buffer-substring (match-beginning 0) (match-end 0)))
-      (if (he-string-member result he-tried-table)
-	  (setq result nil)))	            ; if already in table, ignore
+      (if (or (and (> (match-beginning 0) (point-min))
+		   (memq (char-syntax (char-after (1- (match-beginning 0))))
+			 '(?_ ?w)))
+	      (he-string-member result he-tried-table t))
+	  (setq result nil)))     ; ignore if bad prefix or already in table
     result))
 
+(defvar he-dabbrev-skip-space ()
+  "Non-NIL means tolerate trailing spaces in the abbreviation to expand.")
+
 (defun he-dabbrev-beg ()
-  (min (point)
-       (save-excursion
-         (skip-syntax-backward "w_")
-         (skip-syntax-forward "_")
-         (point))))
+  (let ((op (point)))
+    (save-excursion
+      (if he-dabbrev-skip-space
+	  (skip-syntax-backward ". "))
+      (if (= (skip-syntax-backward "w_") 0)
+	  op
+	(point)))))
+
+(defun try-expand-dabbrev-from-kill (old)
+  "Try to expand word \"dynamically\", searching the kill ring.
+The argument OLD has to be nil the first call of this function, and t
+for subsequent calls (for further possible completions of the same
+string).  It returns t if a new completion is found, nil otherwise."
+  (let ((expansion ()))
+    (if (not old)
+	(progn 
+	  (he-init-string (he-dabbrev-beg) (point))
+	  (setq he-expand-list
+		(if (not (equal he-search-string ""))
+		    kill-ring))
+	  (setq he-search-loc2 0)))
+    (if (not (equal he-search-string ""))
+	(setq expansion (he-dabbrev-kill-search he-search-string)))
+    (if (not expansion)
+	(progn
+	  (if old (he-reset-string))
+	  ())
+	(progn
+	  (he-substitute-string expansion t)
+	  t))))
+
+(defun he-dabbrev-kill-search (pattern)
+  (let ((result ())
+	(regpat (if (eq (char-syntax (aref pattern 0)) ?_)
+		    (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+")
+		  (concat "\\<" (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+")))
+	(killstr (car he-expand-list)))
+    (while (and (not result) 
+		he-expand-list)
+      (while (and (not result)
+		  (string-match regpat killstr he-search-loc2))
+	(setq result (substring killstr (match-beginning 0) (match-end 0)))
+	(setq he-search-loc2 (1+ (match-beginning 0)))
+	(if (or (and (> (match-beginning 0) 0)
+		     (memq (char-syntax (aref killstr (1- (match-beginning 0))))
+			   '(?_ ?w)))
+		(he-string-member result he-tried-table t))
+	    (setq result nil)))     ; ignore if bad prefix or already in table
+      (if (and (not result) 
+		he-expand-list)
+	  (progn
+	    (setq he-expand-list (cdr he-expand-list)) 
+	    (setq killstr (car he-expand-list))
+	    (setq he-search-loc2 0))))
+    result))
+
+(defun try-expand-whole-kill (old)
+  "Try to complete text with something from the kill ring.
+The argument OLD has to be nil the first call of this function, and t
+for subsequent calls (for further possible completions of the same
+string).  It returns t if a new completion is found, nil otherwise."
+  (let ((expansion ()))
+    (if (not old)
+	(progn 
+	  (he-init-string (he-kill-beg) (point))
+	  (if (not (he-string-member he-search-string he-tried-table))
+	      (setq he-tried-table (cons he-search-string he-tried-table)))
+	  (setq he-expand-list 
+		(if (not (equal he-search-string ""))
+		    kill-ring))
+	  (setq he-search-loc2 ())))
+    (if (not (equal he-search-string ""))
+	(setq expansion (he-whole-kill-search he-search-string)))
+    (if (not expansion)
+	(progn
+	  (if old (he-reset-string))
+	  ())
+	(progn
+	  (he-substitute-string expansion)
+	  t))))
+
+(defun he-whole-kill-search (str)
+  (let ((case-fold-search ())
+	(result ())
+	(str (regexp-quote str))
+	(killstr (car he-expand-list))
+	(pos -1))
+    (while (and (not result)
+		he-expand-list)
+      (if (not he-search-loc2)
+	  (while (setq pos (string-match str killstr (1+ pos)))
+	    (setq he-search-loc2 (cons pos he-search-loc2))))
+      (while (and (not result)
+		  he-search-loc2)
+	(setq pos (car he-search-loc2))
+	(setq he-search-loc2 (cdr he-search-loc2))
+	(save-excursion
+	  (goto-char he-string-beg)
+	  (if (and (>= (- (point) pos) (point-min))   ; avoid some string GC
+		   (eq (char-after (- (point) pos)) (aref killstr 0))
+		   (search-backward (substring killstr 0 pos)
+				    (- (point) pos) t))
+	      (setq result (substring killstr pos))))
+	(if (and result
+		 (he-string-member result he-tried-table))
+	    (setq result nil)))     ; ignore if already in table
+      (if (and (not result)
+		he-expand-list)
+	  (progn
+	    (setq he-expand-list (cdr he-expand-list)) 
+	    (setq killstr (car he-expand-list))
+	    (setq pos -1))))
+    result))
+
+(defun he-kill-beg ()
+  (let ((op (point)))
+    (save-excursion
+      (skip-syntax-backward "^w_")
+      (if (= (skip-syntax-backward "w_") 0)
+	  op
+	(point)))))
+
 
 (provide 'hippie-exp)