;;; dabbrev.el --- dynamic abbreviation package
-;; Copyright (C) 1985, 1986, 1992, 1994 Free Software Foundation, Inc.
+
+;; Copyright (C) 1985, 86, 92, 94, 96, 1997, 2000
+;; Free Software Foundation, Inc.
;; Author: Don Morrison
;; Maintainer: Lars Lindberg <Lars.Lindberg@sypro.cap.se>
;; Created: 16 Mars 1992
;; Lindberg's last update version: 5.7
-;; Keywords: abbrev expand completion
+;; Keywords: abbrev expand completion convenience
+
+;; This file is part of GNU Emacs.
-;; This program is free software; you can redistribute it and/or modify
+;; 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:
;;
;; Set the variables you want special for your mode like this:
;; (set (make-local-variable 'dabbrev-case-replace) nil)
-;; Then you don't interfer with other modes.
+;; Then you don't interfere with other modes.
;;
;; If your mode handles buffers that refers to other buffers
;; (i.e. compilation-mode, gud-mode), then try to set
;; [tromey] Tom Tromey <tromey@busco.lanl.gov>
;; [Rolf] Rolf Schreiber <rolf@mathematik.uni-stuttgart.de>
;; [Petri] Petri Raitio <per@tekla.fi>
-;; [ejb] Jay Berkenbilt <ejb@ERA.COM>
+;; [ejb] Jay Berkenbilt <ejb@ql.org>
;; [hawley] Bob Hawley <rth1@quartet.mt.att.com>
;; ... and to all the people who have participated in the beta tests.
;;; 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
+ :group 'convenience)
-(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.\)
-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
- "*Non-nil if dabbrev searches should ignore case.
+(defcustom dabbrev-case-fold-search 'case-fold-search
+ "*Control whether 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.")
-
-(defvar dabbrev-upcase-means-case-search nil
+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' evaluates to t.")
+`dabbrev-case-fold-search' says to ignore case."
+ :type 'boolean
+ :group 'dabbrev)
-;; I recommend that you set this to nil.
-(defvar dabbrev-case-replace 'case-replace
- "*Non-nil means dabbrev should preserve case when expanding the abbreviation.
-The value of this variable is an expression; it is evaluated
-and the resulting value determines the decision.
-For example, setting this to `case-replace' means evaluate that
-variable to see if its value is t or nil.
+(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' evaluates to t.")
+`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)
-(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.")
-
-(defvar dabbrev-check-other-buffers t
+all the other buffers, except those named in `dabbrev-ignored-buffer-names',
+or matched by `dabbrev-ignored-regexps'."
+ :type 'boolean
+ :group 'dabbrev)
+
+(defcustom dabbrev-ignored-buffer-names '("*Messages*" "*Buffer List*")
+ "*List of buffer names that dabbrev should not check.
+See also `dabbrev-ignored-regexps'."
+ :type '(repeat (string :tag "Buffer name"))
+ :group 'dabbrev
+ :version "20.3")
+
+(defcustom dabbrev-ignored-regexps nil
+ "*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?\
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)
+ (other :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 ()
;; variable ELEMENT, and include it in the result
;; if CONDITION evaluates non-nil.
(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))))
-
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
-;;; Exported functions
-;;;----------------------------------------------------------------
-;;;----------------------------------------------------------------
+ `(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)))
+
+;;----------------------------------------------------------------
+;; Exported functions
+;;----------------------------------------------------------------
;;;###autoload
(define-key esc-map "/" 'dabbrev-expand)
(dabbrev-check-all-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)))))
+ (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
(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)
(cond
((or (not ignore-case-p)
(not dabbrev-case-replace))
- (mapcar (function (lambda (string)
- (intern string my-obarray)))
+ (mapc (function (lambda (string)
+ (intern string my-obarray)))
completion-list))
((string= abbrev (upcase abbrev))
- (mapcar (function (lambda (string)
- (intern (upcase string) my-obarray)))
+ (mapc (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)))
+ (mapc (function (lambda (string)
+ (intern (capitalize string) my-obarray)))
completion-list))
(t
- (mapcar (function (lambda (string)
- (intern (downcase string) my-obarray)))
+ (mapc (function (lambda (string)
+ (intern (downcase string) my-obarray)))
completion-list)))
(setq dabbrev--last-obarray my-obarray)
(setq dabbrev--last-completion-buffer (current-buffer))
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
;; as our expansion this time.
(re-search-forward
(concat "\\(\\(" dabbrev--abbrev-char-regexp "\\)+\\)"))
- (setq expansion
- (buffer-substring dabbrev--last-expansion-location
- (point)))
+ (setq expansion (buffer-substring-no-properties
+ 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)))
;;--------------------------------
(or expansion
(setq expansion
(dabbrev--find-expansion abbrev direction
- (and (eval dabbrev-case-fold-search)
+ (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
(error "No%s dynamic expansion for `%s' found"
(if old " further" "") abbrev))
(t
- (if (not (eq dabbrev--last-buffer dabbrev--last-buffer-found))
+ (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))
;; 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 (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)))))
+
;; Save state for re-expand.
- (setq dabbrev--last-expansion expansion)
+ (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)
(error "No possible abbreviation preceding point"))))
;; Now find the beginning of that one.
(dabbrev--goto-start-of-abbrev)
- (buffer-substring dabbrev--last-abbrev-location
- (point))))
-
+ (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
(nreverse
(dabbrev-filter-elements
buffer (buffer-list)
- (not (memq buffer dabbrev--friend-buffer-list))))
+ (let ((bn (buffer-name buffer)))
+ (and (not (member bn dabbrev-ignored-buffer-names))
+ (not (memq buffer dabbrev--friend-buffer-list))
+ (not
+ (let ((tail dabbrev-ignored-regexps)
+ (match nil))
+ (while (and tail (not match))
+ (setq match (string-match (car tail) bn)
+ tail (cdr tail)))
+ match))))))
dabbrev--friend-buffer-list
(append dabbrev--friend-buffer-list
non-friend-buffer-list)))))
+ ;; Move buffers that are visible on the screen
+ ;; to the front of the list. Remove the current buffer.
+ (when dabbrev--friend-buffer-list
+ (walk-windows (lambda (w)
+ (unless (eq w (selected-window))
+ (setq dabbrev--friend-buffer-list
+ (cons (window-buffer w)
+ (delq (window-buffer w)
+ dabbrev--friend-buffer-list))))))
+ (setq dabbrev--friend-buffer-list
+ (delq (current-buffer) dabbrev--friend-buffer-list)))
;; Walk through the buffers
(while (and (not expansion) dabbrev--friend-buffer-list)
(setq dabbrev--last-buffer
;;; EXPANSION is the expansion substring.
(defun dabbrev--substitute-expansion (old abbrev expansion)
;;(undo-boundary)
- (let ((use-case-replace (and (eval dabbrev-case-fold-search)
+ (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)))
- (eval dabbrev-case-replace))))
+ (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)))
+ ;; 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))
- ;;(store-match-data (list (point-marker) (point-marker)))
+ ;;(set-match-data (list (point-marker) (point-marker)))
(search-backward abbrev))
;; Make case of replacement conform to case of abbreviation
;; provided (1) that kind of thing is enabled in this buffer
;;; ABBREV is string to find as prefix of word. Second arg, REVERSE,
;;; is t for reverse search, nil for forward. Variable dabbrev-limit
-;;; controls the maximum search region size. Third argment IGNORE-CASE
+;;; controls the maximum search region size. Third argument IGNORE-CASE
;;; non-nil means treat case as insignificant while looking for a match
;;; and when comparing with previous matches. Also if that's non-nil
;;; and the match is found at the beginning of a sentence and is in
nil
;; We have a truly valid match. Find the end.
(re-search-forward pattern2)
- (setq found-string
- (buffer-substring (match-beginning 1) (match-end 1)))
+ (setq found-string (buffer-substring-no-properties
+ (match-beginning 1) (match-end 1)))
(and ignore-case (setq found-string (downcase found-string)))
;; Ignore this match if it's already in the table.
(if (dabbrev-filter-elements
(if found-string
;; Put it into `dabbrev--last-table'
;; and return it (either downcased, or as is).
- (let ((result
- (buffer-substring (match-beginning 0) (match-end 0))))
+ (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))
- (downcase result)
+ result
result)))))))
-(provide 'dabbrev)
-
-;; dabbrev.el ends here
+(dolist (mess '("^No dynamic expansion for .* found$"
+ "^No further dynamic expansion for .* found$"
+ "^No possible abbreviation preceding point$"))
+ (add-to-list 'debug-ignored-errors mess))
+(provide 'dabbrev)
+;;; dabbrev.el ends here
HCoop / bpt / emacs.git / blobdiff