;;; dabbrev.el --- dynamic abbreviation package
-;; Copyright (C) 1985, 86, 92, 94, 96, 1997, 2000, 2001
+;; Copyright (C) 1985, 86, 92, 94, 96, 1997, 2000, 01, 03, 2004
;; Free Software Foundation, Inc.
;; Author: Don Morrison
(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.
+nil means case fold search when searching for possible expansions;
+non-nil means case sensitive search.
This variable has an effect only when the value of
`dabbrev-case-fold-search' says to ignore case."
:type 'boolean
:group 'dabbrev)
+(defcustom dabbrev-case-distinction 'case-replace
+ "*Whether dabbrev treats expansions as the same if they differ in case.
+
+A value of nil means treat them as different.
+A value of `case-replace' means distinguish them if `case-replace' is nil.
+Any other non-nil value means to treat them as the same.
+
+This variable has an effect only when the value of
+`dabbrev-case-fold-search' specifies to ignore case."
+ :type '(choice (const :tag "off" nil)
+ (const :tag "based on `case-replace'" case-replace)
+ (other :tag "on" t))
+ :group 'dabbrev
+ :version "22.1")
+
(defcustom dabbrev-case-replace 'case-replace
- "*Controls whether dabbrev preserves case when expanding the abbreviation.
-A value of nil means preserve case.
-A value of `case-replace' means preserve case if `case-replace' is nil.
-Any other non-nil version means do not preserve case.
+ "*Whether dabbrev applies the abbreviations's case pattern to the expansion.
+
+A value of nil means preserve the expansion's case pattern.
+A value of `case-replace' means preserve it if `case-replace' is nil.
+Any other non-nil value means modify the expansion
+by applying the abbreviation's case pattern to it.
This variable has an effect only when the value of
`dabbrev-case-fold-search' specifies to ignore case."
:type '(choice (const :tag "off" nil)
- (const :tag "like M-x query-replace" case-replace)
+ (const :tag "based on `case-replace'" case-replace)
(other :tag "on" t))
:group 'dabbrev)
"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.")
+this list."
+ :group 'dabbrev)
;;----------------------------------------------------------------
;; Internal variables
;; Exported functions
;;----------------------------------------------------------------
-;;;###autoload
-(define-key esc-map "/" 'dabbrev-expand)
+;;;###autoload (define-key esc-map "/" 'dabbrev-expand)
;;;??? Do we want this?
-;;;###autoload
-(define-key esc-map [?\C-/] 'dabbrev-completion)
+;;;###autoload (define-key esc-map [?\C-/] 'dabbrev-completion)
;;;###autoload
(defun dabbrev-completion (&optional arg)
(t
;; * String is a common substring completion already. Make list.
(message "Making completion list...")
- (with-output-to-temp-buffer " *Completions*"
+ (with-output-to-temp-buffer "*Completions*"
(display-completion-list (all-completions init my-obarray)))
(message "Making completion list...done")))
(and (window-minibuffer-p (selected-window))
;; The "abbrev" to expand is just the space.
(setq abbrev " ")
(save-excursion
- (if dabbrev--last-buffer
- (set-buffer dabbrev--last-buffer))
- ;; Find the end of the last "expansion" word.
- (if (or (eq dabbrev--last-direction 1)
- (and (eq dabbrev--last-direction 0)
- (< dabbrev--last-expansion-location (point))))
- (setq dabbrev--last-expansion-location
- (+ dabbrev--last-expansion-location
- (length dabbrev--last-expansion))))
- (goto-char dabbrev--last-expansion-location)
- ;; Take the following word, with intermediate separators,
- ;; as our expansion this time.
- (re-search-forward
- (concat "\\(\\(" dabbrev--abbrev-char-regexp "\\)+\\)"))
- (setq expansion (buffer-substring-no-properties
- dabbrev--last-expansion-location (point)))
-
- ;; Record the end of this expansion, in case we repeat this.
- (setq dabbrev--last-expansion-location (point)))
+ (save-restriction
+ (widen)
+ (if dabbrev--last-buffer
+ (set-buffer dabbrev--last-buffer))
+ ;; Find the end of the last "expansion" word.
+ (if (or (eq dabbrev--last-direction 1)
+ (and (eq dabbrev--last-direction 0)
+ (< dabbrev--last-expansion-location (point))))
+ (setq dabbrev--last-expansion-location
+ (+ dabbrev--last-expansion-location
+ (length dabbrev--last-expansion))))
+ (goto-char dabbrev--last-expansion-location)
+ ;; Take the following word, with intermediate separators,
+ ;; as our expansion this time.
+ (re-search-forward
+ (concat "\\(?:" dabbrev--abbrev-char-regexp "\\)+"))
+ (setq expansion (buffer-substring-no-properties
+ dabbrev--last-expansion-location (point)))
+
+ ;; Record the end of this expansion, in case we repeat this.
+ (setq dabbrev--last-expansion-location (point))))
;; Indicate that dabbrev--last-expansion-location is
;; at the end of the expansion.
(setq dabbrev--last-direction -1))
(defun dabbrev--goto-start-of-abbrev ()
;; Move backwards over abbrev chars
(save-match-data
- (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))))
+ (when (> (point) (minibuffer-prompt-end))
+ (forward-char -1)
+ (while (and (looking-at dabbrev--abbrev-char-regexp)
+ (> (point) (minibuffer-prompt-end))
+ (not (= (point) (field-beginning (point) nil
+ (1- (point))))))
+ (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)))))
(while (and (> count 0)
(setq expansion (dabbrev--search abbrev
reverse
- ignore-case)))
+ (and ignore-case
+ (if (eq dabbrev-case-distinction 'case-replace)
+ case-replace
+ dabbrev-case-distinction))
+ )))
(setq count (1- count))))
(and expansion
(setq dabbrev--last-expansion-location (point)))
IGNORE-CASE non-nil means ignore case when searching.
This sets `dabbrev--last-direction' to 1 or -1 according
to the direction in which the occurrence was actually found.
-It sets `dabbrev--last-expansion-location' to the location
+It sets `dabbrev--last-expansion-location' to the location
of the start of the occurrence."
(save-excursion
;; If we were scanning something other than the current buffer,
;; Walk through the buffers till we find a match.
(let (expansion)
(while (and (not expansion) dabbrev--friend-buffer-list)
- (setq dabbrev--last-buffer
- (car dabbrev--friend-buffer-list))
- (setq dabbrev--friend-buffer-list
- (cdr dabbrev--friend-buffer-list))
+ (setq dabbrev--last-buffer (pop dabbrev--friend-buffer-list))
(set-buffer dabbrev--last-buffer)
(dabbrev--scanning-message)
(setq dabbrev--last-expansion-location (point-min))
(defun dabbrev--safe-replace-match (string &optional fixedcase literal)
(if (eq major-mode 'picture-mode)
- (picture-replace-match string fixedcase literal)
+ (with-no-warnings
+ (picture-replace-match string fixedcase literal))
(replace-match string fixedcase literal)))
;;;----------------------------------------------------------------
;; matches the start of the expansion,
;; copy the expansion's case
;; instead of downcasing all the rest.
- ;; Treat a one-capital-letter abbrev as "not all upper case",
- ;; so as to force preservation of the expansion's pattern
- ;; if the expansion starts with a capital letter.
- (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))
- (and (string= abbrev (upcase abbrev))
- (> (length abbrev) 1)))))
- (string= abbrev
- (substring expansion 0 (length abbrev))))
+ ;;
+ ;; Treat a one-capital-letter (possibly with preceding non-letter
+ ;; characters) abbrev as "not all upper case", so as to force
+ ;; preservation of the expansion's pattern if the expansion starts
+ ;; with a capital letter.
+ (let ((expansion-rest (substring expansion 1))
+ (first-letter-position (string-match "[[:alpha:]]" abbrev)))
+ (if (or (null first-letter-position)
+ (and (not (and (or (string= expansion-rest (downcase expansion-rest))
+ (string= expansion-rest (upcase expansion-rest)))
+ (or (string= abbrev (downcase abbrev))
+ (and (string= abbrev (upcase abbrev))
+ (> (- (length abbrev) first-letter-position)
+ 1)))))
+ (string= abbrev
+ (substring expansion 0 (length abbrev)))))
(setq use-case-replace nil)))
;; If the abbrev and the expansion are both all-lower-case
;; then don't do any conversion. The conversion would be a no-op
;; for this replacement, but it would carry forward to subsequent words.
- ;; The goal of this is to preven that carrying forward.
+ ;; The goal of this is to prevent that carrying forward.
(if (and (string= expansion (downcase expansion))
(string= abbrev (downcase abbrev)))
(setq use-case-replace nil))
;; record if we upcased or downcased the first word,
;; in order to do likewise for subsequent words.
(and record-case-pattern
- (setq dabbrev--last-case-pattern
+ (setq dabbrev--last-case-pattern
(and use-case-replace
(cond ((equal abbrev (upcase abbrev)) 'upcase)
((equal abbrev (downcase abbrev)) 'downcase)))))
- ;; Convert newlines to spaces.
+ ;; Convert whitespace to single spaces.
(if dabbrev--eliminate-newlines
- (while (string-match "\n" expansion)
- (setq expansion (replace-match " " nil nil expansion))))
+ ;; Start searching at end of ABBREV so that any whitespace
+ ;; carried over from the existing text is not changed.
+ (let ((pos (length abbrev)))
+ (while (string-match "[\n \t]+" expansion pos)
+ (setq pos (1+ (match-beginning 0)))
+ (setq expansion (replace-match " " nil nil expansion)))))
(if old
(save-excursion
"\\(" dabbrev--abbrev-char-regexp "\\)"))
(pattern2 (concat (regexp-quote abbrev)
"\\(\\(" dabbrev--abbrev-char-regexp "\\)+\\)"))
- (found-string nil))
+ ;; This makes it possible to find matches in minibuffer prompts
+ ;; even when they are "inviolable".
+ (inhibit-point-motion-hooks t)
+ found-string result)
;; Limited search.
(save-restriction
(and dabbrev-limit
nil
;; We have a truly valid match. Find the end.
(re-search-forward pattern2)
- (setq found-string (buffer-substring-no-properties
- (match-beginning 1) (match-end 1)))
+ (setq found-string (match-string-no-properties 0))
+ (setq result found-string)
(and ignore-case (setq found-string (downcase found-string)))
;; Ignore this match if it's already in the table.
(if (dabbrev-filter-elements
(string= found-string table-string))
(setq found-string nil)))
;; Prepare to continue searching.
- (if reverse
- (goto-char (match-beginning 0))
- (goto-char (match-end 0))))
+ (goto-char (if reverse (match-beginning 0) (match-end 0))))
;; If we found something, use it.
- (if found-string
- ;; Put it into `dabbrev--last-table'
- ;; and return it (either downcased, or as is).
- (let ((result (buffer-substring-no-properties
- (match-beginning 0) (match-end 0))))
- (setq dabbrev--last-table
- (cons found-string dabbrev--last-table))
- (if (and ignore-case (eval dabbrev-case-replace))
- result
- result)))))))
+ (when found-string
+ ;; Put it into `dabbrev--last-table'
+ ;; and return it (either downcased, or as is).
+ (setq dabbrev--last-table
+ (cons found-string dabbrev--last-table))
+ result)))))
(dolist (mess '("^No dynamic expansion for .* found$"
"^No further dynamic expansion for .* found$"
(provide 'dabbrev)
+;;; arch-tag: 29e58596-f080-4306-a409-70296cf9d46f
;;; dabbrev.el ends here