Fix comment typo.

[bpt/emacs.git] / lisp / hippie-exp.el

diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index f9c3ba2..c8722df 100644 (file)
--- a/lisp/hippie-exp.el
+++ b/lisp/hippie-exp.el
@@ -1,16 +1,19 @@
-;;; hippie.el --- expand a word trying various ways to find its expansion.
+;;; hippie-exp.el --- expand text trying various ways to find its expansion
+
+;; Copyright (C) 1992, 2001, 2002, 2003, 2004, 2005,
+;;   2006, 2007, 2008 Free Software Foundation, Inc.

 
 ;; Author: Anders Holst <aho@sans.kth.se>
 
 ;; Author: Anders Holst <aho@sans.kth.se>

-;; Keywords: extensions
+;; Last change: 3 March 1998
+;; Version: 1.6
+;; Keywords: abbrev convenience

 
 

-;; Copyright (C) 1992 Free Software Foundation, Inc.
-;;

 ;; This file is part of GNU Emacs.
 
 ;; This file is part of GNU Emacs.
 

-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software: you can redistribute it and/or modify

 ;; it under the terms of the GNU General Public License as published by
 ;; it under the terms of the GNU General Public License as published by

-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.

 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 ;; GNU Emacs is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of


@@ -18,16 +21,13 @@
 ;; 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.
-;; 
-;;  Last change: 4 January 1993
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

 
 ;;; 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


@@ -36,12 +36,31 @@
 ;;  ARG functions forward in this list.  Given some other argument
 ;;  (a negative argument or just Ctrl-U) it undoes the tried
 ;;  completion.
 ;;  ARG functions forward in this list.  Given some other argument
 ;;  (a negative argument or just Ctrl-U) it undoes the tried
 ;;  completion.

+;;

 ;;  If the variable `hippie-expand-verbose' is non-nil, `hippie-expand'
 ;;  outputs in a message which try-function in the list that is used
 ;;  currently (ie. was used currently and will be tried first the next
 ;;  time).
 ;;  If the variable `hippie-expand-verbose' is non-nil, `hippie-expand'
 ;;  outputs in a message which try-function in the list that is used
 ;;  currently (ie. was used currently and will be tried first the next
 ;;  time).

+;;  The variable `hippie-expand-max-buffers' determines in how many
+;;  buffers, apart from the current, to search for expansions in.  It
+;;  is used by the try-functions named "-all-buffers".
+;;  The variable `hippie-expand-ignore-buffers' is a list of regexps
+;;  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


@@ -50,24 +69,37 @@
 ;;    `try-complete-file-name-partially' : To insert in the list just
 ;;      before `try-complete-file-name' for those who want first to get
 ;;      a file name completed only as many characters as is unique.
 ;;    `try-complete-file-name-partially' : To insert in the list just
 ;;      before `try-complete-file-name' for those who want first to get
 ;;      a file name completed only as many characters as is unique.

-;;      (NOTE: Not by default in `hippie-expand-try-functions-list'.)

 ;;    `try-expand-all-abbrevs' : can be removed if you don't use abbrevs.
 ;;      Otherwise it looks through all abbrev-tables, starting with
 ;;    `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
 ;;      example as a substitute for (or complement to) the history

-;;      list in shell-like buffers.  Remove it if you find it confusing.
+;;      list in shell-like buffers.  At other times, only confusing.

 ;;    `try-expand-line-all-buffers' : Like `try-expand-line' but searches
 ;;      in all buffers (except the current).  (This may be a little
 ;;    `try-expand-line-all-buffers' : Like `try-expand-line' but searches
 ;;      in all buffers (except the current).  (This may be a little

-;;      slow, don't use it unless you are really fond of `hippie-expand'.
-;;      NOTE: Not by default in hippie-expand-try-functions-list.)
+;;      slow, don't use it unless you are really fond of `hippie-expand'.)
+;;    `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-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


@@ -75,8 +107,18 @@
 ;;      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.  (NOTE: Not by
-;;      default in hippie-expand-try-functions-list.)
+;;      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
+;;  in ".emacs" to make `hippie-expand' behave maximally convenient
+;;  according to personal taste.  Also, instead of loading the
+;;  variable with all kinds of try-functions above, it might be an
+;;  idea to use `make-hippie-expand-function' to construct different
+;;  `hippie-expand'-like functions, with different try-lists and bound
+;;  to different keys. It is also possible to make
+;;  `hippie-expand-try-functions-list' a buffer local variable, and
+;;  let it depend on the mode (by setting it in the mode-hooks).

 ;;
 ;;  To write new try-functions, consider the following:
 ;;  Each try-function takes one argument OLD which is nil the first
 ;;
 ;;  To write new try-functions, consider the following:
 ;;  Each try-function takes one argument OLD which is nil the first


@@ -100,38 +142,45 @@
 ;;    `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
+;;  Known bugs

 ;;
 ;;  It may happen that some completion suggestion occurs twice, in
 ;;
 ;;  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 bee 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.
 ;;

-;;  
-;;  ACKNOWLEDGEMENT
+;;  Acknowledgement

 ;;
 ;;  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-num -1)
 

-(defvar he-string-beg ())
+(defvar he-string-beg (make-marker))

 
 

-(defvar he-string-end ())
+(defvar he-string-end (make-marker))

 
 (defvar he-search-string ())
 
 
 (defvar he-search-string ())
 


@@ -139,36 +188,97 @@
 
 (defvar he-tried-table ())
 
 
 (defvar he-tried-table ())
 

-(defvar he-search-loc ())
+(defvar he-search-loc (make-marker))
+
+(defvar he-search-loc2 ())

 
 (defvar he-search-bw ())
 
 (defvar he-search-bufs ())
 
 
 (defvar he-search-bw ())
 
 (defvar he-search-bufs ())
 

-(defvar hippie-expand-try-functions-list '(try-complete-file-name
-                                          try-expand-all-abbrevs
-                                          try-expand-line
-                                          try-expand-dabbrev
-                                          try-expand-dabbrev-all-buffers
-                                          try-complete-lisp-symbol)
+(defvar he-searched-n-bufs ())
+
+(defvar he-search-window ())
+
+;;;###autoload
+(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)

 
 

-(defvar hippie-expand-verbose t
-  "*Non-nil makes `hippie-expand' output which function it is trying.")
+;;;###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."
+  :type '(choice (const :tag "All" nil)
+                integer)
+  :group 'hippie-expand)
+
+;;;###autoload
+(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)"
+  :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)
   "Try to expand text before point, using multiple methods.
 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
 (defun hippie-expand (arg)
   "Try to expand text before point, using multiple methods.
 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)))))


@@ -181,7 +291,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))


@@ -192,72 +302,105 @@ undoes the expansion."
                  (message "No expansion found")
                  (message "No further expansions found"))
              (ding))
                  (message "No expansion found")
                  (message "No further expansions found"))
              (ding))

-           (if hippie-expand-verbose
-               (message (concat "Using "
-                                (prin1-to-string (nth he-num 
-                                  hippie-expand-try-functions-list)))))))
-      (if (>= he-num 0)
+           (if (and hippie-expand-verbose
+                    (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)
          (progn
            (setq he-num -1)
            (he-reset-string)

-           (if hippie-expand-verbose
+           (if (and hippie-expand-verbose
+                    (not (window-minibuffer-p (selected-window))))

                (message "Undoing expansions"))))))
                (message "Undoing expansions"))))))

-      
+

 ;; Initializes the region to expand (to between BEG and END).
 (defun he-init-string (beg end)
 ;; Initializes the region to expand (to between BEG and END).
 (defun he-init-string (beg end)

-  (setq he-string-beg beg)
-  (setq he-string-end end)
-  (setq he-search-string (buffer-substring beg end)))
+  (set-marker he-string-beg beg)
+  (set-marker he-string-end end)
+  (setq he-search-string (buffer-substring-no-properties beg end)))

 
 ;; Resets the expanded region to its original contents.
 (defun he-reset-string ()
 
 ;; Resets the expanded region to its original contents.
 (defun he-reset-string ()

-  (delete-region he-string-beg he-string-end)
-  (insert he-search-string)
-  (setq he-string-end (point)))
+  (let ((newpos (point-marker)))
+    (goto-char he-string-beg)
+    (insert he-search-string)
+    (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))))
-    (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)
-    (setq he-string-end (point))))
+    (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 (length from-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)
+;; 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


@@ -269,30 +412,32 @@ 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."
 (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."

-  (` '(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))
        (let ((name-part (file-name-nondirectory he-search-string))
              (dir-part (expand-file-name (or (file-name-directory
        (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


@@ -301,7 +446,7 @@ string).  It returns t if a new completion is found, nil otherwise."
              (setq he-tried-table (cons name-part he-tried-table)))
          (if (and (not (equal he-search-string ""))
                   (file-directory-p dir-part))
              (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 
+             (setq he-expand-list (sort (file-name-all-completions

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


@@ -312,23 +457,24 @@ 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

-       (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
+                      (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))
          (let ((name-part (file-name-nondirectory he-search-string))
                (dir-part (expand-file-name (or (file-name-directory
          (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


@@ -338,24 +484,49 @@ otherwise."
                (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

-         (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
+                        (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 '(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 David Hughes <ukchugd@ukpmr.cs.philips.nl> who
+;; helped to make it work on PC.
+(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 '(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.


@@ -363,11 +534,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)


@@ -380,48 +551,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

-       (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

-       (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.


@@ -430,41 +599,44 @@ 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))

-                          shell-prompt-pattern)))
+                          comint-use-prompt-regexp
+                          comint-prompt-regexp)))

     (if (not old)
        (progn
          (he-init-string (he-line-beg strip-prompt) (point))
     (if (not old)
        (progn
          (he-init-string (he-line-beg strip-prompt) (point))

-         (setq he-search-loc he-string-beg)
+         (set-marker he-search-loc he-string-beg)

          (setq he-search-bw t)))
 
     (if (not (equal he-search-string ""))
        (save-excursion
          (setq he-search-bw t)))
 
     (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))
-               (setq he-search-loc (point-marker))
-               (if (not expansion)
-                   (progn
-                     (setq 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))
-               (setq he-search-loc (point-marker))))))
+         (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

-         (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)


@@ -474,74 +646,215 @@ 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))

-                          shell-prompt-pattern))
-       (buf (current-buffer)))
+                          comint-use-prompt-regexp
+                          comint-prompt-regexp))
+       (buf (current-buffer))
+       (orig-case-fold-search case-fold-search))

     (if (not old)
        (progn
          (he-init-string (he-line-beg strip-prompt) (point))
     (if (not old)
        (progn
          (he-init-string (he-line-beg strip-prompt) (point))

-         (setq he-search-loc 0)
-         (setq he-search-bufs (buffer-list))))
+         (setq he-search-bufs (buffer-list))
+         (setq he-searched-n-bufs 0)
+         (set-marker he-search-loc 1 (car he-search-bufs))))

 
     (if (not (equal he-search-string ""))
 
     (if (not (equal he-search-string ""))

-       (while (and he-search-bufs (not expansion))
+       (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 (eq major-mode 'dired-mode)))
-                  ;; dont search dired 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-line-search he-search-string
-                                               strip-prompt nil))
-               (setq he-search-loc (point-marker))))
-         (if expansion
-             (setq he-tried-table (cons expansion he-tried-table))
-             (progn
-               (setq he-search-loc 0)
-               (setq he-search-bufs (cdr 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

-         (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)
   (if strip-prompt
       (point))))
 
 (defun he-line-search-regexp (pat strip-prompt)
   (if strip-prompt

-      (concat "\\(" shell-prompt-pattern "\\|^\\s-*\\)\\("
+      (concat "\\(" comint-prompt-regexp "\\|^\\s-*\\)\\("

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

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

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

+(defun try-expand-list (old)
+  "Try to complete the current beginning of a list.
+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-list-beg) (point))
+         (set-marker he-search-loc he-string-beg)
+         (setq he-search-bw t)))
+
+    (if (not (equal he-search-string ""))
+       (save-excursion
+         (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 old (he-reset-string))
+         ())
+       (progn
+         (he-substitute-string expansion t)
+         t))))
+
+(defun try-expand-list-all-buffers (old)
+  "Try to complete the current list, searching all other buffers.
+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))
+       (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)
+         (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)))
+         (set-buffer (car he-search-bufs))
+         (if (and (not (eq (current-buffer) buf))
+                  (if hippie-expand-only-buffers
+                      (he-buffer-member hippie-expand-only-buffers)
+                    (not (he-buffer-member hippie-expand-ignore-buffers))))
+             (save-excursion
+               (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))
+         ())
+       (progn
+         (he-substitute-string expansion t)
+         t))))
+
+(defun he-list-search (str reverse)
+  (let ((result ())
+       beg pos err)
+    (while (and (not result)
+               (if reverse
+                   (search-backward str nil t)
+                   (search-forward str nil t)))
+      (setq pos (point))
+      (setq beg (match-beginning 0))
+      (goto-char beg)
+      (setq err ())
+      (condition-case ()
+         (forward-list 1)
+       (error (setq err t)))
+      (if (and reverse
+              (> (point) he-string-beg))
+         (setq err t))
+      (if (not err)
+         (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)
+      (error ()))
+    (point)))
+

 (defun try-expand-all-abbrevs (old)
   "Try to expand word before point according to all abbrev tables.
 The argument OLD has to be nil the first call of this function, and t
 (defun try-expand-all-abbrevs (old)
   "Try to expand word before point according to all abbrev tables.
 The argument OLD has to be nil the first call of this function, and t


@@ -550,25 +863,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 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

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

        ())
       (progn
        ())
       (progn

-       (he-substitute-string (car he-expand-list))
-       (setq he-tried-table (cons (car he-expand-list) he-tried-table))
+       (he-substitute-string (car he-expand-list) t)

        (setq he-expand-list (cdr he-expand-list))
        t)))
 
        (setq he-expand-list (cdr he-expand-list))
        t)))
 


@@ -581,35 +894,37 @@ 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-search-loc he-string-beg)
+         (set-marker he-search-loc he-string-beg)

          (setq he-search-bw t)))
 
     (if (not (equal he-search-string ""))
        (save-excursion
          (setq he-search-bw t)))
 
     (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))
-               (setq he-search-loc (point-marker))
-               (if (not expansion)
-                   (progn
-                     (setq 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))
-               (setq he-search-loc (point-marker))))))
-       
+         (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

-         (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)


@@ -618,60 +933,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))
     (if (not old)
        (progn
          (he-init-string (he-dabbrev-beg) (point))

-         (setq he-search-loc 0)
-         (setq he-search-bufs (buffer-list))))
+         (setq he-search-bufs (buffer-list))
+         (setq he-searched-n-bufs 0)
+         (set-marker he-search-loc 1 (car he-search-bufs))))

 
     (if (not (equal he-search-string ""))
 
     (if (not (equal he-search-string ""))

-       (while (and he-search-bufs (not expansion))
+       (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 (eq major-mode 'dired-mode))) 
-                  ;; dont search dired 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))
-               (setq he-search-loc (point-marker))))
-         (if expansion
-             (setq he-tried-table (cons expansion he-tried-table))
-             (progn
-               (setq he-search-loc 0)
-               (setq he-search-bufs (cdr 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

-         (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 "\\b" (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 ()

-  (let ((skips "-a-zA-Z0-9_."))
+  (let ((op (point)))

     (save-excursion
     (save-excursion

-      (skip-chars-backward skips)
-      (skip-chars-forward "-_.")
-      (point))))
+      (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)

 
 

-;;; hippie.el ends here
+;; arch-tag: 5e6e00bf-b061-4a7a-9b46-de0ae105ab99
+;;; hippie-exp.el ends here