Merge from emacs--rel--22

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

diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index 4b16c71..49d7754 100644 (file)
--- a/lisp/hippie-exp.el
+++ b/lisp/hippie-exp.el
@@ -1,11 +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 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 2001, 2002, 2003, 2004, 2005,
+;;   2006, 2007 Free Software Foundation, Inc.

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

-;; Last change: 6 August 1995
-;; Version: 1.4
-;; Keywords: abbrev
+;; Last change: 3 March 1998
+;; Version: 1.6
+;; Keywords: abbrev convenience

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


@@ -21,14 +22,14 @@
 
 ;; 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
 
 ;; 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, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.

 
 ;;; Commentary:
 
 ;;  `hippie-expand' is a single function for a lot of different kinds
 ;;  of completions and expansions.  Called repeatedly it tries all
 
 ;;; Commentary:
 
 ;;  `hippie-expand' is a single function for a lot of different kinds
 ;;  of completions and expansions.  Called repeatedly it tries all

-;;  possible completions in succession. 
+;;  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


@@ -49,8 +50,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


@@ -61,9 +73,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


@@ -72,14 +84,14 @@
 ;;    `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-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.


@@ -97,7 +109,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


@@ -132,14 +144,14 @@
 ;;    `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
 ;;  (hint: `he-string-member').
 ;;
 ;;  Known bugs
 ;;
 ;;  It may happen that some completion suggestion occurs twice, in
 ;;  variable to see whether an expansion has already been tried
 ;;  (hint: `he-string-member').
 ;;
 ;;  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
 ;;  text in `he-tried-table'.  Anyway this seems to occur seldom enough
 ;;  because different try-functions may try to complete different
 ;;  lengths of text, and thus put different amounts of the
 ;;  text in `he-tried-table'.  Anyway this seems to occur seldom enough


@@ -157,6 +169,15 @@
 
 ;;; 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))


@@ -182,34 +203,71 @@
 (defvar he-search-window ())
 
 ;;;###autoload
 (defvar he-search-window ())
 
 ;;;###autoload

-(defvar 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)
+(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
 
 ;;;###autoload

-(defvar hippie-expand-verbose t
-  "*Non-nil makes `hippie-expand' output which function it is trying.")
+(defcustom hippie-expand-verbose t
+  "*Non-nil makes `hippie-expand' output which function it is trying."
+  :type 'boolean
+  :group 'hippie-expand)

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

-(defvar hippie-expand-max-buffers ()
+(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
+(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.
   "*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)


@@ -217,12 +275,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)))))


@@ -235,7 +293,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))


@@ -249,8 +307,7 @@ undoes the expansion."
            (if (and hippie-expand-verbose
                     (not (window-minibuffer-p (selected-window))))
                (message "Using %s"
            (if (and hippie-expand-verbose
                     (not (window-minibuffer-p (selected-window))))
                (message "Using %s"

-                        (prin1-to-string (nth he-num 
-                                  hippie-expand-try-functions-list))))))
+                        (nth he-num hippie-expand-try-functions-list)))))

       (if (and (>= he-num 0)
               (eq (marker-buffer he-string-beg) (current-buffer)))
          (progn
       (if (and (>= he-num 0)
               (eq (marker-buffer he-string-beg) (current-buffer)))
          (progn


@@ -264,7 +321,7 @@ undoes the expansion."
 (defun he-init-string (beg end)
   (set-marker he-string-beg beg)
   (set-marker he-string-end 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 ()
 
 ;; Resets the expanded region to its original contents.
 (defun he-reset-string ()


@@ -275,7 +332,7 @@ undoes the expansion."
     (goto-char newpos)))
 
 ;; Substitutes an expansion STR into the correct region (the region
     (goto-char newpos)))
 
 ;; 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.
 ;; 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.


@@ -326,7 +383,7 @@ undoes the expansion."
 
 
 ;; Check if STR is a member of LST.
 
 
 ;; Check if STR is a member of LST.

-;; Transform to the final case if optional TRANS-CASE is non-NIL.
+;; 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
 (defun he-string-member (str lst &optional trans-case)
   (if str
       (member (if (and trans-case


@@ -336,14 +393,16 @@ undoes the expansion."
                str)
              lst)))
 
                str)
              lst)))
 

-;; Check if STR matches any regexp in LST.
-;; Ignore possible non-strings in LST.
-(defun he-regexp-member (str lst)
-  (while (and lst
-             (or (not (stringp (car lst)))
-                 (not (string-match (car lst) str))))
-    (setq lst (cdr lst)))
-  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


@@ -355,20 +414,20 @@ 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:


@@ -380,7 +439,7 @@ 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-file-name-beg) (point))
        (let ((name-part (he-file-name-nondirectory he-search-string))
              (dir-part (expand-file-name (or (he-file-name-directory
        (he-init-string (he-file-name-beg) (point))
        (let ((name-part (he-file-name-nondirectory he-search-string))
              (dir-part (expand-file-name (or (he-file-name-directory


@@ -389,7 +448,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 ""))
                   (he-file-directory-p dir-part))
              (setq he-tried-table (cons name-part he-tried-table)))
          (if (and (not (equal he-search-string ""))
                   (he-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))


@@ -413,11 +472,11 @@ string).  It returns t if a new completion is found, nil otherwise."
 (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
 (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 (he-file-name-nondirectory he-search-string))
                (dir-part (expand-file-name (or (he-file-name-directory
          (he-init-string (he-file-name-beg) (point))
          (let ((name-part (he-file-name-nondirectory he-search-string))
                (dir-part (expand-file-name (or (he-file-name-directory


@@ -445,19 +504,22 @@ otherwise."
 (defvar he-file-name-chars
   (cond ((memq system-type '(vax-vms axp-vms))
         "-a-zA-Z0-9_/.,~^#$+=:\\[\\]")
 (defvar he-file-name-chars
   (cond ((memq system-type '(vax-vms axp-vms))
         "-a-zA-Z0-9_/.,~^#$+=:\\[\\]")

-       ((memq system-type '(ms-dos ms-windows))
+       ((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 ()
         "-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 ()

-  (save-excursion
-    (skip-chars-backward he-file-name-chars)
-    (point)))
+  (let ((op (point)))
+    (save-excursion
+      (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
 
 ;; 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 
+;; 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."
 ;; 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."


@@ -483,35 +545,36 @@ otherwise."
   (if (memq system-type '(vax-vms axp-vms))
       (or (file-directory-p file)
          (file-directory-p (concat file "[000000]")))
   (if (memq system-type '(vax-vms axp-vms))
       (or (file-directory-p file)
          (file-directory-p (concat file "[000000]")))

-    (file-directory-p dir-part)))
-  
+    (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."
 (defun he-concat-directory-file-name (dir-part name-part)
   "Try to slam together two parts of a file specification, system dependently."

-  (cond ((memq system-type '(axp-vms vax-vms))
+  (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)))
         (if (and (string= (substring dir-part -1) "]")
                  (string= (substring name-part 0 2) "[."))
             (concat (substring dir-part 0 -1) (substring name-part 1))
           (concat dir-part name-part)))

-       ((memq system-type '(ms-dos ms-windows))
+       ((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))
         (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 
+       (t

         (concat dir-part name-part))))
         (concat dir-part name-part))))

-                       
+

 (defun try-complete-lisp-symbol (old)
   "Try to complete word as an Emacs Lisp symbol.
 The argument OLD has to be nil the first call of this function, and t
 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-lisp-symbol (old)
   "Try to complete word as an Emacs Lisp symbol.
 The argument OLD has to be nil the first call of this function, and t
 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)


@@ -534,14 +597,14 @@ string).  It returns t if a new completion is found, nil otherwise."
 (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
 (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)
                    (try-completion he-search-string obarray
                                    (function (lambda (sym)
                                      (or (boundp sym)


@@ -561,10 +624,9 @@ otherwise."
        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.


@@ -573,6 +635,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


@@ -582,24 +645,27 @@ 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


@@ -616,6 +682,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))
        (buf (current-buffer))
        (orig-case-fold-search case-fold-search))
                           comint-prompt-regexp))
        (buf (current-buffer))
        (orig-case-fold-search case-fold-search))


@@ -627,28 +694,33 @@ string).  It returns t if a new completion is found, nil otherwise."
          (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 
+       (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))
                    (not expansion)
                    (or (not hippie-expand-max-buffers)
                        (< he-searched-n-bufs hippie-expand-max-buffers)))
          (set-buffer (car he-search-bufs))
          (if (and (not (eq (current-buffer) buf))

-                  (not (memq major-mode hippie-expand-ignore-buffers))
-                  (not (he-regexp-member (buffer-name)
-                                         hippie-expand-ignore-buffers)))
+                  (if hippie-expand-only-buffers
+                      (he-buffer-member hippie-expand-only-buffers)
+                    (not (he-buffer-member hippie-expand-ignore-buffers))))

              (save-excursion
              (save-excursion

-               (goto-char he-search-loc)
-               (setq strip-prompt (and (get-buffer-process (current-buffer))
-                                       comint-prompt-regexp))
-               (setq expansion (let ((case-fold-search orig-case-fold-search))
-                                 (he-line-search he-search-string
-                                                 strip-prompt nil)))
-               (set-marker he-search-loc (point))
-               (if (not expansion)
-                   (progn
-                     (setq he-search-bufs (cdr he-search-bufs))
-                     (setq he-searched-n-bufs (1+ he-searched-n-bufs))
-                     (set-marker he-search-loc 1 (car he-search-bufs)))))
+               (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)))))
 
            (setq he-search-bufs (cdr he-search-bufs))
            (set-marker he-search-loc 1 (car he-search-bufs)))))
 


@@ -661,24 +733,25 @@ string).  It returns t if a new completion is found, nil otherwise."
          (he-substitute-string expansion t)
          t))))
 
          (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)))
+      (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
       (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

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


@@ -689,7 +762,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]\\)")))
 


@@ -707,22 +780,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


@@ -748,25 +824,29 @@ string).  It returns t if a new completion is found, nil otherwise."
          (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 
+       (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))
                    (not expansion)
                    (or (not hippie-expand-max-buffers)
                        (< he-searched-n-bufs hippie-expand-max-buffers)))
          (set-buffer (car he-search-bufs))
          (if (and (not (eq (current-buffer) buf))

-                  (not (memq major-mode hippie-expand-ignore-buffers))
-                  (not (he-regexp-member (buffer-name)
-                                         hippie-expand-ignore-buffers)))
+                  (if hippie-expand-only-buffers
+                      (he-buffer-member hippie-expand-only-buffers)
+                    (not (he-buffer-member hippie-expand-ignore-buffers))))

              (save-excursion
              (save-excursion

-               (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)))))
+               (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)))))
 
            (setq he-search-bufs (cdr he-search-bufs))
            (set-marker he-search-loc 1 (car he-search-bufs)))))
 


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

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

   (let ((result ())
        beg pos err)
     (while (and (not result)
   (let ((result ())
        beg pos err)
     (while (and (not result)


@@ -793,12 +873,12 @@ string).  It returns t if a new completion is found, nil otherwise."
       (condition-case ()
          (forward-list 1)
        (error (setq err t)))
       (condition-case ()
          (forward-list 1)
        (error (setq err t)))

-      (if (and reverse 
+      (if (and reverse

               (> (point) he-string-beg))
          (setq err t))
       (if (not err)
          (progn
               (> (point) he-string-beg))
          (setq err t))
       (if (not err)
          (progn

-           (setq result (buffer-substring beg (point)))
+           (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))
            (if (he-string-member result he-tried-table t)
                (setq result nil))))           ; if already in table, ignore
       (goto-char pos))


@@ -819,13 +899,13 @@ 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)
                             (if (and (boundp sym) (vectorp (eval sym)))
                                 (abbrev-expansion (downcase he-search-string)
                                                   (eval sym)))))
              (and (not (equal he-search-string ""))
                   (mapcar (function (lambda (sym)
                             (if (and (boundp sym) (vectorp (eval sym)))
                                 (abbrev-expansion (downcase he-search-string)
                                                   (eval sym)))))

-                          (append '(local-abbrev-table 
+                          (append '(local-abbrev-table

                                     global-abbrev-table)
                                   abbrev-table-name-list))))))
   (while (and he-expand-list
                                     global-abbrev-table)
                                   abbrev-table-name-list))))))
   (while (and he-expand-list


@@ -855,23 +935,26 @@ 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-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))))))
-       
+         (save-restriction
+           (if hippie-expand-no-restriction
+               (widen))
+           ;; Try looking backward unless inhibited.
+           (if he-search-bw
+               (progn
+                 (goto-char he-search-loc)
+                 (setq expansion (he-dabbrev-search he-search-string t))
+                 (set-marker he-search-loc (point))
+                 (if (not expansion)
+                     (progn
+                       (set-marker he-search-loc he-string-end)
+                       (setq he-search-bw ())))))
+
+           (if (not expansion) ; Then look forward.
+               (progn
+                 (goto-char he-search-loc)
+                 (setq expansion (he-dabbrev-search he-search-string nil))
+                 (set-marker he-search-loc (point)))))))
+

     (if (not expansion)
        (progn
          (if old (he-reset-string))
     (if (not expansion)
        (progn
          (if old (he-reset-string))


@@ -896,25 +979,29 @@ string).  It returns t if a new expansion is found, nil otherwise."
          (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 
+       (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))
                    (not expansion)
                    (or (not hippie-expand-max-buffers)
                        (< he-searched-n-bufs hippie-expand-max-buffers)))
          (set-buffer (car he-search-bufs))
          (if (and (not (eq (current-buffer) buf))

-                  (not (memq major-mode hippie-expand-ignore-buffers))
-                  (not (he-regexp-member (buffer-name)
-                                         hippie-expand-ignore-buffers)))
+                  (if hippie-expand-only-buffers
+                      (he-buffer-member hippie-expand-only-buffers)
+                    (not (he-buffer-member hippie-expand-ignore-buffers))))

              (save-excursion
              (save-excursion

-               (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)))))
+               (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)))))
 
            (setq he-search-bufs (cdr he-search-bufs))
            (set-marker he-search-loc 1 (car he-search-bufs)))))
 


@@ -961,13 +1048,13 @@ string).  It returns t if a new expansion is found, nil otherwise."
                                               (window-end he-search-window))))
        (set-marker he-search-loc (point) (current-buffer)))
       (if (not expansion)
                                               (window-end he-search-window))))
        (set-marker he-search-loc (point) (current-buffer)))
       (if (not expansion)

-         (progn 
+         (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))))))
            (setq he-search-window (next-window he-search-window nil flag))
            (if (eq he-search-window (selected-window))
                (set-marker he-search-loc nil)
              (set-marker he-search-loc (window-start he-search-window)
                          (window-buffer he-search-window))))))

-    
+

     (set-buffer buf)
     (if (not expansion)
        (progn
     (set-buffer buf)
     (if (not expansion)
        (progn


@@ -979,30 +1066,35 @@ string).  It returns t if a new expansion is found, nil otherwise."
 
 (defun he-dabbrev-search (pattern &optional reverse limit)
   (let ((result ())
 
 (defun he-dabbrev-search (pattern &optional reverse limit)
   (let ((result ())

-       (regpat (if (eq (char-syntax (aref pattern 0)) ?_)
-                   (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+")
-                 (concat "\\<" (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))))
-    (while (and (not result) 
+       (regpat (cond ((not hippie-expand-dabbrev-as-symbol)
+                      (concat "\\<" (regexp-quote pattern) "\\sw+"))
+                     ((eq (char-syntax (aref pattern 0)) ?_)
+                      (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
+                     (t
+                      (concat "\\<" (regexp-quote pattern)
+                              "\\(\\sw\\|\\s_\\)+")))))
+    (while (and (not result)

                (if reverse
                     (re-search-backward regpat limit t)
                     (re-search-forward regpat limit t)))
                (if reverse
                     (re-search-backward regpat limit t)
                     (re-search-forward regpat limit t)))

-      (setq result (buffer-substring (match-beginning 0) (match-end 0)))
-      (if (or (and (> (match-beginning 0) (point-min))
+      (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))
 
                   (memq (char-syntax (char-after (1- (match-beginning 0))))
                         '(?_ ?w)))
              (he-string-member result he-tried-table t))
          (setq result nil)))     ; ignore if bad prefix or already in table
     result))
 

-(defvar he-dabbrev-skip-space ()
-  "Non-NIL means tolerate trailing spaces in the abbreviation to expand.")
-

 (defun he-dabbrev-beg ()
   (let ((op (point)))
     (save-excursion
 (defun he-dabbrev-beg ()
   (let ((op (point)))
     (save-excursion

-      (if he-dabbrev-skip-space
+      (if hippie-expand-dabbrev-skip-space

          (skip-syntax-backward ". "))
          (skip-syntax-backward ". "))

-      (if (= (skip-syntax-backward "w_") 0)
+      (if (= (skip-syntax-backward (if hippie-expand-dabbrev-as-symbol
+                                      "w_" "w"))
+            0)

          op
        (point)))))
 
          op
        (point)))))
 


@@ -1013,7 +1105,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 ()))
     (if (not old)
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ()))
     (if (not old)

-       (progn 
+       (progn

          (he-init-string (he-dabbrev-beg) (point))
          (setq he-expand-list
                (if (not (equal he-search-string ""))
          (he-init-string (he-dabbrev-beg) (point))
          (setq he-expand-list
                (if (not (equal he-search-string ""))


@@ -1031,25 +1123,31 @@ string).  It returns t if a new completion is found, nil otherwise."
 
 (defun he-dabbrev-kill-search (pattern)
   (let ((result ())
 
 (defun he-dabbrev-kill-search (pattern)
   (let ((result ())

-       (regpat (if (eq (char-syntax (aref pattern 0)) ?_)
-                   (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+")
-                 (concat "\\<" (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+")))
+       (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)))
        (killstr (car he-expand-list)))

-    (while (and (not result) 
+    (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)))
                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)))
        (setq he-search-loc2 (1+ (match-beginning 0)))

-       (if (or (and (> (match-beginning 0) 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
                     (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) 
+      (if (and (not result)

                he-expand-list)
          (progn
                he-expand-list)
          (progn

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

            (setq killstr (car he-expand-list))
            (setq he-search-loc2 0))))
     result))
            (setq killstr (car he-expand-list))
            (setq he-search-loc2 0))))
     result))


@@ -1061,11 +1159,11 @@ 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)
 string).  It returns t if a new completion is found, nil otherwise."
   (let ((expansion ()))
     (if (not old)

-       (progn 
+       (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)))
          (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 
+         (setq he-expand-list

                (if (not (equal he-search-string ""))
                    kill-ring))
          (setq he-search-loc2 ())))
                (if (not (equal he-search-string ""))
                    kill-ring))
          (setq he-search-loc2 ())))


@@ -1100,14 +1198,16 @@ string).  It returns t if a new completion is found, nil otherwise."
                   (eq (char-after (- (point) pos)) (aref killstr 0))
                   (search-backward (substring killstr 0 pos)
                                    (- (point) pos) t))
                   (eq (char-after (- (point) pos)) (aref killstr 0))
                   (search-backward (substring killstr 0 pos)
                                    (- (point) pos) t))

-             (setq result (substring killstr pos))))
+             (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
        (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 he-expand-list (cdr he-expand-list))

            (setq killstr (car he-expand-list))
            (setq pos -1))))
     result))
            (setq killstr (car he-expand-list))
            (setq pos -1))))
     result))


@@ -1123,4 +1223,5 @@ string).  It returns t if a new completion is found, nil otherwise."
 
 (provide 'hippie-exp)
 
 
 (provide 'hippie-exp)
 

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

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