xemacs-beta: lisp/packages/diff.el comparison

comparison lisp/packages/diff.el @ 100:4be1180a9e89 r20-1b2

Import from CVS: tag r20-1b2

author	cvs
date	Mon, 13 Aug 2007 09:15:11 +0200
parents	131b0175ea99
children	cf808b4c4290

comparison

equal deleted inserted replaced

-:2d83cbd90d8d
+:4be1180a9e89
-;;; diff.el --- Run `diff' in compilation-mode.
+;; -*-Emacs-Lisp-*-
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Copyright (C) 1992, 1994 Free Software Foundation, Inc.
+;;
+;; File:         diff.el
-;; Keywords: unix, tools
+;; Version:      $Revision: 1.2 $
+;; Author:       This file is based on diff.el by
-;; This file is part of XEmacs.
+;;               sunpitt!wpmstr!fbresz@Sun.COM 1/27/89.
+;;               It has been completely rewritten in July 1994 by
-;; XEmacs is free software; you can redistribute it and/or modify it
+;;               Sandy Rutherford <sandy@ibm550.sissa.it>
-;; under the terms of the GNU General Public License as published by
+;; RCS:
-;; the Free Software Foundation; either version 2, or (at your option)
+;; Description:  diff-mode for handling output from unix diff utility.
-;; any later version.
+;; Modified:     Wed Jul 17 10:26:57 1996 (Andy Norman) ange@hplb.hpl.hp.com
+;;
-;; XEmacs 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
+;;; Copyright (C) 1990 Free Software Foundation, Inc.
-;; General Public License for more details.
+;;; Copyright (C) 1994 Sandy Rutherford
-;; You should have received a copy of the GNU General Public License
+;;; This file is based on diff.el by sunpitt!wpmstr!fbresz@Sun.COM 1/27/89.
-;; along with XEmacs; see the file COPYING.  If not, write to the Free
+;;; It has been completely rewritten in July 1994 by
-;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+;;; Sandy Rutherford <sandy@ibm550.sissa.it>
-;; 02111-1307, USA.
+;;; This program is free software; you can redistribute it and/or modify
-;;; Synched up with: FSF 19.34.
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 1, or (at your option)
-;;; Commentary:
+;;; any later version.
+;;;
-;; This package helps you explore differences between files, using the
+;;; This program is distributed in the hope that it will be useful,
-;; UNIX command diff(1).  The commands are `diff' and `diff-backup'.
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; You can specify options with `diff-switches'.
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
-;;; Code:
+;;;
+;;; A copy of the GNU General Public License can be obtained from this
-(require 'compile)
+;;; program's author (send electronic mail to sandy@ibm550.sissa.it) or
+;;; from the Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
-;;; This is duplicated in vc.el.
+;;; MA 02139, USA.
-;;;###autoload
-(defvar diff-switches (purecopy "-c")
+(provide 'diff)
-"*A string or list of strings specifying switches to be passed to diff.")
+;;; User Variables
-(defvar diff-command "diff"
-"*The command to use to run diff.")
+;; should be in to loaddefs.el now.
+(defvar diff-switches nil
-(defvar diff-regexp-alist
+"*A list of switches (strings) to pass to the diff program.")
-'(
-;; -u format: @@ -OLDSTART,OLDEND +NEWSTART,NEWEND @@
+(defvar diff-do-narrow nil
-("^@@ -\\([0-9]+\\),[0-9]+ \\+\\([0-9]+\\),[0-9]+ @@$" 1 2)
+"*If non-nil diff buffers are initialized narrowed to each difference.")
-;; -c format: *** OLDSTART,OLDEND ****
+(defvar diff-load-hooks nil
-("^\\*\\*\\* \\([0-9]+\\),[0-9]+ \\*\\*\\*\\*$" 1 nil)
+"Hooks to run after loading diff.el")
-;;            --- NEWSTART,NEWEND ----
-("^--- \\([0-9]+\\),[0-9]+ ----$" nil 1)
+;;; Internal variables
-;; plain diff format: OLDSTART[,OLDEND]{a,d,c}NEWSTART[,NEWEND]
+(defconst diff-emacs-19-p
-("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]\\([0-9]+\\)\\(,[0-9]+\\)?$" 1 3)
+(let ((ver (string-to-int (substring emacs-version 0 2))))
+(>= ver 19)))
-;; -e (ed) format: OLDSTART[,OLDEND]{a,d,c}
-("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]$" 1)
+(or diff-emacs-19-p (require 'emacs-19))
-;; -f format: {a,d,c}OLDSTART[ OLDEND]
+(defvar diff-old-file nil)
-;; -n format: {a,d,c}OLDSTART LINES-CHANGED
+;; A list whose car is the name of the old file, and whose cdr indicates
-("^[adc]\\([0-9]+\\)\\( [0-9]+\\)?$" 1)
+;; whether we should delete the buffer on quit.
-)
+(defvar diff-new-file nil)
-"Alist (REGEXP OLD-IDX NEW-IDX) of regular expressions to match difference
+;; Same as diff-old-file, except for the new file.
-sections in \\[diff] output.  If REGEXP matches, the OLD-IDX'th
+(defvar diff-total-differences "0")
-subexpression gives the line number in the old file, and NEW-IDX'th
+;; Total number of difference hunks as a string.
-subexpression gives the line number in the new file.  If OLD-IDX or NEW-IDX
+(defvar diff-current-difference "0")
-is nil, REGEXP matches only half a section.")
+;; Current difference hunk as a string.
+(defvar diff-current-hunk 0)
-(defvar diff-old-file nil
+;; Current difference hunk as an integer.
-"This is the old file name in the comparison in this buffer.")
+(defvar diff-total-hunks 0)
-(defvar diff-new-file nil
+;; Total number of difference hunks as an integer.
-"This is the new file name in the comparison in this buffer.")
+(defvar diff-hunk-vector (vector 0))
-(defvar diff-old-temp-file nil
+;; Vector storing the starting positions of the difference hunks.
-"This is the name of a temp file to be deleted after diff finishes.")
+(defvar diff-old-file-pattern nil)
-(defvar diff-new-temp-file nil
+(defvar diff-new-file-pattern nil)
-"This is the name of a temp file to be deleted after diff finishes.")
+(defvar diff-hunk-pattern nil)
+;; Regexps to use when parsing file lines in difference hunks.
-;; See compilation-parse-errors-function (compile.el).
-(defun diff-parse-differences (limit-search find-at-least)
-(setq compilation-error-list nil)
+(defvar diff-search-pattern-alist
-(message "Parsing differences...")
+(list
+(list ?e "^[0-9]\\(,[0-9]+\\)?[acd]$" "^\\([0-9]+\\)" nil)
-;; Don't reparse diffs already seen at last parse.
+(list ?c "^\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\n"
-(if compilation-parsing-end (goto-char compilation-parsing-end))
+	  "^\\*+ \\([0-9]+\\)" "^-+ \\([0-9]+\\)")
+(list ?u "^@@ " "^@@ -\\([0-9]+\\)" "^@@ -[0-9,]+ \\+\\([0-9]+\\)")
-;; Construct in REGEXP a regexp composed of all those in dired-regexp-alist.
+(list nil "^[0-9]+" "^\\([0-9]+\\)" "^[0-9,]+[acd]\\([0-9]+\\)")))
-(let ((regexp (mapconcat #'(lambda (elt)
-			       (concat "\\(" (car elt) "\\)"))
+(defvar diff-keymap-grokked nil)
-			   diff-regexp-alist
-			   "\\|"))
+(defvar diff-temp-template "/tmp/diff")
-	;; (GROUP-IDX OLD-IDX NEW-IDX)
-	(groups (let ((subexpr 1))
+;; Initialize the keymap if it isn't already
-		  (mapcar #'(lambda (elt)
-			    (prog1
+(defvar diff-mode-map nil
-				(cons subexpr
+"Keymap used in diff mode.")
-				      (mapcar #'(lambda (n)
-						(and n
+(if diff-mode-map
-						     (+ subexpr n)))
+nil
-					      (cdr elt)))
+(setq diff-mode-map (make-keymap))
-			      (setq subexpr (+ subexpr 1
+(suppress-keymap diff-mode-map)
-;;#### undefined??
+(define-key diff-mode-map "?" 'describe-mode)
-					       (count-regexp-groupings
+(define-key diff-mode-map "." 'diff-display-file)
-						(car elt))))))
+(define-key diff-mode-map "N" 'diff-narrow)
-			  diff-regexp-alist)))
+(define-key diff-mode-map "W" 'widen)
+(define-key diff-mode-map "f" 'diff-find-file)
-	(new-error
+(define-key diff-mode-map "h" 'diff-show-header)
-	 (function (lambda (file subexpr)
+(define-key diff-mode-map "j" 'diff-show-difference)
-		     (setq compilation-error-list
+(define-key diff-mode-map "n" 'diff-next-difference)
-			   (cons
+(define-key diff-mode-map "o" 'diff-find-file-other-window)
-			    (cons (save-excursion
+(define-key diff-mode-map "p" 'diff-previous-difference)
-				    ;; Report location of message
+(define-key diff-mode-map "q" 'diff-quit)
-				    ;; at beginning of line.
+(define-key diff-mode-map "w" 'diff-find-file-other-frame)
-				    (goto-char
+(define-key diff-mode-map "\C-c\C-c" 'diff-find-file-other-window)
-				     (match-beginning subexpr))
+(define-key diff-mode-map " " 'diff-advertised-scroll-up)
-				    (beginning-of-line)
+(define-key diff-mode-map "\177" 'diff-advertised-scroll-down)
-				    (point-marker))
+(define-key diff-mode-map "\C-n" 'diff-next-line)
-				  ;; Report location of corresponding text.
+(define-key diff-mode-map "\C-p" 'diff-previous-line)
-				  (let ((line (string-to-int
+(define-key diff-mode-map "\M->" 'diff-end-of-buffer)
-					       (buffer-substring
+(define-key diff-mode-map "\M-<" 'diff-beginning-of-buffer))
-						(match-beginning subexpr)
-						(match-end subexpr)))))
+;;; Internal functions
-				    (save-excursion
-				      (save-match-data
+(defun diff-grok-keys (to-command from-command)
-					(set-buffer (find-file-noselect file)))
+;; Assigns to TO-COMMAND the keys for the global binding of FROM-COMMAND.
-				      (save-excursion
+;; Does not clobber anything in the local keymap.
-					(goto-line line)
+(let ((keys (where-is-internal from-command)))
-					(point-marker)))))
+(while keys
-			    compilation-error-list)))))
+(condition-case nil
+	  (if (eq (global-key-binding (car keys)) (key-binding (car keys)))
-	(found-desired nil)
+	      (local-set-key (car keys) to-command))
-	(num-loci-found 0)
+	(error nil))
-	g)
+(setq keys (cdr keys)))))
-(while (and (not found-desired)
+(defun diff-grok-keymap ()
-		;; We don't just pass LIMIT-SEARCH to re-search-forward
+(if diff-keymap-grokked
-		;; because we want to find matches containing LIMIT-SEARCH
+()
-		;; but which extend past it.
+(if (and term-setup-hook (boundp 'command-line-args-left))
-		(re-search-forward regexp nil t))
+	(progn
+	  (if diff-emacs-19-p
-;; Find which individual regexp matched.
+	      (run-hooks term-setup-hook)
-(setq g groups)
+	    (funcall term-setup-hook))
-(while (and g (null (match-beginning (car (car g)))))
+	  (setq term-setup-hook nil)))
-	(setq g (cdr g)))
+(setq diff-keymap-grokked t)
-(setq g (car g))
+(diff-grok-keys 'diff-next-line 'next-line)
+(diff-grok-keys 'diff-previous-line 'previous-line)
-(if (nth 1 g)			;OLD-IDX
+(diff-grok-keys 'diff-forward-char 'forward-char)
-	  (funcall new-error diff-old-file (nth 1 g)))
+(diff-grok-keys 'diff-backward-char 'backward-char)
-(if (nth 2 g)			;NEW-IDX
+(diff-grok-keys 'diff-scroll-up 'scroll-up)
-	  (funcall new-error diff-new-file (nth 2 g)))
+(diff-grok-keys 'diff-scroll-down 'scroll-down)
+(diff-grok-keys 'diff-beginning-of-buffer 'beginning-of-buffer)
-(setq num-loci-found (1+ num-loci-found))
+(diff-grok-keys 'diff-end-of-buffer 'end-of-buffer)))
-(if (or (and find-at-least
-		   (>= num-loci-found find-at-least))
+(defun diff-buffer-narrowed-p ()
-	      (and limit-search (>= (point) limit-search)))
+;; Returns t if the current buffer is narrowed
-	      ;; We have found as many new loci as the user wants,
+(save-restriction
-	      ;; or the user wanted a specific diff, and we're past it.
+(let ((min (point-min))
-	  (setq found-desired t)))
+	  (max (point-max)))
-(if found-desired
+(widen)
-	(setq compilation-parsing-end (point))
+(not (and (= min (point-min)) (= max (point-max)))))))
-;; Set to point-max, not point, so we don't perpetually
-;; parse the last bit of text when it isn't a diff header.
+(defun diff-current-hunk ()
-(setq compilation-parsing-end (point-max)))
+;; Returns the current diff hunk.
-(message "Parsing differences...done"))
+(let ((pt (point))
-(setq compilation-error-list (nreverse compilation-error-list)))
+	(start 0)
+	(end (1+ diff-total-hunks))
-;;;###autoload
+	m)
-(defun diff (old new &optional switches)
+(while (> (- end start) 1)
-"Find and display the differences between OLD and NEW files.
+(setq m (/ (+ start end) 2))
-Interactively the current buffer's file name is the default for NEW
+(if (>= pt (aref diff-hunk-vector m))
-and a backup file for NEW is the default for OLD.
+	  (setq start m)
-With prefix arg, prompt for diff switches."
+	(setq end m)))
-(interactive
+(if (>= pt (aref diff-hunk-vector end))
-(nconc
+	(setq m end)
-(let (oldf newf)
+(setq m start))
-(nreverse
+;; Don't treat end of buffer as start of next hunk
-(list
+(if (eobp) (1- m) m)))
-	(setq newf (buffer-file-name)
+(defun diff-hunk-min (n)
+;; Returns the start of the current diff hunk.
+(aref diff-hunk-vector n))
+(defun diff-hunk-max (n)
+;; Returns the end of the current diff hunk.
+(aref diff-hunk-vector (1+ n)))
+(defun diff-parse-hunks ()
+;; Parses a buffer of diff output.
+(save-excursion
+(save-restriction
+(message "Parsing differences...")
+(widen)
+(goto-char (point-min))
+(let ((hunks (list 1)))
+	(while (re-search-forward diff-hunk-pattern nil t)
+	  (setq hunks (cons (match-beginning 0) hunks)))
+	(setq diff-total-hunks (1- (length hunks))
+	      diff-hunk-vector (apply 'vector
+				      (nreverse (cons (point-max) hunks)))))))
+(message "Parsing differences...done"))
+(defun diff-update-modeline ()
+;; Updates the mode line to show current diff hunk.
+(if (or (< (point) (diff-hunk-min diff-current-hunk))
+	  (>= (point) (diff-hunk-max diff-current-hunk)))
+(progn
+	(setq diff-current-hunk (diff-current-hunk)
+	      diff-current-difference (int-to-string diff-current-hunk))
+	(set-buffer-modified-p (buffer-modified-p)))))
+(defun diff-read-args (oldprompt newprompt switchprompt
+				 &optional file-for-backup)
+;; Grab the args for diff.  OLDPROMPT and NEWPROMPT are the prompts
+;; for the old & new filenames, SWITCHPROMPT for the list of
+;; switches.  If FILE_FOR_BACKUP is provided (it must be a string if
+;; so), then it will be used to try & work out a file & backup to
+;; diff, & in this case the prompting order is backwards.  %s in a
+;; prompt has a guess substituted into it.  This is nasty.
+(let (oldf newf)
+(if file-for-backup
+	(setq newf file-for-backup
 	      newf (if (and newf (file-exists-p newf))
 		       (read-file-name
-			(concat "Diff new file: ("
+			(format newprompt (file-name-nondirectory newf))
-				(file-name-nondirectory newf) ") ")
 			nil newf t)
-		     (read-file-name "Diff new file: " nil nil t)))
+		     (read-file-name (format newprompt "") nil nil t))
-	(setq oldf (file-newest-backup newf)
+	      oldf (file-newest-backup newf)
 	      oldf (if (and oldf (file-exists-p oldf))
 		       (read-file-name
-			(concat "Diff original file: ("
+			(format oldprompt (file-name-nondirectory oldf))
-				(file-name-nondirectory oldf) ") ")
+			nil oldf t)
-			(file-name-directory oldf) oldf t)
+		     (read-file-name (format oldprompt "")
-		     (read-file-name "Diff original file: "
+				     (file-name-directory newf) nil t)))
-				     (file-name-directory newf) nil t))))))
+;; Else we aren't trying to be bright...
-(if current-prefix-arg
+(setq oldf (read-file-name (format oldprompt "") nil nil t)
-	(list (read-string "Diff switches: "
+	    newf (read-file-name
-			   (if (stringp diff-switches)
+		  (format newprompt (file-name-nondirectory oldf))
-			       diff-switches
+		  nil (file-name-directory oldf) t)))
-			     (mapconcat 'identity diff-switches " "))))
+	(list oldf newf (diff-read-switches switchprompt))))
-nil)))
-(setq new (expand-file-name new)
+(defun diff-read-switches (switchprompt)
-	old (expand-file-name old))
+;; Read and return a list of switches
-;; XEmacs addition -- allow (diff "../old/" "new-file.el") to work
+(if current-prefix-arg
-(cond ((file-directory-p old)
+(let ((default (if (listp diff-switches)
-(or (file-directory-p new)
+			 (mapconcat 'identity diff-switches " ")
-(setq old (expand-file-name (file-name-nondirectory new)
+		       diff-switches)))
-(file-name-as-directory old)))))
+	(diff-fix-switches
-((file-directory-p new)
+	 (read-string (format switchprompt default) default)))))
-(setq new (expand-file-name (file-name-nondirectory old)
-(file-name-as-directory new)))))
+(defun diff-fix-switches (switch-spec)
-(let ((old-alt (file-local-copy old))
+;; Parse a string into a list of switches or leave it be if it's
-	(new-alt (file-local-copy new))
+;; not a string
-	buf)
+(if (stringp switch-spec)
-(unwind-protect
+(let (result (start 0))
-	(let ((command
+	(while (string-match "\\(\\S-+\\)" switch-spec start)
-	       (mapconcat 'identity
+	  (setq result (cons (substring switch-spec (match-beginning 1)
-			  (append (list diff-command)
+					(match-end 1))
-				  ;; Use explicitly specified switches
+			     result)
-				  (if switches
+		start (match-end 0)))
-				      (if (consp switches)
+	(nreverse result))
-					  switches (list switches))
+switch-spec))
-				    ;; If not specified, use default.
-				    (if (consp diff-switches)
+(defun diff-get-file-buffer (file)
-					diff-switches
+;; Returns \(BUFFER . DEL-P\), where DEL-P is t if diff is expected
-				      (list diff-switches)))
+;; to delete the buffer, and nil otherwise.
-				  (if (or old-alt new-alt)
+(let* ((buff (get-file-buffer file))
-				      (list "-L" old "-L" new))
+	 (del-p (null buff)))
-				  (list
+(if (and buff (buffer-modified-p buff))
-				   (shell-quote-argument (or old-alt old)))
+	(progn
-				  (list
+	  (message
-				   (shell-quote-argument (or new-alt new))))
+	   "Buffer %s is modified.  Diffing against buffer contents."
-			  " ")))
+	   (buffer-name buff))
-	  (setq buf
+	  (sit-for 1)))
-		(compile-internal command
+;; Call find-file-noselect even if we already have the buffer,
-				  "No more differences" "Diff"
+;; as it will run verify-buffer-file-modtime.
-				  'diff-parse-differences))
+(cons (find-file-noselect file) del-p)))
-	  (pop-to-buffer buf)
-	  ;; Avoid frightening people with "abnormally terminated"
+(defun diff-cleanup-buffers ()
-	  ;; if diff finds differences.
+;; Cleans up diff buffers by deleting buffers that we don't expect
-	  (set (make-local-variable 'compilation-exit-message-function)
+;; the user to care about.
-	       (lambda (status code msg)
+(let ((files (list diff-old-file diff-new-file)))
-		 (cond ((not (eq status 'exit))
+(while files
-			(cons msg code))
+(let ((ent (car files))
-		       ((zerop code)
+	    buff)
-			'("finished (no differences)\n" . "no differences"))
+	(and (cdr ent)
-		       ((= code 1)
+	     (setq buff (get-file-buffer (car ent)))
-			'("finished\n" . "differences found"))
+	     (not (buffer-modified-p buff))
-		       (t
+	     (kill-buffer buff)))
-			(cons msg code)))))
+(setq files (cdr files)))
-	  (set (make-local-variable 'diff-old-file) old)
+(if (get-buffer "*Diff Header*")
-	  (set (make-local-variable 'diff-new-file) new)
+	(kill-buffer "*Diff Header*"))))
-	  (set (make-local-variable 'diff-old-temp-file) old-alt)
-	  (set (make-local-variable 'diff-new-temp-file) new-alt)
+(defun diff-latest-backup-file (file)
-	  (set (make-local-variable 'compilation-finish-function)
-	       (function (lambda (buff msg)
-			   (if diff-old-temp-file
-			       (delete-file diff-old-temp-file))
-			   (if diff-new-temp-file
-			       (delete-file diff-new-temp-file)))))
-	  buf))))
-;;;###autoload
-(defun diff-backup (file &optional switches)
-"Diff this file with its backup file or vice versa.
-Uses the latest backup, if there are several numerical backups.
-If this file is a backup, diff it with its original.
-The backup file is the first file given to `diff'."
-(interactive (list (read-file-name "Diff (file with backup): ")
-		     (if current-prefix-arg
-			 (read-string "Diff switches: "
-				      (if (stringp diff-switches)
-					  diff-switches
-					(mapconcat 'identity
-						   diff-switches " ")))
-		       nil)))
-(let (bak ori)
-(if (backup-file-name-p file)
-	(setq bak file
-	      ori (file-name-sans-versions file))
-(setq bak (or (diff-latest-backup-file file)
-		    (error "No backup found for %s" file))
-	    ori file))
-(diff bak ori switches)))
-(defun diff-latest-backup-file (fn)	; actually belongs into files.el
 "Return the latest existing backup of FILE, or nil."
-(let ((handler (find-file-name-handler fn 'diff-latest-backup-file)))
+;; First try simple backup, then the highest numbered of the
+;; numbered backups.
+;; Ignore the value of version-control because we look for existing
+;; backups, which maybe were made earlier or by another user with
+;; a different value of version-control.
+(let* ((file (expand-file-name file))
+	 (handler (find-file-name-handler file 'diff-latest-backup-file)))
 (if handler
-	(funcall handler 'diff-latest-backup-file fn)
+	(funcall handler 'diff-latest-backup-file file)
-;; First try simple backup, then the highest numbered of the
-;; numbered backups.
-;; Ignore the value of version-control because we look for existing
-;; backups, which maybe were made earlier or by another user with
-;; a different value of version-control.
-(setq fn (file-chase-links (expand-file-name fn)))
 (or
-(let ((bak (make-backup-file-name fn)))
+(let ((bak (make-backup-file-name file)))
 	 (if (file-exists-p bak) bak))
-;; We use BACKUPNAME to cope with backups stored in a different dir.
+(let* ((dir (file-name-directory file))
-(let* ((backupname (car (find-backup-file-name fn)))
+	      (base-versions (concat (file-name-nondirectory file) ".~"))
-	      (dir (file-name-directory backupname))
-	      (base-versions (concat (file-name-sans-versions
-				      (file-name-nondirectory backupname))
-				     ".~"))
 	      (bv-length (length base-versions)))
 	 (concat dir
 		 (car (sort
 		       (file-name-all-completions base-versions dir)
 		       ;; bv-length is a fluid var for backup-extract-version:
 		       (function
 			(lambda (fn1 fn2)
 			  (> (backup-extract-version fn1)
 			     (backup-extract-version fn2))))))))))))
-(provide 'diff)
+(defun diff-file-line (&optional old-file-p)
+"Return line number of current hunk in `diff-new-file'.
-;;; diff.el ends here
+With optional argument OLD-FILE-P, use `diff-old-file' instead."
+(save-excursion
+(let ((min (diff-hunk-min diff-current-hunk))
+	  (max (diff-hunk-max diff-current-hunk))
+	  (regexp (if old-file-p diff-old-file-pattern diff-new-file-pattern)))
+(goto-char min)
+(or (and regexp (re-search-forward regexp max t))
+	  (error "Unable to locate a file line for %s file."
+		 (if old-file-p "old" "new")))
+(string-to-int (buffer-substring (match-beginning 1) (match-end 1))))))
+(defun diff-run-diff (switches old old-temp new new-temp)
+;; Actually run the diff process with SWITCHES on OLD and NEW.
+;; OLD-TEMP and NEW-TEMP are names of temp files that can be used
+;; to dump the data out to.
+(insert "diff " (mapconcat 'identity switches " ") " " old
+	  " " new "\n")
+(apply 'call-process "diff" nil t nil
+	 (append switches (list old-temp new-temp))))
+(defun diff-fix-file-names (old old-temp new new-temp pattern)
+;; Replaces any temp file names with the real names of files.
+(save-excursion
+(save-restriction
+(let ((files (list old new))
+	    (temps (list old-temp new-temp))
+	    buffer-read-only case-fold-search)
+	(goto-char (point-min))
+	(if (re-search-forward pattern nil t)
+	    (narrow-to-region (point-min) (match-beginning 0)))
+	(while files
+	  (let ((regexp (concat "[ \t\n]\\("
+				(regexp-quote (car temps))
+				"\\)[ \t\n]")))
+	    (goto-char (point-min))
+	    (forward-line 1)
+	    (while (re-search-forward regexp nil t)
+	      (goto-char (match-beginning 1))
+	      (delete-region (point) (match-end 1))
+	      (insert (car files))))
+	  (setq files (cdr files)
+		temps (cdr temps)))))))
+;;;; User commands
+(defun diff-mode ()
+"Diff Mode is used by \\[diff] for perusing the output from the diff program.
+All normal editing commands are turned off.  Instead, these are available:
+\\<diff-mode-map>
+\\[diff-advertised-scroll-up]	Scroll to next screen of this difference.
+\\[diff-advertised-scroll-down]	Scroll to previous screen of this difference.
+\\[diff-next-difference]	Move to Next Difference.
+\\[diff-previous-difference]	Move to Previous Difference.
+\\[diff-show-difference]	Jump to difference specified by numeric position.
+\\[diff-find-file]	Find current diff in file
+\\[diff-find-file-other-window]	Find current diff in file in other window
+\\[diff-display-file]	Display file in other window
+\\[diff-narrow]	Narrow diff buffer to current difference
+\\[widen]	Widen diff buffer
+\\[diff-show-header]	Show diff header describing file name etc.
+\\[diff-quit]	Quit diff
+"
+(interactive)
+(use-local-map diff-mode-map)
+(diff-grok-keymap)
+(setq buffer-read-only t
+	major-mode 'diff-mode
+	mode-name "Diff"
+	mode-line-modified "--- "
+	mode-line-process
+	'(" " diff-current-difference "/" diff-total-differences))
+(diff-parse-hunks)
+(setq diff-total-differences (int-to-string diff-total-hunks)))
+;;; Motion commands
+(defun diff-next-difference (n)
+"In diff-mode go the the beginning of the next difference hunk."
+(interactive "p")
+(if (zerop n)
+(goto-char (diff-hunk-min diff-current-hunk))
+(let ((narrow (diff-buffer-narrowed-p))
+	  (max (point-max))
+	  (min (point-min)))
+(unwind-protect
+	  (progn
+	    (widen)
+	    (setq diff-current-hunk (+ n diff-current-hunk))
+	    (cond ((> diff-current-hunk diff-total-hunks)
+		   (setq diff-current-hunk diff-total-hunks)
+		   (message "No following difference hunks."))
+		  ((< diff-current-hunk 0)
+		   (setq diff-current-hunk 0)
+		   (message "No preceding difference hunks.")))
+	    (setq diff-current-difference (int-to-string diff-current-hunk)
+		  min (goto-char (diff-hunk-min diff-current-hunk))
+		  max (diff-hunk-max diff-current-hunk)))
+	(if narrow (narrow-to-region min max))))
+(set-buffer-modified-p (buffer-modified-p))))
+(defun diff-previous-difference (n)
+"In diff-mode go the the beginning of the previous difference hunk."
+(interactive "p")
+(diff-next-difference (- n)))
+(defun diff-next-line (n)
+"In diff-mode go to the next line."
+(interactive "p")
+(condition-case nil
+(next-line n)
+(error (if (> n 0) (message "End of difference hunk"))))
+(diff-update-modeline))
+(defun diff-previous-line (n)
+"In diff-mode go to the previous line."
+(interactive "p")
+(diff-next-line (- n)))
+(defun diff-forward-char (n)
+"In diff-mode move the point forward."
+(interactive "p")
+(forward-char n)
+(diff-update-modeline))
+(defun diff-backward-char (n)
+"In diff-mode move the point backward."
+(interactive "p")
+(backward-char n)
+(diff-update-modeline))
+(defun diff-scroll-up (n)
+"In diff-mode scroll the buffer up."
+(interactive "P")
+(scroll-up n)
+(diff-update-modeline))
+(fset 'diff-advertised-scroll-up 'diff-scroll-up)
+(defun diff-scroll-down (n)
+"In diff-mode scroll the buffer down."
+(interactive "P")
+(scroll-down n)
+(diff-update-modeline))
+(fset 'diff-advertised-scroll-down 'diff-scroll-down)
+(defun diff-beginning-of-buffer (n)
+"In diff-mode go to the beginning of the buffer."
+(interactive "P")
+(beginning-of-buffer n)
+(diff-update-modeline))
+(defun diff-end-of-buffer (n)
+"In diff-mode go to the end of the buffer."
+(interactive "P")
+(end-of-buffer n)
+(diff-update-modeline))
+;;; The main command.
+(defun diff (old new &optional switches)
+"Find and display the differences between OLD and NEW files.
+Interactively you are prompted with the current buffer's file name for NEW
+and what appears to be its backup for OLD."
+;; Support for diffing directories is rather limited.  It needs work.
+(interactive (diff-read-args "Diff original file (%s) "
+			       "Diff new file (%s) "
+			       "Switches for diff (%s) "
+			       (buffer-file-name)))
+(setq switches (diff-fix-switches (or switches diff-switches))
+	old (expand-file-name old)
+	new (expand-file-name new))
+(let ((curr-buff (current-buffer))
+	doing-dirs old-temp new-temp old-buffer new-buffer flag)
+(let ((fdp-old (file-directory-p old))
+	  (fdp-new (file-directory-p new)))
+(cond
+((null (or fdp-new fdp-old)))
+((null fdp-new)
+	(setq old (expand-file-name (file-name-nondirectory new) old)))
+((null fdp-old)
+	(setq new (expand-file-name (file-name-nondirectory old) new)))
+(t (setq doing-dirs t))))
+;;    (message "diff %s %s %s..."
+;;	     (mapconcat (function identity) switches " ") new old)
+(message "diff %s %s %s..."
+	     (mapconcat (function identity) switches " ") old new)
+(if doing-dirs
+	(setq diff-old-file nil
+	      diff-new-file nil)
+(setq old-temp (make-temp-name (concat diff-temp-template "1"))
+	    new-temp (make-temp-name (concat diff-temp-template "2"))
+	    old-buffer (diff-get-file-buffer old)
+	    new-buffer (diff-get-file-buffer new)
+	    diff-old-file (cons old (cdr old-buffer))
+	    diff-new-file (cons new (cdr new-buffer))))
+(let (case-fold-search)
+(mapcar (function
+	       (lambda (x)
+		 (if (string-match "[ecu]" x)
+		     (setq flag (aref x (match-beginning 0))))))
+	      switches))
+(unwind-protect
+	(let ((patterns (assq flag diff-search-pattern-alist)))
+	  (set-buffer (get-buffer-create "*Diff Output*"))
+	  (setq default-directory (file-name-directory new)
+		diff-old-file-pattern (nth 2 patterns)
+		diff-new-file-pattern (nth 3 patterns)
+		diff-hunk-pattern (nth 1 patterns))
+	  (let (buffer-read-only)
+	    (if (fboundp 'buffer-disable-undo)
+		(buffer-disable-undo (current-buffer))
+	      ;; old style (Emacs 18.55 and earlier)
+	      (buffer-disable-undo (current-buffer)))
+	    (widen)
+	    (erase-buffer)
+	    (if doing-dirs
+		(progn
+		  (diff-run-diff switches old old new new)
+		  (setq diff-hunk-pattern (concat diff-hunk-pattern
+						  "\\|^Only in ")))
+	      (save-excursion
+		(set-buffer (car old-buffer))
+		(write-region (point-min) (point-max) old-temp nil 'quiet)
+		(set-buffer (car new-buffer))
+		(write-region (point-min) (point-max) new-temp nil 'quiet))
+	      (diff-run-diff switches old old-temp new new-temp))
+	    ;; Need to replace file names
+	    (if (and (not doing-dirs) (memq flag '(?c ?u)))
+		(diff-fix-file-names old old-temp new new-temp
+				     diff-hunk-pattern))
+	    (diff-mode)
+	    (goto-char (point-min))
+	    (setq diff-current-difference "0"
+		  diff-current-hunk 0)
+	    (if (zerop diff-total-hunks)
+		(progn
+		  (diff-cleanup-buffers)
+		  (message "No differences"))
+	      (if diff-do-narrow (narrow-to-region (point) (diff-hunk-max 0)))
+	      (display-buffer (current-buffer))
+	      (message "%s difference hunk%s" diff-total-differences
+		       (if (= diff-total-hunks 1) "" "s")))))
+(condition-case nil
+	  (delete-file old-temp)
+	(error nil))
+(condition-case nil
+	  (delete-file new-temp)
+	(error nil))
+(set-buffer curr-buff))))
+(defun diff-backup (file &optional switches)
+"Diff this file with its backup file or vice versa.
+Uses the latest backup, if there are several numerical backups.
+If this file is a backup, diff it with its original.
+The backup file is the first file given to `diff'."
+(interactive (list (read-file-name "Diff (file with backup): ")
+		     (and current-prefix-arg
+			  (diff-read-switches "Diff switches: "))))
+(let (bak ori)
+(if (backup-file-name-p file)
+	(setq bak file
+	      ori (file-name-sans-versions file))
+(setq bak (or (diff-latest-backup-file file)
+		    (error "No backup found for %s" file))
+	    ori file))
+(diff bak ori switches)))
+(defun diff-show-difference (n)
+"Show difference number N (prefix argument)."
+(interactive "p")
+(let ((narrowedp (diff-buffer-narrowed-p))
+	(min (diff-hunk-min diff-current-hunk))
+	(max (diff-hunk-max diff-current-hunk)))
+(unwind-protect
+	(progn
+	  (widen)
+	  (cond
+	   ((< n 0)
+	    (message "No negative hunks.")
+	    (setq n 0))
+	   ((> n diff-total-hunks)
+	    (message "No hunk %d." n)
+	    (setq n diff-total-hunks)))
+	  (setq diff-current-hunk n
+		diff-current-difference (int-to-string diff-current-hunk)
+		min (diff-hunk-min n)
+		max (diff-hunk-max n))
+	  (goto-char min))
+(if narrowedp (narrow-to-region min max))
+(set-buffer-modified-p (buffer-modified-p)))))
+(defun diff-show-header ()
+"Show `diff-header'."
+(interactive)
+(with-output-to-temp-buffer "*Diff Header*"
+(princ (save-restriction
+	     (widen)
+	     (buffer-substring (diff-hunk-min 0) (diff-hunk-max 0))))))
+(defun diff-find-file (old-file-p)
+"Visit diffed file, at the point corresponding to the current hunk.
+Default is to visit the new file; prefix means visit old file instead."
+(interactive "P")
+(let ((line (diff-file-line old-file-p)))
+(find-file
+(if old-file-p
+	 (car diff-old-file)
+(car diff-new-file)))
+(goto-line line)
+(recenter 0)))
+(defun diff-find-file-other-window (old-file-p)
+"Visit the diffed file in other window, with the point at the current hunk.
+Default is to visit the new file; prefix means visit the old file instead."
+(interactive "P")
+(let ((line (diff-file-line old-file-p)))
+(find-file-other-window
+(if old-file-p
+	 (car diff-old-file)
+(car diff-new-file)))
+(goto-line line)
+(recenter 0)))
+(defun diff-find-file-other-frame (old-file-p)
+"Visit the diffed file in other frame, with point at the current hunk.
+Default is to visit the new file; prefix means visit the old file instead."
+(interactive "P")
+(let ((line (diff-file-line old-file-p)))
+(find-file-other-frame
+(if old-file-p
+	 (car diff-old-file)
+(car diff-new-file)))
+(goto-line line)
+(recenter 0)))
+(defun diff-display-file (old-file-p)
+"Display the diffed file in other window, with point at the current hunk.
+Default is to visit the new file; prefix means visit the old file instead."
+(interactive "P")
+(let ((line (diff-file-line old-file-p))
+	(wind (display-buffer (find-file-noselect (if old-file-p
+						      (car diff-old-file)
+						    (car diff-new-file)))))
+	(curr-wind (selected-window)))
+(unwind-protect
+	(progn
+	  (select-window wind)
+	  (goto-line line)
+	  (recenter 0))
+(select-window curr-wind))))
+(defun diff-quit ()
+"Quit diff by killing the diff buffer."
+(interactive)
+(kill-buffer "*Diff Output*")
+(diff-cleanup-buffers))
+(defun diff-narrow ()
+"Narrow diff buffer to current difference hunk."
+(interactive)
+(narrow-to-region (diff-hunk-min diff-current-hunk)
+		    (diff-hunk-max diff-current-hunk)))
+;;; Run any load hooks
+(run-hooks 'diff-load-hook)
+;;; end of diff.el

Mercurial > hg > xemacs-beta

comparison lisp/packages/diff.el @ 100:4be1180a9e89 r20-1b2