(mail-reply-buffer): Add defvar.

[gnu-emacs] / lisp / hippie-exp.el

diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index 65317f96a9db08862609d55f44d075c19bd537dd..1210166305b3af0731959947ed42f741c1362fab 100644 (file)
--- 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.
+;;; hippie-exp.el --- expand text trying various ways to find its expansion
+
+;; Copyright (C) 1992, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

 
 ;; Author: Anders Holst <aho@sans.kth.se>
 
 ;; 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
 ;; This file is part of GNU Emacs.
 
 ;; GNU Emacs is free software; you can redistribute it and/or modify


@@ -20,14 +20,15 @@
 ;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
 ;; 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., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.

 
 ;;; Commentary:
 
 ;;; Commentary:

-;;  
+

 ;;  `hippie-expand' is a single function for a lot of different kinds
 ;;  of completions and expansions.  Called repeatedly it tries all
 ;;  `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. 
+;;  possible completions in succession.

 ;;  Which kinds of completions to try, and in which order, is
 ;;  determined by the contents of `hippie-expand-try-functions-list'.
 ;;  Much customization of `hippie-expand' can be made by changing the
 ;;  Which kinds of completions to try, and in which order, is
 ;;  determined by the contents of `hippie-expand-try-functions-list'.
 ;;  Much customization of `hippie-expand' can be made by changing the


@@ -48,8 +49,19 @@
 ;;  matching buffer names (as strings) or major modes (as atoms) of
 ;;  buffers that should not be searched by the try-functions named
 ;;  "-all-buffers".
 ;;  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.
 ;;  See also the macro `make-hippie-expand-function' below.

-;;  
+;;

 ;;  A short description of the current try-functions in this file:
 ;;    `try-complete-file-name' : very convenient to have in any buffer,
 ;;      and not just in the minibuffer or (some) shell-mode.  It goes
 ;;  A short description of the current try-functions in this file:
 ;;    `try-complete-file-name' : very convenient to have in any buffer,
 ;;      and not just in the minibuffer or (some) shell-mode.  It goes


@@ -60,9 +72,9 @@
 ;;      a file name completed only as many characters as is unique.
 ;;    `try-expand-all-abbrevs' : can be removed if you don't use abbrevs.
 ;;      Otherwise it looks through all abbrev-tables, starting with
 ;;      a file name completed only as many characters as is unique.
 ;;    `try-expand-all-abbrevs' : can be removed if you don't use abbrevs.
 ;;      Otherwise it looks through all abbrev-tables, starting with

-;;      the local followed by the global. 
-;;    `try-expand-line' : Searches the buffer for an entire line that 
-;;      begins exactly as the current line.  Convenient sometimes, for 
+;;      the local followed by the global.
+;;    `try-expand-line' : Searches the buffer for an entire line that
+;;      begins exactly as the current line.  Convenient sometimes, for

 ;;      example as a substitute for (or complement to) the history
 ;;      list in shell-like buffers.  At other times, only confusing.
 ;;    `try-expand-line-all-buffers' : Like `try-expand-line' but searches
 ;;      example as a substitute for (or complement to) the history
 ;;      list in shell-like buffers.  At other times, only confusing.
 ;;    `try-expand-line-all-buffers' : Like `try-expand-line' but searches


@@ -71,14 +83,24 @@
 ;;    `try-expand-list' : Tries to expand the text back to the nearest
 ;;      open delimiter, to a whole list from the buffer. Convenient for
 ;;      example when writing lisp or TeX.
 ;;    `try-expand-list' : Tries to expand the text back to the nearest
 ;;      open delimiter, to a whole list from the buffer. Convenient for
 ;;      example when writing lisp or TeX.

-;;    `try-expand-list-all-buffers' : Like `try-expand-list' but searches 
-;;      in all buffers (except the current).  
+;;    `try-expand-list-all-buffers' : Like `try-expand-list' but searches
+;;      in all buffers (except the current).

 ;;    `try-expand-dabbrev' : works exactly as dabbrev-expand (but of
 ;;      course in a way compatible with the other try-functions).
 ;;    `try-expand-dabbrev-all-buffers' : perhaps the most useful of them,
 ;;      like `dabbrev-expand' but searches all Emacs buffers (except the
 ;;      current) for matching words.  (No, I don't find this one
 ;;    `try-expand-dabbrev' : works exactly as dabbrev-expand (but of
 ;;      course in a way compatible with the other try-functions).
 ;;    `try-expand-dabbrev-all-buffers' : perhaps the most useful of them,
 ;;      like `dabbrev-expand' but searches all Emacs buffers (except the
 ;;      current) for matching words.  (No, I don't find this one

-;;      particularly slow.) 
+;;      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
 ;;    `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


@@ -86,7 +108,7 @@
 ;;      already has a key of its own, you might want to remove this.
 ;;    `try-complete-lisp-symbol-partially' : To insert in the list just
 ;;      before `try-complete-lisp-symbol' for those who first want to get
 ;;      already has a key of its own, you might want to remove this.
 ;;    `try-complete-lisp-symbol-partially' : To insert in the list just
 ;;      before `try-complete-lisp-symbol' for those who first want to get

-;;      completion of what is unique in the name.  
+;;      completion of what is unique in the name.

 ;;
 ;;  Not all of the above functions are by default in
 ;;  `hippie-expand-try-functions-list'.  This variable is better set
 ;;
 ;;  Not all of the above functions are by default in
 ;;  `hippie-expand-try-functions-list'.  This variable is better set


@@ -121,18 +143,18 @@
 ;;    `he-reset-string' : Resets the initialized region to its original
 ;;      contents.
 ;;  There is also a variable: `he-tried-table' which is meant to contain
 ;;    `he-reset-string' : Resets the initialized region to its original
 ;;      contents.
 ;;  There is also a variable: `he-tried-table' which is meant to contain

-;;  all tried expansions so far.  The try-function can check this 
+;;  all tried expansions so far.  The try-function can check this

 ;;  variable to see whether an expansion has already been tried
 ;;  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
 ;;
 ;;  It may happen that some completion suggestion occurs twice, in
 ;;
 ;;  Known bugs
 ;;
 ;;  It may happen that some completion suggestion occurs twice, in

-;;  spite of the use of `he-tried-table' to prevent that.  This is 
+;;  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
 ;;  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.
 ;;
 ;;  opposite situation to occur, that `hippie-expand' misses some
 ;;  suggestion because it thinks it has already tried it.
 ;;


@@ -141,11 +163,20 @@
 ;;  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
 ;;  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:
 
 ;;
 
 ;;; Code:
 

+(eval-when-compile (require 'comint))
+
+(defgroup hippie-expand nil
+  "Expand text trying various ways to find its expansion."
+  :link '(custom-manual "(autotype)Hippie Expand")
+  :link '(emacs-commentary-link "hippie-exp")
+  :group 'abbrev
+  :group 'convenience)
+

 (defvar he-num -1)
 
 (defvar he-string-beg (make-marker))
 (defvar he-num -1)
 
 (defvar he-string-beg (make-marker))


@@ -160,38 +191,82 @@
 
 (defvar he-search-loc (make-marker))
 
 
 (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-bw ())
 
 (defvar he-search-bufs ())
 
 (defvar he-searched-n-bufs ())
 

+(defvar he-search-window ())
+

 ;;;###autoload
 ;;;###autoload

-(defvar hippie-expand-try-functions-list '(try-complete-file-name
-                                          try-expand-all-abbrevs
-                                           try-expand-list
-                                          try-expand-line
-                                          try-expand-dabbrev
-                                          try-expand-dabbrev-all-buffers
-                                          try-complete-lisp-symbol)
+(defcustom hippie-expand-try-functions-list
+  '(try-complete-file-name-partially
+    try-complete-file-name
+    try-expand-all-abbrevs
+    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,
   "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.")
+or insert functions in this list."
+  :type '(repeat function)
+  :group 'hippie-expand)
+
+;;;###autoload
+(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
+(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
 
 ;;;###autoload

-(defvar hippie-expand-verbose t
-  "*Non-nil makes `hippie-expand' output which function it is trying.")
+(defcustom hippie-expand-no-restriction t
+  "*Non-nil means that narrowed buffers are widened during search."
+  :group 'hippie-expand
+  :type 'boolean)

 
 ;;;###autoload
 
 ;;;###autoload

-(defvar hippie-expand-max-buffers ()
+(defcustom hippie-expand-max-buffers ()

   "*The maximum number of buffers (apart from the current) searched.
   "*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
 
 ;;;###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
   "*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)
 
 ;;;###autoload
 (defun hippie-expand (arg)


@@ -199,12 +274,12 @@ Can contain both regexps matching buffer names (as strings) and major modes
 The expansion functions in `hippie-expand-try-functions-list' are
 tried in order, until a possible expansion is found.  Repeated
 application of `hippie-expand' inserts successively possible
 The expansion functions in `hippie-expand-try-functions-list' are
 tried in order, until a possible expansion is found.  Repeated
 application of `hippie-expand' inserts successively possible

-expansions.  
+expansions.

 With a positive numeric argument, jumps directly to the ARG next
 With a positive numeric argument, jumps directly to the ARG next

-function in this list.  With a negative argument or just \\[universal-argument], 
-undoes the expansion." 
+function in this list.  With a negative argument or just \\[universal-argument],
+undoes the expansion."

   (interactive "P")
   (interactive "P")

-  (if (or (not arg) 
+  (if (or (not arg)

          (and (integerp arg) (> arg 0)))
       (let ((first (or (= he-num -1)
                       (not (equal this-command last-command)))))
          (and (integerp arg) (> arg 0)))
       (let ((first (or (= he-num -1)
                       (not (equal this-command last-command)))))


@@ -217,7 +292,7 @@ undoes the expansion."
            (setq arg 0))
        (let ((i (max (+ he-num arg) 0)))
          (while (not (or (>= i (length hippie-expand-try-functions-list))
            (setq arg 0))
        (let ((i (max (+ he-num arg) 0)))
          (while (not (or (>= i (length hippie-expand-try-functions-list))

-                         (apply (nth i hippie-expand-try-functions-list) 
+                         (apply (nth i hippie-expand-try-functions-list)

                                 (list (= he-num i)))))
            (setq i (1+ i)))
          (setq he-num i))
                                 (list (= he-num i)))))
            (setq i (1+ i)))
          (setq he-num i))


@@ -229,92 +304,104 @@ undoes the expansion."
                  (message "No further expansions found"))
              (ding))
            (if (and hippie-expand-verbose
                  (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
          (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)
                (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)))
 
 ;; 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)
     (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
 
 ;; Substitutes an expansion STR into the correct region (the region

-;; initialized with `he-init-string'). 
+;; initialized with `he-init-string').

 ;; An optional argument TRANS-CASE means that it is ok to transfer case
 ;; from the abbreviation to the expansion if that is possible, and is
 ;; enabled in the buffer.
 (defun he-substitute-string (str &optional trans-case)
   (let ((trans-case (and trans-case
                         case-replace
 ;; An optional argument TRANS-CASE means that it is ok to transfer case
 ;; from the abbreviation to the expansion if that is possible, and is
 ;; enabled in the buffer.
 (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)
     (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))
 
 (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.
 
 ;; 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
 
 ;;  For the real hippie-expand enthusiast: A macro that makes it
 ;;  possible to use many functions like hippie-expand, but with


@@ -326,40 +413,41 @@ undoes the expansion."
 ;;    (fset 'my-complete-line (make-hippie-expand-function
 ;;                             '(try-expand-line
 ;;                               try-expand-line-all-buffers)))
 ;;    (fset 'my-complete-line (make-hippie-expand-function
 ;;                             '(try-expand-line
 ;;                               try-expand-line-all-buffers)))

-;;  
+;;

 ;;;###autoload
 (defmacro make-hippie-expand-function (try-list &optional verbose)
   "Construct a function similar to `hippie-expand'.
 Make it use the expansion functions in TRY-LIST.  An optional second
 argument VERBOSE non-nil makes the function verbose."
 ;;;###autoload
 (defmacro make-hippie-expand-function (try-list &optional verbose)
   "Construct a function similar to `hippie-expand'.
 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"
-          (mapconcat 'prin1-to-string (eval try-list) ", ")))
-       (interactive "P")
-       (let ((hippie-expand-try-functions-list (, try-list))
-            (hippie-expand-verbose (, verbose)))
-        (hippie-expand arg))))))
+  `(function (lambda (arg)
+    ,(concat
+      "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)
+          (hippie-expand-verbose ,verbose))
+      (hippie-expand arg)))))

 
 
 ;;;  Here follows the try-functions and their requisites:
 
 
 
 ;;;  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
 for subsequent calls (for further possible completions of the same
 string).  It returns t if a new completion is found, nil otherwise."
   (if (not old)
 (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
 for subsequent calls (for further possible completions of the same
 string).  It returns t if a new completion is found, nil otherwise."
   (if (not old)

-      (progn 
+      (progn

        (he-init-string (he-file-name-beg) (point))
        (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 ""))
                                               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))
-             (setq he-expand-list (sort (file-name-all-completions 
+                  (he-file-directory-p dir-part))
+             (setq he-expand-list (sort (file-name-all-completions

                                          name-part
                                          dir-part)
                                         'string-lessp))
                                          name-part
                                          dir-part)
                                         'string-lessp))


@@ -370,50 +458,110 @@ 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
     (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)
        (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)))
 
 (defun try-complete-file-name-partially (old)
   "Try to complete text as a file name, as many characters as unique.
 The argument OLD has to be nil the first call of this function.  It
        (setq he-expand-list (cdr he-expand-list))
        t)))
 
 (defun try-complete-file-name-partially (old)
   "Try to complete text as a file name, as many characters as unique.
 The argument OLD has to be nil the first call of this function.  It

-returns t if a unique, possibly partial, completion is found, nil 
+returns t if a unique, possibly partial, completion is found, nil

 otherwise."
   (let ((expansion ()))
     (if (not old)
 otherwise."
   (let ((expansion ()))
     (if (not old)

-       (progn 
+       (progn

          (he-init-string (he-file-name-beg) (point))
          (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 ""))
                                                 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)
                (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
                (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)
          (he-substitute-string filename)

-         (setq he-tried-table (cons expansion he-tried-table))
+         (setq he-tried-table (cons expansion (cdr he-tried-table)))

          t))))
 
          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 cygwin))
+        "-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 ()
 (defun he-file-name-beg ()

-  (let ((skips "-a-zA-Z0-9_./~^#$"))
+  (let ((op (point)))

     (save-excursion
     (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.
 
 (defun try-complete-lisp-symbol (old)
   "Try to complete word as an Emacs Lisp symbol.


@@ -421,11 +569,11 @@ 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."
   (if (not old)
 for subsequent calls (for further possible completions of the same
 string).  It returns t if a new completion is found, nil otherwise."
   (if (not old)

-      (progn 
+      (progn

        (he-init-string (he-lisp-symbol-beg) (point))
        (if (not (he-string-member he-search-string he-tried-table))
            (setq he-tried-table (cons he-search-string he-tried-table)))
        (he-init-string (he-lisp-symbol-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 
+       (setq he-expand-list

              (and (not (equal he-search-string ""))
                   (sort (all-completions he-search-string obarray
                                          (function (lambda (sym)
              (and (not (equal he-search-string ""))
                   (sort (all-completions he-search-string obarray
                                          (function (lambda (sym)


@@ -438,48 +586,46 @@ 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
     (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))
        ())
       (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)))
 
 (defun try-complete-lisp-symbol-partially (old)
   "Try to complete as an Emacs Lisp symbol, as many characters as unique.
 The argument OLD has to be nil the first call of this function.  It
        (setq he-expand-list (cdr he-expand-list))
        t)))
 
 (defun try-complete-lisp-symbol-partially (old)
   "Try to complete as an Emacs Lisp symbol, as many characters as unique.
 The argument OLD has to be nil the first call of this function.  It

-returns t if a unique, possibly partial, completion is found, nil 
+returns t if a unique, possibly partial, completion is found, nil

 otherwise."
   (let ((expansion ()))
     (if (not old)
 otherwise."
   (let ((expansion ()))
     (if (not old)

-       (progn 
+       (progn

          (he-init-string (he-lisp-symbol-beg) (point))
          (if (not (string= he-search-string ""))
          (he-init-string (he-lisp-symbol-beg) (point))
          (if (not (string= he-search-string ""))

-             (setq expansion 
+             (setq expansion

                    (try-completion he-search-string obarray
                                    (function (lambda (sym)
                                      (or (boundp sym)
                                          (fboundp sym)
                                          (symbol-plist sym)))))))
          (if (or (eq expansion t)
                    (try-completion he-search-string obarray
                                    (function (lambda (sym)
                                      (or (boundp sym)
                                          (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
              (setq expansion ()))))
 
   (if (not expansion)
       (progn

-        (if old (he-reset-string))
+       (if old (he-reset-string))

        ())
       (progn
        (he-substitute-string expansion)
        ())
       (progn
        (he-substitute-string expansion)

-       (setq he-tried-table (cons expansion he-tried-table))

        t))))
 
 (defun he-lisp-symbol-beg ()
        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.
 
 (defun try-expand-line (old)
   "Try to complete the current line to an entire line in the buffer.


@@ -488,6 +634,7 @@ for subsequent calls (for further possible completions of the same
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ())
        (strip-prompt (and (get-buffer-process (current-buffer))
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ())
        (strip-prompt (and (get-buffer-process (current-buffer))

+                          comint-use-prompt-regexp

                           comint-prompt-regexp)))
     (if (not old)
        (progn
                           comint-prompt-regexp)))
     (if (not old)
        (progn


@@ -497,32 +644,34 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
        (save-excursion
 
     (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 (not expansion)
        (progn

-          (if old (he-reset-string))
+         (if old (he-reset-string))

          ())
        (progn
          (he-substitute-string expansion t)
          ())
        (progn
          (he-substitute-string expansion t)

-         (setq he-tried-table (cons expansion he-tried-table))

          t))))
 
 (defun try-expand-line-all-buffers (old)
          t))))
 
 (defun try-expand-line-all-buffers (old)


@@ -532,72 +681,79 @@ for subsequent calls (for further possible completions of the same
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ())
        (strip-prompt (and (get-buffer-process (current-buffer))
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ())
        (strip-prompt (and (get-buffer-process (current-buffer))

+                          comint-use-prompt-regexp

                           comint-prompt-regexp))
                           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))
     (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 ""))
          (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)))
+       (while (and he-search-bufs
+                   (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))
          (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
              (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-use-prompt-regexp
+                                         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
 
     (set-buffer buf)
     (if (not expansion)
        (progn

-          (if old (he-reset-string))
+         (if old (he-reset-string))

          ())
        (progn
          (he-substitute-string expansion t)
          t))))
 
          ())
        (progn
          (he-substitute-string expansion t)
          t))))
 

-(defun he-line-search (str strip-prompt reverse) 
+(defun he-line-search (str strip-prompt reverse)

   (let ((result ()))
     (while (and (not result)
                (if reverse
   (let ((result ()))
     (while (and (not result)
                (if reverse

-                   (re-search-backward 
+                   (re-search-backward

                     (he-line-search-regexp str strip-prompt)
                     nil t)
                    (re-search-forward
                     (he-line-search-regexp str strip-prompt)
                     nil t)))
                     (he-line-search-regexp str strip-prompt)
                     nil t)
                    (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-end 1)
+                                                  (match-end 0)))
+      (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
     result))
 
 (defun he-line-beg (strip-prompt)
   (save-excursion

-    (end-of-line)
-    (if (re-search-backward (he-line-search-regexp "" strip-prompt) 
+    (if (re-search-backward (he-line-search-regexp "" strip-prompt)

                            (save-excursion (beginning-of-line)
                                            (point)) t)
        (match-beginning 2)
                            (save-excursion (beginning-of-line)
                                            (point)) t)
        (match-beginning 2)

-      (beginning-of-line)

       (point))))
 
 (defun he-line-search-regexp (pat strip-prompt)
       (point))))
 
 (defun he-line-search-regexp (pat strip-prompt)


@@ -605,7 +761,7 @@ string).  It returns t if a new completion is found, nil otherwise."
       (concat "\\(" comint-prompt-regexp "\\|^\\s-*\\)\\("
              (regexp-quote pat)
              "[^\n]*[^ \t\n]\\)")
       (concat "\\(" comint-prompt-regexp "\\|^\\s-*\\)\\("
              (regexp-quote pat)
              "[^\n]*[^ \t\n]\\)")

-      (concat "^\\(\\s-*\\)\\(" 
+      (concat "^\\(\\s-*\\)\\("

              (regexp-quote pat)
              "[^\n]*[^ \t\n]\\)")))
 
              (regexp-quote pat)
              "[^\n]*[^ \t\n]\\)")))
 


@@ -623,22 +779,25 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
        (save-excursion
 
     (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
 
     (if (not expansion)
        (progn


@@ -646,7 +805,6 @@ string).  It returns t if a new completion is found, nil otherwise."
          ())
        (progn
          (he-substitute-string expansion t)
          ())
        (progn
          (he-substitute-string expansion t)

-         (setq he-tried-table (cons expansion he-tried-table))

          t))))
 
 (defun try-expand-list-all-buffers (old)
          t))))
 
 (defun try-expand-list-all-buffers (old)


@@ -655,48 +813,54 @@ 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 ())
 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))
     (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 ""))
          (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)))
+       (while (and he-search-bufs
+                   (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))
          (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
              (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
 
     (set-buffer buf)
     (if (not expansion)
        (progn

-          (if old (he-reset-string))
+         (if old (he-reset-string))

          ())
        (progn
          (he-substitute-string expansion t)
          t))))
 
          ())
        (progn
          (he-substitute-string expansion t)
          t))))
 

-(defun he-list-search (str reverse) 
+(defun he-list-search (str reverse)

   (let ((result ())
   (let ((result ())

-        beg pos err)
+       beg pos err)

     (while (and (not result)
                (if reverse
                    (search-backward str nil t)
     (while (and (not result)
                (if reverse
                    (search-backward str nil t)


@@ -706,23 +870,23 @@ string).  It returns t if a new completion is found, nil otherwise."
       (goto-char beg)
       (setq err ())
       (condition-case ()
       (goto-char beg)
       (setq err ())
       (condition-case ()

-          (forward-list 1)
-        (error (setq err t)))
-      (if (and reverse 
-               (> (point) he-string-beg))
-          (setq err t))
+         (forward-list 1)
+       (error (setq err t)))
+      (if (and reverse
+              (> (point) he-string-beg))
+         (setq err t))

       (if (not err)
       (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 ()
       (goto-char pos))
     result))
 
 (defun he-list-beg ()
   (save-excursion
     (condition-case ()

-        (backward-up-list 1)
+       (backward-up-list 1)

       (error ()))
     (point)))
 
       (error ()))
     (point)))
 


@@ -734,25 +898,25 @@ string).  It returns t if a new expansion is found, nil otherwise."
   (if (not old)
       (progn
        (he-init-string (he-dabbrev-beg) (point))
   (if (not old)
       (progn
        (he-init-string (he-dabbrev-beg) (point))

-       (setq he-expand-list 
+       (setq he-expand-list

              (and (not (equal he-search-string ""))
                   (mapcar (function (lambda (sym)
              (and (not (equal he-search-string ""))
                   (mapcar (function (lambda (sym)

-                            (abbrev-expansion (downcase he-search-string)
-                                              (eval sym))))
-                          (append '(local-abbrev-table 
+                            (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))
                                     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
     (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)
        ())
       (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)))
 
        (setq he-expand-list (cdr he-expand-list))
        t)))
 


@@ -770,30 +934,32 @@ string).  It returns t if a new expansion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
        (save-excursion
 
     (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 (not expansion)
        (progn

-          (if old (he-reset-string))
+         (if old (he-reset-string))

          ())
        (progn
          (he-substitute-string expansion t)
          ())
        (progn
          (he-substitute-string expansion t)

-         (setq he-tried-table (cons expansion he-tried-table))

          t))))
 
 (defun try-expand-dabbrev-all-buffers (old)
          t))))
 
 (defun try-expand-dabbrev-all-buffers (old)


@@ -802,69 +968,259 @@ 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 ())
 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))
     (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 ""))
          (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)))
+       (while (and he-search-bufs
+                   (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))
          (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
              (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
 
     (set-buffer buf)
     (if (not expansion)
        (progn

-          (if old (he-reset-string))
+         (if old (he-reset-string))

          ())
        (progn
          (he-substitute-string expansion t)
          t))))
 
          ())
        (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))))))

 
 

-(defun he-dab-search (pattern reverse)
-  (let ((result ()))
-    (while (and (not result) 
+    (set-buffer buf)
+    (if (not expansion)
+       (progn
+         (if old (he-reset-string))
+         ())
+       (progn
+         (he-substitute-string expansion t)
+         t))))
+
+(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
                (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 ()
     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)
 
 
 (provide 'hippie-exp)
 

+;;; arch-tag: 5e6e00bf-b061-4a7a-9b46-de0ae105ab99

 ;;; hippie-exp.el ends here
 ;;; hippie-exp.el ends here