Commits

Anonymous committed 548f923

synch dabbrev with fsf 20.7

  • Participants
  • Parent commits 6e29f2e

Comments (0)

Files changed (2)

+2001-02-24  Ben Wing  <ben@xemacs.org>
+
+	* dabbrev.el:
+	* dabbrev.el (dabbrev):
+	* dabbrev.el (dabbrev-abbrev-skip-leading-regexp):
+	* dabbrev.el (dabbrev-case-fold-search):
+	* dabbrev.el (dabbrev-upcase-means-case-search):
+	* dabbrev.el (dabbrev-case-replace):
+	* dabbrev.el (dabbrev-check-all-buffers):
+	* dabbrev.el (dabbrev-ignored-buffer-names): New.
+	* dabbrev.el (dabbrev-check-other-buffers):
+	* dabbrev.el (dabbrev-completion):
+	* dabbrev.el (dabbrev-expand):
+	* dabbrev.el (dabbrev--abbrev-at-point):
+	* dabbrev.el (dabbrev--find-expansion):
+	* dabbrev.el (dabbrev--substitute-expansion):
+	* dabbrev.el (dabbrev--search):
+	Synch with FSF 20.7.
+
 2001-02-16  Martin Buchholz  <martin@xemacs.org>
 
 	* lazy-lock.el (lazy-lock-pre-idle-fontify-windows):
 ;;; 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>
 ;; 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 XEmacs.
 
 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, MA
 ;; 02111-1307, USA.
 
-;;; Synched up with: FSF 19.34.
+;;; Synched up with: FSF 20.7.
 
 ;;; Commentary:
 
 ;;  [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.
 
 (defgroup dabbrev nil
   "Dynamic Abbreviations"
   :tag "Dynamic Abbreviations"
-  :group 'abbrev)
+  :group 'abbrev
+  :group 'convenience)
 
 (defcustom dabbrev-backward-only nil
   "*If non-nil, `dabbrev-expand' only looks backwards."
 
 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."
   :type '(choice regexp
 ;; do you actually want the case-folding behavior here, even though
 ;; it's useful to have case-fold-search set to t most of the time.
 (defcustom dabbrev-case-fold-search nil ;;'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 "like search" case-fold-search)
+		 (other :tag "on" t))
   :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)
 
 ;; XEmacs change: likewise here.
 ;; I recommend that you set this to nil.
 (defcustom dabbrev-case-replace nil ;;'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 "like M-x query-replace" case-replace)
+		 (other :tag "on" t))
   :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*" "*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?\
 
 The default value is t."
   :type '(choice (const :tag "off" nil)
 		 (const :tag "on" t)
-		 (const :tag "ask" other))
+		 (other :tag "ask" other))
   :group 'dabbrev)
 
 ;; I guess setting this to a function that selects all C- or C++-
 	 (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-no-properties 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
       (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))
 ;; 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-no-properties 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)))))
 	;; Move buffers that are visible on the screen
-	;; to the front of the list.
-	(if 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)))))
+	;; to the front of the list.  Remove the current buffer.
+	(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)))
 	;; 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 given abbrev is mixed case and its case pattern
+    ;; 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.
-    (if (and (string= abbrev
-		      (substring expansion 0 (length abbrev)))
-	     (not (string= abbrev (downcase abbrev)))
-	     (not (string= abbrev (upcase abbrev))))
-	(setq use-case-replace nil))
+    (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
     (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-no-properties (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-no-properties (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))