;;----------------------------------------------------------------
;; Customization variables
;;----------------------------------------------------------------
-(defvar dabbrev-backward-only nil
- "*If non-nil, `dabbrev-expand' only looks backwards.")
-(defvar dabbrev-limit nil
- "*Limits region searched by `dabbrev-expand' to this many chars away.")
+(defgroup dabbrev nil
+ "Dynamic Abbreviations"
+ :tag "Dynamic Abbreviations"
+ :group 'abbrev)
-(defvar dabbrev-abbrev-skip-leading-regexp nil
+(defcustom dabbrev-backward-only nil
+ "*If non-nil, `dabbrev-expand' only looks backwards."
+ :type 'boolean
+ :group 'dabbrev)
+
+(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
;; 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)
(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
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)
(and nil use-case-replace
(setq old (concat abbrev (or old "")))
(setq expansion (concat abbrev expansion)))
- ;; If the given abbrev is mixed case and its case pattern
+ ;; 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.
- (if (and (string= abbrev
- (substring expansion 0 (length abbrev)))
- (not (string= abbrev (downcase abbrev)))
- (not (string= abbrev (upcase abbrev))))
- (setq use-case-replace nil)
- (if use-case-replace
- (setq expansion (downcase expansion))))
+ (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))