;;; dabbrev.el --- dynamic abbreviation package
-;; Copyright (C) 1985, 1986, 1992, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 86, 92, 94, 96, 1997 Free Software Foundation, Inc.
;; Author: Don Morrison
;; Maintainer: Lars Lindberg <Lars.Lindberg@sypro.cap.se>
;; [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.
Example: Set this to \"\\\\$\" for programming languages
in which variable names may appear with or without a leading `$'.
-\(For example, in Makefiles.
- :type 'regexp
- :group 'dabbrev))
+\(For example, in Makefiles.\)
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.
(defcustom dabbrev-case-fold-search 'case-fold-search
- "*Non-nil if dabbrev searches should ignore case.
+ "*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."
- :type 'sexp
+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 "on" t)
+ (const :tag "like search" case-fold-search))
:group 'dabbrev)
(defcustom dabbrev-upcase-means-case-search nil
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.
(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.
-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.
+ "*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."
- :type 'sexp
+`dabbrev-case-fold-search' specifies to ignore case."
+ :type '(choice (const :tag "off" nil)
+ (const :tag "on" t)
+ (const :tag "like M-x query-replace" case-replace))
:group 'dabbrev)
(defcustom dabbrev-abbrev-char-regexp nil
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, except those named in `dabbrev-ignored-buffer-names'."
:type 'boolean
:group 'dabbrev)
+(defcustom dabbrev-ignored-buffer-names '("*Messages")
+ "*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?\
(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
;; 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)))
(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
;; set dabbrev--last-case-pattern.
(and record-case-pattern
(setq dabbrev--last-case-pattern
- (and (eval dabbrev-case-fold-search)
+ (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)))))
(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 ()
(nreverse
(dabbrev-filter-elements
buffer (buffer-list)
- (not (memq buffer dabbrev--friend-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)))))
;;; 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 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
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))
HCoop / bpt / emacs.git / blobdiff