X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/d1d1ddbd6ade29048745cc46cf9f4169678605c8..a03b3ce13b064a5f775525d8208e747b87a169cf:/lisp/hippie-exp.el

diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index 65317f96a9..6f82054f8f 100644
--- a/lisp/hippie-exp.el
+++ b/lisp/hippie-exp.el
@@ -1,12 +1,12 @@
 ;;; hippie-exp.el --- expand text trying various ways to find its expansion.
 
+;; Copyright (C) 1992 Free Software Foundation, Inc.
+
 ;; Author: Anders Holst <aho@sans.kth.se>
-;; Last change: 2 September 1993
-;; Version: 1.3
-;; Keywords: abbrev
+;; Last change: 3 March 1998
+;; Version: 1.6
+;; Keywords: abbrev convenience
 
-;; Copyright (C) 1992, 1993 Free Software Foundation, Inc.
-;;
 ;; This file is part of GNU Emacs.
 
 ;; GNU Emacs is free software; you can redistribute it and/or modify
@@ -20,11 +20,12 @@
 ;; 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.
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
 
 ;;; Commentary:
-;;  
+
 ;;  `hippie-expand' is a single function for a lot of different kinds
 ;;  of completions and expansions.  Called repeatedly it tries all
 ;;  possible completions in succession. 
@@ -48,6 +49,17 @@
 ;;  matching buffer names (as strings) or major modes (as atoms) of
 ;;  buffers that should not be searched by the try-functions named
 ;;  "-all-buffers".
+;;  If set, the variable `hippie-expand-only-buffers' does the opposite
+;;  of `hippie-expand-ignore-buffers', in that the search is restricted
+;;  to only the kind of buffers listed.
+;;  If the variable `hippie-expand-no-restriction' is non-nil, narrowed
+;;  buffers are widened before they are searched.
+;;  The variable `hippie-expand-dabbrev-skip-space' controls whether
+;;  trailing spaces will be included in the abbreviation to search for,
+;;  which then gives the same behavior as the original `dabbrev-expand'.
+;;  The variable `hippie-expand-dabbrev-as-symbol' controls whether
+;;  characters of syntax '_' is considered part of the words to expand
+;;  dynamically.
 ;;  See also the macro `make-hippie-expand-function' below.
 ;;  
 ;;  A short description of the current try-functions in this file:
@@ -79,6 +91,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 +145,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 +153,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,11 +163,16 @@
 ;;  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:
 
+(defgroup hippie-expand nil
+  "Expand text trying various ways to find its expansion."
+  :group 'abbrev
+  :group 'convenience)
+
 (defvar he-num -1)
 
 (defvar he-string-beg (make-marker))
@@ -160,38 +187,79 @@
 
 (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,
 or insert functions in this list.")
 
 ;;;###autoload
-(defvar hippie-expand-verbose t
-  "*Non-nil makes `hippie-expand' output which function it is trying.")
+(defcustom hippie-expand-verbose t
+  "*Non-nil makes `hippie-expand' output which function it is trying."
+  :type 'boolean
+  :group 'hippie-expand)
+
+;;;###autoload
+(defcustom hippie-expand-dabbrev-skip-space nil
+  "*Non-nil means tolerate trailing spaces in the abbreviation to expand."
+  :group 'hippie-expand
+  :type 'boolean)
 
 ;;;###autoload
-(defvar hippie-expand-max-buffers ()
+(defcustom hippie-expand-dabbrev-as-symbol t
+  "*Non-nil means expand as symbols, i.e. syntax `_' is considered a letter."
+  :group 'hippie-expand
+  :type 'boolean)
+
+;;;###autoload
+(defcustom hippie-expand-no-restriction t
+  "*Non-nil means that narrowed buffers are widened during search."
+  :group 'hippie-expand
+  :type 'boolean)
+
+;;;###autoload
+(defcustom hippie-expand-max-buffers ()
   "*The maximum number of buffers (apart from the current) searched.
-If nil, all buffers are searched.")
+If nil, all buffers are searched."
+  :type '(choice (const :tag "All" nil)
+		 integer)
+  :group 'hippie-expand)
 
 ;;;###autoload
-(defvar hippie-expand-ignore-buffers '("^ \\*.*\\*$" dired-mode)
+(defcustom hippie-expand-ignore-buffers '("^ \\*.*\\*$" dired-mode)
   "*A list specifying which buffers not to search (if not current).
 Can contain both regexps matching buffer names (as strings) and major modes
-(as atoms)")
+\(as atoms)"
+  :type '(repeat (choice regexp (symbol :tag "Major Mode")))
+  :group 'hippie-expand)
+
+;;;###autoload
+(defcustom hippie-expand-only-buffers ()
+  "*A list specifying the only buffers to search (in addition to current).
+Can contain both regexps matching buffer names (as strings) and major modes
+\(as atoms). If non-NIL, this variable overrides the variable
+`hippie-expand-ignore-buffers'."
+  :type '(repeat (choice regexp (symbol :tag "Major Mode")))
+  :group 'hippie-expand)
 
 ;;;###autoload
 (defun hippie-expand (arg)
@@ -229,34 +297,31 @@ undoes the expansion."
 		  (message "No further expansions found"))
 	      (ding))
 	    (if (and hippie-expand-verbose
-                     (not (window-minibuffer-p (selected-window))))
-		(message (concat "Using "
-				 (prin1-to-string (nth he-num 
-				   hippie-expand-try-functions-list)))))))
-      (if (>= he-num 0)
+		     (not (window-minibuffer-p (selected-window))))
+		(message "Using %s"
+			 (nth he-num hippie-expand-try-functions-list)))))
+      (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).
 (defun he-init-string (beg end)
   (set-marker he-string-beg beg)
   (set-marker he-string-end end)
-  (setq he-search-string (buffer-substring beg end)))
+  (setq he-search-string (buffer-substring-no-properties beg end)))
 
 ;; 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,55 +331,70 @@ 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-str)
+	((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)
-
-;; 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))))
-    (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 current buffer matches any atom or regexp in LST.
+;; Atoms are interpreted as major modes, strings as regexps mathing the name.
+(defun he-buffer-member (lst)
+  (or (memq major-mode lst)
+      (progn
+	(while (and lst
+		    (or (not (stringp (car lst)))
+			(not (string-match (car lst) (buffer-name)))))
+	  (setq lst (cdr lst)))
+	lst)))
 
 ;;  For the real hippie-expand enthusiast: A macro that makes it
 ;;  possible to use many functions like hippie-expand, but with
@@ -334,7 +414,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 +424,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 +433,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 +451,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 +470,92 @@ 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 windows-nt))
+	 "-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_./~^#$"))
+  (let ((op (point)))
     (save-excursion
-      (skip-chars-backward skips)
-      (point))))
-
+      (skip-chars-backward he-file-name-chars)
+      (if (> (skip-syntax-backward "w") 0)  ;; No words with non-file chars
+	  op
+	(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 file)))
+  
+(defun he-concat-directory-file-name (dir-part name-part)
+  "Try to slam together two parts of a file specification, system dependently."
+  (cond ((null dir-part) name-part)
+	((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 w32))
+	 (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 +579,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,23 +603,22 @@ 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 ()
-  (let ((skips "-a-zA-Z0-9_."))
-    (save-excursion
-      (skip-chars-backward skips)
-      (point))))
+  (save-excursion
+    (skip-syntax-backward "w_")
+    (point)))
 
 (defun try-expand-line (old)
   "Try to complete the current line to an entire line in the buffer.
@@ -497,32 +636,34 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
 	(save-excursion
-	  ;; Try looking backward unless inhibited.
-	  (if he-search-bw
-	      (progn 
-		(goto-char he-search-loc)
-		(setq expansion (he-line-search he-search-string
-						strip-prompt t))
-		(set-marker he-search-loc (point))
-		(if (not expansion)
-		    (progn
-		      (set-marker he-search-loc he-string-end)
-		      (setq he-search-bw ())))))
-	  
-	  (if (not expansion) ; Then look forward.
-	      (progn 
-		(goto-char he-search-loc)
-		(setq expansion (he-line-search he-search-string 
-						strip-prompt nil))
-		(set-marker he-search-loc (point))))))
+	  (save-restriction
+	    (if hippie-expand-no-restriction
+		(widen))
+	    ;; Try looking backward unless inhibited.
+	    (if he-search-bw
+		(progn 
+		  (goto-char he-search-loc)
+		  (setq expansion (he-line-search he-search-string
+						  strip-prompt t))
+		  (set-marker he-search-loc (point))
+		  (if (not expansion)
+		      (progn
+			(set-marker he-search-loc he-string-end)
+			(setq he-search-bw ())))))
+
+	    (if (not expansion) ; Then look forward.
+		(progn 
+		  (goto-char he-search-loc)
+		  (setq expansion (he-line-search he-search-string 
+						  strip-prompt 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-line-all-buffers (old)
@@ -533,43 +674,49 @@ 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)))
+		   (if hippie-expand-only-buffers
+		       (he-buffer-member hippie-expand-only-buffers)
+		     (not (he-buffer-member 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))
-		(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)))))
+		(save-restriction
+		  (if hippie-expand-no-restriction
+		      (widen))
+		  (goto-char he-search-loc)
+		  (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 (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)
@@ -585,19 +732,18 @@ string).  It returns t if a new completion is found, nil otherwise."
 		    (re-search-forward
 		     (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
+      (setq result (buffer-substring-no-properties (match-beginning 2)
+						   (match-end 2)))
+      (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)
@@ -623,22 +769,25 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
 	(save-excursion
-	  ;; Try looking backward unless inhibited.
-	  (if he-search-bw
-	      (progn 
-		(goto-char he-search-loc)
-		(setq expansion (he-list-search he-search-string t))
-		(set-marker he-search-loc (point))
-		(if (not expansion)
-		    (progn
-		      (set-marker he-search-loc he-string-end)
-		      (setq he-search-bw ())))))
-	  
-	  (if (not expansion) ; Then look forward.
-	      (progn 
-		(goto-char he-search-loc)
-		(setq expansion (he-list-search he-search-string nil))
-		(set-marker he-search-loc (point))))))
+	  (save-restriction
+	    (if hippie-expand-no-restriction
+		(widen))
+	    ;; Try looking backward unless inhibited.
+	    (if he-search-bw
+		(progn 
+		  (goto-char he-search-loc)
+		  (setq expansion (he-list-search he-search-string t))
+		  (set-marker he-search-loc (point))
+		  (if (not expansion)
+		      (progn
+			(set-marker he-search-loc he-string-end)
+			(setq he-search-bw ())))))
+
+	    (if (not expansion) ; Then look forward.
+		(progn 
+		  (goto-char he-search-loc)
+		  (setq expansion (he-list-search he-search-string nil))
+		  (set-marker he-search-loc (point)))))))
 
     (if (not expansion)
 	(progn
@@ -646,7 +795,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 +803,46 @@ 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)))
+		   (if hippie-expand-only-buffers
+		       (he-buffer-member hippie-expand-only-buffers)
+		     (not (he-buffer-member hippie-expand-ignore-buffers))))
 	      (save-excursion
-		(goto-char he-search-loc)
-		(setq expansion (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)))))
+		(save-restriction
+		  (if hippie-expand-no-restriction
+		      (widen))
+		  (goto-char he-search-loc)
+		  (setq expansion 
+			(let ((case-fold-search orig-case-fold-search))
+			  (he-list-search he-search-string nil)))
+		  (set-marker he-search-loc (point))
+		  (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 +850,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 +860,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-no-properties 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 +891,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)))
 
@@ -770,30 +924,32 @@ string).  It returns t if a new expansion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
 	(save-excursion
-	  ;; Try looking backward unless inhibited.
-	  (if he-search-bw
-	      (progn 
-		(goto-char he-search-loc)
-		(setq expansion (he-dab-search he-search-string t))
-		(set-marker he-search-loc (point))
-		(if (not expansion)
-		    (progn
-		      (set-marker he-search-loc he-string-end)
-		      (setq he-search-bw ())))))
-	  
-	  (if (not expansion) ; Then look forward.
-	      (progn 
-		(goto-char he-search-loc)
-		(setq expansion (he-dab-search he-search-string nil))
-		(set-marker he-search-loc (point))))))
+	  (save-restriction
+	    (if hippie-expand-no-restriction
+		(widen))
+	    ;; Try looking backward unless inhibited.
+	    (if he-search-bw
+		(progn 
+		  (goto-char he-search-loc)
+		  (setq expansion (he-dabbrev-search he-search-string t))
+		  (set-marker he-search-loc (point))
+		  (if (not expansion)
+		      (progn
+			(set-marker he-search-loc he-string-end)
+			(setq he-search-bw ())))))
+
+	    (if (not expansion) ; Then look forward.
+		(progn 
+		  (goto-char he-search-loc)
+		  (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 +958,257 @@ 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)))
+		   (if hippie-expand-only-buffers
+		       (he-buffer-member hippie-expand-only-buffers)
+		     (not (he-buffer-member hippie-expand-ignore-buffers))))
 	      (save-excursion
-		(goto-char he-search-loc)
-		(setq expansion (he-dab-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)))))
+		(save-restriction
+		  (if hippie-expand-no-restriction
+		      (widen))
+		  (goto-char he-search-loc)
+		  (setq expansion
+			(let ((case-fold-search orig-case-fold-search))
+			  (he-dabbrev-search he-search-string nil)))
+		  (set-marker he-search-loc (point))
+		  (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 (cond ((not hippie-expand-dabbrev-as-symbol)
+		       (concat "\\<" (regexp-quote pattern) "\\sw+"))
+		      ((eq (char-syntax (aref pattern 0)) ?_)
+		       (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
+		      (t
+		       (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)))
-      (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
+		     (re-search-backward regpat limit t)
+		     (re-search-forward regpat limit t)))
+      (setq result (buffer-substring-no-properties (match-beginning 0)
+						   (match-end 0)))
+      (if (or (and hippie-expand-dabbrev-as-symbol
+		   (> (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))
 
 (defun he-dabbrev-beg ()
-  (min (point)
-       (save-excursion
-         (skip-syntax-backward "w_")
-         (skip-syntax-forward "_")
-         (point))))
+  (let ((op (point)))
+    (save-excursion
+      (if hippie-expand-dabbrev-skip-space
+	  (skip-syntax-backward ". "))
+      (if (= (skip-syntax-backward (if hippie-expand-dabbrev-as-symbol
+				       "w_" "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 (cond ((not hippie-expand-dabbrev-as-symbol)
+		       (concat "\\<" (regexp-quote pattern) "\\sw+"))
+		      ((eq (char-syntax (aref pattern 0)) ?_)
+		       (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
+		      (t
+		       (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)))
+	(set-text-properties 0 (length result) () result)
+	(setq he-search-loc2 (1+ (match-beginning 0)))
+	(if (or (and hippie-expand-dabbrev-as-symbol
+		     (> (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))
+	      (progn
+		(setq result (substring killstr pos))
+		(set-text-properties 0 (length result) () result))))
+	(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)