;;; dabbrev.el --- dynamic abbreviation package
+
;; Copyright (C) 1985, 1986, 1992, 1994 Free Software Foundation, Inc.
;; Author: Don Morrison
;; Lindberg's last update version: 5.7
;; Keywords: abbrev expand completion
-;; This program is free software; you can redistribute it and/or modify
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2 of the License, or
-;; (at your option) any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
-;;
+
;; You should have received a copy of the GNU General Public License
-;; along with this program; if not, write to the Free Software
-;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
;;; Code:
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-;;; Customization variables
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-(defvar dabbrev-backward-only nil
- "*If non-nil, `dabbrev-expand' only looks backwards.")
+;;----------------------------------------------------------------
+;; Customization variables
+;;----------------------------------------------------------------
+
+(defgroup dabbrev nil
+ "Dynamic Abbreviations"
+ :tag "Dynamic Abbreviations"
+ :group 'abbrev)
-(defvar dabbrev-limit nil
- "*Limits region searched by `dabbrev-expand' to this many chars away.")
+(defcustom dabbrev-backward-only nil
+ "*If non-nil, `dabbrev-expand' only looks backwards."
+ :type 'boolean
+ :group 'dabbrev)
-(defvar dabbrev-abbrev-skip-leading-regexp nil
+(defcustom dabbrev-limit nil
+ "*Limits region searched by `dabbrev-expand' to this many chars away."
+ :type '(choice (const :tag "off" nil)
+ integer)
+ :group 'dabbrev)
+
+(defcustom dabbrev-abbrev-skip-leading-regexp nil
"*Regexp for skipping leading characters of an abbreviation.
Example: Set this to \"\\\\$\" for programming languages
in which variable names may appear with or without a leading `$'.
-(For example, in Makefiles.)
+\(For example, in Makefiles.
+ :type 'regexp
+ :group 'dabbrev))
-Set this to nil if no characters should be skipped.")
+Set this to nil if no characters should be skipped."
+ :type '(choice regexp
+ (const :tag "off" nil))
+ :group 'dabbrev)
;; I recommend that you set this to nil.
-(defvar dabbrev-case-fold-search 'case-fold-search
+(defcustom dabbrev-case-fold-search 'case-fold-search
"*Non-nil if dabbrev searches should ignore case.
A value of nil means case is significant.
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.")
+variable to see whether its value is nil."
+ :type 'sexp
+ :group 'dabbrev)
-(defvar dabbrev-upcase-means-case-search nil
+(defcustom 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 has an effect only when the value of
-`dabbrev-case-fold-search' evaluates to t.")
+`dabbrev-case-fold-search' evaluates to t."
+ :type 'boolean
+ :group 'dabbrev)
;; I recommend that you set this to nil.
-(defvar dabbrev-case-replace 'case-replace
+(defcustom dabbrev-case-replace 'case-replace
"*Non-nil means dabbrev should preserve case when expanding the abbreviation.
More precisely, it preserves the case pattern of the abbreviation as you
typed it--as opposed to the case pattern of the expansion that is copied.
variable to see if its value is t or nil.
This variable has an effect only when the value of
-`dabbrev-case-fold-search' evaluates to t.")
+`dabbrev-case-fold-search' evaluates to t."
+ :type 'sexp
+ :group 'dabbrev)
-(defvar dabbrev-abbrev-char-regexp nil
+(defcustom dabbrev-abbrev-char-regexp nil
"*Regexp to recognize a character in an abbreviation or expansion.
This regexp will be surrounded with \\\\( ... \\\\) when actually used.
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_\".")
+The recommended value is \"\\\\sw\\\\|\\\\s_\"."
+ :type '(choice (const nil)
+ regexp)
+ :group 'dabbrev)
-(defvar dabbrev-check-all-buffers t
+(defcustom dabbrev-check-all-buffers t
"*Non-nil means dabbrev package should search *all* buffers.
Dabbrev always searches the current buffer first. Then, if
designated by `dabbrev-select-buffers-function'.
Then, if `dabbrev-check-all-buffers' is non-nil, dabbrev searches
-all the other buffers.")
+all the other buffers."
+ :type 'boolean
+ :group 'dabbrev)
-(defvar dabbrev-check-other-buffers t
+(defcustom dabbrev-check-other-buffers t
"*Should \\[dabbrev-expand] look in other buffers?\
nil: Don't look in other buffers.
the current buffer, then ask the user whether to look in other
buffers too.
-The default value is t.")
+The default value is t."
+ :type '(choice (const :tag "off" nil)
+ (const :tag "on" t)
+ (const :tag "ask" other))
+ :group 'dabbrev)
;; I guess setting this to a function that selects all C- or C++-
;; mode buffers would be a good choice for a debugging buffer,
A mode setting this variable should make it buffer local.")
-(defvar dabbrev-friend-buffer-function 'dabbrev--same-major-mode-p
+(defcustom dabbrev-friend-buffer-function 'dabbrev--same-major-mode-p
"*A function to decide whether dabbrev should search OTHER-BUFFER.
The function should take one argument, OTHER-BUFFER, and return
non-nil if that buffer should be searched. Have a look at
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.")
+A mode setting this variable should make it buffer local."
+ :type 'function
+ :group 'dabbrev)
-(defvar dabbrev-search-these-buffers-only nil
+(defcustom dabbrev-search-these-buffers-only nil
"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.")
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-;;; Internal variables
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
+;;----------------------------------------------------------------
+;; Internal variables
+;;----------------------------------------------------------------
;; Last obarray of completions in `dabbrev-completion'
(defvar dabbrev--last-obarray nil)
;; The buffer we last did a completion in.
(defvar dabbrev--last-completion-buffer nil)
+;; Non-nil means we should upcase
+;; when copying successive words.
+(defvar dabbrev--last-case-pattern nil)
+
;; Same as dabbrev-check-other-buffers, but is set for every expand.
(defvar dabbrev--check-other-buffers dabbrev-check-other-buffers)
;; The regexp for recognizing a character in an abbreviation.
(defvar dabbrev--abbrev-char-regexp nil)
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-;;; Macros
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
+;;----------------------------------------------------------------
+;; Macros
+;;----------------------------------------------------------------
;;; Get the buffer that mini-buffer was activated from
(defsubst dabbrev--minibuffer-origin ()
(setq dabbrev-tail (cdr dabbrev-tail)))
(nreverse dabbrev-result))))
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-;;; Exported functions
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
+;;----------------------------------------------------------------
+;; Exported functions
+;;----------------------------------------------------------------
;;;###autoload
(define-key esc-map "/" 'dabbrev-expand)
(and arg (= (prefix-numeric-value arg) 16)))
(abbrev (dabbrev--abbrev-at-point))
(ignore-case-p (and (eval dabbrev-case-fold-search)
- (or (not dabbrev-upcase-means-case-search)
- (string= abbrev (downcase abbrev)))))
+ (or (not dabbrev-upcase-means-case-search)
+ (string= abbrev (downcase abbrev)))))
(my-obarray dabbrev--last-obarray)
init)
(save-excursion
(setq dabbrev--last-abbreviation abbrev)
;; Find all expansion
(let ((completion-list
- (dabbrev--find-all-expansions abbrev ignore-case-p)))
+ (dabbrev--find-all-expansions abbrev ignore-case-p))
+ (completion-ignore-case ignore-case-p))
;; Make an obarray with all expansions
(setq my-obarray (make-vector (length completion-list) 0))
(or (> (length my-obarray) 0)
See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
(interactive "*P")
- (let (abbrev expansion old direction (orig-point (point)))
+ (let (abbrev record-case-pattern
+ expansion old direction (orig-point (point)))
;; abbrev -- the abbrev to expand
;; expansion -- the expansion found (eventually) or nil until then
;; old -- the text currently in the buffer
(setq expansion
(buffer-substring dabbrev--last-expansion-location
(point)))
+ (if dabbrev--last-case-pattern
+ (setq expansion (upcase expansion)))
;; Record the end of this expansion, in case we repeat this.
(setq dabbrev--last-expansion-location (point)))
(if dabbrev-backward-only 1 0)
(prefix-numeric-value arg)))
(setq abbrev (dabbrev--abbrev-at-point))
+ (setq record-case-pattern t)
(setq old nil)))
;;--------------------------------
;; Success: stick it in and return.
(setq buffer-undo-list (cons orig-point buffer-undo-list))
(dabbrev--substitute-expansion old abbrev expansion)
+
+ ;; If we are not copying successive words now,
+ ;; set dabbrev--last-case-pattern.
+ (and record-case-pattern
+ (setq dabbrev--last-case-pattern
+ (and (eval dabbrev-case-fold-search)
+ (not dabbrev-upcase-means-case-search)
+ (equal abbrev (upcase abbrev)))))
+
;; Save state for re-expand.
(setq dabbrev--last-expansion expansion)
(setq dabbrev--last-abbreviation abbrev)
(setq dabbrev--last-abbrev-location (point-marker))))))
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-;;; Local functions
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
+;;----------------------------------------------------------------
+;; Local functions
+;;----------------------------------------------------------------
;;; Checks if OTHER-BUFFER has the same major mode as current buffer.
(defun dabbrev--same-major-mode-p (other-buffer)
(and nil use-case-replace
(setq old (concat abbrev (or old "")))
(setq expansion (concat abbrev expansion)))
+ ;; If the expansion has mixed case
+ ;; and it is not simply a capitalized word,
+ ;; or if the abbrev has mixed case,
+ ;; and if the given abbrev's case pattern
+ ;; matches the start of the expansion,
+ ;; copy the expansion's case
+ ;; instead of downcasing all the rest.
+ (let ((expansion-rest (substring expansion 1)))
+ (if (and (not (and (or (string= expansion-rest (downcase expansion-rest))
+ (string= expansion-rest (upcase expansion-rest)))
+ (or (string= abbrev (downcase abbrev))
+ (string= abbrev (upcase abbrev)))))
+ (string= abbrev
+ (substring expansion 0 (length abbrev))))
+ (setq use-case-replace nil)))
+ (if (equal abbrev " ")
+ (setq use-case-replace nil))
+ (if use-case-replace
+ (setq expansion (downcase expansion)))
(if old
(save-excursion
(search-backward old))
(setq dabbrev--last-table
(cons found-string dabbrev--last-table))
(if (and ignore-case (eval dabbrev-case-replace))
- (downcase result)
+ result
result)))))))
(provide 'dabbrev)
-;; dabbrev.el ends here
-
-
+;;; dabbrev.el ends here