Don't require cl, picture, or reporter.

Don't provide new-dabbrev.
(dabbrev--try-find): Don't use `loop'.
Don't create or kill local bindings.
(dabbrev-completion): Use key-description to say what to type.
Fix style of "done" message.
(dabbrev-submit-feedback): Function deleted.
(dabbrev--same-major-mode-p): Simplify.
(dabbrev-completion, dabbrev--abbrev-at-point): Fix error msg style.

(dabbrev-filter-elements): New macro.
(dabbrev--select-buffers, dabbrev--find-expansion): Use that.
(dabbrev--search): Use that.

1 files changed, 130 insertions, 225 deletions

diff --git a/lisp/dabbrev.el b/lisp/dabbrev.el
index fdb9e27c805..f9df40e211b 100644
--- a/lisp/dabbrev.el
+++ b/lisp/dabbrev.el
@@ -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.
-
-This variable only makes sense when the value of
-`dabbrev-case-fold-search' evaluates to t.
+  "*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.
 
-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 @@ The function should take one argument, OTHER-BUFFER, and return
 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 @@ in the current buffer if it is not a member of this list.")
 (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 @@ in the current buffer if it is not a member of this list.")
 
 ;;;###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 @@ before making a new one."
                         (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 @@ before making a new one."
           ;; 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 @@ before making a new one."
      ((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 @@ before making a new one."
       (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 @@ considered.  If still no suitable word is found, then look in the
 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 @@ with the next possible expansion not yet tried.
 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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
                    (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
           (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
       (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
 
 ;;; 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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
                                          (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
     (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))))
-
-;;; Try to find ABBREV in REVERSE direction N times.
+      (dabbrev-filter-elements
+       buffer (buffer-list)
+       (and (not (eq orig-buffer buffer))
+            (boundp 'dabbrev-friend-buffer-function)
+            (funcall dabbrev-friend-buffer-function buffer))))))
+
+;;; 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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
     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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
             (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
           (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
 ;;;----------------------------------------------------------------
 ;;; 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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
                   (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 @@ Also check out `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
                 (downcase result)
               result))))))))
 
-(provide 'new-dabbrev)
 (provide 'dabbrev)
-;; new-dabbrev.el ends here
+
+;; dabbrev.el ends here