;;; ediff-util.el --- the core commands and utilities of ediff
-;;; Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+
+;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
;; Author: Michael Kifer <kifer@cs.sunysb.edu>
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 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.
;;; Code:
+
+(provide 'ediff-util)
+
+;; Compiler pacifier
+(defvar ediff-patch-diagnostics)
+(defvar ediff-patchbufer)
+(defvar ediff-toolbar)
+(defvar ediff-toolbar-3way)
+(defvar bottom-toolbar)
+(defvar bottom-toolbar-visible-p)
+(defvar bottom-toolbar-height)
+(defvar mark-active)
+
+(eval-when-compile
+ (let ((load-path (cons (expand-file-name ".") load-path)))
+ (or (featurep 'ediff-init)
+ (load "ediff-init.el" nil nil 'nosuffix))
+ (or (featurep 'ediff-help)
+ (load "ediff-help.el" nil nil 'nosuffix))
+ (or (featurep 'ediff-mult)
+ (load "ediff-mult.el" nil nil 'nosuffix))
+ (or (featurep 'ediff-wind)
+ (load "ediff-wind.el" nil nil 'nosuffix))
+ (or (featurep 'ediff-diff)
+ (load "ediff-diff.el" nil nil 'nosuffix))
+ (or (featurep 'ediff-merg)
+ (load "ediff-merg.el" nil nil 'nosuffix))
+ (or (featurep 'ediff)
+ (load "ediff.el" nil nil 'nosuffix))
+ (or (featurep 'ediff-tbar)
+ ediff-emacs-p
+ (load "ediff-tbar.el" 'noerror nil 'nosuffix))
+ ))
+;; end pacifier
+
(require 'ediff-init)
+(require 'ediff-help)
+(require 'ediff-mult)
+(require 'ediff-wind)
+(require 'ediff-diff)
+(require 'ediff-merg)
+
+(if ediff-xemacs-p
+ (require 'ediff-tbar))
\f
;;; Functions
(defun ediff-mode ()
- "Ediff mode is used by the Ediff file-difference package.
-It is entered only through one of the following commands:
+ "Ediff mode controls all operations in a single Ediff session.
+This mode is entered through one of the following commands:
`ediff'
`ediff-files'
`ediff-buffers'
+ `ebuffers'
`ediff3'
`ediff-files3'
`ediff-buffers3'
+ `ebuffers3'
`ediff-merge'
`ediff-merge-files'
`ediff-merge-files-with-ancestor'
`ediff-patch-file'
`ediff-patch-buffer'
`epatch-buffer'
+ `erevision'
`ediff-revision'
Commands:
(kill-all-local-variables)
(setq major-mode 'ediff-mode)
(setq mode-name "Ediff")
- (run-hooks 'ediff-mode-hooks))
+ (run-hooks 'ediff-mode-hook))
-(defun ediff-version ()
- "Return string describing the version of Ediff.
-When called interactively, displays the version."
- (interactive)
- (if (interactive-p)
- (message (ediff-version))
- (format "Ediff %s of %s" ediff-version ediff-date)))
-
-(require 'ediff-diff)
-(require 'ediff-merg)
-
\f
;;; Build keymaps
(setq ediff-mode-map (make-sparse-keymap))
(suppress-keymap ediff-mode-map)
+ (define-key ediff-mode-map
+ (if ediff-emacs-p [mouse-2] [button2]) 'ediff-help-for-quick-help)
+ (define-key ediff-mode-map "\C-m" 'ediff-help-for-quick-help)
+
(define-key ediff-mode-map "p" 'ediff-previous-difference)
(define-key ediff-mode-map "\C-?" 'ediff-previous-difference)
- (define-key ediff-mode-map [backspace] 'ediff-previous-difference)
(define-key ediff-mode-map [delete] 'ediff-previous-difference)
(define-key ediff-mode-map "\C-h" (if ediff-no-emacs-help-in-control-buffer
'ediff-previous-difference nil))
- (define-key ediff-mode-map [f1] (if ediff-no-emacs-help-in-control-buffer
- 'ediff-previous-difference nil))
- (define-key ediff-mode-map [help] (if ediff-no-emacs-help-in-control-buffer
- 'ediff-previous-difference nil))
+ ;; must come after C-h, or else C-h wipes out backspace's binding in XEmacs
+ (define-key ediff-mode-map [backspace] 'ediff-previous-difference)
(define-key ediff-mode-map "n" 'ediff-next-difference)
(define-key ediff-mode-map " " 'ediff-next-difference)
(define-key ediff-mode-map "j" 'ediff-jump-to-difference)
(define-key ediff-mode-map "ga" 'ediff-jump-to-difference-at-point)
(define-key ediff-mode-map "gb" 'ediff-jump-to-difference-at-point)
(define-key ediff-mode-map "q" 'ediff-quit)
+ (define-key ediff-mode-map "D" 'ediff-show-diff-output)
(define-key ediff-mode-map "z" 'ediff-suspend)
(define-key ediff-mode-map "\C-l" 'ediff-recenter)
(define-key ediff-mode-map "|" 'ediff-toggle-split)
(define-key ediff-mode-map "<" 'ediff-scroll-horizontally)
(define-key ediff-mode-map ">" 'ediff-scroll-horizontally)
(define-key ediff-mode-map "i" 'ediff-status-info)
- (define-key ediff-mode-map "D" 'ediff-documentation)
+ (define-key ediff-mode-map "E" 'ediff-documentation)
(define-key ediff-mode-map "?" 'ediff-toggle-help)
(define-key ediff-mode-map "!" 'ediff-update-diffs)
+ (define-key ediff-mode-map "M" 'ediff-show-current-session-meta-buffer)
+ (define-key ediff-mode-map "R" 'ediff-show-registry)
(or ediff-word-mode
(define-key ediff-mode-map "*" 'ediff-make-or-kill-fine-diffs))
(define-key ediff-mode-map "a" nil)
(define-key ediff-mode-map "b" nil)
(define-key ediff-mode-map "r" nil)
(cond (ediff-merge-job
+ ;; Will barf if no ancestor
+ (define-key ediff-mode-map "/" 'ediff-show-ancestor)
;; In merging, we allow only A->C and B->C copying.
- (define-key ediff-mode-map "a" (function
- (lambda (arg)
- (interactive "P")
- (ediff-diff-to-diff arg "ac"))))
- (define-key ediff-mode-map "b" (function
- (lambda (arg)
- (interactive "P")
- (ediff-diff-to-diff arg "bc"))))
- (define-key ediff-mode-map "r" (function
- (lambda (arg)
- (interactive "P")
- (ediff-restore-diff arg ?c))))
+ (define-key ediff-mode-map "a" 'ediff-copy-A-to-C)
+ (define-key ediff-mode-map "b" 'ediff-copy-B-to-C)
+ (define-key ediff-mode-map "r" 'ediff-restore-diff-in-merge-buffer)
(define-key ediff-mode-map "s" 'ediff-shrink-window-C)
(define-key ediff-mode-map "+" 'ediff-combine-diffs)
(define-key ediff-mode-map "$" 'ediff-toggle-show-clashes-only)
(define-key ediff-mode-map "&" 'ediff-re-merge))
(ediff-3way-comparison-job
- (define-key ediff-mode-map "ab" 'ediff-diff-to-diff)
- (define-key ediff-mode-map "ba" 'ediff-diff-to-diff)
- (define-key ediff-mode-map "ac" 'ediff-diff-to-diff)
- (define-key ediff-mode-map "bc" 'ediff-diff-to-diff)
+ (define-key ediff-mode-map "ab" 'ediff-copy-A-to-B)
+ (define-key ediff-mode-map "ba" 'ediff-copy-B-to-A)
+ (define-key ediff-mode-map "ac" 'ediff-copy-A-to-C)
+ (define-key ediff-mode-map "bc" 'ediff-copy-B-to-C)
(define-key ediff-mode-map "c" nil)
- (define-key ediff-mode-map "ca" 'ediff-diff-to-diff)
- (define-key ediff-mode-map "cb" 'ediff-diff-to-diff)
+ (define-key ediff-mode-map "ca" 'ediff-copy-C-to-A)
+ (define-key ediff-mode-map "cb" 'ediff-copy-C-to-B)
(define-key ediff-mode-map "ra" 'ediff-restore-diff)
(define-key ediff-mode-map "rb" 'ediff-restore-diff)
(define-key ediff-mode-map "rc" 'ediff-restore-diff)
(define-key ediff-mode-map "C" 'ediff-toggle-read-only))
(t ; 2-way comparison
- (define-key ediff-mode-map "a" (function
- (lambda (arg)
- (interactive "P")
- (ediff-diff-to-diff arg "ab"))))
- (define-key ediff-mode-map "b" (function
- (lambda (arg)
- (interactive "P")
- (ediff-diff-to-diff arg "ba"))))
+ (define-key ediff-mode-map "a" 'ediff-copy-A-to-B)
+ (define-key ediff-mode-map "b" 'ediff-copy-B-to-A)
(define-key ediff-mode-map "ra" 'ediff-restore-diff)
(define-key ediff-mode-map "rb" 'ediff-restore-diff))
) ; cond
(define-key ediff-mode-map "wa" 'ediff-save-buffer)
(define-key ediff-mode-map "wb" 'ediff-save-buffer)
(define-key ediff-mode-map "wd" 'ediff-save-buffer)
+ (define-key ediff-mode-map "=" 'ediff-inferior-compare-regions)
+ (if (fboundp 'ediff-show-patch-diagnostics)
+ (define-key ediff-mode-map "P" 'ediff-show-patch-diagnostics))
(if ediff-3way-job
(progn
(define-key ediff-mode-map "wc" 'ediff-save-buffer)
(define-key ediff-mode-map "m" 'ediff-toggle-wide-display)
- (define-key ediff-mode-map "k" nil)
- (define-key ediff-mode-map "kkk" 'ediff-reload-keymap) ; for debugging
-
;; Allow ediff-mode-map to be referenced indirectly
(fset 'ediff-mode-map ediff-mode-map)
- (run-hooks 'ediff-keymap-setup-hooks))
+ (run-hooks 'ediff-keymap-setup-hook))
;;; Setup functions
-(require 'ediff-wind)
-
-;; Common startup entry for all Ediff functions
-;; It now returns control buffer so other functions can do post-processing
+;; Common startup entry for all Ediff functions It now returns control buffer
+;; so other functions can do post-processing SETUP-PARAMETERS is a list of the
+;; form ((param .val) (param . val)...) This serves a similar purpose to
+;; STARTUP-HOOKS, but these parameters are set in the new control buffer right
+;; after this buf is created and before any windows are set and such.
(defun ediff-setup (buffer-A file-A buffer-B file-B buffer-C file-C
- startup-hooks setup-parameters)
- (setq file-A (expand-file-name file-A))
- (setq file-B (expand-file-name file-B))
+ startup-hooks setup-parameters
+ &optional merge-buffer-file)
+ ;; ediff-convert-standard-filename puts file names in the form appropriate
+ ;; for the OS at hand.
+ (setq file-A (ediff-convert-standard-filename (expand-file-name file-A)))
+ (setq file-B (ediff-convert-standard-filename (expand-file-name file-B)))
(if (stringp file-C)
- (setq file-C (expand-file-name file-C)))
+ (setq file-C
+ (ediff-convert-standard-filename (expand-file-name file-C))))
+ (if (stringp merge-buffer-file)
+ (progn
+ (setq merge-buffer-file
+ (ediff-convert-standard-filename
+ (expand-file-name merge-buffer-file)))
+ ;; check the directory exists
+ (or (file-exists-p (file-name-directory merge-buffer-file))
+ (error "Directory %s given as place to save the merge doesn't exist."
+ (abbreviate-file-name
+ (file-name-directory merge-buffer-file))))
+ (if (and (file-exists-p merge-buffer-file)
+ (file-directory-p merge-buffer-file))
+ (error "The merge buffer file %s must not be a directory"
+ (abbreviate-file-name merge-buffer-file)))
+ ))
(let* ((control-buffer-name
(ediff-unique-buffer-name "*Ediff Control Panel" "*"))
- (control-buffer (ediff-eval-in-buffer buffer-A
+ (control-buffer (ediff-with-current-buffer buffer-A
(get-buffer-create control-buffer-name))))
- (ediff-eval-in-buffer control-buffer
+ (ediff-with-current-buffer control-buffer
(ediff-mode)
+
+ (make-local-variable 'ediff-use-long-help-message)
+ (make-local-variable 'ediff-prefer-iconified-control-frame)
+ (make-local-variable 'ediff-split-window-function)
+ (make-local-variable 'ediff-default-variant)
+ (make-local-variable 'ediff-merge-window-share)
+ (make-local-variable 'ediff-window-setup-function)
+ (make-local-variable 'ediff-keep-variants)
;; unwrap set up parameters passed as argument
(while setup-parameters
(setq setup-parameters (cdr setup-parameters)))
;; set variables classifying the current ediff job
+ ;; must come AFTER setup-parameters
(setq ediff-3way-comparison-job (ediff-3way-comparison-job)
ediff-merge-job (ediff-merge-job)
ediff-merge-with-ancestor-job (ediff-merge-with-ancestor-job)
ediff-narrow-job (ediff-narrow-job)
ediff-windows-job (ediff-windows-job)
ediff-word-mode-job (ediff-word-mode-job))
-
- (make-local-variable 'ediff-prefer-long-help-message)
- (make-local-variable 'ediff-prefer-iconified-control-frame)
- (make-local-variable 'ediff-split-window-function)
- (make-local-variable 'ediff-default-variant)
- (make-local-variable 'ediff-merge-window-share)
- (make-local-variable 'ediff-window-setup-function)
+
+ ;; Don't delete variants in case of ediff-buffer-* jobs without asking.
+ ;; This is because u may loose work---dangerous.
+ (if (string-match "buffer" (symbol-name ediff-job-name))
+ (setq ediff-keep-variants t))
+
+ (make-local-hook 'pre-command-hook)
+ (if (ediff-window-display-p)
+ (add-hook 'pre-command-hook 'ediff-spy-after-mouse nil t))
+ (setq ediff-mouse-pixel-position (mouse-pixel-position))
;; adjust for merge jobs
(if ediff-merge-job
(let ((buf
- ;; Use buf A even if `combined'. The right stuff is
+ ;; If default variant is `combined', the right stuff is
;; inserted by ediff-do-merge
- (if (eq ediff-default-variant 'default-B) buffer-B buffer-A)))
+ ;; Note: at some point, we tried to put ancestor buffer here
+ ;; (which is currently buffer C. This didn't work right
+ ;; because the merge buffer will contain lossage: diff regions
+ ;; in the ancestor, which correspond to revisions that agree
+ ;; in both buf A and B.
+ (cond ((eq ediff-default-variant 'default-B)
+ buffer-B)
+ (t buffer-A))))
(setq ediff-split-window-function
ediff-merge-split-window-function)
(save-excursion
(set-buffer buffer-C)
(insert-buffer buf)
- (funcall (ediff-eval-in-buffer buf major-mode))
- ;; after Stig@hackvan.com
- (add-hook 'local-write-file-hooks 'ediff-set-merge-mode)
+ (funcall (ediff-with-current-buffer buf major-mode))
+ (add-hook 'local-write-file-hooks 'ediff-set-merge-mode nil t)
)))
(setq buffer-read-only nil
ediff-buffer-A buffer-A
(string-match "[0-9]+" ediff-control-buffer-suffix)
0))))))
- (setq ediff-error-buffer (get-buffer-create (ediff-unique-buffer-name
- "*ediff-errors" "*")))
+ (setq ediff-error-buffer
+ (get-buffer-create (ediff-unique-buffer-name "*ediff-errors" "*")))
- (ediff-eval-in-buffer buffer-A (ediff-strip-mode-line-format))
- (ediff-eval-in-buffer buffer-B (ediff-strip-mode-line-format))
+ (ediff-with-current-buffer buffer-A (ediff-strip-mode-line-format))
+ (ediff-with-current-buffer buffer-B (ediff-strip-mode-line-format))
(if ediff-3way-job
- (ediff-eval-in-buffer buffer-C (ediff-strip-mode-line-format)))
+ (ediff-with-current-buffer buffer-C (ediff-strip-mode-line-format)))
+ (if (ediff-buffer-live-p ediff-ancestor-buffer)
+ (ediff-with-current-buffer ediff-ancestor-buffer
+ (ediff-strip-mode-line-format)))
(ediff-save-protected-variables) ; save variables to be restored on exit
(or ediff-narrow-bounds
(setq ediff-narrow-bounds ediff-wide-bounds))
- ;; All these must be inside ediff-eval-in-buffer control-buffer,
+ ;; All these must be inside ediff-with-current-buffer control-buffer,
;; since these vars are local to control-buffer
;; These won't run if there are errors in diff
- (ediff-eval-in-buffer ediff-buffer-A
+ (ediff-with-current-buffer ediff-buffer-A
(ediff-nuke-selective-display)
- (run-hooks 'ediff-prepare-buffer-hooks)
- (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
+ (run-hooks 'ediff-prepare-buffer-hook)
+ (if (ediff-with-current-buffer control-buffer ediff-merge-job)
(setq buffer-read-only t))
;; add control-buffer to the list of sessions--no longer used, but may
;; be used again in the future
- (or (memq control-buffer ediff-this-buffer-control-sessions)
- (setq ediff-this-buffer-control-sessions
- (cons control-buffer ediff-this-buffer-control-sessions)))
+ (or (memq control-buffer ediff-this-buffer-ediff-sessions)
+ (setq ediff-this-buffer-ediff-sessions
+ (cons control-buffer ediff-this-buffer-ediff-sessions)))
+ (if ediff-make-buffers-readonly-at-startup
+ (setq buffer-read-only t))
)
- (ediff-eval-in-buffer ediff-buffer-B
+
+ (ediff-with-current-buffer ediff-buffer-B
(ediff-nuke-selective-display)
- (run-hooks 'ediff-prepare-buffer-hooks)
- (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
+ (run-hooks 'ediff-prepare-buffer-hook)
+ (if (ediff-with-current-buffer control-buffer ediff-merge-job)
(setq buffer-read-only t))
;; add control-buffer to the list of sessions
- (or (memq control-buffer ediff-this-buffer-control-sessions)
- (setq ediff-this-buffer-control-sessions
- (cons control-buffer ediff-this-buffer-control-sessions)))
+ (or (memq control-buffer ediff-this-buffer-ediff-sessions)
+ (setq ediff-this-buffer-ediff-sessions
+ (cons control-buffer ediff-this-buffer-ediff-sessions)))
+ (if ediff-make-buffers-readonly-at-startup
+ (setq buffer-read-only t))
)
+
(if ediff-3way-job
- (ediff-eval-in-buffer ediff-buffer-C
+ (ediff-with-current-buffer ediff-buffer-C
(ediff-nuke-selective-display)
- (run-hooks 'ediff-prepare-buffer-hooks)
+ (run-hooks 'ediff-prepare-buffer-hook)
;; add control-buffer to the list of sessions
- (or (memq control-buffer ediff-this-buffer-control-sessions)
- (setq ediff-this-buffer-control-sessions
+ (or (memq control-buffer ediff-this-buffer-ediff-sessions)
+ (setq ediff-this-buffer-ediff-sessions
+ (cons control-buffer
+ ediff-this-buffer-ediff-sessions)))
+ (if ediff-make-buffers-readonly-at-startup
+ (setq buffer-read-only t))
+ ))
+
+ (if (ediff-buffer-live-p ediff-ancestor-buffer)
+ (ediff-with-current-buffer ediff-ancestor-buffer
+ (ediff-nuke-selective-display)
+ (setq buffer-read-only t)
+ (run-hooks 'ediff-prepare-buffer-hook)
+ (or (memq control-buffer ediff-this-buffer-ediff-sessions)
+ (setq ediff-this-buffer-ediff-sessions
(cons control-buffer
- ediff-this-buffer-control-sessions)))
+ ediff-this-buffer-ediff-sessions)))
))
;; must come after setting up ediff-narrow-bounds AND after
(ediff-make-current-diff-overlay 'B)
(if ediff-3way-job
(ediff-make-current-diff-overlay 'C))
-
- (if (ediff-window-display-p)
- (ediff-init-var-faces))
+ (if ediff-merge-with-ancestor-job
+ (ediff-make-current-diff-overlay 'Ancestor))
(ediff-setup-windows buffer-A buffer-B buffer-C control-buffer)
(select-window ediff-control-window)
(ediff-visible-region)
- ;; The following is a hack to placate OS/2
- ;; The problem is that OS/2 doesn't let us delete files used by other
- ;; processes. Thus, in ediff-buffers and other functions, we can't
- ;; delete temp files because they might be used by the asynchronous
- ;; process that computes custom diffs. So, under OS/1 we have to wait
- ;; for some time until custom diffs are done.
- (if (eq system-type 'emx)
- (ediff-eval-in-buffer ediff-custom-diff-buffer
- (let ((proc (get-buffer-process (current-buffer))))
- (while (and (processp proc)
- (eq (process-status proc) 'run))
- (message "Waiting for the diff program to quit")
- (sleep-for 1))
- (message "")
- )))
-
- (run-hooks 'startup-hooks 'ediff-startup-hooks)
+ (run-hooks 'startup-hooks)
+ (ediff-arrange-autosave-in-merge-jobs merge-buffer-file)
+
(ediff-refresh-mode-lines)
- (setq buffer-read-only t))
+ (setq buffer-read-only t)
+ (setq ediff-session-registry
+ (cons control-buffer ediff-session-registry))
+ (ediff-update-registry)
+ (if (ediff-buffer-live-p ediff-meta-buffer)
+ (ediff-update-meta-buffer
+ ediff-meta-buffer nil ediff-meta-session-number))
+ (run-hooks 'ediff-startup-hook)
+ ) ; eval in control-buffer
control-buffer))
(shrink-window-if-larger-than-buffer)
(or (ediff-multiframe-setup-p)
(ediff-indent-help-message))
+ (ediff-set-help-overlays)
+
(set-buffer-modified-p nil)
(ediff-refresh-mode-lines)
(setq ediff-control-window (selected-window))
ediff-split-window-function
(ediff-multiframe-setup-p)
ediff-wide-display-p))
+
+ ;; In multiframe, toolbar is set in ediff-setup-control-frame
+ (if (not (ediff-multiframe-setup-p))
+ (ediff-make-bottom-toolbar)) ; this checks if toolbar is requested
(goto-char (point-min))
(skip-chars-forward ediff-whitespace)))
-;; assuming we are in control window, calculate length of the first line in
-;; help message
-(defun ediff-help-message-line-length ()
- (save-excursion
- (goto-char (point-min))
- (if ediff-prefer-long-help-message
- (next-line 1))
- (end-of-line)
- (current-column)))
-
-
-(defun ediff-indent-help-message ()
- (let* ((shift (/ (max 0 (- (window-width (selected-window))
- (ediff-help-message-line-length)))
- 2))
- (str (make-string shift ?\ )))
- (save-excursion
- (goto-char (point-min))
- (while (< (point) (point-max))
- (insert str)
- (beginning-of-line)
- (forward-line 1)))))
-
-
-(defun ediff-set-help-message ()
- (setq ediff-long-help-message
- (cond ((and ediff-long-help-message-custom
- (or (symbolp ediff-long-help-message-custom)
- (consp ediff-long-help-message-custom)))
- (funcall ediff-long-help-message-custom))
- (ediff-word-mode
- (concat ediff-long-help-message-head
- ediff-long-help-message-word-mode
- ediff-long-help-message-tail))
- (ediff-narrow-job
- (concat ediff-long-help-message-head
- ediff-long-help-message-narrow2
- ediff-long-help-message-tail))
- (ediff-merge-job
- (concat ediff-long-help-message-head
- ediff-long-help-message-merge
- ediff-long-help-message-tail))
- (ediff-diff3-job
- (concat ediff-long-help-message-head
- ediff-long-help-message-compare3
- ediff-long-help-message-tail))
- (t
- (concat ediff-long-help-message-head
- ediff-long-help-message-compare2
- ediff-long-help-message-tail))))
- (setq ediff-brief-help-message
- (cond ((and ediff-brief-help-message-custom
- (or (symbolp ediff-brief-help-message-custom)
- (consp ediff-brief-help-message-custom)))
- (funcall ediff-brief-help-message-custom))
- ((stringp ediff-brief-help-message-custom)
- ediff-brief-help-message-custom)
- ((ediff-multiframe-setup-p) ediff-brief-message-string)
- (t ; long brief msg, not multiframe --- put in the middle
- ediff-brief-message-string)
- ))
- (setq ediff-help-message (if ediff-prefer-long-help-message
- ediff-long-help-message
- ediff-brief-help-message))
- (run-hooks 'ediff-display-help-hooks)
- )
-
-
+;; This executes in control buffer and sets auto-save, visited file name, etc,
+;; in the merge buffer
+(defun ediff-arrange-autosave-in-merge-jobs (merge-buffer-file)
+ (if (not ediff-merge-job)
+ ()
+ (if (stringp merge-buffer-file)
+ (setq ediff-autostore-merges t
+ ediff-merge-store-file merge-buffer-file))
+ (if (stringp ediff-merge-store-file)
+ (progn
+ ;; save before leaving ctl buffer
+ (setq merge-buffer-file ediff-merge-store-file)
+ (ediff-with-current-buffer ediff-buffer-C
+ (set-visited-file-name merge-buffer-file))))
+ (ediff-with-current-buffer ediff-buffer-C
+ (setq buffer-offer-save t) ; ask before killing buffer
+ ;; make sure the contents is auto-saved
+ (auto-save-mode 1))
+ ))
\f
;;; Commands for working with Ediff
to these buffers are not saved at this point---the user can do this later,
if necessary."
(interactive)
- (let ((point-A (ediff-eval-in-buffer ediff-buffer-A (point)))
- ;;(point-B (ediff-eval-in-buffer ediff-buffer-B (point)))
+ (ediff-barf-if-not-control-buffer)
+ (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
+ (not
+ (y-or-n-p
+ "Ancestor buffer will not be used. Recompute diffs anyway? ")))
+ (error "Recomputation of differences canceled"))
+
+ (let ((point-A (ediff-with-current-buffer ediff-buffer-A (point)))
+ ;;(point-B (ediff-with-current-buffer ediff-buffer-B (point)))
(tmp-buffer (get-buffer-create ediff-tmp-buffer))
- (buf-A-file-name
- (file-name-nondirectory (or (buffer-file-name ediff-buffer-A)
- (buffer-name ediff-buffer-A)
- )))
- (buf-B-file-name
- (file-name-nondirectory (or (buffer-file-name ediff-buffer-B)
- (buffer-name ediff-buffer-B)
- )))
- (buf-C-file-name
- (file-name-nondirectory (or (buffer-file-name ediff-buffer-C)
- ;; if (null ediff-buffer-C), there is
- ;; no danger, since we later check if
- ;; ediff-buffer-C is alive
- (buffer-name ediff-buffer-C)
- )))
+ (buf-A-file-name (buffer-file-name ediff-buffer-A))
+ (buf-B-file-name (buffer-file-name ediff-buffer-B))
+ ;; (null ediff-buffer-C) is no problem, as we later check if
+ ;; ediff-buffer-C is alive
+ (buf-C-file-name (buffer-file-name ediff-buffer-C))
(overl-A (ediff-get-value-according-to-buffer-type
'A ediff-narrow-bounds))
(overl-B (ediff-get-value-according-to-buffer-type
'C ediff-narrow-bounds))
beg-A end-A beg-B end-B beg-C end-C
file-A file-B file-C)
+
+ (if (stringp buf-A-file-name)
+ (setq buf-A-file-name (file-name-nondirectory buf-A-file-name)))
+ (if (stringp buf-B-file-name)
+ (setq buf-B-file-name (file-name-nondirectory buf-B-file-name)))
+ (if (stringp buf-C-file-name)
+ (setq buf-C-file-name (file-name-nondirectory buf-C-file-name)))
+
(ediff-unselect-and-select-difference -1)
(setq beg-A (ediff-overlay-start overl-A)
(if ediff-word-mode
(progn
(ediff-wordify beg-A end-A ediff-buffer-A tmp-buffer)
- (ediff-eval-in-buffer tmp-buffer
- (setq file-A (ediff-make-temp-file "regA")))
+ (setq file-A (ediff-make-temp-file tmp-buffer "regA"))
(ediff-wordify beg-B end-B ediff-buffer-B tmp-buffer)
- (ediff-eval-in-buffer tmp-buffer
- (setq file-B (ediff-make-temp-file "regB")))
+ (setq file-B (ediff-make-temp-file tmp-buffer "regB"))
(if ediff-3way-job
(progn
(ediff-wordify beg-C end-C ediff-buffer-C tmp-buffer)
- (ediff-eval-in-buffer tmp-buffer
- (setq file-C (ediff-make-temp-file "regC")))))
+ (setq file-C (ediff-make-temp-file tmp-buffer "regC"))))
)
;; not word-mode
- (ediff-eval-in-buffer ediff-buffer-A
- (setq file-A (ediff-make-temp-file buf-A-file-name)))
- (ediff-eval-in-buffer ediff-buffer-B
- (setq file-B (ediff-make-temp-file buf-B-file-name)))
+ (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name))
+ (setq file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
(if ediff-3way-job
- (ediff-eval-in-buffer ediff-buffer-C
- (setq file-C (ediff-make-temp-file buf-C-file-name))))
+ (setq file-C (ediff-make-temp-file ediff-buffer-C buf-C-file-name)))
)
(ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
(ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
(ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
+ (ediff-clear-diff-vector
+ 'ediff-difference-vector-Ancestor 'fine-diffs-also)
+ ;; let them garbage collect. we can't use the ancestor after recomputing
+ ;; the diffs.
+ (setq ediff-difference-vector-Ancestor nil
+ ediff-ancestor-buffer nil
+ ediff-state-of-merge nil)
+
(setq ediff-killed-diffs-alist nil) ; invalidate saved killed diff regions
- ;; In case of merge job, full it into thinking that it is just doing
+ ;; In case of merge job, fool it into thinking that it is just doing
;; comparison
(let ((ediff-setup-diff-regions-function ediff-setup-diff-regions-function)
+ (ediff-3way-comparison-job ediff-3way-comparison-job)
+ (ediff-merge-job ediff-merge-job)
+ (ediff-merge-with-ancestor-job ediff-merge-with-ancestor-job)
(ediff-job-name ediff-job-name))
(if ediff-merge-job
(setq ediff-setup-diff-regions-function 'ediff-setup-diff-regions3
+ ediff-3way-comparison-job t
+ ediff-merge-job nil
+ ediff-merge-with-ancestor-job nil
ediff-job-name 'ediff-files3))
(funcall ediff-setup-diff-regions-function file-A file-B file-C))
(defun ediff-revert-buffers-then-recompute-diffs (noconfirm)
"Revert buffers A, B and C. Then rerun Ediff on file A and file B."
(interactive "P")
+ (ediff-barf-if-not-control-buffer)
(let ((bufA ediff-buffer-A)
(bufB ediff-buffer-B)
(bufC ediff-buffer-C)
(ctl-buf ediff-control-buffer)
+ (keep-variants ediff-keep-variants)
(ancestor-buf ediff-ancestor-buffer)
(ancestor-job ediff-merge-with-ancestor-job)
(merge ediff-merge-job)
(comparison ediff-3way-comparison-job))
- (ediff-eval-in-buffer bufA
+ (ediff-with-current-buffer bufA
(revert-buffer t noconfirm))
- (ediff-eval-in-buffer bufB
+ (ediff-with-current-buffer bufB
(revert-buffer t noconfirm))
;; this should only be executed in a 3way comparison, not in merge
(if comparison
- (ediff-eval-in-buffer bufC
+ (ediff-with-current-buffer bufC
(revert-buffer t noconfirm)))
(if merge
(progn
(set-buffer ctl-buf)
- (ediff-really-quit)
+ ;; the argument says whether to reverse the meaning of
+ ;; ediff-keep-variants, i.e., ediff-really-quit runs here with
+ ;; variants kept.
+ (ediff-really-quit (not keep-variants))
(kill-buffer bufC)
(if ancestor-job
(ediff-merge-buffers-with-ancestor bufA bufB ancestor-buf)
"Bring the highlighted region of all buffers being compared into view.
Reestablish the default three-window display."
(interactive)
-
- ;; force all minibuffer to display ediff's messages.
- ;; when xemacs implements minibufferless frames, this won't be necessary
- (if ediff-xemacs-p (setq synchronize-minibuffers t))
-
- (setq ediff-disturbed-overlays nil) ; clear after use
+ (ediff-barf-if-not-control-buffer)
(let (buffer-read-only)
(if (and (ediff-buffer-live-p ediff-buffer-A)
(ediff-buffer-live-p ediff-buffer-B)
(ediff-setup-windows
ediff-buffer-A ediff-buffer-B ediff-buffer-C ediff-control-buffer)
(or (eq this-command 'ediff-quit)
- (message
- "You've killed an essential Ediff buffer---Please quit Ediff"
- (beep 1)))
+ (message ediff-KILLED-VITAL-BUFFER
+ (beep 1)))
))
-
+
;; set visibility range appropriate to this invocation of Ediff.
(ediff-visible-region)
-
;; raise
(if (and (ediff-window-display-p)
(symbolp this-command)
;; Either one of the display-changing commands
(or (memq this-command
'(ediff-recenter
+ ediff-dir-action ediff-registry-action
+ ediff-patch-action
ediff-toggle-wide-display ediff-toggle-multiframe))
;; Or one of the movement cmds and prev cmd was an Ediff cmd
- ;; This avoids rasing frames unnecessarily.
+ ;; This avoids raising frames unnecessarily.
(and (memq this-command
'(ediff-next-difference
ediff-previous-difference
(raise-frame (window-frame ediff-window-C)))))
(if (and (ediff-window-display-p)
(frame-live-p ediff-control-frame)
+ (not ediff-use-long-help-message)
(not (ediff-frame-iconified-p ediff-control-frame)))
(raise-frame ediff-control-frame))
;; Redisplay whatever buffers are showing, if there is a selected difference
- (let* ((control-frame ediff-control-frame)
- (control-buf ediff-control-buffer))
+ (let ((control-frame ediff-control-frame)
+ (control-buf ediff-control-buffer))
(if (and (ediff-buffer-live-p ediff-buffer-A)
(ediff-buffer-live-p ediff-buffer-B)
(or (not ediff-3way-job)
- (ediff-buffer-live-p ediff-buffer-C))
- (ediff-valid-difference-p))
+ (ediff-buffer-live-p ediff-buffer-C)))
(progn
(or no-rehighlight
(ediff-select-difference ediff-current-difference))
-
+
(ediff-recenter-one-window 'A)
(ediff-recenter-one-window 'B)
(if ediff-3way-job
(ediff-recenter-one-window 'C))
- (if (and (ediff-multiframe-setup-p)
- (not (ediff-frame-iconified-p ediff-control-frame)))
- (progn
- (ediff-reset-mouse control-frame)
- (or ediff-xemacs-p
- (cond ((eq (ediff-device-type) 'ns)
- (unfocus-frame (selected-frame)))
- (t (unfocus-frame))))
- ))
+ (ediff-with-current-buffer control-buf
+ (ediff-recenter-ancestor) ; check if ancestor is alive
+
+ (if (and (ediff-multiframe-setup-p)
+ (not ediff-use-long-help-message)
+ (not (ediff-frame-iconified-p ediff-control-frame)))
+ ;; never grab mouse on quit in this place
+ (ediff-reset-mouse
+ control-frame
+ (eq this-command 'ediff-quit))))
))
- (ediff-eval-in-buffer control-buf
- (ediff-refresh-mode-lines))
+
+ (ediff-restore-highlighting)
+ (ediff-with-current-buffer control-buf (ediff-refresh-mode-lines))
))
;; this function returns to the window it was called from
;; (which was the control window)
(defun ediff-recenter-one-window (buf-type)
- (let* (;; context must be saved before switching to windows A/B/C
- (ctl-wind (selected-window))
- (shift (ediff-overlay-start
- (ediff-get-value-according-to-buffer-type
- buf-type ediff-narrow-bounds)))
- (job-name ediff-job-name)
- (control-buf ediff-control-buffer)
- (window-name (intern (format "ediff-window-%S" buf-type)))
- (window (if (window-live-p (symbol-value window-name))
- (symbol-value window-name))))
-
- (if (and window ediff-windows-job)
- (set-window-start window shift))
- (if window
- (progn
- (select-window window)
- (ediff-deactivate-mark)
- (ediff-position-region
- (ediff-get-diff-posn buf-type 'beg nil control-buf)
- (ediff-get-diff-posn buf-type 'end nil control-buf)
- (ediff-get-diff-posn buf-type 'beg nil control-buf)
- job-name
- )))
- (select-window ctl-wind)
- ))
+ (if (ediff-valid-difference-p)
+ ;; context must be saved before switching to windows A/B/C
+ (let* ((ctl-wind (selected-window))
+ (shift (ediff-overlay-start
+ (ediff-get-value-according-to-buffer-type
+ buf-type ediff-narrow-bounds)))
+ (job-name ediff-job-name)
+ (control-buf ediff-control-buffer)
+ (window-name (ediff-get-symbol-from-alist
+ buf-type ediff-window-alist))
+ (window (if (window-live-p (symbol-value window-name))
+ (symbol-value window-name))))
+
+ (if (and window ediff-windows-job)
+ (set-window-start window shift))
+ (if window
+ (progn
+ (select-window window)
+ (ediff-deactivate-mark)
+ (ediff-position-region
+ (ediff-get-diff-posn buf-type 'beg nil control-buf)
+ (ediff-get-diff-posn buf-type 'end nil control-buf)
+ (ediff-get-diff-posn buf-type 'beg nil control-buf)
+ job-name
+ )))
+ (select-window ctl-wind)
+ )))
+
+(defun ediff-recenter-ancestor ()
+ ;; do half-hearted job by recentering the ancestor buffer, if it is alive and
+ ;; visible.
+ (if (and (ediff-buffer-live-p ediff-ancestor-buffer)
+ (ediff-valid-difference-p))
+ (let ((window (ediff-get-visible-buffer-window ediff-ancestor-buffer))
+ (ctl-wind (selected-window))
+ (job-name ediff-job-name)
+ (ctl-buf ediff-control-buffer))
+ (ediff-with-current-buffer ediff-ancestor-buffer
+ (goto-char (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf))
+ (if window
+ (progn
+ (select-window window)
+ (ediff-position-region
+ (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
+ (ediff-get-diff-posn 'Ancestor 'end nil ctl-buf)
+ (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf)
+ job-name))))
+ (select-window ctl-wind)
+ )))
;; This will have to be refined for 3way jobs
"Toggle vertical/horizontal window split.
Does nothing if file-A and file-B are in different frames."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(let* ((wind-A (if (window-live-p ediff-window-A) ediff-window-A))
(wind-B (if (window-live-p ediff-window-B) ediff-window-B))
(wind-C (if (window-live-p ediff-window-C) ediff-window-C))
"Switch between highlighting using ASCII flags and highlighting using faces.
On a dumb terminal, switches between ASCII highlighting and no highlighting."
(interactive)
- (if (not (ediff-window-display-p))
+ (ediff-barf-if-not-control-buffer)
+ (if (not (ediff-has-face-support-p))
(if (eq ediff-highlighting-style 'ascii)
(progn
(message "ASCII highlighting flags removed")
ediff-highlight-all-diffs t)))
(if (and ediff-use-faces ediff-highlight-all-diffs)
- (if (not (face-differs-from-default-p 'ediff-odd-diff-face-A-var))
- (progn
- (copy-face ediff-odd-diff-face-A 'ediff-odd-diff-face-A-var)
- (copy-face ediff-odd-diff-face-B 'ediff-odd-diff-face-B-var)
- (copy-face ediff-odd-diff-face-C 'ediff-odd-diff-face-C-var)
- (copy-face ediff-even-diff-face-A 'ediff-even-diff-face-A-var)
- (copy-face ediff-even-diff-face-B 'ediff-even-diff-face-B-var)
- (copy-face ediff-even-diff-face-C 'ediff-even-diff-face-C-var)
- ))
- (copy-face 'default 'ediff-odd-diff-face-A-var)
- (copy-face 'default 'ediff-odd-diff-face-B-var)
- (copy-face 'default 'ediff-odd-diff-face-C-var)
- (copy-face 'default 'ediff-even-diff-face-A-var)
- (copy-face 'default 'ediff-even-diff-face-B-var)
- (copy-face 'default 'ediff-even-diff-face-C-var))
+ (ediff-paint-background-regions)
+ (ediff-paint-background-regions 'unhighlight))
(ediff-unselect-and-select-difference
ediff-current-difference 'select-only))
)
+
(defun ediff-toggle-autorefine ()
"Toggle auto-refine mode."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(if ediff-word-mode
(error "No fine differences in this mode"))
(cond ((eq ediff-auto-refine 'nix)
(message "Refinements are HIDDEN")
(setq ediff-auto-refine 'nix))
))
+
+(defun ediff-show-ancestor ()
+ "Show the ancestor buffer in a suitable window."
+ (interactive)
+ (ediff-recenter)
+ (or (ediff-buffer-live-p ediff-ancestor-buffer)
+ (if ediff-merge-with-ancestor-job
+ (error "Lost connection to ancestor buffer...sorry")
+ (error "Not merging with ancestor")))
+ (let (wind)
+ (cond ((setq wind (ediff-get-visible-buffer-window ediff-ancestor-buffer))
+ (raise-frame (window-frame wind)))
+ (t (set-window-buffer ediff-window-C ediff-ancestor-buffer)))))
(defun ediff-make-or-kill-fine-diffs (arg)
"Compute fine diffs. With negative prefix arg, kill fine diffs.
In both cases, operates on the currrent difference region."
(interactive "P")
+ (ediff-barf-if-not-control-buffer)
(cond ((eq arg '-)
(ediff-clear-fine-differences ediff-current-difference))
((and (numberp arg) (< arg 0))
(defun ediff-toggle-help ()
"Toggle short/long help message."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(let (buffer-read-only)
(erase-buffer)
- (setq ediff-prefer-long-help-message (not ediff-prefer-long-help-message))
+ (setq ediff-use-long-help-message (not ediff-use-long-help-message))
(ediff-set-help-message))
;; remember the icon status of the control frame when the user requested
;; full control message
- (if (and ediff-prefer-long-help-message (ediff-multiframe-setup-p))
+ (if (and ediff-use-long-help-message (ediff-multiframe-setup-p))
(setq ediff-prefer-iconified-control-frame
(ediff-frame-iconified-p ediff-control-frame)))
If optional argument BUF is specified, toggle read-only in that buffer instead
of the current buffer."
(interactive)
- (let ((ctl-buf (if (null buf) (current-buffer))))
+ (ediff-barf-if-not-control-buffer)
+ (let ((ctl-buf (if (null buf) (current-buffer)))
+ (buf-type (ediff-char-to-buftype last-command-char)))
(or buf (ediff-recenter))
(or buf
- (setq buf
- (ediff-get-buffer (ediff-char-to-buftype last-command-char))))
+ (setq buf (ediff-get-buffer buf-type)))
- (ediff-eval-in-buffer buf ; eval in buf A/B/C
+ (ediff-with-current-buffer buf ; eval in buf A/B/C
(let* ((file (buffer-file-name buf))
(file-writable (and file
(file-exists-p file)
(y-or-n-p
(format
"File %s is under version control. Check it out? "
- (abbreviate-file-name file))))
+ (ediff-abbreviate-file-name file))))
;; if we checked the file out, we should also change the
;; original state of buffer-read-only to nil. If we don't
;; do this, the mode line will show %%, since the file was
;; RO before ediff started, so the user will think the file
;; is checked in.
- (ediff-eval-in-buffer ctl-buf
+ (ediff-with-current-buffer ctl-buf
(ediff-change-saved-variable
- 'buffer-read-only nil
- (ediff-char-to-buftype last-command-char))))
+ 'buffer-read-only nil buf-type)))
(t
(setq toggle-ro-cmd 'toggle-read-only)
(beep 1) (beep 1)
(message
- "Boy, this is risky! Better don't change this file...")
- (sit-for 3))))
+ "Boy, this is risky! Don't modify this file...")
+ (sit-for 3)))) ; let the user see the warning
(if (and toggle-ro-cmd
(string-match "toggle-read-only" (symbol-name toggle-ro-cmd)))
(save-excursion
(save-window-excursion
+ (select-window (ediff-get-visible-buffer-window buf))
(command-execute toggle-ro-cmd)))
(error "Don't know how to toggle read-only in buffer %S" buf))
(file-exists-p file)
(not (file-writable-p file)))
(message "Warning: file %s is read-only"
- (abbreviate-file-name file) (beep 1)))
+ (ediff-abbreviate-file-name file) (beep 1)))
))))
-
-;; This is a simple-minded check for whether a file is under version control
-;; and is checked out.
+;; checkout if visited file is checked in
+(defun ediff-maybe-checkout (buf)
+ (let ((file (expand-file-name (buffer-file-name buf)))
+ (checkout-function (key-binding "\C-x\C-q")))
+ (if (and (ediff-file-checked-in-p file)
+ (or (beep 1) t)
+ (y-or-n-p
+ (format
+ "File %s is under version control. Check it out? "
+ (ediff-abbreviate-file-name file))))
+ (ediff-with-current-buffer buf
+ (command-execute checkout-function)))))
+
+
+;; This is a simple-minded check for whether a file is under version control.
;; If file,v exists but file doesn't, this file is considered to be not checked
;; in and not checked out for the purpose of patching (since patch won't be
;; able to read such a file anyway).
;; FILE is a string representing file name
+;;(defun ediff-file-under-version-control (file)
+;; (let* ((filedir (file-name-directory file))
+;; (file-nondir (file-name-nondirectory file))
+;; (trial (concat file-nondir ",v"))
+;; (full-trial (concat filedir trial))
+;; (full-rcs-trial (concat filedir "RCS/" trial)))
+;; (and (stringp file)
+;; (file-exists-p file)
+;; (or
+;; (and
+;; (file-exists-p full-trial)
+;; ;; in FAT FS, `file,v' and `file' may turn out to be the same!
+;; ;; don't be fooled by this!
+;; (not (equal (file-attributes file)
+;; (file-attributes full-trial))))
+;; ;; check if a version is in RCS/ directory
+;; (file-exists-p full-rcs-trial)))
+;; ))
+
+
(defsubst ediff-file-checked-out-p (file)
- (and (stringp file)
- (file-exists-p file)
- (file-writable-p file)
- (file-exists-p (concat file ",v"))))
+ (or (not (featurep 'vc-hooks))
+ (and (vc-backend file)
+ (vc-locking-user file))))
(defsubst ediff-file-checked-in-p (file)
- (and (stringp file)
- (file-exists-p file)
- (not (file-writable-p file))
- (file-exists-p (concat file ",v"))))
+ (and (featurep 'vc-hooks)
+ (vc-backend file)
+ (not (vc-locking-user file))))
+
+(defun ediff-file-compressed-p (file)
+ (condition-case nil
+ (require 'jka-compr)
+ (error))
+ (if (featurep 'jka-compr)
+ (string-match (jka-compr-build-file-regexp) file)))
+
(defun ediff-swap-buffers ()
"Rotate the display of buffers A, B, and C."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(if (and (window-live-p ediff-window-A) (window-live-p ediff-window-B))
(let ((buf ediff-buffer-A)
(values ediff-buffer-values-orig-A)
(hide-regexp ediff-regexp-hide-A)
(focus-regexp ediff-regexp-focus-A)
(wide-visibility-p (eq ediff-visible-bounds ediff-wide-bounds))
- (overlay (if (ediff-window-display-p)
+ (overlay (if (ediff-has-face-support-p)
ediff-current-diff-overlay-A)))
(if ediff-3way-comparison-job
(progn
;; The following is needed for XEmacs, since there one can't move
;; overlay to another buffer. In Emacs, this swap is redundant.
- (if (ediff-window-display-p)
+ (if (ediff-has-face-support-p)
(if ediff-3way-comparison-job
(setq ediff-current-diff-overlay-A ediff-current-diff-overlay-C
ediff-current-diff-overlay-C ediff-current-diff-overlay-B
"Toggle wide/regular display.
This is especially useful when comparing buffers side-by-side."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(or (ediff-window-display-p)
(error "%sEmacs is not running as a window application"
(if ediff-emacs-p "" "X")))
(let ((ctl-buf ediff-control-buffer))
(setq ediff-wide-display-p (not ediff-wide-display-p))
(if (not ediff-wide-display-p)
- (ediff-eval-in-buffer ctl-buf
+ (ediff-with-current-buffer ctl-buf
(modify-frame-parameters
ediff-wide-display-frame ediff-wide-display-orig-parameters)
- (sit-for (if ediff-xemacs-p 0.4 0))
+ ;;(sit-for (if ediff-xemacs-p 0.4 0))
;; restore control buf, since ctl window may have been deleted
;; during resizing
(set-buffer ctl-buf)
ediff-window-B nil) ; force update of window config
(ediff-recenter 'no-rehighlight))
(funcall ediff-make-wide-display-function)
- (sit-for (if ediff-xemacs-p 0.4 0))
- (ediff-eval-in-buffer ctl-buf
+ ;;(sit-for (if ediff-xemacs-p 0.4 0))
+ (ediff-with-current-buffer ctl-buf
(setq ediff-window-B nil) ; force update of window config
(ediff-recenter 'no-rehighlight)))))
+;;;###autoload
(defun ediff-toggle-multiframe ()
- "Switch from the multiframe display to single-frame display and back.
-This is primarily for debugging, but one can use it for fun, too."
+ "Switch from multiframe display to single-frame display and back.
+To change the default, set the variable `ediff-window-setup-function',
+which see."
(interactive)
- (or (ediff-window-display-p)
- (error "%sEmacs is not running as a window application"
- (if ediff-emacs-p "" "X")))
+ (let (window-setup-func)
+ (or (ediff-window-display-p)
+ (error "%sEmacs is not running as a window application"
+ (if ediff-emacs-p "" "X")))
+
(cond ((eq ediff-window-setup-function 'ediff-setup-windows-multiframe)
- (setq ediff-window-setup-function 'ediff-setup-windows-plain))
+ (setq window-setup-func 'ediff-setup-windows-plain))
((eq ediff-window-setup-function 'ediff-setup-windows-plain)
- (setq ediff-window-setup-function 'ediff-setup-windows-multiframe)))
- (setq ediff-window-B nil)
- (ediff-recenter 'no-rehighlight))
+ (if (ediff-in-control-buffer-p)
+ (ediff-kill-bottom-toolbar))
+ (setq window-setup-func 'ediff-setup-windows-multiframe)))
+
+ ;; change default
+ (setq-default ediff-window-setup-function window-setup-func)
+ ;; change in all active ediff sessions
+ (mapcar (function (lambda(buf)
+ (ediff-with-current-buffer buf
+ (setq ediff-window-setup-function window-setup-func
+ ediff-window-B nil))))
+ ediff-session-registry)
+ (if (ediff-in-control-buffer-p)
+ (ediff-recenter 'no-rehighlight))))
+
+
+;;;###autoload
+(defun ediff-toggle-use-toolbar ()
+ "Enable or disable Ediff toolbar.
+Works only in versions of Emacs that support toolbars.
+To change the default, set the variable `ediff-use-toolbar-p', which see."
+ (interactive)
+ (if (featurep 'ediff-tbar)
+ (progn
+ (or (ediff-window-display-p)
+ (error "%sEmacs is not running as a window application"
+ (if ediff-emacs-p "" "X")))
+ (if (ediff-use-toolbar-p)
+ (ediff-kill-bottom-toolbar))
+ ;; do this only after killing the toolbar
+ (setq ediff-use-toolbar-p (not ediff-use-toolbar-p))
+
+ (mapcar (function (lambda(buf)
+ (ediff-with-current-buffer buf
+ ;; force redisplay
+ (setq ediff-window-config-saved "")
+ )))
+ ediff-session-registry)
+ (if (ediff-in-control-buffer-p)
+ (ediff-recenter 'no-rehighlight)))))
+
+
+;; if was using toolbar, kill it
+(defun ediff-kill-bottom-toolbar ()
+ ;; Using ctl-buffer or ediff-control-window for LOCALE does not
+ ;; work properly in XEmacs 19.14: we have to use
+ ;;(selected-frame).
+ ;; The problem with this is that any previous bottom-toolbar
+ ;; will not re-appear after our cleanup here. Is there a way
+ ;; to do "push" and "pop" toolbars ? --marcpa
+ (if (ediff-use-toolbar-p)
+ (progn
+ (set-specifier bottom-toolbar (list (selected-frame) nil))
+ (set-specifier bottom-toolbar-visible-p (list (selected-frame) nil)))))
+
+;; If wants to use toolbar, make it.
+;; If not, zero the toolbar for XEmacs.
+;; Do nothing for Emacs.
+(defun ediff-make-bottom-toolbar (&optional frame)
+ (if (ediff-window-display-p)
+ (progn
+ (setq frame (or frame (selected-frame)))
+ (cond ((ediff-use-toolbar-p) ; this checks for XEmacs
+ (set-specifier
+ bottom-toolbar
+ (list frame (if (ediff-3way-comparison-job)
+ ediff-toolbar-3way ediff-toolbar)))
+ (set-specifier bottom-toolbar-visible-p (list frame t))
+ (set-specifier bottom-toolbar-height
+ (list frame ediff-toolbar-height)))
+ ((ediff-has-toolbar-support-p)
+ (set-specifier bottom-toolbar-height (list frame 0)))
+ ))
+ ))
;; Merging
(defun ediff-toggle-show-clashes-only ()
"Toggle the mode where only the regions where both buffers differ with the ancestor are shown."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(if (not ediff-merge-with-ancestor-job)
(error "This command makes sense only when merging with an ancestor"))
(setq ediff-show-clashes-only (not ediff-show-clashes-only))
Used in ediff-windows/regions only."
(interactive)
(if (eq ediff-buffer-A ediff-buffer-B)
- (error
- "Buffers A and B are the same. Can't narrow to two different regions"))
+ (error ediff-NO-DIFFERENCES))
(if (eq ediff-visible-bounds ediff-wide-bounds)
(setq ediff-visible-bounds ediff-narrow-bounds)
(setq ediff-visible-bounds ediff-wide-bounds))
(overl-C (ediff-get-value-according-to-buffer-type
'C ediff-visible-bounds))
)
- (ediff-eval-in-buffer ediff-buffer-A
- (narrow-to-region
- (ediff-overlay-start overl-A) (ediff-overlay-end overl-A)))
- (ediff-eval-in-buffer ediff-buffer-B
- (narrow-to-region
- (ediff-overlay-start overl-B) (ediff-overlay-end overl-B)))
+ (ediff-with-current-buffer ediff-buffer-A
+ (if (ediff-overlay-buffer overl-A)
+ (narrow-to-region
+ (ediff-overlay-start overl-A) (ediff-overlay-end overl-A))))
+ (ediff-with-current-buffer ediff-buffer-B
+ (if (ediff-overlay-buffer overl-B)
+ (narrow-to-region
+ (ediff-overlay-start overl-B) (ediff-overlay-end overl-B))))
- (if ediff-3way-job
- (ediff-eval-in-buffer ediff-buffer-C
+ (if (and ediff-3way-job (ediff-overlay-buffer overl-C))
+ (ediff-with-current-buffer ediff-buffer-C
(narrow-to-region
(ediff-overlay-start overl-C) (ediff-overlay-end overl-C))))
)))
(ediff-buffer-live-p ediff-buffer-B)
(or (not ediff-3way-job) ediff-buffer-C)
))
- (error "You've killed an essential Ediff buffer---Please quit Ediff"))
+ (error ediff-KILLED-VITAL-BUFFER))
(let* ((wind (selected-window))
(wind-A ediff-window-A)
(wind-B ediff-window-B)
(wind-C ediff-window-C)
- (three-way ediff-3way-job))
+ (coefA (ediff-get-region-size-coefficient 'A operation))
+ (coefB (ediff-get-region-size-coefficient 'B operation))
+ (three-way ediff-3way-job)
+ (coefC (if three-way
+ (ediff-get-region-size-coefficient 'C operation))))
(select-window wind-A)
(condition-case nil
- (funcall operation arg)
+ (funcall operation (round (* coefA arg)))
(error))
(select-window wind-B)
(condition-case nil
- (funcall operation arg)
+ (funcall operation (round (* coefB arg)))
(error))
(if three-way
(progn
(select-window wind-C)
(condition-case nil
- (funcall operation arg)
+ (funcall operation (round (* coefC arg)))
(error))))
-
(select-window wind)))
(defun ediff-scroll-vertically (&optional arg)
"Vertically scroll buffers A, B \(and C if appropriate\).
With optional argument ARG, scroll ARG lines; otherwise scroll by nearly
-the height of window-A."
+the one half of the height of window-A."
(interactive "P")
+ (ediff-barf-if-not-control-buffer)
;; make sure windows aren't dead
(if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
(or (not ediff-3way-job)
(ediff-buffer-live-p ediff-buffer-C))
))
- (error "You've killed an essential Ediff buffer---Please quit Ediff"))
+ (error ediff-KILLED-VITAL-BUFFER))
(ediff-operate-on-windows
(if (memq last-command-char '(?v ?\C-v))
;; use it
(prefix-numeric-value arg)
;; if not, see if we can determine a default amount (the window height)
- (let* (default-amount)
+ (let (default-amount)
(setq default-amount
- (- (min (window-height ediff-window-A)
- (window-height ediff-window-B)
- (if ediff-3way-job
- (window-height ediff-window-C)
- 123) ; some large number
- )
+ (- (/ (min (window-height ediff-window-A)
+ (window-height ediff-window-B)
+ (if ediff-3way-job
+ (window-height ediff-window-C)
+ 500)) ; some large number
+ 2)
1 next-screen-context-lines))
;; window found
(if arg
If an argument is given, that is how many columns are scrolled, else nearly
the width of the A/B/C windows."
(interactive "P")
+ (ediff-barf-if-not-control-buffer)
;; make sure windows aren't dead
(if (not (and (window-live-p ediff-window-A) (window-live-p ediff-window-B)))
(or (not ediff-3way-job)
(ediff-buffer-live-p ediff-buffer-C))
))
- (error "You've killed an essential Ediff buffer---Please quit Ediff"))
+ (error ediff-KILLED-VITAL-BUFFER))
(ediff-operate-on-windows
(if (= last-command-char ?<)
;;BEG, END show the region to be positioned.
-;;JOB-NAME holds ediff-job-name. Ediff-windows job positions regions
+;;JOB-NAME holds ediff-job-name. The ediff-windows job positions regions
;;differently.
(defun ediff-position-region (beg end pos job-name)
(if (> end (point-max))
(move-to-window-line lines)
(point)))
;; `end' may be beyond the window bottom, so check
- ;; that we are making progres
+ ;; that we are making progress
(< prev-point (point)))
(setq prev-point (point))
(setq lines (1+ lines)))
(goto-char pos)
))
+;; get number of lines from window start to region end
+(defun ediff-get-lines-to-region-end (buf-type &optional n ctl-buf)
+ (or n (setq n ediff-current-difference))
+ (or ctl-buf (setq ctl-buf ediff-control-buffer))
+ (ediff-with-current-buffer ctl-buf
+ (let* ((buf (ediff-get-buffer buf-type))
+ (wind (eval (ediff-get-symbol-from-alist
+ buf-type ediff-window-alist)))
+ (beg (window-start wind))
+ (end (ediff-get-diff-posn buf-type 'end))
+ lines)
+ (ediff-with-current-buffer buf
+ (if (< beg end)
+ (setq lines (count-lines beg end))
+ (setq lines 0))
+ lines
+ ))))
+
+;; Calculate the number of lines from window end to the start of diff region
+(defun ediff-get-lines-to-region-start (buf-type &optional diff-num ctl-buf)
+ (or diff-num (setq diff-num ediff-current-difference))
+ (or ctl-buf (setq ctl-buf ediff-control-buffer))
+ (ediff-with-current-buffer ctl-buf
+ (let* ((buf (ediff-get-buffer buf-type))
+ (wind (eval (ediff-get-symbol-from-alist
+ buf-type ediff-window-alist)))
+ (end (or (window-end wind) (window-end wind t)))
+ (beg (ediff-get-diff-posn buf-type 'beg diff-num)))
+ (ediff-with-current-buffer buf
+ (if (< beg end)
+ (count-lines (max beg (point-min)) (min end (point-max))) 0))
+ )))
+
+
+;; region size coefficient is a coefficient by which to adjust scrolling
+;; up/down of the window displaying buffer of type BUFTYPE.
+;; The purpose of this coefficient is to make the windows scroll in sync, so
+;; that it won't happen that one diff region is scrolled off while the other is
+;; still seen.
+;;
+;; If the difference region is invalid, the coefficient is 1
+(defun ediff-get-region-size-coefficient (buf-type op &optional n ctl-buf)
+ (ediff-with-current-buffer (or ctl-buf ediff-control-buffer)
+ (if (ediff-valid-difference-p n)
+ (let* ((func (cond ((eq op 'scroll-down)
+ 'ediff-get-lines-to-region-start)
+ ((eq op 'scroll-up)
+ 'ediff-get-lines-to-region-end)
+ (t '(lambda (a b c) 0))))
+ (max-lines (max (funcall func 'A n ctl-buf)
+ (funcall func 'B n ctl-buf)
+ (if (ediff-buffer-live-p ediff-buffer-C)
+ (funcall func 'C n ctl-buf)
+ 0))))
+ ;; this covers the horizontal coefficient as well:
+ ;; if max-lines = 0 then coef = 1
+ (if (> max-lines 0)
+ (/ (+ (funcall func buf-type n ctl-buf) 0.0)
+ (+ max-lines 0.0))
+ 1))
+ 1)))
+
(defun ediff-next-difference (&optional arg)
"Advance to the next difference.
-With a prefix argument, go back that many differences."
- (interactive "P")
+With a prefix argument, go forward that many differences."
+ (interactive "p")
+ (ediff-barf-if-not-control-buffer)
(if (< ediff-current-difference ediff-number-of-differences)
(let ((n (min ediff-number-of-differences
- (+ ediff-current-difference (if arg arg 1))))
- regexp-skip)
+ (+ ediff-current-difference (or arg 1))))
+ non-clash-skip regexp-skip)
+ (ediff-visible-region)
(or (>= n ediff-number-of-differences)
(setq regexp-skip (funcall ediff-skip-diff-region-function n))
+ ;; this won't exec if regexp-skip is t
+ (setq non-clash-skip (ediff-merge-region-is-non-clash n))
(ediff-install-fine-diff-if-necessary n))
(while (and (< n ediff-number-of-differences)
(or
;; regexp skip
regexp-skip
;; skip clashes, if necessary
- (and ediff-show-clashes-only
- (string-match "prefer"
- (or (ediff-get-state-of-merge n) "")))
+ non-clash-skip
;; skip difference regions that differ in white space
(and ediff-ignore-similar-regions
- (ediff-no-fine-diffs-p n))))
+ (eq (ediff-no-fine-diffs-p n) t))))
(setq n (1+ n))
(if (= 0 (mod n 20))
(message "Skipped over region %d and counting ..." n))
(or (>= n ediff-number-of-differences)
(setq regexp-skip (funcall ediff-skip-diff-region-function n))
+ ;; this won't exec if regexp-skip is t
+ (setq non-clash-skip (ediff-merge-region-is-non-clash n))
(ediff-install-fine-diff-if-necessary n))
)
(message "")
(defun ediff-previous-difference (&optional arg)
"Go to the previous difference.
With a prefix argument, go back that many differences."
- (interactive "P")
+ (interactive "p")
+ (ediff-barf-if-not-control-buffer)
(if (> ediff-current-difference -1)
- (let ((n (max -1 (- ediff-current-difference (if arg arg 1))))
- regexp-skip)
+ (let ((n (max -1 (- ediff-current-difference (or arg 1))))
+ non-clash-skip regexp-skip)
+ (ediff-visible-region)
(or (< n 0)
(setq regexp-skip (funcall ediff-skip-diff-region-function n))
+ ;; this won't exec if regexp-skip is t
+ (setq non-clash-skip (ediff-merge-region-is-non-clash n))
(ediff-install-fine-diff-if-necessary n))
(while (and (> n -1)
(or
;; regexp skip
regexp-skip
;; skip clashes, if necessary
- (and ediff-show-clashes-only
- (string-match "prefer"
- (or (ediff-get-state-of-merge n) "")))
+ non-clash-skip
;; skip difference regions that differ in white space
(and ediff-ignore-similar-regions
- (ediff-no-fine-diffs-p n))))
+ (eq (ediff-no-fine-diffs-p n) t))))
(if (= 0 (mod (1+ n) 20))
(message "Skipped over region %d and counting ..." (1+ n)))
(setq n (1- n))
(or (< n 0)
(setq regexp-skip (funcall ediff-skip-diff-region-function n))
+ ;; this won't exec if regexp-skip is t
+ (setq non-clash-skip (ediff-merge-region-is-non-clash n))
(ediff-install-fine-diff-if-necessary n))
)
(message "")
(ediff-visible-region)
(error "At beginning of the difference list")))
+;; The diff number is as perceived by the user (i.e., 1+ the internal
+;; representation)
(defun ediff-jump-to-difference (difference-number)
- "Go to the difference specified as a prefix argument."
+ "Go to the difference specified as a prefix argument.
+If the prefix is negative, count differences from the end."
(interactive "p")
- (setq difference-number (1- difference-number))
+ (ediff-barf-if-not-control-buffer)
+ (setq difference-number
+ (cond ((< difference-number 0)
+ (+ ediff-number-of-differences difference-number))
+ ((> difference-number 0) (1- difference-number))
+ (t -1)))
+ ;; -1 is allowed by ediff-unselect-and-select-difference --- it is the
+ ;; position before the first one.
(if (and (>= difference-number -1)
- (< difference-number (1+ ediff-number-of-differences)))
+ (<= difference-number ediff-number-of-differences))
(ediff-unselect-and-select-difference difference-number)
- (error "Bad difference number, %d" difference-number)))
+ (error ediff-BAD-DIFF-NUMBER
+ this-command (1+ difference-number) ediff-number-of-differences)))
-(defun ediff-jump-to-difference-at-point ()
+(defun ediff-jump-to-difference-at-point (arg)
"Go to difference closest to the point in buffer A, B, or C.
-The type of buffer depends on last command character \(a, b, or c\) that
-invoked this command."
- (interactive)
- (let ((buf-type (ediff-char-to-buftype last-command-char)))
- (ediff-jump-to-difference (ediff-diff-at-point buf-type))))
+The buffer depends on last command character \(a, b, or c\) that invoked this
+command. For instance, if the command was `ga' then the point value in buffer A
+is used.
+With a prefix argument, synchronize all files around the current point position
+in the specified buffer."
+ (interactive "P")
+ (ediff-barf-if-not-control-buffer)
+ (let* ((buf-type (ediff-char-to-buftype last-command-char))
+ (buffer (ediff-get-buffer buf-type))
+ (pt (ediff-with-current-buffer buffer (point)))
+ (diff-no (ediff-diff-at-point buf-type nil (if arg 'after)))
+ (past-last-diff (< ediff-number-of-differences diff-no))
+ (beg (if past-last-diff
+ (ediff-with-current-buffer buffer (point-max))
+ (ediff-get-diff-posn buf-type 'beg (1- diff-no))))
+ ctl-wind wind-A wind-B wind-C
+ shift)
+ (if past-last-diff
+ (ediff-jump-to-difference -1)
+ (ediff-jump-to-difference diff-no))
+ (setq ctl-wind (selected-window)
+ wind-A ediff-window-A
+ wind-B ediff-window-B
+ wind-C ediff-window-C)
+ (if arg
+ (progn
+ (ediff-with-current-buffer buffer
+ (setq shift (- beg pt)))
+ (select-window wind-A)
+ (if past-last-diff (goto-char (point-max)))
+ (condition-case nil
+ (backward-char shift) ; noerror, if beginning of buffer
+ (error))
+ (recenter)
+ (select-window wind-B)
+ (if past-last-diff (goto-char (point-max)))
+ (condition-case nil
+ (backward-char shift) ; noerror, if beginning of buffer
+ (error))
+ (recenter)
+ (if (window-live-p wind-C)
+ (progn
+ (select-window wind-C)
+ (if past-last-diff (goto-char (point-max)))
+ (condition-case nil
+ (backward-char shift) ; noerror, if beginning of buffer
+ (error))
+ (recenter)
+ ))
+ (select-window ctl-wind)
+ ))
+ ))
;; find region most related to the current point position (or POS, if given)
-(defun ediff-diff-at-point (buf-type &optional pos)
+;; returns diff number as seen by the user (i.e., 1+ the internal
+;; representation)
+;; The optional argument WHICH-DIFF can be `after' or `before'. If `after',
+;; find the diff after the point. If `before', find the diff before the
+;; point. If the point is inside a diff, return that diff.
+(defun ediff-diff-at-point (buf-type &optional pos which-diff)
(let ((buffer (ediff-get-buffer buf-type))
(ctl-buffer ediff-control-buffer)
(max-dif-num (1- ediff-number-of-differences))
(beg 0)
(end 0))
- (ediff-eval-in-buffer buffer
+ (ediff-with-current-buffer buffer
(setq pos (or pos (point)))
(while (and (or (< pos prev-beg) (> pos beg))
(< diff-no max-dif-num))
end (ediff-get-diff-posn buf-type 'end diff-no ctl-buffer))
)
- (if (< (abs (- pos prev-end))
- (abs (- pos beg)))
- diff-no
- (1+ diff-no)) ; jump-to-diff works with diff nums higher by 1
+ ;; boost diff-no by 1, if past the last diff region
+ (if (and (memq which-diff '(after before))
+ (> pos beg) (= diff-no max-dif-num))
+ (setq diff-no (1+ diff-no)))
+
+ (cond ((eq which-diff 'after) (1+ diff-no))
+ ((eq which-diff 'before) diff-no)
+ ((< (abs (count-lines pos (max 1 prev-end)))
+ (abs (count-lines pos (max 1 beg))))
+ diff-no) ; choose prev difference
+ (t
+ (1+ diff-no))) ; choose next difference
)))
\f
;;; Copying diffs.
(defun ediff-diff-to-diff (arg &optional keys)
- "Copy buffer-X'th diff to buffer Y \(X,Y are A, B, or C\).
-If numerical prefix argument, copy this diff specified in the arg.
+ "Copy buffer-X'th difference region to buffer Y \(X,Y are A, B, or C\).
+If numerical prefix argument, copy the difference specified in the arg.
Otherwise, copy the difference given by `ediff-current-difference'.
This command assumes it is bound to a 2-character key sequence, `ab', `ba',
`ac', etc., which is used to determine the types of buffers to be used for
If the second optional argument, a 2-character string, is given, use it to
determine the source and the target buffers instead of the command keys."
(interactive "P")
+ (ediff-barf-if-not-control-buffer)
(or keys (setq keys (this-command-keys)))
- (if arg
- (ediff-jump-to-difference arg))
+ (if (eq arg '-) (setq arg -1)) ; translate neg arg to -1
+ (if (numberp arg) (ediff-jump-to-difference arg))
+
(let* ((key1 (aref keys 0))
(key2 (aref keys 1))
(char1 (if (and ediff-xemacs-p (eventp key1)) (event-key key1) key1))
- (char2 (if (and ediff-xemacs-p (eventp key1)) (event-key key2) key2)))
+ (char2 (if (and ediff-xemacs-p (eventp key1)) (event-key key2) key2))
+ ediff-verbose-p)
(ediff-copy-diff ediff-current-difference
(ediff-char-to-buftype char1)
(ediff-char-to-buftype char2))
- (ediff-recenter 'no-rehighlight)))
+ ;; recenter with rehighlighting, but no messages
+ (ediff-recenter)))
+
+(defun ediff-copy-A-to-B (arg)
+ "Copy ARGth difference region from buffer A to B.
+ARG is a prefix argument. If nil, copy the current difference region."
+ (interactive "P")
+ (ediff-diff-to-diff arg "ab"))
+
+(defun ediff-copy-B-to-A (arg)
+ "Copy ARGth difference region from buffer B to A.
+ARG is a prefix argument. If nil, copy the current difference region."
+ (interactive "P")
+ (ediff-diff-to-diff arg "ba"))
+
+(defun ediff-copy-A-to-C (arg)
+ "Copy ARGth difference region from buffer A to buffer C.
+ARG is a prefix argument. If nil, copy the current difference region."
+ (interactive "P")
+ (ediff-diff-to-diff arg "ac"))
+
+(defun ediff-copy-B-to-C (arg)
+ "Copy ARGth difference region from buffer B to buffer C.
+ARG is a prefix argument. If nil, copy the current difference region."
+ (interactive "P")
+ (ediff-diff-to-diff arg "bc"))
+
+(defun ediff-copy-C-to-B (arg)
+ "Copy ARGth difference region from buffer C to B.
+ARG is a prefix argument. If nil, copy the current difference region."
+ (interactive "P")
+ (ediff-diff-to-diff arg "cb"))
+
+(defun ediff-copy-C-to-A (arg)
+ "Copy ARGth difference region from buffer C to A.
+ARG is a prefix argument. If nil, copy the current difference region."
+ (interactive "P")
+ (ediff-diff-to-diff arg "ca"))
+
;; Copy diff N from FROM-BUF-TYPE \(given as A, B or C\) to TO-BUF-TYPE.
n to-buf-type ctrl-buf
reg-to-delete-beg reg-to-delete-end))
- (setq ediff-disturbed-overlays nil) ; clear before use
-
(if (string= reg-to-delete reg-to-copy)
- (setq saved-p nil) ; refuse to copy identical buffers
+ (setq saved-p nil) ; don't copy identical buffers
;; seems ok to copy
(if (or batch-invocation (ediff-test-save-region n to-buf-type))
(condition-case conds
(progn
- (ediff-eval-in-buffer to-buf
+ (ediff-with-current-buffer to-buf
;; to prevent flags from interfering if buffer is writable
(let ((inhibit-read-only (null buffer-read-only)))
- ;; these two insert a dummy char to overcome a bug in
- ;; XEmacs, which sometimes prevents 0-length extents
- ;; from sensing insertion at its end-points.
- (if ediff-xemacs-p
- (progn
- (goto-char reg-to-delete-end)
- (insert-before-markers "@")))
(goto-char reg-to-delete-end)
- (insert-before-markers reg-to-copy)
-
- ;; delete the dummy char "@"
- (if ediff-xemacs-p
- (delete-char 1))
+ (insert reg-to-copy)
- (if ediff-xemacs-p
- (if (> reg-to-delete-end reg-to-delete-beg)
- (kill-region reg-to-delete-beg
- reg-to-delete-end))
- (if (> reg-to-delete-end reg-to-delete-beg)
- (kill-region reg-to-delete-beg reg-to-delete-end)
- (ediff-move-disturbed-overlays reg-to-delete-beg)
- ))
+ (if (> reg-to-delete-end reg-to-delete-beg)
+ (kill-region reg-to-delete-beg reg-to-delete-end))
))
(or batch-invocation
(setq
(car conds)
(mapconcat 'prin1-to-string (cdr conds) " "))
(beep 1)
- (sit-for 2)
+ (sit-for 2) ; let the user see the error msg
(setq saved-p nil)
)))
)
(setq saved-diff (cdr saved-rec))
(if (> ediff-number-of-differences 0)
(error "Nothing saved for diff %d in buffer %S" (1+ n) buf-type)
- (error "No differences found")))
+ (error ediff-NO-DIFFERENCES)))
(setq reg-beg (ediff-get-diff-posn buf-type 'beg n ediff-control-buffer))
(setq reg-end (ediff-get-diff-posn buf-type 'end n ediff-control-buffer))
- (setq ediff-disturbed-overlays nil) ; clear before use
(condition-case conds
- (ediff-eval-in-buffer buf
+ (ediff-with-current-buffer buf
(let ((inhibit-read-only (null buffer-read-only)))
- ;; these two insert a dummy char to overcome a bug in XEmacs,
- ;; which sometimes prevents 0-length extents from sensing
- ;; insertion at its end-points.
- (if ediff-xemacs-p
- (progn
- (goto-char reg-end)
- (insert-before-markers "@")))
(goto-char reg-end)
- (insert-before-markers saved-diff)
+ (insert saved-diff)
- ;; delete dummy char
- (if ediff-xemacs-p
- (delete-char 1))
-
- (if ediff-xemacs-p
- (if (> reg-end reg-beg)
- (kill-region reg-beg reg-end))
- (if (> reg-end reg-beg)
- (kill-region reg-beg reg-end)
- (ediff-move-disturbed-overlays reg-beg)
- ))
+ (if (> reg-end reg-beg)
+ (kill-region reg-beg reg-end))
(setq recovered t)
))
(defun ediff-restore-diff (arg &optional key)
"Restore ARGth diff from `ediff-killed-diffs-alist'.
-ARG is a prefix argument. If ARG is nil, restore current-difference.
-
+ARG is a prefix argument. If ARG is nil, restore the current-difference.
If the second optional argument, a character, is given, use it to
determine the target buffer instead of last-command-char"
(interactive "P")
- (if arg
+ (ediff-barf-if-not-control-buffer)
+ (if (numberp arg)
(ediff-jump-to-difference arg))
(ediff-pop-diff ediff-current-difference
(ediff-char-to-buftype (or key last-command-char)))
- (ediff-recenter 'no-rehighlight))
+ ;; recenter with rehighlighting, but no messages
+ (let (ediff-verbose-p)
+ (ediff-recenter)))
+
+(defun ediff-restore-diff-in-merge-buffer (arg)
+ "Restore ARGth diff in the merge buffer.
+ARG is a prefix argument. If nil, restore the current diff."
+ (interactive "P")
+ (ediff-restore-diff arg ?c))
+
(defun ediff-toggle-regexp-match ()
"Toggle between focusing and hiding of difference regions that match
a regular expression typed in by the user."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(let ((regexp-A "")
(regexp-B "")
(regexp-C "")
msg-connective alt-msg-connective alt-connective)
(cond
((or (and (eq ediff-skip-diff-region-function
- 'ediff-focus-on-regexp-matches)
+ ediff-focus-on-regexp-matches-function)
(eq last-command-char ?f))
- (and (eq ediff-skip-diff-region-function 'ediff-hide-regexp-matches)
+ (and (eq ediff-skip-diff-region-function
+ ediff-hide-regexp-matches-function)
(eq last-command-char ?h)))
(message "Selective browsing by regexp turned off")
(setq ediff-skip-diff-region-function 'ediff-show-all-diffs))
((eq last-command-char ?h)
- (setq ediff-skip-diff-region-function 'ediff-hide-regexp-matches
+ (setq ediff-skip-diff-region-function ediff-hide-regexp-matches-function
regexp-A
(read-string
(format
alt-connective 'and))
(if (y-or-n-p
(format
- "Hiding diff regions that match %s regexps. Use %s instead? "
+ "Ignore regions that match %s regexps, OK? "
msg-connective alt-msg-connective))
- (progn
- (setq ediff-hide-regexp-connective alt-connective)
- (message "Hiding diff regions that match %s regexps"
- alt-msg-connective))
- (message "Hiding diff regions that match %s regexps" msg-connective))
+ (message "Will ignore regions that match %s regexps" msg-connective)
+ (setq ediff-hide-regexp-connective alt-connective)
+ (message "Will ignore regions that match %s regexps"
+ alt-msg-connective))
+
(or (string= regexp-A "") (setq ediff-regexp-hide-A regexp-A))
(or (string= regexp-B "") (setq ediff-regexp-hide-B regexp-B))
(or (string= regexp-C "") (setq ediff-regexp-hide-C regexp-C)))
+
((eq last-command-char ?f)
- (setq ediff-skip-diff-region-function 'ediff-focus-on-regexp-matches
+ (setq ediff-skip-diff-region-function
+ ediff-focus-on-regexp-matches-function
regexp-A
(read-string
(format
alt-connective 'and))
(if (y-or-n-p
(format
- "Focusing on diff regions that match %s regexps. Use %s instead? "
+ "Focus on regions that match %s regexps, OK? "
msg-connective alt-msg-connective))
- (progn
- (setq ediff-focus-regexp-connective alt-connective)
- (message "Focusing on diff regions that match %s regexps"
- alt-msg-connective))
- (message "Focusing on diff regions that match %s regexps"
- msg-connective))
+ (message "Will focus on regions that match %s regexps"
+ msg-connective)
+ (setq ediff-focus-regexp-connective alt-connective)
+ (message "Will focus on regions that match %s regexps"
+ alt-msg-connective))
+
(or (string= regexp-A "") (setq ediff-regexp-focus-A regexp-A))
(or (string= regexp-B "") (setq ediff-regexp-focus-B regexp-B))
(or (string= regexp-C "") (setq ediff-regexp-focus-C regexp-C))))))
(defun ediff-toggle-skip-similar ()
(interactive)
+ (ediff-barf-if-not-control-buffer)
(if (not (eq ediff-auto-refine 'on))
(error
"Can't skip over whitespace regions: first turn auto-refining on"))
(regex-A ediff-regexp-focus-A)
(regex-B ediff-regexp-focus-B)
(regex-C ediff-regexp-focus-C)
- (reg-A-match (ediff-eval-in-buffer ediff-buffer-A
- (goto-char (ediff-get-diff-posn 'A 'beg n ctl-buf))
- (re-search-forward
- regex-A
- (ediff-get-diff-posn 'A 'end n ctl-buf)
- t)))
- (reg-B-match (ediff-eval-in-buffer ediff-buffer-B
- (goto-char (ediff-get-diff-posn 'B 'beg n ctl-buf))
- (re-search-forward
- regex-B
- (ediff-get-diff-posn 'B 'end n ctl-buf)
- t)))
+ (reg-A-match (ediff-with-current-buffer ediff-buffer-A
+ (save-restriction
+ (narrow-to-region
+ (ediff-get-diff-posn 'A 'beg n ctl-buf)
+ (ediff-get-diff-posn 'A 'end n ctl-buf))
+ (goto-char (point-min))
+ (re-search-forward regex-A nil t))))
+ (reg-B-match (ediff-with-current-buffer ediff-buffer-B
+ (save-restriction
+ (narrow-to-region
+ (ediff-get-diff-posn 'B 'beg n ctl-buf)
+ (ediff-get-diff-posn 'B 'end n ctl-buf))
+ (re-search-forward regex-B nil t))))
(reg-C-match (if ediff-3way-comparison-job
- (ediff-eval-in-buffer ediff-buffer-C
- (goto-char
- (ediff-get-diff-posn 'C 'beg n ctl-buf))
- (re-search-forward
- regex-C
- (ediff-get-diff-posn 'C 'end n ctl-buf)
- t)))))
+ (ediff-with-current-buffer ediff-buffer-C
+ (save-restriction
+ (narrow-to-region
+ (ediff-get-diff-posn 'C 'beg n ctl-buf)
+ (ediff-get-diff-posn 'C 'end n ctl-buf))
+ (re-search-forward regex-C nil t))))))
(not (eval (if ediff-3way-comparison-job
(list ediff-focus-regexp-connective
reg-A-match reg-B-match reg-C-match)
(regex-A ediff-regexp-hide-A)
(regex-B ediff-regexp-hide-B)
(regex-C ediff-regexp-hide-C)
- (reg-A-match (ediff-eval-in-buffer ediff-buffer-A
- (goto-char (ediff-get-diff-posn 'A 'beg n ctl-buf))
- (re-search-forward
- regex-A
- (ediff-get-diff-posn 'A 'end n ctl-buf)
- t)))
- (reg-B-match (ediff-eval-in-buffer ediff-buffer-B
- (goto-char (ediff-get-diff-posn 'B 'beg n ctl-buf))
- (re-search-forward
- regex-B
- (ediff-get-diff-posn 'B 'end n ctl-buf)
- t)))
+ (reg-A-match (ediff-with-current-buffer ediff-buffer-A
+ (save-restriction
+ (narrow-to-region
+ (ediff-get-diff-posn 'A 'beg n ctl-buf)
+ (ediff-get-diff-posn 'A 'end n ctl-buf))
+ (goto-char (point-min))
+ (re-search-forward regex-A nil t))))
+ (reg-B-match (ediff-with-current-buffer ediff-buffer-B
+ (save-restriction
+ (narrow-to-region
+ (ediff-get-diff-posn 'B 'beg n ctl-buf)
+ (ediff-get-diff-posn 'B 'end n ctl-buf))
+ (goto-char (point-min))
+ (re-search-forward regex-B nil t))))
(reg-C-match (if ediff-3way-comparison-job
- (ediff-eval-in-buffer ediff-buffer-C
- (goto-char
- (ediff-get-diff-posn 'C 'beg n ctl-buf))
- (re-search-forward
- regex-C
- (ediff-get-diff-posn 'C 'end n ctl-buf)
- t)))))
+ (ediff-with-current-buffer ediff-buffer-C
+ (save-restriction
+ (narrow-to-region
+ (ediff-get-diff-posn 'C 'beg n ctl-buf)
+ (ediff-get-diff-posn 'C 'end n ctl-buf))
+ (goto-char (point-min))
+ (re-search-forward regex-C nil t))))))
(eval (if ediff-3way-comparison-job
(list ediff-hide-regexp-connective
reg-A-match reg-B-match reg-C-match)
\f
;;; Quitting, suspending, etc.
-(defun ediff-quit ()
+(defun ediff-quit (reverse-default-keep-variants)
"Finish an Ediff session and exit Ediff.
Unselects the selected difference, if any, restores the read-only and modified
flags of the compared file buffers, kills Ediff buffers for this session
-\(but not buffers A, B, C\)."
- (interactive)
- (if (prog1
- (y-or-n-p "Do you really want to exit Ediff? ")
- (message ""))
- (ediff-really-quit)))
+\(but not buffers A, B, C\).
+
+If `ediff-keep-variants' is nil, the user will be asked whether the buffers
+containing the variants should be removed \(if they haven't been modified\).
+If it is t, they will be preserved unconditionally. A prefix argument,
+temporarily reverses the meaning of this variable."
+ (interactive "P")
+ (ediff-barf-if-not-control-buffer)
+ (let ((ctl-buf (current-buffer)))
+ (if (y-or-n-p (format "Quit this Ediff session%s? "
+ (if (ediff-buffer-live-p ediff-meta-buffer)
+ " & show containing session group" "")))
+ (progn
+ (message "")
+ (set-buffer ctl-buf)
+ (ediff-really-quit reverse-default-keep-variants))
+ (message ""))))
;; Perform the quit operations.
-(defun ediff-really-quit ()
+(defun ediff-really-quit (reverse-default-keep-variants)
(ediff-unhighlight-diffs-totally)
(ediff-clear-diff-vector 'ediff-difference-vector-A 'fine-diffs-also)
(ediff-clear-diff-vector 'ediff-difference-vector-B 'fine-diffs-also)
(ediff-clear-diff-vector 'ediff-difference-vector-C 'fine-diffs-also)
-
+ (ediff-clear-diff-vector 'ediff-difference-vector-Ancestor 'fine-diffs-also)
+
(ediff-delete-temp-files)
;; Restore visibility range. This affects only ediff-*-regions/windows.
(if (ediff-overlayp overl)
(ediff-delete-overlay overl))))
ediff-narrow-bounds)
-
+
;; restore buffer mode line id's in buffer-A/B/C
- (let ((control-buffer ediff-control-buffer))
+ (let ((control-buffer ediff-control-buffer)
+ (meta-buffer ediff-meta-buffer)
+ (session-number ediff-meta-session-number)
+ ;; suitable working frame
+ (warp-frame (if (and (ediff-window-display-p) (eq ediff-grab-mouse t))
+ (cond ((window-live-p ediff-window-A)
+ (window-frame ediff-window-A))
+ ((window-live-p ediff-window-B)
+ (window-frame ediff-window-B))
+ (t (next-frame))))))
(condition-case nil
- (ediff-eval-in-buffer ediff-buffer-A
- (setq ediff-this-buffer-control-sessions
- (delq control-buffer ediff-this-buffer-control-sessions))
+ (ediff-with-current-buffer ediff-buffer-A
+ (setq ediff-this-buffer-ediff-sessions
+ (delq control-buffer ediff-this-buffer-ediff-sessions))
(kill-local-variable 'mode-line-buffer-identification)
(kill-local-variable 'mode-line-format)
)
(error))
(condition-case nil
- (ediff-eval-in-buffer ediff-buffer-B
- (setq ediff-this-buffer-control-sessions
- (delq control-buffer ediff-this-buffer-control-sessions))
+ (ediff-with-current-buffer ediff-buffer-B
+ (setq ediff-this-buffer-ediff-sessions
+ (delq control-buffer ediff-this-buffer-ediff-sessions))
(kill-local-variable 'mode-line-buffer-identification)
(kill-local-variable 'mode-line-format)
)
(error))
(condition-case nil
- (ediff-eval-in-buffer ediff-buffer-C
+ (ediff-with-current-buffer ediff-buffer-C
+ (setq ediff-this-buffer-ediff-sessions
+ (delq control-buffer ediff-this-buffer-ediff-sessions))
+ (kill-local-variable 'mode-line-buffer-identification)
+ (kill-local-variable 'mode-line-format)
+ )
+ (error))
+
+ (condition-case nil
+ (ediff-with-current-buffer ediff-ancestor-buffer
+ (setq ediff-this-buffer-ediff-sessions
+ (delq control-buffer ediff-this-buffer-ediff-sessions))
(kill-local-variable 'mode-line-buffer-identification)
(kill-local-variable 'mode-line-format)
)
(error))
- )
+
+ (setq ediff-session-registry
+ (delq ediff-control-buffer ediff-session-registry))
+ (ediff-update-registry)
;; restore state of buffers to what it was before ediff
(ediff-restore-protected-variables)
+
+ ;; If the user interrupts (canceling saving the merge buffer), continue
+ ;; normally.
+ (condition-case nil
+ (if (ediff-merge-job)
+ (run-hooks 'ediff-quit-merge-hook))
+ (quit))
+
;; good place to kill buffers A/B/C
- (run-hooks 'ediff-cleanup-hooks)
- (run-hooks 'ediff-quit-hooks))
+ (run-hooks 'ediff-cleanup-hook)
+ (let ((ediff-keep-variants ediff-keep-variants))
+ (if reverse-default-keep-variants
+ (setq ediff-keep-variants (not ediff-keep-variants)))
+ (or ediff-keep-variants (ediff-janitor 'ask)))
+
+ (run-hooks 'ediff-quit-hook)
+ (ediff-update-meta-buffer meta-buffer nil session-number)
+
+ ;; warp mouse into a working window
+ (setq warp-frame ; if mouse is over a reasonable frame, use it
+ (cond ((ediff-good-frame-under-mouse))
+ (t warp-frame)))
+ (if (frame-live-p warp-frame)
+ (set-mouse-position (if ediff-emacs-p
+ warp-frame
+ (frame-selected-window warp-frame))
+ 2 1))
+
+ (if (ediff-buffer-live-p meta-buffer)
+ (ediff-show-meta-buffer meta-buffer session-number))
+ ))
+
+;; Returns frame under mouse, if this frame is not a minibuffer
+;; frame. Otherwise: nil
+(defun ediff-good-frame-under-mouse ()
+ (let ((frame-or-win (car (mouse-position)))
+ (buf-name "")
+ frame obj-ok)
+ (setq obj-ok
+ (if ediff-emacs-p
+ (frame-live-p frame-or-win)
+ (window-live-p frame-or-win)))
+ (if obj-ok
+ (setq frame (if ediff-emacs-p frame-or-win (window-frame frame-or-win))
+ buf-name
+ (buffer-name (window-buffer (frame-selected-window frame)))))
+ (if (string-match "Minibuf" buf-name)
+ nil
+ frame)))
(defun ediff-delete-temp-files ()
- (if (stringp ediff-temp-file-A)
+ (if (and (stringp ediff-temp-file-A) (file-exists-p ediff-temp-file-A))
(delete-file ediff-temp-file-A))
- (if (stringp ediff-temp-file-B)
+ (if (and (stringp ediff-temp-file-B) (file-exists-p ediff-temp-file-B))
(delete-file ediff-temp-file-B))
- (if (stringp ediff-temp-file-C)
+ (if (and (stringp ediff-temp-file-C) (file-exists-p ediff-temp-file-C))
(delete-file ediff-temp-file-C)))
(ediff-kill-buffer-carefully ediff-fine-diff-buffer)
(ediff-kill-buffer-carefully ediff-tmp-buffer)
(ediff-kill-buffer-carefully ediff-error-buffer)
- (ediff-kill-buffer-carefully ediff-patch-diagnostics)
(ediff-kill-buffer-carefully ediff-msg-buffer)
(ediff-kill-buffer-carefully ediff-debug-buffer)
+ (if (boundp 'ediff-patch-diagnostics)
+ (ediff-kill-buffer-carefully ediff-patch-diagnostics))
- ;;(redraw-display)
(if (and (ediff-window-display-p) (frame-live-p ctl-frame))
(delete-frame ctl-frame))
+ ;; Hide bottom toolbar. --marcpa
+ (if (not (ediff-multiframe-setup-p))
+ (ediff-kill-bottom-toolbar))
+
(ediff-kill-buffer-carefully ctl-buf)
(delete-other-windows)
(or (ediff-get-visible-buffer-window buff-A)
(progn
(if (ediff-get-visible-buffer-window buff-B)
- (split-window-vertically))
+ (funcall ediff-split-window-function))
(switch-to-buffer buff-A)))
(error))
(if three-way-job
(progn
(if (or (ediff-get-visible-buffer-window buff-A)
(ediff-get-visible-buffer-window buff-B))
- (split-window-vertically))
+ (funcall ediff-split-window-function))
(switch-to-buffer buff-C)
(balance-windows)))
(error)))
(message "")
))
-(defun ediff-janitor ()
+(defun ediff-janitor (&optional ask)
"Kill buffers A, B, and, possibly, C, if these buffers aren't modified.
In merge jobs, buffer C is never deleted.
However, the side effect of cleaning up may be that you cannot compare the same
buffer in another session as well."
(or (not (ediff-buffer-live-p ediff-buffer-A))
(buffer-modified-p ediff-buffer-A)
+ (and ask
+ (not (y-or-n-p (format "Kill buffer A [%s]? "
+ (buffer-name ediff-buffer-A)))))
(ediff-kill-buffer-carefully ediff-buffer-A))
(or (not (ediff-buffer-live-p ediff-buffer-B))
(buffer-modified-p ediff-buffer-B)
+ (and ask
+ (not (y-or-n-p (format "Kill buffer B [%s]? "
+ (buffer-name ediff-buffer-B)))))
(ediff-kill-buffer-carefully ediff-buffer-B))
(if ediff-merge-job ; don't del buf C if merging--del ancestor buf instead
(or (not (ediff-buffer-live-p ediff-ancestor-buffer))
(buffer-modified-p ediff-ancestor-buffer)
+ (and ask
+ (not (y-or-n-p (format "Kill the ancestor buffer [%s]? "
+ (buffer-name ediff-ancestor-buffer)))))
(ediff-kill-buffer-carefully ediff-ancestor-buffer))
(or (not (ediff-buffer-live-p ediff-buffer-C))
(buffer-modified-p ediff-buffer-C)
+ (and ask (not (y-or-n-p (format "Kill buffer C [%s]? "
+ (buffer-name ediff-buffer-C)))))
(ediff-kill-buffer-carefully ediff-buffer-C))))
+(defun ediff-maybe-save-and-delete-merge (&optional save-and-continue)
+ "Default hook to run on quitting a merge job.
+This can also be used to save merge buffer in the middle of an Ediff session.
+
+If the optional SAVE-AND-CONTINUE argument is non-nil, save merge buffer and
+continue. Otherwise:
+If `ediff-autostore-merges' is nil, this does nothing.
+If it is t, it saves the merge buffer in the file `ediff-merge-store-file'
+or asks the user, if the latter is nil. It then asks the user whether to
+delete the merge buffer.
+If `ediff-autostore-merges' is neither nil nor t, the merge buffer is saved
+only if this merge job is part of a group, i.e., was invoked from within
+`ediff-merge-directories', `ediff-merge-directory-revisions', and such."
+ (let ((merge-store-file ediff-merge-store-file)
+ (ediff-autostore-merges ; fake ediff-autostore-merges, if necessary
+ (if save-and-continue t ediff-autostore-merges)))
+ (if ediff-autostore-merges
+ (cond ((stringp ediff-merge-store-file)
+ ;; store, ask to delete
+ (ediff-write-merge-buffer-and-maybe-kill
+ ediff-buffer-C merge-store-file 'show-file save-and-continue))
+ ((eq ediff-autostore-merges t)
+ ;; ask for file name
+ (setq merge-store-file
+ (read-file-name "Save the merge buffer in file: "))
+ (ediff-write-merge-buffer-and-maybe-kill
+ ediff-buffer-C merge-store-file nil save-and-continue))
+ ((and (ediff-buffer-live-p ediff-meta-buffer)
+ (ediff-with-current-buffer ediff-meta-buffer
+ (ediff-merge-metajob)))
+ ;; This case shouldn't occur, as the parent metajob must pass on
+ ;; a file name, ediff-merge-store-file, where to save the result
+ ;; of the merge.
+ ;; Ask where to save anyway--will decide what to do here later.
+ (setq merge-store-file
+ (read-file-name "Save the merge buffer in file: "))
+ (ediff-write-merge-buffer-and-maybe-kill
+ ediff-buffer-C merge-store-file nil save-and-continue))))
+ ))
+
+;; write merge buffer. If the optional argument save-and-continue is non-nil,
+;; then don't kill the merge buffer
+(defun ediff-write-merge-buffer-and-maybe-kill (buf file
+ &optional
+ show-file save-and-continue)
+ (ediff-with-current-buffer buf
+ (if (or (not (file-exists-p file))
+ (y-or-n-p (format "File %s exists, overwrite? " file)))
+ (progn
+ (write-region (point-min) (point-max) file)
+ (if show-file
+ (progn
+ (message "Merge buffer saved in: %s" file)
+ (set-buffer-modified-p nil)
+ (sit-for 2)))
+ (if (and
+ (not save-and-continue)
+ (y-or-n-p "Merge buffer saved in file. Now kill the buffer? "))
+ (ediff-kill-buffer-carefully buf))))))
+
;; The default way of suspending Ediff.
;; Buries Ediff buffers, kills all windows.
-(defun ediff-default-suspend-hook ()
+(defun ediff-default-suspend-function ()
(let* ((buf-A ediff-buffer-A)
(buf-B ediff-buffer-B)
(buf-C ediff-buffer-C)
(buf-A-wind (ediff-get-visible-buffer-window buf-A))
(buf-B-wind (ediff-get-visible-buffer-window buf-B))
(buf-C-wind (ediff-get-visible-buffer-window buf-C))
- (buf-patch ediff-patch-buf)
- (buf-patch-diag ediff-patch-diagnostics)
+ (buf-patch (if (boundp 'ediff-patchbufer) ediff-patchbufer nil))
+ (buf-patch-diag (if (boundp 'ediff-patch-diagnostics)
+ ediff-patch-diagnostics nil))
(buf-err ediff-error-buffer)
(buf-diff ediff-diff-buffer)
(buf-custom-diff ediff-custom-diff-buffer)
(select-window buf-A-wind)
(delete-other-windows)
(bury-buffer))
- (if (ediff-buffer-live-p buf-A) (bury-buffer buf-A)))
+ (if (ediff-buffer-live-p buf-A)
+ (progn
+ (set-buffer buf-A)
+ (bury-buffer))))
(if (window-live-p buf-B-wind)
(progn
(select-window buf-B-wind)
(delete-other-windows)
(bury-buffer))
- (if (ediff-buffer-live-p buf-B) (bury-buffer buf-B)))
+ (if (ediff-buffer-live-p buf-B)
+ (progn
+ (set-buffer buf-B)
+ (bury-buffer))))
(if (window-live-p buf-C-wind)
(progn
(select-window buf-C-wind)
(delete-other-windows)
(bury-buffer))
- (if (ediff-buffer-live-p buf-C) (bury-buffer buf-C)))
-
+ (if (ediff-buffer-live-p buf-C)
+ (progn
+ (set-buffer buf-C)
+ (bury-buffer))))
))
buffer and then type \\[ediff-recenter]. Ediff will automatically set
up an appropriate window config."
(interactive)
- (let ((key (substitute-command-keys "\\[ediff-recenter]")))
- (run-hooks 'ediff-suspend-hooks)
+ (ediff-barf-if-not-control-buffer)
+ (run-hooks 'ediff-suspend-hook)
(message
- "To resume, switch to Ediff Control Panel and hit `%s'" key)))
+ "To resume, type M-x eregistry and select the desired Ediff session"))
(defun ediff-status-info ()
"Show the names of the buffers or files being operated on by Ediff.
Hit \\[ediff-recenter] to reset the windows afterward."
(interactive)
- (with-output-to-temp-buffer " *ediff-info*"
+ (ediff-barf-if-not-control-buffer)
+ (save-excursion
+ (ediff-skip-unsuitable-frames))
+ (with-output-to-temp-buffer ediff-msg-buffer
+ (raise-frame (selected-frame))
(princ (ediff-version))
(princ "\n\n")
- (ediff-eval-in-buffer ediff-buffer-A
+ (ediff-with-current-buffer ediff-buffer-A
(if buffer-file-name
(princ
(format "File A = %S\n" buffer-file-name))
(princ
(format "Buffer A = %S\n" (buffer-name)))))
- (ediff-eval-in-buffer ediff-buffer-B
+ (ediff-with-current-buffer ediff-buffer-B
(if buffer-file-name
(princ
(format "File B = %S\n" buffer-file-name))
(princ
(format "Buffer B = %S\n" (buffer-name)))))
(if ediff-3way-job
- (ediff-eval-in-buffer ediff-buffer-C
+ (ediff-with-current-buffer ediff-buffer-C
(if buffer-file-name
(princ
(format "File C = %S\n" buffer-file-name))
(princ
(format "Buffer C = %S\n" (buffer-name))))))
+ (princ (format "Customized diff output %s\n"
+ (if (ediff-buffer-live-p ediff-custom-diff-buffer)
+ (concat "\tin buffer "
+ (buffer-name ediff-custom-diff-buffer))
+ " is not available")))
+ (princ (format "Plain diff output %s\n"
+ (if (ediff-buffer-live-p ediff-diff-buffer)
+ (concat "\tin buffer "
+ (buffer-name ediff-diff-buffer))
+ " is not available")))
- (let* ((A-line (ediff-eval-in-buffer ediff-buffer-A
+ (let* ((A-line (ediff-with-current-buffer ediff-buffer-A
(1+ (count-lines (point-min) (point)))))
- (B-line (ediff-eval-in-buffer ediff-buffer-B
+ (B-line (ediff-with-current-buffer ediff-buffer-B
(1+ (count-lines (point-min) (point)))))
C-line)
(princ (format "\Buffer A's point is on line %d\n" A-line))
(princ (format "Buffer B's point is on line %d\n" B-line))
(if ediff-3way-job
(progn
- (setq C-line (ediff-eval-in-buffer ediff-buffer-C
+ (setq C-line (ediff-with-current-buffer ediff-buffer-C
(1+ (count-lines (point-min) (point)))))
(princ (format "Buffer C's point is on line %d\n" C-line)))))
ediff-number-of-differences) 'end)
(t (1+ ediff-current-difference)))))
- (cond (ediff-ignore-similar-regions
- (princ "\nSkipping regions that differ only in white space & line breaks"))
- (t
- (princ "\nNot skipping regions that differ in white space & line breaks")))
+ (princ
+ (format "\n%s regions that differ in white space & line breaks only"
+ (if ediff-ignore-similar-regions
+ "Ignoring" "Showing")))
+ (if (and ediff-merge-job ediff-show-clashes-only)
+ (princ
+ "\nFocusing on regions where both buffers differ from the ancestor"))
(cond ((eq ediff-skip-diff-region-function 'ediff-show-all-diffs)
- (princ "\nSelective browsing by regexp is off.\n"))
- ((eq ediff-skip-diff-region-function 'ediff-hide-regexp-matches)
+ (princ "\nSelective browsing by regexp is off\n"))
+ ((eq ediff-skip-diff-region-function
+ ediff-hide-regexp-matches-function)
(princ
"\nIgnoring regions that match")
(princ
"\n\t regexp `%s' in buffer A %S\n\t regexp `%s' in buffer B\n"
ediff-regexp-hide-A ediff-hide-regexp-connective
ediff-regexp-hide-B)))
- ((eq ediff-skip-diff-region-function 'ediff-focus-on-regexp-matches)
+ ((eq ediff-skip-diff-region-function
+ ediff-focus-on-regexp-matches-function)
(princ
"\nFocusing on regions that match")
(princ
(princ
(format "\nBugs/suggestions: type `%s' while in Ediff Control Panel."
(substitute-command-keys "\\[ediff-submit-report]")))
- ))
-
-(defun ediff-documentation ()
- "Jump to Ediff's Info file."
- (interactive)
- (let ((ctl-window ediff-control-window)
- (ctl-buf ediff-control-buffer))
-
- (ediff-skip-unsuitable-frames)
- (condition-case nil
- (progn
- (pop-to-buffer (get-buffer-create "*info*"))
- (info "ediff")
- (message "Type `i' to search for a specific topic"))
- (error (beep 1)
- (with-output-to-temp-buffer " *ediff-info*"
- (princ (format "
-The Info file for Ediff does not seem to be installed.
-
-This file is part of the distribution of %sEmacs.
-Please contact your system administrator. "
- (if ediff-xemacs-p "X" ""))))
- (if (window-live-p ctl-window)
- (progn
- (select-window ctl-window)
- (switch-to-buffer ctl-buf)))))))
+ ) ; with output
+ (if (frame-live-p ediff-control-frame)
+ (ediff-reset-mouse ediff-control-frame))
+ (if (window-live-p ediff-control-window)
+ (select-window ediff-control-window)))
(ediff-buffer-live-p ediff-buffer-B)
(ediff-valid-difference-p n))
(progn
- (if (and (ediff-window-display-p) ediff-use-faces)
+ (if (and (ediff-has-face-support-p) ediff-use-faces)
(progn
(ediff-highlight-diff n)
(setq ediff-highlighting-style 'face))
(if ediff-3way-job
(ediff-place-flags-in-buffer
'C ediff-buffer-C ediff-control-buffer n))
+ (if (ediff-buffer-live-p ediff-ancestor-buffer)
+ (ediff-place-flags-in-buffer
+ 'Ancestor ediff-ancestor-buffer
+ ediff-control-buffer n))
)
(ediff-install-fine-diff-if-necessary n)
- (run-hooks 'ediff-select-hooks))))
+ (run-hooks 'ediff-select-hook))))
;; Unselect a difference by removing the ASCII flags in the buffers.
(defun ediff-unselect-difference (n)
(if (ediff-valid-difference-p n)
(progn
- (cond ((and (ediff-window-display-p) ediff-use-faces)
+ (cond ((and (ediff-has-face-support-p) ediff-use-faces)
(ediff-unhighlight-diff))
((eq ediff-highlighting-style 'ascii)
(ediff-remove-flags-from-buffer
(ediff-remove-flags-from-buffer
ediff-buffer-C
(ediff-get-diff-overlay n 'C)))
+ (if (ediff-buffer-live-p ediff-ancestor-buffer)
+ (ediff-remove-flags-from-buffer
+ ediff-ancestor-buffer
+ (ediff-get-diff-overlay n 'Ancestor)))
))
(setq ediff-highlighting-style nil)
;; unhighlight fine diffs
(ediff-set-fine-diff-properties ediff-current-difference 'default)
- (run-hooks 'ediff-unselect-hooks))))
+ (run-hooks 'ediff-unselect-hook))))
;; Unselects prev diff and selects a new one, if FLAG has value other than
;; unselected. If FLAG is 'unselect-only then the current selection is
;; unselected, but the next one is not selected. If NO-RECENTER is non-nil,
;; don't recenter buffers after selecting/unselecting.
-;;
(defun ediff-unselect-and-select-difference (n &optional flag no-recenter)
(let ((ediff-current-difference n))
(or no-recenter
(setq ediff-current-difference n)
) ; end protected section
- (ediff-eval-in-buffer control-buf
- (ediff-refresh-mode-lines))
+ (ediff-with-current-buffer control-buf (ediff-refresh-mode-lines))
)))
;; hack default-dir if it is not set
(setq default-dir
(file-name-as-directory
- (abbreviate-file-name
+ (ediff-abbreviate-file-name
(expand-file-name (or default-dir
(and default-file
(file-name-directory default-file))
(let (f)
(setq f (expand-file-name
(read-file-name
- (format "%s%s: "
+ (format "%s%s "
prompt
- (if default-file
- (concat " (default " default-file ")")
- ""))
+ (cond (default-file
+ (concat " (default " default-file "):"))
+ (t (concat " (default " default-dir "):"))))
default-dir
- default-file
+ (or default-file default-dir)
t ; must match, no-confirm
(if default-file (file-name-directory default-file))
)
(file-name-nondirectory default-file) f)))
f))
-;; If `prefix' is given, then it is used as a prefix for the temp file
-;; name. Otherwise, `_buffer-name' is used. If `file' is given, use this
+;; If PREFIX is given, then it is used as a prefix for the temp file
+;; name. Otherwise, `ediff_' is used. If FILE is given, use this
;; file and don't create a new one.
+;; On MS-DOS, make sure the prefix isn't longer than 7 characters, or
+;; else `make-temp-name' isn't guaranteed to return a unique filename.
;; Also, save buffer from START to END in the file.
;; START defaults to (point-min), END to (point-max)
-(defun ediff-make-temp-file (&optional prefix given-file start end)
- (let ((f (or given-file
- (make-temp-name (concat
- ediff-temp-file-prefix
- (if prefix
- (concat prefix "_")
- "ediff_"))))))
+(defun ediff-make-temp-file (buff &optional prefix given-file start end)
+ (let ((p (or prefix "ediff"))
+ f)
+ (if (and (eq system-type 'ms-dos) (> (length p) 7))
+ (setq p (substring p 0 7)))
+
+ (setq f (concat ediff-temp-file-prefix p)
+ f (cond (given-file)
+ ((find-file-name-handler f 'find-file-noselect)
+ ;; to thwart file handlers in write-region, e.g., if file
+ ;; name ends with .Z or .gz
+ ;; This is needed so that patches produced by ediff will
+ ;; have more meaningful names
+ (make-temp-name f))
+ ;; Prefix is most often the same as the file name for the
+ ;; variant. Here we are trying to use the original file name
+ ;; but in the temp directory.
+ ((and prefix (not (file-exists-p f))) f)
+ ;; If a file with the orig name exists, add some random stuff
+ ;; to it.
+ (t (make-temp-name f))))
+
;; create the file
- (write-region (if start start (point-min))
- (if end end (point-max))
- f
- nil ; don't append---erase
- 'no-message)
- (set-file-modes f ediff-temp-file-mode)
- f))
+ (ediff-with-current-buffer buff
+ (write-region (if start start (point-min))
+ (if end end (point-max))
+ f
+ nil ; don't append---erase
+ 'no-message)
+ (set-file-modes f ediff-temp-file-mode)
+ (ediff-convert-standard-filename (expand-file-name f)))))
;; Quote metacharacters (using \) when executing diff in Unix, but not in
;; EMX OS/2
-(defun ediff-protect-metachars (str)
- (or (memq system-type '(emx vax-vms axp-vms))
- (let ((limit 0))
- (while (string-match ediff-metachars str limit)
- (setq str (concat (substring str 0 (match-beginning 0))
- "\\"
- (substring str (match-beginning 0))))
- (setq limit (1+ (match-end 0))))))
- str)
+;;(defun ediff-protect-metachars (str)
+;; (or (memq system-type '(emx vax-vms axp-vms))
+;; (let ((limit 0))
+;; (while (string-match ediff-metachars str limit)
+;; (setq str (concat (substring str 0 (match-beginning 0))
+;; "\\"
+;; (substring str (match-beginning 0))))
+;; (setq limit (1+ (match-end 0))))))
+;; str)
;; Make sure the current buffer (for a file) has the same contents as the
;; file on disk, and attempt to remedy the situation if not.
;; Signal an error if we can't make them the same, or the user doesn't want
;; to do what is necessary to make them the same.
-;; If file has file handlers (indicated by the optional arg), then we
-;; offer to instead of saving. This is one difference with Emerge.
-;; Another is that we always offer to revert obsolete files, whether they
+;; Also, Ediff always offers to revert obsolete buffers, whether they
;; are modified or not.
(defun ediff-verify-file-buffer (&optional file-magic)
;; First check if the file has been modified since the buffer visited it.
(if (buffer-modified-p)
;; If buffer is not obsolete and is modified, offer to save
(if (yes-or-no-p
- (format "Buffer out of sync with visited file. %s file %s? "
- (if file-magic "Revert" "Save")
+ (format "Buffer out of sync with visited file. Save file %s? "
buffer-file-name))
- (if (not file-magic)
+ (condition-case nil
(save-buffer)
- ;; for some reason, file-name-handlers append instead of
- ;; replacing, so we have to erase first.
- (erase-buffer)
- (revert-buffer t t))
- (error "Buffer out of sync for file %s" buffer-file-name))
+ (error
+ (beep)
+ (message "Couldn't save %s" buffer-file-name)))
+ (error "Buffer is out of sync for file %s" buffer-file-name))
;; If buffer is not obsolete and is not modified, do nothing
nil)
;; If buffer is obsolete, offer to revert
(if (yes-or-no-p
- (format "Buffer out of sync with visited file. Revert file %s? "
+ (format "Buffer is out of sync with visited file. REVERT file %s? "
buffer-file-name))
(progn
(if file-magic
(error "Buffer out of sync for file %s" buffer-file-name))))
+(defun ediff-filename-magic-p (file)
+ (or (ediff-file-compressed-p file)
+ (ediff-file-remote-p file)))
+
-(defun ediff-check-for-ascii-flags ()
- (eval
- (cons 'or
- (mapcar (function (lambda (buf)
- (if (ediff-buffer-live-p buf)
- (ediff-eval-in-buffer buf
- (eq ediff-highlighting-style 'ascii)))))
- ediff-this-buffer-control-sessions))))
-
-;; It would be nice to use these two functions as hooks instead of
-;; ediff-insert-in-front and ediff-move-disturbed-overlays.
-;; However, Emacs has a bug that causes BEG and END, below, to be
-;; the same, i.e., the end of inserted text is not passed correctly.
-;; Since the overlay doesn't move when these hooks run,
-;; there is no way to correctly determine the new (desired) position of
-;; the overlay end.
-;; Either this bug is fixed, or (better) use sticky overlays when they will
-;; be implemented in Emacs, like they are in XEmacs.
-;;(defun ediff-capture-inserts-in-front (overl beg end)
-;; (if (ediff-overlay-get overl 'ediff-diff-num)
-;; (ediff-move-overlay
-;; overl beg (+ (- end beg) (ediff-overlay-end overl)))
-;; ))
-;;(defun ediff-capture-inserts-behind (overl beg end)
-;; (if (ediff-overlay-get overl 'ediff-diff-num)
-;; (ediff-move-overlay overl (ediff-overlay-start overl) end))
-;; ))
-
-;; to be deleted in due time
-;; Capture overlays that had insertions in the front.
-;; Called when overlay OVERL gets insertion in front.
-(defun ediff-insert-in-front (overl &optional flag beg end length)
- (if (ediff-overlay-get overl 'ediff-diff-num)
- (setq ediff-disturbed-overlays
- (cons overl ediff-disturbed-overlays))))
-
-
-;; to be deleted in due time
-;; We can't move overlays directly in insert-in-front-hooks
-;; because when diff is highlighted with ascii flags, they will disturb
-;; overlays and so they will be included in them, which we don't want.
-(defun ediff-move-disturbed-overlays (posn)
- (mapcar (function (lambda (overl)
- (ediff-move-overlay overl
- posn
- (ediff-overlay-end overl))
- ))
- ediff-disturbed-overlays)
- (setq ediff-disturbed-overlays nil))
-
-
(defun ediff-save-buffer (arg)
"Safe way of saving buffers A, B, C, and the diff output.
`wa' saves buffer A, `wb' saves buffer B, `wc' saves buffer C,
-and `wd' saves the diff output."
+and `wd' saves the diff output.
+
+With prefix argument, `wd' saves plain diff output.
+Without an argument, it saves customized diff argument, if available
+\(and plain output, if customized output was not generated\)."
(interactive "P")
- (ediff-eval-in-buffer
+ (ediff-barf-if-not-control-buffer)
+ (ediff-compute-custom-diffs-maybe)
+ (ediff-with-current-buffer
(cond ((memq last-command-char '(?a ?b ?c))
(ediff-get-buffer
(ediff-char-to-buftype last-command-char)))
((eq last-command-char ?d)
- (message "Saving diff output ...")(sit-for 1)
- (if arg ediff-diff-buffer ediff-custom-diff-buffer)
- ))
+ (message "Saving diff output ...")
+ (sit-for 1) ; let the user see the message
+ (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
+ ediff-diff-buffer)
+ ((ediff-buffer-live-p ediff-custom-diff-buffer)
+ ediff-custom-diff-buffer)
+ ((ediff-buffer-live-p ediff-diff-buffer)
+ ediff-diff-buffer)
+ (t (error "Output from `diff' not found"))))
+ )
(save-buffer)))
+
+(defun ediff-compute-custom-diffs-maybe ()
+ (let ((buf-A-file-name (buffer-file-name ediff-buffer-A))
+ (buf-B-file-name (buffer-file-name ediff-buffer-B))
+ file-A file-B)
+ (if (stringp buf-A-file-name)
+ (setq buf-A-file-name (file-name-nondirectory buf-A-file-name)))
+ (if (stringp buf-B-file-name)
+ (setq buf-B-file-name (file-name-nondirectory buf-B-file-name)))
+ (setq file-A (ediff-make-temp-file ediff-buffer-A buf-A-file-name)
+ file-B (ediff-make-temp-file ediff-buffer-B buf-B-file-name))
+
+ (or (ediff-buffer-live-p ediff-custom-diff-buffer)
+ (setq ediff-custom-diff-buffer
+ (get-buffer-create
+ (ediff-unique-buffer-name "*ediff-custom-diff" "*"))))
+ (ediff-exec-process
+ ediff-custom-diff-program ediff-custom-diff-buffer 'synchronize
+ ediff-custom-diff-options file-A file-B)
+ (delete-file file-A)
+ (delete-file file-B)
+ ))
+
+(defun ediff-show-diff-output (arg)
+ (interactive "P")
+ (ediff-barf-if-not-control-buffer)
+ (ediff-compute-custom-diffs-maybe)
+ (save-excursion
+ (ediff-skip-unsuitable-frames ' ok-unsplittable))
+ (let ((buf (cond ((and arg (ediff-buffer-live-p ediff-diff-buffer))
+ ediff-diff-buffer)
+ ((ediff-buffer-live-p ediff-custom-diff-buffer)
+ ediff-custom-diff-buffer)
+ ((ediff-buffer-live-p ediff-diff-buffer)
+ ediff-diff-buffer)
+ (t
+ (beep)
+ (message "Output from `diff' not found")
+ nil))))
+ (if buf
+ (progn
+ (ediff-with-current-buffer buf
+ (goto-char (point-min)))
+ (switch-to-buffer buf)
+ (raise-frame (selected-frame)))))
+ (if (frame-live-p ediff-control-frame)
+ (ediff-reset-mouse ediff-control-frame))
+ (if (window-live-p ediff-control-window)
+ (select-window ediff-control-window)))
+
+
+(defun ediff-inferior-compare-regions ()
+ "Compare regions in an active Ediff session.
+Like ediff-regions-linewise but is called from under an active Ediff session on
+the files that belong to that session.
+
+After quitting the session invoked via this function, type C-l to the parent
+Ediff Control Panel to restore highlighting."
+ (interactive)
+ (let ((answer "")
+ (possibilities (list ?A ?B ?C))
+ (zmacs-regions t)
+ (ctl-buf (current-buffer))
+ quit-now
+ begA begB endA endB bufA bufB)
+
+ (cond ((ediff-merge-job)
+ (setq bufB ediff-buffer-C)
+ (while (cond ((eq answer ?A)
+ (setq bufA ediff-buffer-A
+ possibilities '(?B))
+ nil)
+ ((eq answer ?B)
+ (setq bufA ediff-buffer-B
+ possibilities '(?A))
+ nil)
+ ((equal answer ""))
+ (t (beep 1)
+ (message "Valid values are A or B")
+ (sit-for 2)
+ t))
+ (let ((cursor-in-echo-area t))
+ (message "Which buffer to compare to the merge buffer (A/B)? ")
+ (setq answer (capitalize (read-char-exclusive))))))
+
+ ((ediff-3way-comparison-job)
+ (while (cond ((memq answer possibilities)
+ (setq possibilities (delq answer possibilities))
+ (setq bufA
+ (eval
+ (ediff-get-symbol-from-alist
+ answer ediff-buffer-alist)))
+ nil)
+ ((equal answer ""))
+ (t (beep 1)
+ (message
+ "Valid values are %s"
+ (mapconcat 'char-to-string possibilities " or "))
+ (sit-for 2)
+ t))
+ (let ((cursor-in-echo-area t))
+ (message "Enter the 1st buffer you want to compare (%s): "
+ (mapconcat 'char-to-string possibilities "/"))
+ (setq answer (capitalize (read-char-exclusive)))))
+ (setq answer "") ; silence error msg
+ (while (cond ((memq answer possibilities)
+ (setq possibilities (delq answer possibilities))
+ (setq bufB
+ (eval
+ (ediff-get-symbol-from-alist
+ answer ediff-buffer-alist)))
+ nil)
+ ((equal answer ""))
+ (t (beep 1)
+ (message
+ "Valid values are %s"
+ (mapconcat 'char-to-string possibilities " or "))
+ (sit-for 2)
+ t))
+ (let ((cursor-in-echo-area t))
+ (message "Enter the 2nd buffer you want to compare (%s): "
+ (mapconcat 'char-to-string possibilities "/"))
+ (setq answer (capitalize (read-char-exclusive))))))
+ (t ; 2way comparison
+ (setq bufA ediff-buffer-A
+ bufB ediff-buffer-B
+ possibilities nil)))
+
+ (ediff-with-current-buffer bufA
+ (or (mark t)
+ (error "You forgot to specify a region in buffer %s" (buffer-name)))
+ (setq begA (region-beginning)
+ endA (region-end))
+ (goto-char begA)
+ (beginning-of-line)
+ (setq begA (point))
+ (goto-char endA)
+ (end-of-line)
+ (or (eobp) (forward-char)) ; include the newline char
+ (setq endA (point)))
+ (ediff-with-current-buffer bufB
+ (or (mark t)
+ (error "You forgot to specify a region in buffer %s" (buffer-name)))
+ (setq begB (region-beginning)
+ endB (region-end))
+ (goto-char begB)
+ (beginning-of-line)
+ (setq begB (point))
+ (goto-char endB)
+ (end-of-line)
+ (or (eobp) (forward-char)) ; include the newline char
+ (setq endB (point)))
+
+ (ediff-unselect-and-select-difference
+ ediff-current-difference 'unselect-only)
+ (ediff-paint-background-regions 'unhighlight)
+
+ (ediff-with-current-buffer bufA
+ (goto-char begA)
+ (set-mark endA)
+ (narrow-to-region begA endA)
+ ;; (ediff-activate-mark)
+ )
+ ;; (sit-for 0)
+ (ediff-with-current-buffer bufB
+ (goto-char begB)
+ (set-mark endB)
+ (narrow-to-region begB endB)
+ ;; (ediff-activate-mark)
+ )
+ ;; (sit-for 0)
+
+ ;; At this point, possibilities contains either the window char A/B/C
+ ;; that was not selected, or it is nil. We delete the window that is not
+ ;; selected.
+ (if possibilities
+ (ediff-with-current-buffer ctl-buf
+ (let* ((wind-to-delete (eval
+ (ediff-get-symbol-from-alist
+ (car possibilities)
+ ediff-window-alist)))
+ (frame (window-frame wind-to-delete)))
+ (delete-window wind-to-delete)
+ (select-frame frame)
+ (balance-windows))))
+ (or (y-or-n-p
+ "Please check regions selected for comparison. Continue? ")
+ (setq quit-now t))
+
+ (ediff-with-current-buffer bufA
+ (widen))
+ (ediff-with-current-buffer bufB
+ (widen))
+ (if quit-now
+ (ediff-with-current-buffer ctl-buf
+ (ediff-recenter)
+ (sit-for 0)
+ (error "All right. Make up your mind and come back...")))
+
+ (ediff-regions-internal
+ bufA begA endA bufB begB endB
+ nil ; setup-hook
+ 'ediff-regions-linewise ; job name
+ nil ; no word mode
+ ;; setup param to pass to ediff-setup
+ (list (cons 'ediff-split-window-function ediff-split-window-function)))
+ ))
+
-;; will simplify it in due time, when emacs acquires before/after strings
(defun ediff-remove-flags-from-buffer (buffer overlay)
- (ediff-eval-in-buffer buffer
+ (ediff-with-current-buffer buffer
(let ((inhibit-read-only t))
(if ediff-xemacs-p
(ediff-overlay-put overlay 'begin-glyph nil)
- ;; before-string is not yet implemented in emacs.
- ;; when it will be, I will be able to delete much of the rest of
- ;; this function
(ediff-overlay-put overlay 'before-string nil))
(if ediff-xemacs-p
(ediff-overlay-put overlay 'end-glyph nil)
- ;; after-string is not yet implemented in emacs.
(ediff-overlay-put overlay 'after-string nil))
)))
-;; will simplify it in due time, when emacs acquires before/after strings
(defun ediff-place-flags-in-buffer (buf-type buffer ctl-buffer diff)
- (ediff-eval-in-buffer buffer
+ (ediff-with-current-buffer buffer
(ediff-place-flags-in-buffer1 buf-type ctl-buffer diff)))
(defun ediff-place-flags-in-buffer1 (buf-type ctl-buffer diff-no)
- (let* ((curr-overl (ediff-eval-in-buffer ctl-buffer
+ (let* ((curr-overl (ediff-with-current-buffer ctl-buffer
(ediff-get-diff-overlay diff-no buf-type)))
(before (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer))
after beg-of-line flag)
(goto-char before)
(setq beg-of-line (bolp))
- (setq flag (ediff-eval-in-buffer ctl-buffer
+ (setq flag (ediff-with-current-buffer ctl-buffer
(if (eq ediff-highlighting-style 'ascii)
(if beg-of-line
ediff-before-flag-bol ediff-before-flag-mol))))
(goto-char after)
(setq beg-of-line (bolp))
- (setq flag (ediff-eval-in-buffer ctl-buffer
+ (setq flag (ediff-with-current-buffer ctl-buffer
(if (eq ediff-highlighting-style 'ascii)
(if beg-of-line
ediff-after-flag-eol ediff-after-flag-mol))))
))
+;; Returns positions of difference sectors in the BUF-TYPE buffer.
+;; BUF-TYPE should be a symbol -- `A', `B', or `C'.
+;; POS is either `beg' or `end'--it specifies whether you want the position at
+;; the beginning of a difference or at the end.
+;;
+;; The optional argument N says which difference (default:
+;; `ediff-current-difference'). N is the internal difference number (1- what
+;; the user sees). The optional argument CONTROL-BUF says
+;; which control buffer is in effect in case it is not the current
+;; buffer.
(defun ediff-get-diff-posn (buf-type pos &optional n control-buf)
- "Returns positions of difference sectors in the BUF-TYPE buffer.
-BUF-TYPE should be a symbol--either `A' or `B'.
-POS is either `beg' or `end'--it specifies whether you want the position at the
-beginning of a difference or at the end.
-
-The optional argument N says which difference \(default:
-`ediff-current-difference'\). The optional argument CONTROL-BUF says
-which control buffer is in effect in case it is not the current
-buffer."
(let (diff-overlay)
(or control-buf
(setq control-buf (current-buffer)))
- (ediff-eval-in-buffer control-buf
+ (ediff-with-current-buffer control-buf
(or n (setq n ediff-current-difference))
(if (or (< n 0) (>= n ediff-number-of-differences))
(if (> ediff-number-of-differences 0)
- (error "There is no diff %d. Valid diffs are 1 to %d"
- (1+ n) ediff-number-of-differences)
- (error "No differences found")))
+ (error ediff-BAD-DIFF-NUMBER
+ this-command (1+ n) ediff-number-of-differences)
+ (error ediff-NO-DIFFERENCES)))
(setq diff-overlay (ediff-get-diff-overlay n buf-type)))
-
+ (if (not (ediff-buffer-live-p (ediff-overlay-buffer diff-overlay)))
+ (error ediff-KILLED-VITAL-BUFFER))
(if (eq pos 'beg)
(ediff-overlay-start diff-overlay)
(ediff-overlay-end diff-overlay))
))
+;; Restore highlighting to what it should be according to ediff-use-faces,
+;; ediff-highlighting-style, and ediff-highlight-all-diffs variables.
+(defun ediff-restore-highlighting (&optional ctl-buf)
+ (ediff-with-current-buffer (or ctl-buf (current-buffer))
+ (if (and (ediff-has-face-support-p)
+ ediff-use-faces
+ ediff-highlight-all-diffs)
+ (ediff-paint-background-regions))
+ (ediff-select-difference ediff-current-difference)))
-(defun ediff-highlight-diff-in-one-buffer (n buf-type)
- (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
- (let* ((buff (ediff-get-buffer buf-type))
- (last (ediff-eval-in-buffer buff (point-max)))
- (begin (ediff-get-diff-posn buf-type 'beg n))
- (end (ediff-get-diff-posn buf-type 'end n))
- (xtra (if (equal begin end) 1 0))
- (end-hilit (min last (+ end xtra)))
- (current-diff-overlay
- (symbol-value
- (intern (format "ediff-current-diff-overlay-%S" buf-type))))
- (odd-diff-face
- (symbol-value
- (intern (format "ediff-odd-diff-face-%S" buf-type))))
- (even-diff-face
- (symbol-value
- (intern (format "ediff-even-diff-face-%S" buf-type))))
- (odd-diff-face-var
- (intern (format "ediff-odd-diff-face-%S-var" buf-type)))
- (even-diff-face-var
- (intern (format "ediff-even-diff-face-%S-var" buf-type)))
- )
-
- (if ediff-xemacs-p
- (ediff-move-overlay current-diff-overlay begin end-hilit)
- (ediff-move-overlay current-diff-overlay begin end-hilit buff))
- ;; giving priority of 0 and then changing it may look funny, but
- ;; this overcomes an obscure Emacs bug.
- (ediff-overlay-put current-diff-overlay 'priority 0)
- (ediff-overlay-put current-diff-overlay 'priority
- (ediff-highest-priority begin end-hilit buff))
-
- (or (face-differs-from-default-p odd-diff-face-var)
- (not ediff-highlight-all-diffs)
- (progn
- (copy-face odd-diff-face odd-diff-face-var)
- (copy-face even-diff-face even-diff-face-var)))
-
- ;; unhighlight the background overlay for diff n so they won't
- ;; interfere with the current diff overlay
- (ediff-overlay-put (ediff-get-diff-overlay n buf-type) 'face nil)
- )))
-
-
-(defun ediff-unhighlight-diff-in-one-buffer (buf-type)
- (if (ediff-buffer-live-p (ediff-get-buffer buf-type))
- (let ((current-diff-overlay
- (symbol-value
- (intern (format "ediff-current-diff-overlay-%S" buf-type))))
- (odd-diff-face-var
- (intern (format "ediff-odd-diff-face-%S-var" buf-type)))
- (even-diff-face-var
- (intern (format "ediff-even-diff-face-%S-var" buf-type)))
- (overlay
- (ediff-get-diff-overlay ediff-current-difference buf-type))
- )
-
- (ediff-move-overlay current-diff-overlay 1 1)
-
- ;; rehighlight the overlay in the background of the
- ;; current difference region
- (ediff-overlay-put overlay
- 'face (if (ediff-odd-p ediff-current-difference)
- odd-diff-face-var
- even-diff-face-var))
- )))
-
-(defun ediff-unhighlight-diffs-totally-in-one-buffer (buf-type)
- (ediff-unselect-and-select-difference -1)
- (if (and (ediff-window-display-p) ediff-use-faces)
- (let* ((inhibit-quit t)
- (current-diff-overlay-var
- (intern (format "ediff-current-diff-overlay-%S" buf-type)))
- (current-diff-overlay (symbol-value current-diff-overlay-var))
- (odd-diff-face-var
- (intern (format "ediff-odd-diff-face-%S-var" buf-type)))
- (even-diff-face-var
- (intern (format "ediff-even-diff-face-%S-var" buf-type))))
- (if (face-differs-from-default-p odd-diff-face-var)
- (progn
- (copy-face 'default odd-diff-face-var)
- (copy-face 'default even-diff-face-var)))
- (if (ediff-overlayp current-diff-overlay)
- (ediff-delete-overlay current-diff-overlay))
- (set current-diff-overlay-var nil)
- )))
;; null out difference overlays so they won't slow down future
(symbol-value vec-var)))
;; allow them to be garbage collected
(set vec-var nil))
-
+
\f
;;; Misc
-;; These two functions are here to neutralize XEmacs unwillingless to
-;; handle overlays whose buffers were deleted.
-(defun ediff-move-overlay (overlay beg end &optional buffer)
- "Calls `move-overlay' in Emacs and `set-extent-endpoints' in Lemacs.
-Checks if overlay's buffer exists before actually doing the move."
- (let ((buf (and overlay (ediff-overlay-buffer overlay))))
- (if (ediff-buffer-live-p buf)
- (if ediff-xemacs-p
- (set-extent-endpoints overlay beg end)
- (move-overlay overlay beg end buffer))
- ;; buffer's dead
- (if overlay
- (ediff-delete-overlay overlay)))))
-
-(defun ediff-overlay-put (overlay prop value)
- "Calls `overlay-put' or `set-extent-property' depending on Emacs version.
-Checks if overlay's buffer exists."
- (if (ediff-buffer-live-p (ediff-overlay-buffer overlay))
- (if ediff-xemacs-p
- (set-extent-property overlay prop value)
- (overlay-put overlay prop value))
- (ediff-delete-overlay overlay)))
-
-
;; In Emacs, this just makes overlay. In the future, when Emacs will start
;; supporting sticky overlays, this function will make a sticky overlay.
;; BEG and END are expressions telling where overlay starts.
(defun ediff-make-bullet-proof-overlay (beg end buff)
(if (ediff-buffer-live-p buff)
(let (overl)
- (ediff-eval-in-buffer buff
+ (ediff-with-current-buffer buff
(or (number-or-marker-p beg)
(setq beg (eval beg)))
(or (number-or-marker-p end)
(setq end (eval end)))
- (setq overl (ediff-make-overlay beg end buff))
+ (setq overl
+ (if ediff-xemacs-p
+ (make-extent beg end buff)
+ ;; advance front and rear of the overlay
+ (make-overlay beg end buff nil 'rear-advance)))
+ ;; never detach
+ (ediff-overlay-put
+ overl (if ediff-emacs-p 'evaporate 'detachable) nil)
+ ;; make vip-minibuffer-overlay open-ended
+ ;; In emacs, it is made open ended at creation time
(if ediff-xemacs-p
(progn
- ;; take precautions against detached extents
- (ediff-overlay-put overl 'detachable nil)
- ;; chars inserted at both ends will be inside extent
- (ediff-overlay-put overl 'start-open nil)
- (ediff-overlay-put overl 'end-open nil))
- (ediff-overlay-put overl 'ediff-diff-num 0)
- ;;(ediff-overlay-put overl 'insert-in-front-hooks
- ;; (list 'ediff-capture-inserts-in-front))
- ;;(ediff-overlay-put overl 'insert-behind-hooks
- ;; (list 'ediff-capture-inserts-behind))
- ;; These two are not yet implemented in Emacs
- ;;(ediff-overlay-put overl 'rear-sticky t)
- ;;(ediff-overlay-put overl 'front-sticky t)
- )
+ (ediff-overlay-put overl 'start-open nil)
+ (ediff-overlay-put overl 'end-open nil)))
+ (ediff-overlay-put overl 'ediff-diff-num 0)
overl))))
-(defsubst ediff-overlay-start (overl)
- (if (ediff-overlayp overl)
- (if ediff-emacs-p
- (overlay-start overl)
- (extent-start-position overl))))
-
-(defsubst ediff-overlay-end (overl)
- (if (ediff-overlayp overl)
- (if ediff-emacs-p
- (overlay-end overl)
- (extent-end-position overl))))
-
;; Like other-buffer, but prefers visible buffers and ignores temporary or
;; other insignificant buffers (those beginning with "^[ *]").
;; Gets one arg--buffer name or a list of buffer names (it won't return
;; these buffers).
-(defun ediff-other-buffer (buff)
- (if (not (listp buff)) (setq buff (list buff)))
+(defun ediff-other-buffer (buff-lst)
+ (or (listp buff-lst) (setq buff-lst (list buff-lst)))
(let* ((frame-buffers (buffer-list))
+ (buff-name-list
+ (mapcar
+ (function (lambda (b)
+ (cond ((stringp b) b)
+ ((bufferp b) (buffer-name b)))))
+ buff-lst))
(significant-buffers
(mapcar
(function (lambda (x)
- (cond ((member (buffer-name x) buff)
- nil)
- ((not (ediff-get-visible-buffer-window x))
- nil)
- ((string-match "^ " (buffer-name x))
+ (cond ((member (buffer-name x) buff-name-list) nil)
+ ((not (ediff-get-visible-buffer-window x)) nil)
+ ((string-match "^[ *]" (buffer-name x)) nil)
+ ((memq (ediff-with-current-buffer x major-mode)
+ '(dired-mode))
nil)
(t x))))
frame-buffers))
(mapcar
(function
(lambda (x)
- (cond ((member (buffer-name x) buff) nil)
+ (cond ((member (buffer-name x) buff-name-list) nil)
((string-match "^[ *]" (buffer-name x)) nil)
+ ((memq
+ (ediff-with-current-buffer x major-mode)
+ '(dired-mode))
+ nil)
(t x))))
frame-buffers)))
(car less-significant-buffers))
(defun ediff-submit-report ()
"Submit bug report on Ediff."
(interactive)
+ (ediff-barf-if-not-control-buffer)
(let ((reporter-prompt-for-summary-p t)
(ctl-buf ediff-control-buffer)
(ediff-device-type (ediff-device-type))
(bury-buffer)
(beep 1)(message "Bug report aborted")
(if (ediff-buffer-live-p ctl-buf)
- (ediff-eval-in-buffer ctl-buf
+ (ediff-with-current-buffer ctl-buf
(ediff-recenter 'no-rehighlight))))
))
-(defun ediff-union (list1 list2)
- "Combine LIST1 and LIST2 using a set-union operation.
-The result list contains all items that appear in either LIST1 or LIST2.
-This is a non-destructive function; it makes a copy of the data if necessary
-to avoid corrupting the original LIST1 and LIST2.
-This is a slightly simplified version from `cl-seq.el'. Added here to
-avoid loading cl-*."
- (cond ((null list1) list2) ((null list2) list1)
- ((equal list1 list2) list1)
- (t
- (or (>= (length list1) (length list2))
- (setq list1 (prog1 list2 (setq list2 list1))))
- (while list2
- (or (memq (car list2) list1)
- (setq list1 (cons (car list2) list1)))
- (setq list2 (cdr list2)))
- list1)))
-
(defun ediff-deactivate-mark ()
(if ediff-xemacs-p
(zmacs-deactivate-region)
(deactivate-mark)))
+(defun ediff-activate-mark ()
+ (if ediff-emacs-p
+ (setq mark-active t)
+ (zmacs-activate-region)))
(cond ((fboundp 'nuke-selective-display)
;; XEmacs 19.12 has nuke-selective-display
(while vars
(set (car vars) (cdr (assoc (car vars) assoc-list)))
(setq vars (cdr vars))))
+
(defun ediff-change-saved-variable (var value buf-type)
(let* ((assoc-list
- (symbol-value (intern
- (concat "ediff-buffer-values-orig-"
- (symbol-name buf-type)))))
+ (symbol-value (ediff-get-symbol-from-alist
+ buf-type
+ ediff-buffer-values-orig-alist)))
(assoc-elt (assoc var assoc-list)))
(if assoc-elt
(setcdr assoc-elt value))))
;; must execute in control buf
(defun ediff-save-protected-variables ()
(setq ediff-buffer-values-orig-A
- (ediff-eval-in-buffer ediff-buffer-A
+ (ediff-with-current-buffer ediff-buffer-A
(ediff-save-variables ediff-protected-variables)))
(setq ediff-buffer-values-orig-B
- (ediff-eval-in-buffer ediff-buffer-B
+ (ediff-with-current-buffer ediff-buffer-B
(ediff-save-variables ediff-protected-variables)))
(if ediff-3way-comparison-job
(setq ediff-buffer-values-orig-C
- (ediff-eval-in-buffer ediff-buffer-C
+ (ediff-with-current-buffer ediff-buffer-C
+ (ediff-save-variables ediff-protected-variables))))
+ (if (ediff-buffer-live-p ediff-ancestor-buffer)
+ (setq ediff-buffer-values-orig-Ancestor
+ (ediff-with-current-buffer ediff-ancestor-buffer
(ediff-save-variables ediff-protected-variables)))))
;; must execute in control buf
(defun ediff-restore-protected-variables ()
(let ((values-A ediff-buffer-values-orig-A)
(values-B ediff-buffer-values-orig-B)
- (values-C ediff-buffer-values-orig-C))
- (ediff-eval-in-buffer ediff-buffer-A
- (ediff-restore-variables ediff-protected-variables values-A))
- (ediff-eval-in-buffer ediff-buffer-B
- (ediff-restore-variables ediff-protected-variables values-B))
- (if ediff-3way-comparison-job
- (ediff-eval-in-buffer ediff-buffer-C
- (ediff-restore-variables ediff-protected-variables values-C)))))
+ (values-C ediff-buffer-values-orig-C)
+ (values-Ancestor ediff-buffer-values-orig-Ancestor))
+ (ediff-with-current-buffer ediff-buffer-A
+ (ediff-restore-variables ediff-protected-variables values-A))
+ (ediff-with-current-buffer ediff-buffer-B
+ (ediff-restore-variables ediff-protected-variables values-B))
+ (if ediff-3way-comparison-job
+ (ediff-with-current-buffer ediff-buffer-C
+ (ediff-restore-variables ediff-protected-variables values-C)))
+ (if (ediff-buffer-live-p ediff-ancestor-buffer)
+ (ediff-with-current-buffer ediff-ancestor-buffer
+ (ediff-restore-variables ediff-protected-variables values-Ancestor)))
+ ))
+
+;; save BUFFER in FILE. used in hooks.
+(defun ediff-save-buffer-in-file (buffer file)
+ (ediff-with-current-buffer buffer
+ (write-file file)))
;;; Debug
(defun ediff-profile ()
"Toggle profiling Ediff commands."
(interactive)
- (or (ediff-buffer-live-p ediff-control-buffer)
- (error "This command runs only out of Ediff Control Buffer"))
- (make-local-hook 'pre-command-hook)
+ (ediff-barf-if-not-control-buffer)
(make-local-hook 'post-command-hook)
- (if (memq 'ediff-save-time pre-command-hook)
- (progn (remove-hook 'pre-command-hook 'ediff-save-time t)
- (remove-hook 'post-command-hook 'ediff-calc-command-time t)
- (setq ediff-command-begin-time '(0 0 0))
- (message "Ediff profiling disabled"))
- (add-hook 'pre-command-hook 'ediff-save-time t t)
- (add-hook 'post-command-hook 'ediff-calc-command-time nil t)
- (message "Ediff profiling enabled")))
+ (let ((pre-hook 'pre-command-hook)
+ (post-hook 'post-command-hook))
+ (if (not (equal ediff-command-begin-time '(0 0 0)))
+ (progn (remove-hook pre-hook 'ediff-save-time)
+ (remove-hook post-hook 'ediff-calc-command-time)
+ (setq ediff-command-begin-time '(0 0 0))
+ (message "Ediff profiling disabled"))
+ (add-hook pre-hook 'ediff-save-time t t)
+ (add-hook post-hook 'ediff-calc-command-time nil t)
+ (message "Ediff profiling enabled"))))
(defun ediff-print-diff-vector (diff-vector-var)
(princ (format "\n*** %S ***\n" diff-vector-var))
(defun ediff-debug-info ()
(interactive)
- (or (ediff-buffer-live-p ediff-control-buffer)
- (error "This command runs only out of Ediff Control Buffer"))
+ (ediff-barf-if-not-control-buffer)
(with-output-to-temp-buffer ediff-debug-buffer
(princ (format "\nCtl buffer: %S\n" ediff-control-buffer))
- (ediff-print-diff-vector (intern (concat "ediff-difference-vector-" "A")))
- (ediff-print-diff-vector (intern (concat "ediff-difference-vector-" "B")))
- (ediff-print-diff-vector (intern (concat "ediff-difference-vector-" "C")))
+ (ediff-print-diff-vector (intern "ediff-difference-vector-A"))
+ (ediff-print-diff-vector (intern "ediff-difference-vector-B"))
+ (ediff-print-diff-vector (intern "ediff-difference-vector-C"))
+ (ediff-print-diff-vector (intern "ediff-difference-vector-Ancestor"))
))
+
+;;; General utilities
+
+;; this uses comparison-func to decide who is a member
+(defun ediff-member (elt lis comparison-func)
+ (while (and lis (not (funcall comparison-func (car lis) elt)))
+ (setq lis (cdr lis)))
+ lis)
+
+;; this uses comparison-func to decide who is a member, and this determines how
+;; intersection looks like
+(defun ediff-intersection (lis1 lis2 comparison-func)
+ (let ((result (list 'a)))
+ (while lis1
+ (if (ediff-member (car lis1) lis2 comparison-func)
+ (nconc result (list (car lis1))))
+ (setq lis1 (cdr lis1)))
+ (cdr result)))
+
+
+;; eliminates duplicates using comparison-func
+(defun ediff-union (lis1 lis2 comparison-func)
+ (let ((result (list 'a)))
+ (while lis1
+ (or (ediff-member (car lis1) (cdr result) comparison-func)
+ (nconc result (list (car lis1))))
+ (setq lis1 (cdr lis1)))
+ (while lis2
+ (or (ediff-member (car lis2) (cdr result) comparison-func)
+ (nconc result (list (car lis2))))
+ (setq lis2 (cdr lis2)))
+ (cdr result)))
+
+;; eliminates duplicates using comparison-func
+(defun ediff-set-difference (lis1 lis2 comparison-func)
+ (let ((result (list 'a)))
+ (while lis1
+ (or (ediff-member (car lis1) (cdr result) comparison-func)
+ (ediff-member (car lis1) lis2 comparison-func)
+ (nconc result (list (car lis1))))
+ (setq lis1 (cdr lis1)))
+ (cdr result)))
+
+(defun ediff-copy-list (list)
+ (if (consp list)
+ ;;;(let ((res nil))
+ ;;; (while (consp list) (push (pop list) res))
+ ;;; (prog1 (nreverse res) (setcdr res list)))
+ (let (res elt)
+ (while (consp list)
+ (setq elt (car list)
+ res (cons elt res)
+ list (cdr list)))
+ (nreverse res))
+ (car list)))
+
+
;; don't report error if version control package wasn't found
;;(ediff-load-version-control 'silent)
-(run-hooks 'ediff-load-hooks)
+(run-hooks 'ediff-load-hook)
;;; Local Variables:
;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
-;;; eval: (put 'ediff-eval-in-buffer 'lisp-indent-hook 1)
+;;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1)
+;;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body))
;;; End:
-(provide 'ediff-util)
-
;;; ediff-util.el ends here