(defgroup dabbrev nil
"Dynamic Abbreviations"
:tag "Dynamic Abbreviations"
:group 'abbrev
:group 'convenience)
(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.\)
Set this to nil if no characters should be skipped."
:type '(choice regexp
(const :tag "off" nil))
:group 'dabbrev)
(defcustom dabbrev-case-fold-search 'case-fold-search
"*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.
Any other non-nil version means case is not significant."
:type '(choice (const :tag "off" nil)
(const :tag "like search" case-fold-search)
(other :tag "on" t))
:group 'dabbrev)
(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' says to ignore case."
:type 'boolean
:group 'dabbrev)
(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.
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)
(other :tag "on" t))
:group 'dabbrev)
(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.
Set this variable to \"\\\\sw\" if you want ordinary words or
\"\\\\sw\\\\|\\\\s_\" if you want symbols (including characters whose
syntax is \"symbol\" as well as those whose syntax is \"word\".
The value nil has a special meaning: the abbreviation is from point to
previous word-start, but 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 this
variable is 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_\"."
:type '(choice (const nil)
regexp)
:group 'dabbrev)
(defcustom dabbrev-check-all-buffers t
"*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
designated by `dabbrev-select-buffers-function'.
Then, if `dabbrev-check-all-buffers' is non-nil, dabbrev searches
all the other buffers, except those named in `dabbrev-ignored-buffer-names'."
:type 'boolean
:group 'dabbrev)
(defcustom dabbrev-ignored-buffer-names '("*Messages*" "*Buffer List*")
"*List of buffer names that dabbrev should not check."
:type '(repeat (string :tag "Buffer name"))
:group 'dabbrev
:version "20.3")
(defcustom dabbrev-check-other-buffers t
"*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
`dabbrev-select-buffers-function'.
Anything else: When we can't find any more expansions in
the current buffer, then ask the user whether to look in other
buffers too.
The default value is t."
:type '(choice (const :tag "off" nil)
(const :tag "on" t)
(other :tag "ask" other))
:group 'dabbrev)
(defvar dabbrev-select-buffers-function 'dabbrev--select-buffers
"A function that selects buffers that should be searched by dabbrev.
The function should take no arguments and return a list of buffers to
search for expansions. Have a look at `dabbrev--select-buffers' for
an example.
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.
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.
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."
:type 'function
:group 'dabbrev)
(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.")
(defvar dabbrev--last-obarray nil)
(defvar dabbrev--last-table nil)
(defvar dabbrev--last-abbreviation nil)
(defvar dabbrev--last-abbrev-location nil)
(defvar dabbrev--last-direction 0)
(defvar dabbrev--last-expansion nil)
(defvar dabbrev--last-expansion-location nil)
(defvar dabbrev--friend-buffer-list nil)
(defvar dabbrev--last-buffer nil)
(defvar dabbrev--last-buffer-found nil)
(defvar dabbrev--last-completion-buffer nil)
(defvar dabbrev--last-case-pattern nil)
(defvar dabbrev--check-other-buffers dabbrev-check-other-buffers)
(defvar dabbrev--abbrev-char-regexp nil)
(defsubst dabbrev--minibuffer-origin ()
(car (cdr (buffer-list))))
(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))))
(define-key esc-map "/" 'dabbrev-expand)
(define-key esc-map [?\C-/] 'dabbrev-completion)
(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.
With a prefix argument, 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),
then it searches *all* buffers.
With no prefix argument, it reuses an old completion list
if there is a suitable one already."
(interactive "*P")
(dabbrev--reset-global-variables)
(let* ((dabbrev-check-other-buffers (and arg t))
(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
(if (and (null arg)
my-obarray
(or (eq dabbrev--last-completion-buffer (current-buffer))
(and (window-minibuffer-p (selected-window))
(eq dabbrev--last-completion-buffer
(dabbrev--minibuffer-origin))))
dabbrev--last-abbreviation
(>= (length abbrev) (length dabbrev--last-abbreviation))
(string= dabbrev--last-abbreviation
(substring abbrev 0
(length dabbrev--last-abbreviation)))
(setq init (try-completion abbrev my-obarray)))
nil
(setq dabbrev--last-abbreviation abbrev)
(let ((completion-list
(dabbrev--find-all-expansions abbrev ignore-case-p))
(completion-ignore-case ignore-case-p))
(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))
(mapcar (function (lambda (string)
(intern string my-obarray)))
completion-list))
((string= abbrev (upcase abbrev))
(mapcar (function (lambda (string)
(intern (upcase string) my-obarray)))
completion-list))
((string= (substring abbrev 0 1)
(upcase (substring abbrev 0 1)))
(mapcar (function (lambda (string)
(intern (capitalize string) my-obarray)))
completion-list))
(t
(mapcar (function (lambda (string)
(intern (downcase string) my-obarray)))
completion-list)))
(setq dabbrev--last-obarray my-obarray)
(setq dabbrev--last-completion-buffer (current-buffer))
(setq init (try-completion abbrev my-obarray)))))
(or (stringp init)
(setq init abbrev))
(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"
(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")))
(and (window-minibuffer-p (selected-window))
(message nil))))
(defun dabbrev-expand (arg)
"Expand previous word \"dynamically\".
Expands to the most recent, preceding word for which this is a prefix.
If no suitable preceding word is found, words following point are
considered. If still no suitable word is found, then look in the
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*
possibility. A negative argument says search forward.
If the cursor has not moved from the end of the previous expansion and
no argument is given, replace the previously-made expansion
with the next possible expansion not yet tried.
The variable `dabbrev-backward-only' may be used to limit the
direction of search to backward if set non-nil.
See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
(interactive "*P")
(let (abbrev record-case-pattern
expansion old direction (orig-point (point)))
(save-excursion
(if (and (null arg)
(markerp dabbrev--last-abbrev-location)
(marker-position dabbrev--last-abbrev-location)
(or (eq last-command this-command)
(and (window-minibuffer-p (selected-window))
(= dabbrev--last-abbrev-location
(point)))))
(progn
(setq abbrev dabbrev--last-abbreviation)
(setq old dabbrev--last-expansion)
(setq direction dabbrev--last-direction))
(if (and (eq (preceding-char) ?\ )
(markerp dabbrev--last-abbrev-location)
(marker-position dabbrev--last-abbrev-location)
(= (point) (1+ dabbrev--last-abbrev-location)))
(progn
(setq abbrev " ")
(save-excursion
(if dabbrev--last-buffer
(set-buffer dabbrev--last-buffer))
(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)
(re-search-forward
(concat "\\(\\(" dabbrev--abbrev-char-regexp "\\)+\\)"))
(setq expansion (buffer-substring-no-properties
dabbrev--last-expansion-location (point)))
(if dabbrev--last-case-pattern
(setq expansion (upcase expansion)))
(setq dabbrev--last-expansion-location (point)))
(setq dabbrev--last-direction -1))
(dabbrev--reset-global-variables)
(setq direction (if (null arg)
(if dabbrev-backward-only 1 0)
(prefix-numeric-value arg)))
(setq abbrev (dabbrev--abbrev-at-point))
(setq record-case-pattern t)
(setq old nil)))
(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))))))))
(cond
((not expansion)
(dabbrev--reset-global-variables)
(if old
(save-excursion
(setq buffer-undo-list (cons orig-point buffer-undo-list))
(search-backward old)
(insert abbrev)
(delete-region (point) (+ (point) (length old)))))
(error "No%s dynamic expansion for `%s' found"
(if old " further" "") abbrev))
(t
(if (not (or (eq dabbrev--last-buffer dabbrev--last-buffer-found)
(minibuffer-window-active-p (selected-window))))
(progn
(message "Expansion found in '%s'"
(buffer-name dabbrev--last-buffer))
(setq dabbrev--last-buffer-found dabbrev--last-buffer))
(message nil))
(if (and (or (eq (current-buffer) dabbrev--last-buffer)
(null dabbrev--last-buffer))
(numberp dabbrev--last-expansion-location)
(and (> dabbrev--last-expansion-location (point))))
(setq dabbrev--last-expansion-location
(copy-marker dabbrev--last-expansion-location)))
(setq buffer-undo-list (cons orig-point buffer-undo-list))
(dabbrev--substitute-expansion old abbrev expansion)
(and record-case-pattern
(setq dabbrev--last-case-pattern
(and (if (eq dabbrev-case-fold-search 'case-fold-search)
case-fold-search
dabbrev-case-fold-search)
(not dabbrev-upcase-means-case-search)
(equal abbrev (upcase abbrev)))))
(setq dabbrev--last-expansion expansion)
(setq dabbrev--last-abbreviation abbrev)
(setq dabbrev--last-abbrev-location (point-marker))))))
(defun dabbrev--same-major-mode-p (other-buffer)
(eq major-mode
(save-excursion
(set-buffer other-buffer)
major-mode)))
(defun dabbrev--goto-start-of-abbrev ()
(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))))
(and dabbrev-abbrev-skip-leading-regexp
(while (looking-at dabbrev-abbrev-skip-leading-regexp)
(forward-char 1)))))
(defun dabbrev--abbrev-at-point ()
(if (bobp)
(error "No possible abbreviation preceding point"))
(save-excursion
(setq dabbrev--last-abbrev-location (point))
(save-match-data
(if (save-excursion
(forward-char -1)
(not (looking-at (concat "\\("
(or dabbrev-abbrev-char-regexp
"\\sw\\|\\s_")
"\\)+"))))
(if (re-search-backward (or dabbrev-abbrev-char-regexp
"\\sw\\|\\s_")
nil t)
(forward-char 1)
(error "No possible abbreviation preceding point"))))
(dabbrev--goto-start-of-abbrev)
(buffer-substring-no-properties
dabbrev--last-abbrev-location (point))))
(defun dabbrev--reset-global-variables ()
(setq dabbrev--last-table nil
dabbrev--last-abbreviation nil
dabbrev--last-abbrev-location nil
dabbrev--last-direction nil
dabbrev--last-expansion nil
dabbrev--last-expansion-location nil
dabbrev--friend-buffer-list nil
dabbrev--last-buffer nil
dabbrev--last-buffer-found nil
dabbrev--abbrev-char-regexp (or dabbrev-abbrev-char-regexp
"\\sw\\|\\s_")
dabbrev--check-other-buffers dabbrev-check-other-buffers))
(defun dabbrev--select-buffers ()
(save-excursion
(and (window-minibuffer-p (selected-window))
(set-buffer (dabbrev--minibuffer-origin)))
(let ((orig-buffer (current-buffer)))
(dabbrev-filter-elements
buffer (buffer-list)
(and (not (eq orig-buffer buffer))
(boundp 'dabbrev-friend-buffer-function)
(funcall dabbrev-friend-buffer-function buffer))))))
(defun dabbrev--try-find (abbrev reverse n ignore-case)
(save-excursion
(save-restriction
(widen)
(let ((expansion nil))
(and dabbrev--last-expansion-location
(goto-char dabbrev--last-expansion-location))
(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))))
(defun dabbrev--find-all-expansions (abbrev ignore-case)
(let ((all-expansions nil)
expansion)
(save-excursion
(goto-char (point-min))
(while (setq expansion (dabbrev--find-expansion abbrev -1 ignore-case))
(setq all-expansions (cons expansion all-expansions))))
all-expansions))
(defun dabbrev--scanning-message ()
(message "Scanning `%s'" (buffer-name (current-buffer))))
(defun dabbrev--find-expansion (abbrev direction ignore-case)
(let (expansion)
(save-excursion
(cond
(dabbrev--last-buffer
(set-buffer dabbrev--last-buffer)
(dabbrev--scanning-message))
((and (not dabbrev-search-these-buffers-only)
(window-minibuffer-p (selected-window)))
(set-buffer (dabbrev--minibuffer-origin))
(goto-char (point-min))
(setq direction -1)
(dabbrev--scanning-message)))
(cond
((and (not dabbrev-search-these-buffers-only)
(>= direction 0)
(setq dabbrev--last-direction (min 1 direction))
(setq expansion (dabbrev--try-find abbrev t
(max 1 direction)
ignore-case)))
expansion)
((and (or (not dabbrev-search-these-buffers-only)
dabbrev--last-buffer)
(<= direction 0)
(setq dabbrev--last-direction -1)
(setq expansion (dabbrev--try-find abbrev nil
(max 1 (- direction))
ignore-case)))
expansion)
(t
(setq dabbrev--last-direction -1)
(or dabbrev--friend-buffer-list
dabbrev--last-buffer
(setq dabbrev--friend-buffer-list
(mapcar (function get-buffer)
dabbrev-search-these-buffers-only))
(not dabbrev--check-other-buffers)
(not (or (eq dabbrev--check-other-buffers t)
(progn
(setq dabbrev--check-other-buffers
(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))
(if dabbrev-check-all-buffers
(setq non-friend-buffer-list
(nreverse
(dabbrev-filter-elements
buffer (buffer-list)
(and (not (member (buffer-name buffer)
dabbrev-ignored-buffer-names))
(not (memq buffer dabbrev--friend-buffer-list)))))
dabbrev--friend-buffer-list
(append dabbrev--friend-buffer-list
non-friend-buffer-list)))))
(when dabbrev--friend-buffer-list
(let ((w (next-window (selected-window))))
(while (not (eq w (selected-window)))
(setq dabbrev--friend-buffer-list
(cons (window-buffer w)
(delq (window-buffer w) dabbrev--friend-buffer-list)))
(setq w (next-window w))))
(setq dabbrev--friend-buffer-list
(delq (current-buffer) dabbrev--friend-buffer-list)))
(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))
(set-buffer dabbrev--last-buffer)
(dabbrev--scanning-message)
(setq dabbrev--last-expansion-location (point-min))
(setq expansion (dabbrev--try-find abbrev nil 1 ignore-case)))
expansion)))))
(defun dabbrev--safe-replace-match (string &optional fixedcase literal)
(if (eq major-mode 'picture-mode)
(picture-replace-match string fixedcase literal)
(replace-match string fixedcase literal)))
(defun dabbrev--substitute-expansion (old abbrev expansion)
(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))))
(and nil use-case-replace
(setq old (concat abbrev (or old "")))
(setq expansion (concat abbrev 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))
(search-backward abbrev))
(dabbrev--safe-replace-match expansion
(not use-case-replace)
t)))
(defun dabbrev--search (abbrev reverse ignore-case)
(save-match-data
(let ((pattern1 (concat (regexp-quote abbrev)
"\\(" dabbrev--abbrev-char-regexp "\\)"))
(pattern2 (concat (regexp-quote abbrev)
"\\(\\(" dabbrev--abbrev-char-regexp "\\)+\\)"))
(found-string nil))
(save-restriction
(and dabbrev-limit
(narrow-to-region dabbrev--last-expansion-location
(+ (point)
(if reverse (- dabbrev-limit) dabbrev-limit))))
(while (and (not found-string)
(if reverse
(re-search-backward pattern1 nil t)
(re-search-forward pattern1 nil t)))
(goto-char (match-beginning 0))
(dabbrev--goto-start-of-abbrev)
(if (not (looking-at pattern1))
nil
(re-search-forward pattern2)
(setq found-string (buffer-substring-no-properties
(match-beginning 1) (match-end 1)))
(and ignore-case (setq found-string (downcase found-string)))
(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))))
(if found-string
(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)))))))
(provide 'dabbrev)