(hippie-expand-dabbrev-skip-space): Renamed `he-dabbrev-skip-space'.

(hippie-expand-dabbrev-as-symbol): Renamed `he-dabbrev-as-symbol'.
(hippie-expand-no-restriction): New variable.
(hippie-expand-only-buffers): New variable.
(he-init-string,he-line-search,he-list-search,he-dabbrev-search): Use
`buffer-substring-no-properties' to avoid transfer of text properties.
(he-dabbrev-kill-search,he-whole-kill-search): Remove text properties
from search result.
(he-regexp-member): Removed function.
(he-buffer-member): New function used instead of `he-regexp-member'.
(try-expand-line,try-expand-line-all-buffers,try-expand-list,
 try-expand-list-all-buffers,try-expand-dabbrev,
 try-expand-dabbrev-all-buffers): Depending on
`hippie-expand-no-restriction', widen the buffer before search.
(try-expand-line-all-buffers,try-expand-list-all-buffers,
 try-expand-dabbrev-all-buffers): Use `he-buffer-member' and
`hippie-expand-only-buffers'.

1 files changed, 195 insertions, 137 deletions

diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index 70a653eb738..3af8e1b270d 100644
--- a/lisp/hippie-exp.el
+++ b/lisp/hippie-exp.el
@@ -3,8 +3,8 @@
 ;; Copyright (C) 1992 Free Software Foundation, Inc.
 
 ;; Author: Anders Holst <aho@sans.kth.se>
-;; Last change: 28 May 1997
-;; Version: 1.5
+;; Last change: 3 March 1998
+;; Version: 1.6
 ;; Keywords: abbrev
 
 ;; This file is part of GNU Emacs.
@@ -49,6 +49,17 @@
 ;;  matching buffer names (as strings) or major modes (as atoms) of
 ;;  buffers that should not be searched by the try-functions named
 ;;  "-all-buffers".
+;;  If set, the variable `hippie-expand-only-buffers' does the opposite
+;;  of `hippie-expand-ignore-buffers', in that the search is restricted
+;;  to only the kind of buffers listed.
+;;  If the variable `hippie-expand-no-restriction' is non-nil, narrowed
+;;  buffers are widened before they are searched.
+;;  The variable `hippie-expand-dabbrev-skip-space' controls whether
+;;  trailing spaces will be included in the abbreviation to search for,
+;;  which then gives the same behavior as the original `dabbrev-expand'.
+;;  The variable `hippie-expand-dabbrev-as-symbol' controls whether
+;;  characters of syntax '_' is considered part of the words to expand
+;;  dynamically.
 ;;  See also the macro `make-hippie-expand-function' below.
 ;;  
 ;;  A short description of the current try-functions in this file:
@@ -161,16 +172,6 @@
   "Expand text trying various ways to find its expansion."
   :group 'abbrev)
 
-(defcustom he-dabbrev-skip-space nil
-  "Non-nil means tolerate trailing spaces in the abbreviation to expand."
-  :group 'hippie-expand
-  :type 'boolean)
-
-(defcustom he-dabbrev-as-symbol t
-  "Non-nil means expand as symbols, i.e. syntax `_' is considered a letter."
-  :group 'hippie-expand
-  :type 'boolean)
-
 (defvar he-num -1)
 
 (defvar he-string-beg (make-marker))
@@ -217,6 +218,24 @@ or insert functions in this list.")
   :group 'hippie-expand)
 
 ;;;###autoload
+(defcustom hippie-expand-dabbrev-skip-space nil
+  "*Non-nil means tolerate trailing spaces in the abbreviation to expand."
+  :group 'hippie-expand
+  :type 'boolean)
+
+;;;###autoload
+(defcustom hippie-expand-dabbrev-as-symbol t
+  "*Non-nil means expand as symbols, i.e. syntax `_' is considered a letter."
+  :group 'hippie-expand
+  :type 'boolean)
+
+;;;###autoload
+(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."
@@ -233,6 +252,15 @@ Can contain both regexps matching buffer names (as strings) and major modes
   :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
@@ -270,7 +298,7 @@ undoes the expansion."
             (if (and hippie-expand-verbose
                      (not (window-minibuffer-p (selected-window))))
                 (message "Using %s"
-                         (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
@@ -284,7 +312,7 @@ undoes the expansion."
 (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 ()
@@ -356,14 +384,16 @@ undoes the expansion."
                 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
@@ -476,8 +506,8 @@ otherwise."
     (save-excursion
       (skip-chars-backward he-file-name-chars)
       (if (> (skip-syntax-backward "w") 0)  ;; No words with non-file chars
-          op
-        (point)))))
+          op
+        (point)))))
 
 ;; Thanks go to Richard Levitte <levitte@e.kth.se> who helped to make these
 ;; work under VMS, and to David Hughes <ukchugd@ukpmr.cs.philips.nl> who 
@@ -605,24 +635,27 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
         (save-excursion
-          ;; Try looking backward unless inhibited.
-          (if he-search-bw
-              (progn 
-                (goto-char he-search-loc)
-                (setq expansion (he-line-search he-search-string
-                                                strip-prompt t))
-                (set-marker he-search-loc (point))
-                (if (not expansion)
-                    (progn
-                      (set-marker he-search-loc he-string-end)
-                      (setq he-search-bw ())))))
-          
-          (if (not expansion) ; Then look forward.
-              (progn 
-                (goto-char he-search-loc)
-                (setq expansion (he-line-search he-search-string 
-                                                strip-prompt nil))
-                (set-marker he-search-loc (point))))))
+          (save-restriction
+            (if hippie-expand-no-restriction
+                (widen))
+            ;; Try looking backward unless inhibited.
+            (if he-search-bw
+                (progn 
+                  (goto-char he-search-loc)
+                  (setq expansion (he-line-search he-search-string
+                                                  strip-prompt t))
+                  (set-marker he-search-loc (point))
+                  (if (not expansion)
+                      (progn
+                        (set-marker he-search-loc he-string-end)
+                        (setq he-search-bw ())))))
+
+            (if (not expansion) ; Then look forward.
+                (progn 
+                  (goto-char he-search-loc)
+                  (setq expansion (he-line-search he-search-string 
+                                                  strip-prompt nil))
+                  (set-marker he-search-loc (point)))))))
 
     (if (not expansion)
         (progn
@@ -656,22 +689,26 @@ string).  It returns t if a new completion is found, nil otherwise."
                         (< he-searched-n-bufs hippie-expand-max-buffers)))
           (set-buffer (car he-search-bufs))
           (if (and (not (eq (current-buffer) buf))
-                   (not (memq major-mode hippie-expand-ignore-buffers))
-                   (not (he-regexp-member (buffer-name)
-                                          hippie-expand-ignore-buffers)))
+                   (if hippie-expand-only-buffers
+                       (he-buffer-member hippie-expand-only-buffers)
+                     (not (he-buffer-member hippie-expand-ignore-buffers))))
               (save-excursion
-                (goto-char he-search-loc)
-                (setq strip-prompt (and (get-buffer-process (current-buffer))
-                                        comint-prompt-regexp))
-                (setq expansion (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-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)))))
 
@@ -694,7 +731,8 @@ string).  It returns t if a new completion is found, nil otherwise."
                     (re-search-forward
                      (he-line-search-regexp str strip-prompt)
                      nil t)))
-      (setq result (buffer-substring (match-beginning 2) (match-end 2)))
+      (setq result (buffer-substring-no-properties (match-beginning 2)
+                                                   (match-end 2)))
       (if (he-string-member result he-tried-table t)
           (setq result nil)))               ; if already in table, ignore
     result))
@@ -730,22 +768,25 @@ string).  It returns t if a new completion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
         (save-excursion
-          ;; Try looking backward unless inhibited.
-          (if he-search-bw
-              (progn 
-                (goto-char he-search-loc)
-                (setq expansion (he-list-search he-search-string t))
-                (set-marker he-search-loc (point))
-                (if (not expansion)
-                    (progn
-                      (set-marker he-search-loc he-string-end)
-                      (setq he-search-bw ())))))
-          
-          (if (not expansion) ; Then look forward.
-              (progn 
-                (goto-char he-search-loc)
-                (setq expansion (he-list-search he-search-string nil))
-                (set-marker he-search-loc (point))))))
+          (save-restriction
+            (if hippie-expand-no-restriction
+                (widen))
+            ;; Try looking backward unless inhibited.
+            (if he-search-bw
+                (progn 
+                  (goto-char he-search-loc)
+                  (setq expansion (he-list-search he-search-string t))
+                  (set-marker he-search-loc (point))
+                  (if (not expansion)
+                      (progn
+                        (set-marker he-search-loc he-string-end)
+                        (setq he-search-bw ())))))
+
+            (if (not expansion) ; Then look forward.
+                (progn 
+                  (goto-char he-search-loc)
+                  (setq expansion (he-list-search he-search-string nil))
+                  (set-marker he-search-loc (point)))))))
 
     (if (not expansion)
         (progn
@@ -777,19 +818,23 @@ string).  It returns t if a new completion is found, nil otherwise."
                         (< he-searched-n-bufs hippie-expand-max-buffers)))
           (set-buffer (car he-search-bufs))
           (if (and (not (eq (current-buffer) buf))
-                   (not (memq major-mode hippie-expand-ignore-buffers))
-                   (not (he-regexp-member (buffer-name)
-                                          hippie-expand-ignore-buffers)))
+                   (if hippie-expand-only-buffers
+                       (he-buffer-member hippie-expand-only-buffers)
+                     (not (he-buffer-member hippie-expand-ignore-buffers))))
               (save-excursion
-                (goto-char he-search-loc)
-                (setq expansion (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)))))
 
@@ -821,7 +866,7 @@ string).  It returns t if a new completion is found, nil otherwise."
           (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))
@@ -878,22 +923,25 @@ string).  It returns t if a new expansion is found, nil otherwise."
 
     (if (not (equal he-search-string ""))
         (save-excursion
-          ;; Try looking backward unless inhibited.
-          (if he-search-bw
-              (progn 
-                (goto-char he-search-loc)
-                (setq expansion (he-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
@@ -925,19 +973,23 @@ string).  It returns t if a new expansion is found, nil otherwise."
                         (< he-searched-n-bufs hippie-expand-max-buffers)))
           (set-buffer (car he-search-bufs))
           (if (and (not (eq (current-buffer) buf))
-                   (not (memq major-mode hippie-expand-ignore-buffers))
-                   (not (he-regexp-member (buffer-name)
-                                          hippie-expand-ignore-buffers)))
+                   (if hippie-expand-only-buffers
+                       (he-buffer-member hippie-expand-only-buffers)
+                     (not (he-buffer-member hippie-expand-ignore-buffers))))
               (save-excursion
-                (goto-char he-search-loc)
-                (setq expansion (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)))))
 
@@ -1002,20 +1054,21 @@ string).  It returns t if a new expansion is found, nil otherwise."
 
 (defun he-dabbrev-search (pattern &optional reverse limit)
   (let ((result ())
-        (regpat (cond ((not he-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_\\)+")))))
+        (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)))
-      (setq result (buffer-substring (match-beginning 0) (match-end 0)))
-      (if (or (and he-dabbrev-as-symbol
-                   (> (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))
@@ -1025,9 +1078,11 @@ string).  It returns t if a new expansion is found, nil otherwise."
 (defun he-dabbrev-beg ()
   (let ((op (point)))
     (save-excursion
-      (if he-dabbrev-skip-space
+      (if hippie-expand-dabbrev-skip-space
           (skip-syntax-backward ". "))
-      (if (= (skip-syntax-backward (if he-dabbrev-as-symbol "w_" "w")) 0)
+      (if (= (skip-syntax-backward (if hippie-expand-dabbrev-as-symbol
+                                       "w_" "w"))
+             0)
           op
         (point)))))
 
@@ -1056,22 +1111,23 @@ string).  It returns t if a new completion is found, nil otherwise."
 
 (defun he-dabbrev-kill-search (pattern)
   (let ((result ())
-        (regpat (cond ((not he-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_\\)+"))))
+        (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 he-dabbrev-as-symbol
-                     (> (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))
@@ -1130,7 +1186,9 @@ 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))
-              (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