-;;; 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>
;; 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
;; (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
;; - 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>
;; ... and to all the people who have participated in the beta tests.
;;; Code:
-(require 'cl)
;;;----------------------------------------------------------------
;;;----------------------------------------------------------------
;;;----------------------------------------------------------------
;;;----------------------------------------------------------------
(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.")
(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.
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.")
;;;----------------------------------------------------------------
;;;----------------------------------------------------------------
(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
;;;###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))
(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.
;;--------------------------------
;; 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
((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
(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))))
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
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
(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)
(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))
(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
;;; 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
(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))
(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)))
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.
(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
(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)
;;;----------------------------------------------------------------
;;; 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
(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))))
(downcase result)
result))))))))
-(provide 'new-dabbrev)
(provide 'dabbrev)
-;; new-dabbrev.el ends here
+
+;; dabbrev.el ends here
projects / emacs.git / commitdiff