Mercurial > emacs

--- a/lisp/dabbrev.el	Sat Dec 24 01:26:51 1994 +0000
+++ b/lisp/dabbrev.el	Sat Dec 24 01:30:55 1994 +0000
@@ -1,5 +1,5 @@
-;;; new-dabbrev.el --- dynamic abbreviation package
-;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+;;; dabbrev.el --- dynamic abbreviation package
+;; Copyright (C) 1985, 1986, 1992, 1994 Free Software Foundation, Inc.

 ;; Author: Don Morrison
 ;; Maintainer: Lars Lindberg <Lars.Lindberg@sypro.cap.se>
@@ -32,14 +32,14 @@
 ;; M-/ (dabbrev-expand) or M-C-/ (dabbrev-completion).
 ;;
 ;; There are powerful things in this package that aren't turned on by
-;; default. I recommend you to do the following.
+;; default.  I recommend you to do the following.
 ;;
 ;; Put the following 2 lines in your .emacs file:
 ;; (setq dabbrev-always-check-other-buffers t)
 ;; (setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
 ;;
 ;; Dabbrev will now search in all buffers with the same major mode for
-;; your expansions. It will also search for complete symbols, the old
+;; your expansions.  It will also search for complete symbols, the old
 ;; dabbrev package only looked half-heartedly for symbols.
 ;;
 ;; Check out the customizable variables below to learn about all the
@@ -72,69 +72,6 @@
 ;;           (set-buffer buffer)
 ;;           (memq major-mode '(news-reply-mode gnus-article-mode)))))

-;;; Change Log
-;;  4.4.2 1994-11-25
-;;      Added new variable; `dabbrev-check-rest-of-buffers'.
-;;  4.4.1 1994-11-24
-;;      Now has correct creation date.
-;;      Added kill-ring idea to "Future enhancements".
-;;  4.4 1994-11-22
-;;	Changed the copyright text.  Thanks [hymie].
-;;	new-dabbrev now handles abbrevs that starts with symbol
-;;	syntax. Thanks [burgett] for kicking me to do it.
-;;	Now also handles `dabbrev-abbrev-skip-leading-regexp' better.
-;;  4.3 1994-11-14
-;;	Now only displays "Expansion found in <buffer>" when the
-;;	expansion has been found in buffers that hasn't been examined
-;;	yet. Thanks [kifer].
-;;      Added a new variable; `dabbrev-search-these-buffers-only'.
-;;      Fixed bug in mini-buffer completion. Thanks [kifer].
-;;      Found a real time-waster when using `dabbrev-completion'.
-;;      Thanks for the elp.el package Barry Warsaw!
-;;	Found bug that made point move in other buffers.
-;;      Now handles Lucid emacs define-key style.
-;;      Thanks [jules].
-;;      Now uses the `<symbol>' syntax in doc strings.
-;;      Cosmetic bugs and syntactical bugs in documentation strings.
-;;      Thanks [hawley].
-;;  4.2 1994-03-04
-;;      Now searches other buffers again. Thanks [ake].
-;;  4.1 1994-02-22
-;;      Introduced the new variables `dabbrev-case-fold-search' and
-;;      `dabbrev-case-replace'.
-;;      Introduced the new variable `dabbrev-select-buffers-function'.
-;;      Introduced the new variable `dabbrev-abbrev-skip-leading-regexp'.
-;;      Changed `dabbrev-always-check-other-buffers' to not buffer local.
-;;      Thanks [kifer].
-;;      Bug in `dabbrev-completion', x expanded to xxy instead of xy.
-;;      Thanks [kifer].
-;;      Added `dabbrev-submit-feedback' for better error-reporting.
-;;      The hooks (`dabbrev-select-buffers-function' and
-;;      `dabbrev-friend-buffer-function') are now not automatically
-;;      buffer local.
-;;      Now provides dabbrev too.
-;;  3.2 1993-12-14
-;;      Message for expansion found in buffer other than current.
-;;	Minor bugs.
-;;  3.1 1993-12-13
-;;      Better comment for `dabbrev-abbrev-char-regexp'.
-;;  3.0 1993-12-09
-;;      Freshed things up for the release.
-;;      `dabbrev-completion' now doesn't have to use the minibuffer.
-;;      Thanks [alon].
-;;  2.0 1993-12-02 Lars Lindberg <lli@sypro.cap.se>
-;;      Searches in other buffers for the expansion.
-;;      Works also for the minibuffer.
-;;      Added `dabbrev-completion'.
-;;      More efficient code.
-;;      Found minor bugs.
-;;  1.0 converted to Emacs Lisp by Spencer Thomas.
-;;      Thoroughly cleaned up by Richard Stallman.
-;;  0.0
-;;      DABBREVS - "Dynamic abbreviations" hack, originally written by
-;;      Don Morrison for Twenex Emacs.  Converted to mlisp by Russ Fish.
-;;      Supports the table feature to avoid hitting the same expansion on
-;;      re-expand, and the search size limit variable.

 ;; Known bugs and limitations.
 ;; - Possible to do several levels of `dabbrev-completion' in the
@@ -146,8 +83,8 @@
 ;;  - Check the tags-files? Like tags-complete?
 ;;  - Add the possibility of searching both forward and backward to
 ;;    the nearest expansion.
-;;  - Check the kill-ring when everything else fails. (Maybe something
-;;  for hippie-expand?). [Bng] <boris@cs.rochester.edu>
+;;  - Check the kill-ring when everything else fails.  (Maybe something
+;;  for hippie-expand?).  [Bng] <boris@cs.rochester.edu>

 ;;; Thanks goes to
 ;;  [hymie]	Hyman Rosen <marks!hymie@jyacc.jyacc.com>
@@ -164,7 +101,6 @@
 ;;  ... and to all the people who have participated in the beta tests.

 ;;; Code:
-(require 'cl)

 ;;;----------------------------------------------------------------
 ;;;----------------------------------------------------------------
@@ -172,7 +108,7 @@
 ;;;----------------------------------------------------------------
 ;;;----------------------------------------------------------------
 (defvar dabbrev-backward-only nil
-  "*If non-NIL, `dabbrev-expand' only looks backwards.")
+  "*If non-nil, `dabbrev-expand' only looks backwards.")

 (defvar dabbrev-limit nil
   "*Limits region searched by `dabbrev-expand' to this many chars away.")
@@ -180,72 +116,67 @@
 (defvar dabbrev-abbrev-skip-leading-regexp nil
   "*Regexp for skipping leading characters of an abbreviation.

-Example: Set this to \"\\\\$\" for programming languages that sometimes
-has and sometimes has not a leading $ for variable names.
+Example: Set this to \"\\\\$\" for programming languages
+in which variable names may appear with or without a leading `$'.
+(For example, in Makefiles.)

 Set this to nil if no characters should be skipped.")

 ;; I recommend that you set this to nil.
 (defvar dabbrev-case-fold-search 'case-fold-search
-  "*T if dabbrev searches should ignore case.
-nil if case is significant.
-Non-nil and not t means evaluate for value.
+  "*Non-nil if dabbrev searches should ignore case.
+A value of nil means case is significant.

-Example:Setting this to 'case-fold-search means evaluate that variable
-to see if it is t or non-nil.")
+The value of this variable is an expression; it is evaluated
+and the resulting value determines the decision.
+For example: setting this to `case-fold-search' means evaluate that
+variable to see whether its value is nil.")

 (defvar dabbrev-upcase-means-case-search nil
   "*The significance of an uppercase character in an abbreviation.
+nil means case fold search, non-nil means case sensitive search.

-This variable only makes sense when the value of
-`dabbrev-case-fold-search' evaluates to t.
-
-nil = case fold search
-t = case sensitive search")
+This variable has an effect only when the value of
+`dabbrev-case-fold-search' evaluates to t.")

 ;; I recommend that you set this to nil.
 (defvar dabbrev-case-replace 'case-replace
-  "*T if dabbrev should preserve case when expanding the abbreviation.
-nil if it should not.
-Non-nil and not t means evaluate for value.
+  "*Non-nil means dabbrev should preserve case when expanding the abbreviation.
+The value of this variable is an expression; it is evaluated
+and the resulting value determines the decision.
+For example, setting this to `case-replace' means evaluate that
+variable to see if its value is t or nil.

-This variable only makes sense when the value of
-`dabbrev-case-fold-search' evaluates to t.
-
-Example: Setting this to 'case-replace means evaluate that variable to
-see if it is t or non-nil.")
+This variable has an effect only when the value of
+`dabbrev-case-fold-search' evaluates to t.")

 ;; I recommend that you set this to "\\sw\\|\\s_"
 (defvar dabbrev-abbrev-char-regexp nil
-  "*A regexp that recognizes a character in an abbreviation or an
-expansion.  Will be surrounded with \\\\( ... \\\\) when used.
+  "*Regexp to recognize a character in an abbreviation or expansion.
+This regexp will be surrounded with \\\\( ... \\\\) when actually used.

-Set this to \"\\\\sw\" if you want ordinary words or
+Set this variable to \"\\\\sw\" if you want ordinary words or
 \"\\\\sw\\\\|\\\\s_\" if you want symbols.

 You can also set it to nil if you want old-style dabbrev searching
-(the abbreviation is from point to previous word-start, the
+\(the abbreviation is from point to previous word-start, the
 search is for symbols).

-For instance, if you are programming in Lisp, yes-or-no-p is a symbol,
-while 'yes', 'or', 'no' and 'p' are considered words.  If you set this
-variable to nil, then expanding yes-or-no- will look for a symbol
-starting with or containing 'no-'.  If you set this variable to
-\"\\\\sw\\\\|\\\\s_\" dabbrev will look for a symbol starting with
-\"yes-or-no-\". Finally, if you set this variable to \"\\\\sw\", then an
-error will be signalled, because \"-\" is not part of a word but if you
-try to expand \"yes-or-no\", dabbrev will look for a word starting with
-\"no\".
+For instance, if you are programming in Lisp, `yes-or-no-p' is a symbol,
+while `yes', `or', `no' and `p' are considered words.  If you set this
+variable to nil, then expanding `yes-or-no-' looks for a symbol
+starting with or containing `no-'.  If you set this variable to
+\"\\\\sw\\\\|\\\\s_\", that expansion looks for a symbol starting with
+`yes-or-no-'.  Finally, if you set this variable to \"\\\\sw\", then
+expanding `yes-or-no-' signals an error because `-' is not part of a word;
+but expanding `yes-or-no' looks for a word starting with `no'.

 The recommended value is \"\\\\sw\\\\|\\\\s_\".")

-;; I recommend that you set this to t.
-(defvar dabbrev-check-rest-of-buffers nil
-  "*Should dabbrev package search in all buffers?.
-
-Non-nil means first look in buffers pointed out by
-`dabbrev-select-buffers-function' and then look in the rest of the
-buffers.")
+(defvar dabbrev-check-rest-of-buffers t
+  "*Non-nil means dabbrev package should search in all buffers.
+It searches the buffers pointed out by `dabbrev-select-buffers-function'
+first; afterward it looks in the rest of the buffers.")


 ;; I recommend that you set this to t.
@@ -277,17 +208,17 @@
 non-nil if that buffer should be searched.  Have a look at
 `dabbrev--same-major-mode-p' for an example.

-Setting this makes sense only if the function pointed out by
-`dabbrev-select-buffers-function' uses it.  The package function
-`dabbrev--select-buffers' is such a function.
+The value of `dabbrev-friend-buffer-function' has an effect only if
+the value of `dabbrev-select-buffers-function' uses it.  The function
+`dabbrev--select-buffers' is one function you can use here.

 A mode setting this variable should make it buffer local.")

 (defvar dabbrev-search-these-buffers-only nil
-  "Should be a list of buffers if non-nil.
-
-Dabbrev search will only look in these buffers. It will not even look
-in the current buffer if it is not a member of this list.")
+  "If non-nil, a list of buffers which dabbrev should search.
+If this variable is non-nil, dabbrev will only look in these buffers.
+It will not even look in the current buffer if it is not a member of
+this list.")

 ;;;----------------------------------------------------------------
 ;;;----------------------------------------------------------------
@@ -344,6 +275,20 @@
 (defsubst dabbrev--minibuffer-origin ()
   (car (cdr (buffer-list))))

+;; Make a list of some of the elements of LIST.
+;; Check each element of LIST, storing it temporarily in the
+;; variable ELEMENT, and include it in the result
+;; if CONDITION evaluates non-nil.
+(defmacro dabbrev-filter-elements (element list condition)
+  (` (let (dabbrev-result dabbrev-tail (, element))
+       (setq dabbrev-tail (, list))
+       (while dabbrev-tail
+	 (setq (, element) (car dabbrev-tail))
+	 (if (, condition)
+	     (setq dabbrev-result (cons (, element) dabbrev-result)))
+	 (setq dabbrev-tail (cdr dabbrev-tail)))
+       (nreverse dabbrev-result))))
+
 ;;;----------------------------------------------------------------
 ;;;----------------------------------------------------------------
 ;;; Exported functions
@@ -352,24 +297,22 @@

 ;;;###autoload
 (define-key esc-map "/" 'dabbrev-expand)
+;;;??? Do we want this?
 ;;;###autoload
-(if (string-match "Lucid$" emacs-version)
-    (define-key esc-map [(control /)] 'dabbrev-completion)
-  (define-key esc-map [?\C-/] 'dabbrev-completion))
+(define-key esc-map [?\C-/] 'dabbrev-completion))

 ;;;###autoload
 (defun dabbrev-completion (&optional arg)
   "Completion on current word.
-
 Like \\[dabbrev-expand] but finds all expansions in the current buffer
 and presents suggestions for completion.

-If you call this function with prefix ARG, then it searches all
-buffers accepted by the function pointed out by
-`dabbrev-friend-buffer-function' to find the completions.
+With a prefix argument, it searches all buffers accepted by the
+function pointed out by `dabbrev-friend-buffer-function' to find the
+completions.  \(The argument value does not matter.)

-With no prefix ARG it tries to reuse the old completion list
-before making a new one."
+With no prefix argument, it reuses an old completion list
+if there is a suitable one already."

   (interactive "*P")
   (let* ((dabbrev-always-check-other-buffers (and arg t))
@@ -392,10 +335,8 @@
 			(substring abbrev 0
 				   (length dabbrev--last-abbreviation)))
 	       (setq init (try-completion abbrev my-obarray)))
-	  ;;--------------------------------
-	  ;; This is a continue.
-	  ;;--------------------------------
-	  (progn)
+	  ;; We can reuse the existing completion list.
+	  nil
 	;;--------------------------------
 	;; New abbreviation to expand.
 	;;--------------------------------
@@ -407,7 +348,7 @@
 	  ;; Make an obarray with all expansions
 	  (setq my-obarray (make-vector (length completion-list) 0))
 	  (or (> (length my-obarray) 0)
-	      (error "No dynamic expansion for \"%s\" found%s."
+	      (error "No dynamic expansion for \"%s\" found%s"
 		     abbrev
 		     (if dabbrev--check-other-buffers "" " in this-buffer")))
 	  (cond
@@ -443,7 +384,8 @@
      ((and (not (string-equal init ""))
 	   (not (string-equal (downcase init) (downcase abbrev))))
       (if (> (length (all-completions init my-obarray)) 1)
-	  (message "Repeat '%s' to see all completions" this-command)
+	  (message "Repeat `%s' to see all completions"
+		   (key-description (this-command-keys)))
 	(message "The only possible completion"))
       (dabbrev--substitute-expansion nil abbrev init))
      (t
@@ -451,7 +393,7 @@
       (message "Making completion list...")
       (with-output-to-temp-buffer " *Completions*"
 	(display-completion-list (all-completions init my-obarray)))
-      (message "Making completion list... Done.")))
+      (message "Making completion list...done")))
     (and (window-minibuffer-p (selected-window))
 	 (message nil))))

@@ -465,7 +407,7 @@
 buffers accepted by the function pointed out by variable
 `dabbrev-friend-buffer-function'.

-A positive prefix argument, N, says to take the Nth backward _distinct_
+A positive prefix argument, N, says to take the Nth backward *distinct*
 possibility.  A negative argument says search forward.

 If the cursor has not moved from the end of the previous expansion and
@@ -475,10 +417,11 @@
 The variable `dabbrev-backward-only' may be used to limit the
 direction of search to backward if set non-nil.

+???
 To make it more powerful, make sure that
 `dabbrev-always-check-other-buffers' is set to t.

-Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
+See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
   (interactive "*P")
   (let (abbrev expansion old direction)
     ;; abbrev -- the abbrev to expand
@@ -492,16 +435,12 @@
 		   (and (window-minibuffer-p (selected-window))
 			(= dabbrev--last-abbrev-location
 			   (point)))))
-	  ;;--------------------------------
-	  ;; This is a redo.
-	  ;;--------------------------------
+	  ;; Find a different expansion for the same abbrev as last time.
 	  (progn
 	    (setq abbrev dabbrev--last-abbreviation)
 	    (setq old dabbrev--last-expansion)
 	    (setq direction dabbrev--last-direction))
-	;;--------------------------------
-	;; New abbreviation to expand.
-	;;--------------------------------
+	;; We have a different abbrev to expand.
 	(dabbrev--reset-global-variables)
 	(setq direction (if (null arg)
 			    (if dabbrev-backward-only 1 0)
@@ -524,7 +463,7 @@
 	  (save-excursion
 	    (search-backward (substring old (length abbrev)))
 	    (delete-region (match-beginning 0) (match-end 0))))
-      (error "No%s dynamic expansion for \"%s\" found."
+      (error "No%s dynamic expansion for `%s' found"
 	     (if old " further" "") abbrev))
      (t
       (if (not (eq dabbrev--last-buffer dabbrev--last-buffer-found))
@@ -540,26 +479,6 @@
       (setq dabbrev--last-abbreviation abbrev)
       (setq dabbrev--last-abbrev-location (point-marker))))))

-(eval-when-compile (require 'reporter))
-(defun dabbrev-submit-feedback ()
-  "Submit via mail a bug report on the dabbrev package."
-  (interactive)
-  (require 'reporter)
-  (and (y-or-n-p "Do you really want to submit a report on the dabbrev package? ")
-       (reporter-submit-bug-report
-	"Lars Lindberg <lli@sypro.cap.se>"
-	(format "new-dabbrev.el (Release %s)" (dabbrev--version))
-	'(dabbrev-backward-only
-	  dabbrev-limit
-	  dabbrev-case-fold-search
-	  dabbrev-case-replace
-	  dabbrev-upcase-means-case-search
-	  dabbrev-abbrev-char-regexp
-	  dabbrev-always-check-other-buffers
-	  dabbrev-select-buffers-function
-	  dabbrev-friend-buffer-function)
-	nil nil nil)))
-
 ;;;----------------------------------------------------------------
 ;;;----------------------------------------------------------------
 ;;; Local functions
@@ -584,28 +503,29 @@

 ;;; Checks if OTHER-BUFFER has the same major mode as current buffer.
 (defun dabbrev--same-major-mode-p (other-buffer)
-  (let ((orig-mode major-mode))
-    (save-excursion
-      (set-buffer other-buffer)
-      (eq orig-mode major-mode))))
+  (eq major-mode
+      (save-excursion
+	(set-buffer other-buffer)
+	major-mode)))

 ;;; Back over all abbrev type characters and then moves forward over
 ;;; all skip characters.
 (defun dabbrev--goto-start-of-abbrev ()
   ;; Move backwards over abbrev chars
   (save-match-data
-    (when (not (bobp))
-      (forward-char -1)
-      (while (and (looking-at dabbrev--abbrev-char-regexp)
-		  (not (bobp)))
-	(forward-char -1))
-      (or (looking-at dabbrev--abbrev-char-regexp)
-	  (forward-char 1)))
+    (if (not (bobp))
+	(progn
+	  (forward-char -1)
+	  (while (and (looking-at dabbrev--abbrev-char-regexp)
+		      (not (bobp)))
+	    (forward-char -1))
+	  (or (looking-at dabbrev--abbrev-char-regexp)
+	      (forward-char 1))))
     (and dabbrev-abbrev-skip-leading-regexp
 	 (while (looking-at dabbrev-abbrev-skip-leading-regexp)
 	   (forward-char 1)))))

-;;; Extract the symbol at point to serve as abbrevitation.
+;;; Extract the symbol at point to serve as abbreviation.
 (defun dabbrev--abbrev-at-point ()
   ;; Check for error
   (save-excursion
@@ -617,7 +537,7 @@
 					 (or dabbrev-abbrev-char-regexp
 					     "\\sw\\|\\s_")
 					 "\\)+")))))
-	  (error "Not positioned immediately after an abbreviation."))))
+	  (error "Not positioned immediately after an abbreviation"))))
   ;; Return abbrev at point
   (save-excursion
     (setq dabbrev--last-abbrev-location (point))
@@ -649,37 +569,26 @@
     (and (window-minibuffer-p (selected-window))
 	 (set-buffer (dabbrev--minibuffer-origin)))
     (let ((orig-buffer (current-buffer)))
-      (loop for buffer
-	    in (buffer-list)
-	    if (and (not (eq orig-buffer buffer))
-		    (boundp 'dabbrev-friend-buffer-function)
-		    (funcall dabbrev-friend-buffer-function buffer))
-	    collect buffer))))
+      (dabbrev-filter-elements
+       buffer (buffer-list)
+       (and (not (eq orig-buffer buffer))
+	    (boundp 'dabbrev-friend-buffer-function)
+	    (funcall dabbrev-friend-buffer-function buffer))))))

-;;; Try to find ABBREV in REVERSE direction N times.
+;;; Search for ABBREV, N times, normally looking forward,
+;;; but looking in reverse instead if REVERSE is non-nil.
 (defun dabbrev--try-find (abbrev reverse n ignore-case)
   (save-excursion
-    (let ((case-fold-search-is-local (memq 'case-fold-search
-					   (buffer-local-variables)))
-	  (expansion nil))
+    (let ((expansion nil))
       (and dabbrev--last-expansion-location
 	   (goto-char dabbrev--last-expansion-location))
-      (unwind-protect
-	  (progn
-	    (or case-fold-search-is-local
-		(make-local-variable 'case-fold-search))
-	    ;; Tricky! If `case-fold-search' isn't buffer-local, then
-	    ;; this innocent let creates a buffer-local variable and
-	    ;; when the let returns, it is still there!  The
-	    ;; unwind-protect stuff around this makes sure that there
-	    ;; exists one before the let, and removes it afterwards.
-	    (let ((case-fold-search ignore-case))
-	      (loop repeat n
-		    while (setq expansion (dabbrev--search abbrev
-							   reverse
-							   ignore-case)))))
-	(or case-fold-search-is-local
-	    (kill-local-variable 'case-fold-search)))
+      (let ((case-fold-search ignore-case)
+	    (count n))
+	(while (and (> count 0)
+		    (setq expansion (dabbrev--search abbrev
+						     reverse
+						     ignore-case)))
+	  (setq count (1- count))))
       (and expansion
 	   (setq dabbrev--last-expansion-location (point)))
       expansion)))
@@ -695,7 +604,7 @@
     all-expansions))

 (defun dabbrev--scanning-message ()
-  (message "Scanning '%s'" (buffer-name (current-buffer))))
+  (message "Scanning `%s'" (buffer-name (current-buffer))))

 ;;; Find one occasion of ABBREV.
 ;;; DIRECTION > 0 means look that many times backwards.
@@ -755,20 +664,19 @@
 	    (not (or (eq dabbrev--check-other-buffers t)
 		     (progn
 		       (setq dabbrev--check-other-buffers
-			     (y-or-n-p "Check in other buffers this time? ")))))
+			     (y-or-n-p "Scan other buffers also? ")))))
 	    (let* (friend-buffer-list non-friend-buffer-list)
 	      (setq dabbrev--friend-buffer-list
 		    (funcall dabbrev-select-buffers-function))
-	      (when dabbrev-check-rest-of-buffers
-		(setq non-friend-buffer-list
-		      (nreverse
-		       (loop for buffer
-			     in (buffer-list)
-			     if (not (memq buffer dabbrev--friend-buffer-list))
-			     collect buffer)))
-		(setq dabbrev--friend-buffer-list
-		      (append dabbrev--friend-buffer-list
-			      non-friend-buffer-list)))))
+	      (if dabbrev-check-rest-of-buffers
+		  (setq non-friend-buffer-list
+			(nreverse
+			 (dabbrev-filter-elements
+			  buffer (buffer-list)
+			  (not (memq buffer dabbrev--friend-buffer-list))))
+			dabbrev--friend-buffer-list
+			(append dabbrev--friend-buffer-list
+				non-friend-buffer-list)))))
 	;; Walk through the buffers
 	(while (and (not expansion) dabbrev--friend-buffer-list)
 	  (setq dabbrev--last-buffer
@@ -781,8 +689,6 @@
 	  (setq expansion (dabbrev--try-find abbrev nil 1 ignore-case)))
 	expansion)))))

-(eval-when-compile (require 'picture))
-
 (defun dabbrev--safe-replace-match (string &optional fixedcase literal)
   (if (eq major-mode 'picture-mode)
       (picture-replace-match string fixedcase literal)
@@ -818,7 +724,7 @@
 ;;;----------------------------------------------------------------
 ;;; Search function used by dabbrevs library.

-;;; ABBREV is string to find as prefix of word. Second arg, REVERSE,
+;;; ABBREV is string to find as prefix of word.  Second arg, REVERSE,
 ;;; is t for reverse search, nil for forward.  Variable dabbrev-limit
 ;;; controls the maximum search region size.  Third argment IGNORE-CASE
 ;;; non-nil means treat case as insignificant while looking for a match
@@ -867,11 +773,10 @@
 		  (buffer-substring (match-beginning 1) (match-end 1)))
 	    (and ignore-case (setq found-string (downcase found-string)))
 	    ;; Throw away if found in table
-	    (when (some
-		  (function
-		   (lambda (table-string) (string= found-string table-string)))
-		  dabbrev--last-table)
-	      (setq found-string nil))))
+	    (if (dabbrev-filter-elements
+		 table-string dabbrev--last-table
+		 (string= found-string table-string))
+		(setq found-string nil))))
 	  (if reverse
 	      (goto-char (match-beginning 0))
 	    (goto-char (match-end 0))))
@@ -887,8 +792,8 @@
 		(downcase result)
 	      result))))))))

-(provide 'new-dabbrev)
 (provide 'dabbrev)
-;; new-dabbrev.el ends here
+
+;; dabbrev.el ends here