emacs: lisp/dabbrev.el comparison

comparison lisp/dabbrev.el @ 34596:51c08e149a23

(dabbrev--last-case-pattern): Value is now `upcase' or `downcase' or nil. (dabbrev-expand): Don't do anything with dabbrev--last-case-pattern. Pass new record-case-pattern arg to dabbrev--substitute-expansion. (dabbrev--substitute-expansion): New arg record-case-pattern. If it is non-nil, set dabbrev--last-case-pattern. If ABBREV is " ", use dabbrev--last-case-pattern to change EXPANSION. (dabbrev--find-expansion): Remove extra nreverse.

author	Gerd Moellmann <gerd@gnu.org>
date	Fri, 15 Dec 2000 11:50:36 +0000
parents	edb654a13bf1
children	4eb554667665

comparison

equal deleted inserted replaced

-:5abdd701bf8d
+:51c08e149a23
 (defvar dabbrev--last-buffer-found nil)
 ;; The buffer we last did a completion in.
 (defvar dabbrev--last-completion-buffer nil)
-;; Non-nil means we should upcase
+;; If non-nil, a function to use when copying successive words.
-;; when copying successive words.
+;; It should be `upcase' or `downcase'.
 (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)
 	   (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))
+(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)))
 		;; as our expansion this time.
 		(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)))
 		;; Record the end of this expansion, in case we repeat this.
 		(setq dabbrev--last-expansion-location (point)))
 	      ;; Indicate that dabbrev--last-expansion-location is
 	      ;; at the end of the expansion.
 	       (and (> dabbrev--last-expansion-location (point))))
 	  (setq dabbrev--last-expansion-location
 		(copy-marker dabbrev--last-expansion-location)))
 ;; Success: stick it in and return.
 (setq buffer-undo-list (cons orig-point buffer-undo-list))
-(dabbrev--substitute-expansion old abbrev expansion)
+(dabbrev--substitute-expansion old abbrev expansion
+				     record-case-pattern)
-;; 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-abbreviation abbrev)
 (setq dabbrev--last-abbrev-location (point-marker))))))
 	    (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
-			 (dabbrev-filter-elements
+			 buffer (buffer-list)
-			  buffer (buffer-list)
+			 (let ((bn (buffer-name buffer)))
-			  (let ((bn (buffer-name buffer)))
+			   (and (not (member bn dabbrev-ignored-buffer-names))
-			    (and (not (member bn dabbrev-ignored-buffer-names))
+				(not (memq buffer dabbrev--friend-buffer-list))
-				 (not (memq buffer dabbrev--friend-buffer-list))
+				(not
-				 (not
+				 (let ((tail dabbrev-ignored-regexps)
-				  (let ((tail dabbrev-ignored-regexps)
+				       (match nil))
-					(match nil))
+				   (while (and tail (not match))
-				    (while (and tail (not match))
+				     (setq match (string-match (car tail) bn)
-				      (setq match (string-match (car tail) bn)
+					   tail (cdr tail)))
-					    tail (cdr tail)))
+				   match)))))
-				    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.
 (if (eq major-mode 'picture-mode)
 (picture-replace-match string fixedcase literal)
 (replace-match string fixedcase literal)))
 ;;;----------------------------------------------------------------
-;;; Substitute the current string in buffer with the expansion
+(defun dabbrev--substitute-expansion (old abbrev expansion record-case-pattern)
-;;; OLD is nil or the last expansion substring.
+"Replace OLD with EXPANSION in the buffer.
-;;; ABBREV is the abbreviation we are working with.
+OLD is text currently in the buffer, perhaps the abbreviation
-;;; EXPANSION is the expansion substring.
+or perhaps another expansion that was tried previously.
-(defun dabbrev--substitute-expansion (old abbrev expansion)
+ABBREV is the abbreviation we are expanding.
+It is \" \" if we are copying subsequent words.
+EXPANSION is the expansion substring to be used this time.
+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))))
-(and nil use-case-replace
-	 (setq old (concat abbrev (or old "")))
+;; If we upcased or downcased the original expansion,
-	 (setq expansion (concat abbrev expansion)))
+;; do likewise for the subsequent words when we copy them.
+(and (equal abbrev " ")
+	 dabbrev--last-case-pattern
+	 (setq expansion
+	       (funcall dabbrev--last-case-pattern 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,
 	  (setq use-case-replace nil)))
 (if (equal abbrev " ")
 	(setq use-case-replace nil))
 (if use-case-replace
 	(setq expansion (downcase expansion)))
+;; In case we insert subsequent words,
+;; record if we upcased or downcased the first word,
+;; in order to do likewise for subsequent words.
+(and record-case-pattern
+	 (setq dabbrev--last-case-pattern
+	       (and use-case-replace
+		    (cond ((equal abbrev (upcase abbrev)) 'upcase)
+			  ((equal abbrev (downcase abbrev)) 'downcase)))))
 (if old
 	(save-excursion
 	  (search-backward old))
 ;;(set-match-data (list (point-marker) (point-marker)))
 (search-backward abbrev))

Mercurial > emacs

comparison lisp/dabbrev.el @ 34596:51c08e149a23