mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-11-21 06:55:39 +00:00
Code Issues Releases Activity

Don't require cl, picture, or reporter.

Browse Source 
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.
This commit is contained in:
Richard M. Stallman 1994-12-24 01:30:55 +00:00
parent 6163b3ba74
commit 7313ccdbd0
1 changed files with 129 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

353
lisp/dabbrev.el
View File

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