-;;; dabbrev.el --- dynamic abbreviation package
+;;; dabbrev.el --- dynamic abbreviation package -*- lexical-binding: t -*-
-;; Copyright (C) 1985, 1986, 1992, 1994, 1996, 1997, 2000, 2001, 2002,
-;; 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+;; Copyright (C) 1985-1986, 1992, 1994, 1996-1997, 2000-2012
+;; Free Software Foundation, Inc.
;; Author: Don Morrison
+;; Lars Lindberg
+;; (according to ack.texi)
;; Maintainer: Lars Lindberg <Lars.Lindberg@sypro.cap.se>
;; Created: 16 Mars 1992
;; Lindberg's last update version: 5.7
;; the article for expansion):
;; (set (make-local-variable 'dabbrev-friend-buffer-function)
;; (lambda (buffer)
-;; (save-excursion
-;; (set-buffer buffer)
+;; (with-current-buffer buffer
;; (memq major-mode '(news-reply-mode gnus-article-mode)))))
:group 'convenience)
(defcustom dabbrev-backward-only nil
- "*If non-nil, `dabbrev-expand' only looks backwards."
+ "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."
+ "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.
+ "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 `$'.
:group 'dabbrev)
(defcustom dabbrev-eliminate-newlines t
- "*Non-nil means dabbrev should not insert newlines.
+ "Non-nil means dabbrev should not insert newlines.
Instead it converts them to spaces."
:type 'boolean
:group 'dabbrev)
(defcustom dabbrev-case-fold-search 'case-fold-search
- "*Control whether dabbrev searches should ignore case.
+ "Control whether dabbrev searches should ignore case.
A value of nil means case is significant.
A value of `case-fold-search' means case is significant
if `case-fold-search' is nil.
(const :tag "like search" case-fold-search)
(other :tag "on" t))
:group 'dabbrev)
+;;;###autoload(put 'dabbrev-case-fold-search 'risky-local-variable t)
(defcustom dabbrev-upcase-means-case-search nil
- "*The significance of an uppercase character in an abbreviation.
+ "The significance of an uppercase character in an abbreviation.
A nil value means case fold search when searching for possible expansions;
non-nil means case sensitive search.
:group 'dabbrev)
(defcustom dabbrev-case-distinction 'case-replace
- "*Whether dabbrev treats expansions as the same if they differ in case.
+ "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.
:version "22.1")
(defcustom dabbrev-case-replace 'case-replace
- "*Whether dabbrev applies the abbreviations's case pattern to the expansion.
+ "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.
(const :tag "based on `case-replace'" case-replace)
(other :tag "on" t))
:group 'dabbrev)
+;;;###autoload(put 'dabbrev-case-replace 'risky-local-variable t)
(defcustom dabbrev-abbrev-char-regexp nil
- "*Regexp to recognize a character in an abbreviation or expansion.
+ "Regexp to recognize a character in an abbreviation or expansion.
This regexp will be surrounded with \\\\( ... \\\\) when actually used.
Set this variable to \"\\\\sw\" if you want ordinary words or
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 nil, which will make dabbrev default to
+using \"\\\\sw\\\\|\\\\s_\"."
:type '(choice (const nil)
regexp)
:group 'dabbrev)
(defcustom dabbrev-check-all-buffers t
- "*Non-nil means dabbrev package should search *all* buffers.
+ "Non-nil means dabbrev package should search *all* buffers.
Dabbrev always searches the current buffer first. Then, if
`dabbrev-check-other-buffers' says so, it searches the buffers
:group 'dabbrev)
(defcustom dabbrev-ignored-buffer-names '("*Messages*" "*Buffer List*")
- "*List of buffer names that dabbrev should not check.
+ "List of buffer names that dabbrev should not check.
See also `dabbrev-ignored-buffer-regexps'."
:type '(repeat (string :tag "Buffer name"))
:group 'dabbrev
:version "20.3")
(defcustom dabbrev-ignored-buffer-regexps nil
- "*List of regexps matching names of buffers that dabbrev should not check.
+ "List of regexps matching names of buffers that dabbrev should not check.
See also `dabbrev-ignored-buffer-names'."
:type '(repeat regexp)
:group 'dabbrev
:version "21.1")
(defcustom dabbrev-check-other-buffers t
- "*Should \\[dabbrev-expand] look in other buffers?\
+ "Should \\[dabbrev-expand] look in other buffers?\
nil: Don't look in other buffers.
t: Also look for expansions in the buffers pointed out by
A mode setting this variable should make it buffer local.")
(defcustom dabbrev-friend-buffer-function 'dabbrev--same-major-mode-p
- "*A function to decide whether dabbrev should search OTHER-BUFFER.
+ "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
`dabbrev--same-major-mode-p' for an example.
;; Internal variables
;;----------------------------------------------------------------
-;; Last obarray of completions in `dabbrev-completion'
-(defvar dabbrev--last-obarray nil)
-
;; Table of expansions seen so far
(defvar dabbrev--last-table nil)
;; The buffer we found the expansion last time.
(defvar dabbrev--last-buffer-found nil)
-;; The buffer we last did a completion in.
-(defvar dabbrev--last-completion-buffer nil)
-
;; If non-nil, a function to use when copying successive words.
;; It should be `upcase' or `downcase'.
(defvar dabbrev--last-case-pattern nil)
;; Macros
;;----------------------------------------------------------------
-;;; Get the buffer that mini-buffer was activated from
(defsubst dabbrev--minibuffer-origin ()
- (car (cdr (buffer-list))))
+ "Get the buffer from which mini-buffer."
+ (window-buffer (minibuffer-selected-window)))
;; Make a list of some of the elements of LIST.
;; Check each element of LIST, storing it temporarily in the
;;----------------------------------------------------------------
;;;###autoload (define-key esc-map "/" 'dabbrev-expand)
-;;;??? Do we want this?
+;;??? Do we want this?
;;;###autoload (define-key esc-map [?\C-/] 'dabbrev-completion)
;;;###autoload
Like \\[dabbrev-expand] but finds all expansions in the current buffer
and presents suggestions for completion.
-With a prefix argument, it searches all buffers accepted by the
+With a prefix argument ARG, it searches all buffers accepted by the
function pointed out by `dabbrev-friend-buffer-function' to find the
completions.
-If the prefix argument is 16 (which comes from C-u C-u),
+If the prefix argument is 16 (which comes from \\[universal-argument] \\[universal-argument]),
then it searches *all* buffers."
(interactive "*P")
(dabbrev--reset-global-variables)
(dabbrev-check-all-buffers
(and arg (= (prefix-numeric-value arg) 16)))
(abbrev (dabbrev--abbrev-at-point))
- (ignore-case-p (and (if (eq dabbrev-case-fold-search 'case-fold-search)
- case-fold-search
- dabbrev-case-fold-search)
- (or (not dabbrev-upcase-means-case-search)
- (string= abbrev (downcase abbrev)))))
- (my-obarray dabbrev--last-obarray)
- init)
- (save-excursion
- ;;--------------------------------
- ;; New abbreviation to expand.
- ;;--------------------------------
- (setq dabbrev--last-abbreviation abbrev)
- ;; Find all expansion
- (let ((completion-list
- (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)
- (error "No dynamic expansion for \"%s\" found%s"
- abbrev
- (if dabbrev--check-other-buffers "" " in this-buffer")))
- (cond
- ((or (not ignore-case-p)
- (not dabbrev-case-replace))
- (mapc (function (lambda (string)
- (intern string my-obarray)))
- completion-list))
- ((string= abbrev (upcase abbrev))
- (mapc (function (lambda (string)
- (intern (upcase string) my-obarray)))
- completion-list))
- ((string= (substring abbrev 0 1)
- (upcase (substring abbrev 0 1)))
- (mapc (function (lambda (string)
- (intern (capitalize string) my-obarray)))
- completion-list))
- (t
- (mapc (function (lambda (string)
- (intern (downcase string) my-obarray)))
- completion-list)))
- (setq dabbrev--last-obarray my-obarray)
- (setq dabbrev--last-completion-buffer (current-buffer))
- ;; Find the longest common string.
- (setq init (try-completion abbrev my-obarray))))
- ;;--------------------------------
- ;; Let the user choose between the expansions
- ;;--------------------------------
- (or (stringp init)
- (setq init abbrev))
- (cond
- ;; * Replace string fragment with matched common substring completion.
- ((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"
- (key-description (this-command-keys)))
- (message "The only possible completion"))
- (dabbrev--substitute-expansion nil abbrev init nil))
- (t
- ;; * String is a common substring completion already. Make list.
- (message "Making completion list...")
- (with-output-to-temp-buffer "*Completions*"
- (display-completion-list (all-completions init my-obarray)
- init))
- (message "Making completion list...done")))
- (and (window-minibuffer-p (selected-window))
- (message nil))))
+ (beg (progn (search-backward abbrev) (point)))
+ (end (progn (search-forward abbrev) (point)))
+ (ignore-case-p
+ (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+ case-fold-search
+ dabbrev-case-fold-search)
+ (or (not dabbrev-upcase-means-case-search)
+ (string= abbrev (downcase abbrev)))))
+ (list 'uninitialized)
+ (table
+ (lambda (s p a)
+ (if (eq a 'metadata)
+ `(metadata (cycle-sort-function . ,#'identity)
+ (category . dabbrev))
+ (when (eq list 'uninitialized)
+ (save-excursion
+ ;;--------------------------------
+ ;; New abbreviation to expand.
+ ;;--------------------------------
+ (setq dabbrev--last-abbreviation abbrev)
+ ;; Find all expansion
+ (let ((completion-list
+ (dabbrev--find-all-expansions abbrev ignore-case-p))
+ (completion-ignore-case ignore-case-p))
+ (or (consp completion-list)
+ (error "No dynamic expansion for \"%s\" found%s"
+ abbrev
+ (if dabbrev--check-other-buffers
+ "" " in this-buffer")))
+ (setq list
+ (cond
+ ((not (and ignore-case-p dabbrev-case-replace))
+ completion-list)
+ ((string= abbrev (upcase abbrev))
+ (mapcar #'upcase completion-list))
+ ((string= (substring abbrev 0 1)
+ (upcase (substring abbrev 0 1)))
+ (mapcar #'capitalize completion-list))
+ (t
+ (mapcar #'downcase completion-list)))))))
+ (complete-with-action a list s p)))))
+ (completion-in-region beg end table)))
;;;###autoload
(defun dabbrev-expand (arg)
;;--------------------------------
(or expansion
(setq expansion
- (dabbrev--find-expansion abbrev direction
- (and (if (eq dabbrev-case-fold-search 'case-fold-search)
- case-fold-search
- dabbrev-case-fold-search)
- (or (not dabbrev-upcase-means-case-search)
- (string= abbrev (downcase abbrev))))))))
+ (dabbrev--find-expansion
+ abbrev direction
+ (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+ case-fold-search
+ dabbrev-case-fold-search)
+ (or (not dabbrev-upcase-means-case-search)
+ (string= abbrev (downcase abbrev))))))))
(cond
((not expansion)
(dabbrev--reset-global-variables)
;; Local functions
;;----------------------------------------------------------------
-;;; Checks if OTHER-BUFFER has the same major mode as current buffer.
(defun dabbrev--same-major-mode-p (other-buffer)
+ "Check if OTHER-BUFFER has the same major mode as current buffer."
(eq major-mode
- (save-excursion
- (set-buffer other-buffer)
+ (with-current-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 ()
+ "Back over all abbrev type characters and then moves forward over
+all skip characters."
;; Move backwards over abbrev chars
(save-match-data
(when (> (point) (minibuffer-prompt-end))
(while (looking-at dabbrev-abbrev-skip-leading-regexp)
(forward-char 1)))))
-;;; Extract the symbol at point to serve as abbreviation.
(defun dabbrev--abbrev-at-point ()
+ "Extract the symbol at point to serve as abbreviation."
;; Check for error
(if (bobp)
(error "No possible abbreviation preceding point"))
(save-match-data
(if (save-excursion
(forward-char -1)
- (not (looking-at (concat "\\("
- (or dabbrev-abbrev-char-regexp
- "\\sw\\|\\s_")
- "\\)+"))))
+ (not (looking-at (or dabbrev-abbrev-char-regexp
+ "\\sw\\|\\s_"))))
(if (re-search-backward (or dabbrev-abbrev-char-regexp
"\\sw\\|\\s_")
nil t)
(buffer-substring-no-properties
dabbrev--last-abbrev-location (point))))
-;;; Initializes all global variables
(defun dabbrev--reset-global-variables ()
- ;; dabbrev--last-obarray and dabbrev--last-completion-buffer
- ;; must not be reset here.
+ "Initialize all global variables."
(setq dabbrev--last-table nil
dabbrev--last-abbreviation nil
dabbrev--last-abbrev-location nil
(let ((case-fold-search ignore-case)
(count n))
(while (and (> count 0)
- (setq expansion (dabbrev--search abbrev
- reverse
- (and ignore-case
- (if (eq dabbrev-case-distinction 'case-replace)
- case-replace
- dabbrev-case-distinction))
- )))
+ (setq expansion (dabbrev--search
+ abbrev reverse
+ (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)))
(- (length dabbrev--friend-buffer-list)))
(setq dabbrev--last-expansion-location (point-min))
(setq expansion (dabbrev--try-find abbrev nil 1 ignore-case)))
+ (progress-reporter-done dabbrev--progress-reporter)
expansion)))))
;; Compute the list of buffers to scan.
RECORD-CASE-PATTERN, if non-nil, means set `dabbrev--last-case-pattern'
to record whether we upcased the expansion, downcased it, or did neither."
;;(undo-boundary)
- (let ((use-case-replace (and (if (eq dabbrev-case-fold-search 'case-fold-search)
- case-fold-search
- dabbrev-case-fold-search)
- (or (not dabbrev-upcase-means-case-search)
- (string= abbrev (downcase abbrev)))
- (if (eq dabbrev-case-replace 'case-replace)
- case-replace
- dabbrev-case-replace))))
+ (let ((use-case-replace
+ (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+ case-fold-search
+ dabbrev-case-fold-search)
+ (or (not dabbrev-upcase-means-case-search)
+ (string= abbrev (downcase abbrev)))
+ (if (eq dabbrev-case-replace 'case-replace)
+ case-replace
+ dabbrev-case-replace))))
;; If we upcased or downcased the original expansion,
;; do likewise for the subsequent words when we copy them.
(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)))))
+ (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)))
;; Limited search.
(save-restriction
(and dabbrev-limit
- (narrow-to-region dabbrev--last-expansion-location
- (+ (point)
- (if reverse (- dabbrev-limit) dabbrev-limit))))
+ (narrow-to-region
+ dabbrev--last-expansion-location
+ (+ (point) (if reverse (- dabbrev-limit) dabbrev-limit))))
;;--------------------------------
;; Look for a distinct expansion, using dabbrev--last-table.
;;--------------------------------
(provide 'dabbrev)
-;; arch-tag: 29e58596-f080-4306-a409-70296cf9d46f
;;; dabbrev.el ends here