;;; ediff-util.el --- the core commands and utilities of ediff
-;; Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
;; Author: Michael Kifer <kifer@cs.sunysb.edu>
;; Boston, MA 02111-1307, USA.
;;; Code:
+
+(provide 'ediff-util)
-;; Pacify compiler and avoid the need in checking for boundp
-(defvar ediff-patch-diagnostics nil)
-(defvar ediff-patchbufer nil)
-(and noninteractive
- (eval-when-compile
- (let ((load-path (cons (expand-file-name ".") load-path)))
- (load-file "ediff-init.el")
- (load-file "ediff-help.el"))))
+;; 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)
-;; (defun ediff-use-toolbar-p () nil))
-;;
-;; for the time being
-(defun ediff-use-toolbar-p () nil)
+(if ediff-xemacs-p
+ (require 'ediff-tbar))
\f
;;; Functions
`ediff-patch-file'
`ediff-patch-buffer'
`epatch-buffer'
+ `erevision'
`ediff-revision'
Commands:
(run-hooks 'ediff-mode-hook))
-(require 'ediff-diff)
-(require 'ediff-merg)
-
\f
;;; Build keymaps
(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))
+ ;; 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 "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-meta-buffer)
+ (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))
;;; Setup functions
-(require 'ediff-wind)
-
-;; No longer needed: XEmacs has surrogate minibuffers now.
-;;(or (boundp 'synchronize-minibuffers)
-;; (defvar synchronize-minibuffers nil))
-
-;; 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)
+ 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)))
(if (stringp 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-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)
;; Don't delete variants in case of ediff-buffer-* jobs without asking.
;; This is because u may loose work---dangerous.
(save-excursion
(set-buffer buffer-C)
(insert-buffer buf)
- (funcall (ediff-eval-in-buffer buf major-mode))
- ;; after Stig@hackvan.com
+ (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
(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-eval-in-buffer 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-hook)
- (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
+ (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-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-hook)
- (if (ediff-eval-in-buffer control-buffer ediff-merge-job)
+ (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-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-hook)
;; add control-buffer to the list of 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-eval-in-buffer 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)
(ediff-visible-region)
(run-hooks 'startup-hooks)
+ (ediff-arrange-auto-save-in-merge-jobs merge-buffer-file)
+
(ediff-refresh-mode-lines)
(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))
+ (ediff-update-meta-buffer
+ ediff-meta-buffer nil ediff-meta-session-number))
(run-hooks 'ediff-startup-hook)
) ; eval in control-buffer
control-buffer))
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)) ; checks if toolbar is requested
+ (ediff-make-bottom-toolbar)) ; this checks if toolbar is requested
(goto-char (point-min))
(skip-chars-forward ediff-whitespace)))
-
+;; This executes in control buffer and sets auto-save, visited file name, etc,
+;; in the merge buffer
+(defun ediff-arrange-auto-save-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
(interactive)
(ediff-barf-if-not-control-buffer)
(if (and (ediff-buffer-live-p ediff-ancestor-buffer)
- (not (y-or-n-p "Recompute differences during merge, really? ")))
- (error "God forbid!"))
+ (not
+ (y-or-n-p
+ "Ancestor buffer will not be used. Recompute diffs anyway? ")))
+ (error "Recomputation of differences canceled"))
- (let ((point-A (ediff-eval-in-buffer ediff-buffer-A (point)))
- ;;(point-B (ediff-eval-in-buffer ediff-buffer-B (point)))
+ (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)
(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
Reestablish the default three-window display."
(interactive)
(ediff-barf-if-not-control-buffer)
-
-;; ;; No longer needed: XEmacs has surrogate minibuffers now.
-;; (if ediff-xemacs-p (setq synchronize-minibuffers t))
-
(let (buffer-read-only)
(if (and (ediff-buffer-live-p ediff-buffer-A)
(ediff-buffer-live-p ediff-buffer-B)
(if ediff-3way-job
(ediff-recenter-one-window 'C))
- (ediff-eval-in-buffer control-buf
+ (ediff-with-current-buffer control-buf
(ediff-recenter-ancestor) ; check if ancestor is alive
(if (and (ediff-multiframe-setup-p)
))
(ediff-restore-highlighting)
- (ediff-eval-in-buffer control-buf (ediff-refresh-mode-lines))
+ (ediff-with-current-buffer control-buf (ediff-refresh-mode-lines))
))
;; this function returns to the window it was called from
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-name (ediff-get-symbol-from-alist
+ buf-type ediff-window-alist))
(window (if (window-live-p (symbol-value window-name))
(symbol-value window-name))))
(ctl-wind (selected-window))
(job-name ediff-job-name)
(ctl-buf ediff-control-buffer))
- (ediff-eval-in-buffer ediff-ancestor-buffer
+ (ediff-with-current-buffer ediff-ancestor-buffer
(goto-char (ediff-get-diff-posn 'Ancestor 'beg nil ctl-buf))
(if window
(progn
(or buf
(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)
;; 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 buf-type)))
(t
;; checkout if visited file is checked in
(defun ediff-maybe-checkout (buf)
- (let ((file (buffer-file-name 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)
(format
"File %s is under version control. Check it out? "
(ediff-abbreviate-file-name file))))
- (ediff-eval-in-buffer buf
+ (ediff-with-current-buffer buf
(command-execute checkout-function)))))
;; 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)))
- ))
+;;(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)
+ (or (not (featurep 'vc-hooks))
+ (and (vc-backend file)
+ (vc-locking-user file))))
+(defsubst ediff-file-checked-in-p (file)
+ (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-file-checked-out-p (file)
- (and (ediff-file-under-version-control file)
- (file-writable-p file)))
-(defun ediff-file-checked-in-p (file)
- (and (ediff-file-under-version-control file)
- (not (file-writable-p file))))
(defun ediff-swap-buffers ()
"Rotate the display of buffers A, B, and C."
(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))
(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
+ (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.
-For a permanent change, set the variable `ediff-window-setup-function',
+ "Switch from multiframe display to single-frame display and back.
+To change the default, set the variable `ediff-window-setup-function',
which see."
(interactive)
- (let (set-func)
- (or (ediff-window-display-p)
- (error "%sEmacs is not running as a window application"
- (if ediff-emacs-p "" "X")))
-
- (setq set-func (if (ediff-in-control-buffer-p) 'setq 'setq-default))
+ (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)
- (eval
- (list
- set-func
- '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)
(if (ediff-in-control-buffer-p)
(ediff-kill-bottom-toolbar))
- (eval
- (list
- set-func
- 'ediff-window-setup-function ''ediff-setup-windows-multiframe))))
+ (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
- (setq ediff-window-B nil)
- (ediff-recenter 'no-rehighlight)))))
+ (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 ()
(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
-(defun ediff-make-bottom-toolbar ()
- (if (ediff-use-toolbar-p)
+;; 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
- (set-specifier bottom-toolbar (list (selected-frame) ediff-toolbar))
- (set-specifier bottom-toolbar-visible-p (list (selected-frame) t))
- (set-specifier bottom-toolbar-height (list (selected-frame) 34)))))
+ (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
(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-comparison-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))))
)))
(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-eval-in-buffer ctl-buf
+ (ediff-with-current-buffer ctl-buf
(let* ((buf (ediff-get-buffer buf-type))
- (wind (eval (intern (format "ediff-window-%S" 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-eval-in-buffer buf
+ (ediff-with-current-buffer buf
(if (< beg end)
(setq lines (count-lines beg end))
(setq lines 0))
lines
))))
-;; get number of lines from window end to region start
-(defun ediff-get-lines-to-region-start (buf-type &optional n ctl-buf)
- (or n (setq n ediff-current-difference))
+;; 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-eval-in-buffer ctl-buf
+ (ediff-with-current-buffer ctl-buf
(let* ((buf (ediff-get-buffer buf-type))
- (wind (eval (intern (format "ediff-window-%S" buf-type))))
- (end (window-end wind))
- (beg (ediff-get-diff-posn buf-type 'beg)))
- (ediff-eval-in-buffer buf
- (if (< beg end) (count-lines beg end) 0))
+ (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))
)))
;;
;; If the difference region is invalid, the coefficient is 1
(defun ediff-get-region-size-coefficient (buf-type op &optional n ctl-buf)
- (ediff-eval-in-buffer (or ctl-buf ediff-control-buffer)
+ (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)
(ediff-barf-if-not-control-buffer)
(if (< ediff-current-difference ediff-number-of-differences)
(let ((n (min ediff-number-of-differences
- (+ ediff-current-difference arg)))
- 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 "")
(interactive "p")
(ediff-barf-if-not-control-buffer)
(if (> ediff-current-difference -1)
- (let ((n (max -1 (- ediff-current-difference arg)))
- 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-barf-if-not-control-buffer)
(let* ((buf-type (ediff-char-to-buftype last-command-char))
(buffer (ediff-get-buffer buf-type))
- (pt (ediff-eval-in-buffer buffer (point)))
+ (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-eval-in-buffer buffer (point-max))
+ (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)
wind-C ediff-window-C)
(if arg
(progn
- (ediff-eval-in-buffer buffer
+ (ediff-with-current-buffer buffer
(setq shift (- beg pt)))
(select-window wind-A)
(if past-last-diff (goto-char (point-max)))
(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))
(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)))
(setq reg-end (ediff-get-diff-posn buf-type 'end n ediff-control-buffer))
(condition-case conds
- (ediff-eval-in-buffer buf
+ (ediff-with-current-buffer buf
(let ((inhibit-read-only (null buffer-read-only)))
(goto-char reg-end)
(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
+ (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-eval-in-buffer ediff-buffer-B
+ (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
+ (ediff-with-current-buffer ediff-buffer-C
(save-restriction
(narrow-to-region
(ediff-get-diff-posn 'C 'beg n ctl-buf)
(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
+ (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-eval-in-buffer ediff-buffer-B
+ (reg-B-match (ediff-with-current-buffer ediff-buffer-B
(save-restriction
(narrow-to-region
(ediff-get-diff-posn 'B 'beg 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
+ (ediff-with-current-buffer ediff-buffer-C
(save-restriction
(narrow-to-region
(ediff-get-diff-posn 'C 'beg n ctl-buf)
temporarily reverses the meaning of this variable."
(interactive "P")
(ediff-barf-if-not-control-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 "")
- (ediff-really-quit reverse-default-keep-variants))
- (message "")))
+ (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.
;; restore buffer mode line id's in buffer-A/B/C
(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-B))
(t (next-frame))))))
(condition-case nil
- (ediff-eval-in-buffer ediff-buffer-A
+ (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)
(error))
(condition-case nil
- (ediff-eval-in-buffer ediff-buffer-B
+ (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)
(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)
(error))
(condition-case nil
- (ediff-eval-in-buffer ediff-ancestor-buffer
+ (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)
(or ediff-keep-variants (ediff-janitor 'ask)))
(run-hooks 'ediff-quit-hook)
- (ediff-cleanup-meta-buffer meta-buffer)
+ (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 ((and ediff-xemacs-p (window-live-p (car (mouse-position))))
- (window-frame (car (mouse-position))))
- ((frame-live-p (car (mouse-position)))
- (car (mouse-position)))
+ (cond ((ediff-good-frame-under-mouse))
(t warp-frame)))
(if (frame-live-p warp-frame)
(set-mouse-position (if ediff-emacs-p
2 1))
(if (ediff-buffer-live-p meta-buffer)
- (ediff-show-meta-buffer 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))
(if (and (ediff-window-display-p) (frame-live-p ctl-frame))
(delete-frame ctl-frame))
(buffer-name ediff-buffer-C)))))
(ediff-kill-buffer-carefully ediff-buffer-C))))
-(defun ediff-maybe-save-and-delete-merge ()
+(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 then asks the user whether to
+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))
+ (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-then-kill
- ediff-buffer-C merge-store-file 'show-file))
+ (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 result of the merge in: "))
- (ediff-write-merge-buffer-then-kill
- ediff-buffer-C 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-eval-in-buffer 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 "The result of the merge goes into: "))
- (ediff-write-merge-buffer-then-kill
- ediff-buffer-C 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))))
))
-(defun ediff-write-merge-buffer-then-kill (buf file &optional show-file)
- (ediff-eval-in-buffer buf
+;; 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
(if show-file
(progn
(message "Merge buffer saved in: %s" file)
+ (set-buffer-modified-p nil)
(sit-for 2)))
- (if (y-or-n-p "Merge buffer saved in file. Now kill the buffer? ")
+ (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.
(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-patchbufer)
- (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))))
))
(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))
(if (ediff-buffer-live-p ediff-custom-diff-buffer)
(concat "\tin buffer "
(buffer-name ediff-custom-diff-buffer))
- "is not available")))
+ " 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")))
+ " 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)))))
(t (1+ ediff-current-difference)))))
(princ
- (format "\n%s regions that differ only in white space & line breaks"
+ (format "\n%s regions that differ in white space & line breaks only"
(if ediff-ignore-similar-regions
- "Skipping" "Not skipping")))
+ "Ignoring" "Showing")))
(if (and ediff-merge-job ediff-show-clashes-only)
(princ
"\nFocusing on regions where both buffers differ from the ancestor"))
(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))
)))
(t (make-temp-name f))))
;; create the file
- (ediff-eval-in-buffer buff
+ (ediff-with-current-buffer buff
(write-region (if start start (point-min))
(if end end (point-max))
f
(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-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,
(interactive "P")
(ediff-barf-if-not-control-buffer)
(ediff-compute-custom-diffs-maybe)
- (ediff-eval-in-buffer
+ (ediff-with-current-buffer
(cond ((memq last-command-char '(?a ?b ?c))
(ediff-get-buffer
(ediff-char-to-buftype last-command-char)))
nil))))
(if buf
(progn
- (ediff-eval-in-buffer buf
+ (ediff-with-current-buffer buf
(goto-char (point-min)))
(switch-to-buffer buf)
(raise-frame (selected-frame)))))
(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 ((memq answer '(?A ?a))
- (setq bufA ediff-buffer-A)
+ (while (cond ((eq answer ?A)
+ (setq bufA ediff-buffer-A
+ possibilities '(?B))
nil)
- ((memq answer '(?B ?b))
- (setq bufA ediff-buffer-B)
+ ((eq answer ?B)
+ (setq bufA ediff-buffer-B
+ possibilities '(?A))
nil)
((equal answer ""))
(t (beep 1)
t))
(let ((cursor-in-echo-area t))
(message "Which buffer to compare to the merge buffer (A/B)? ")
- (setq answer (read-char-exclusive)))))
+ (setq answer (capitalize (read-char-exclusive))))))
((ediff-3way-comparison-job)
(while (cond ((memq answer possibilities)
(setq possibilities (delq answer possibilities))
(setq bufA
(eval
- (intern (format "ediff-buffer-%c" answer))))
+ (ediff-get-symbol-from-alist
+ answer ediff-buffer-alist)))
nil)
((equal answer ""))
(t (beep 1)
(setq possibilities (delq answer possibilities))
(setq bufB
(eval
- (intern (format "ediff-buffer-%c" answer))))
+ (ediff-get-symbol-from-alist
+ answer ediff-buffer-alist)))
nil)
((equal answer ""))
(t (beep 1)
(setq answer (capitalize (read-char-exclusive))))))
(t ; 2way comparison
(setq bufA ediff-buffer-A
- bufB ediff-buffer-B)))
+ bufB ediff-buffer-B
+ possibilities nil)))
- (ediff-eval-in-buffer bufA
+ (ediff-with-current-buffer bufA
(or (mark t)
(error "You forgot to specify a region in buffer %s" (buffer-name)))
(setq begA (region-beginning)
(end-of-line)
(or (eobp) (forward-char)) ; include the newline char
(setq endA (point)))
- (ediff-eval-in-buffer bufB
+ (ediff-with-current-buffer bufB
(or (mark t)
(error "You forgot to specify a region in buffer %s" (buffer-name)))
(setq begB (region-beginning)
ediff-current-difference 'unselect-only)
(ediff-paint-background-regions 'unhighlight)
- (ediff-eval-in-buffer bufA
+ (ediff-with-current-buffer bufA
(goto-char begA)
(set-mark endA)
(narrow-to-region begA endA)
;; (ediff-activate-mark)
)
;; (sit-for 0)
- (ediff-eval-in-buffer bufB
+ (ediff-with-current-buffer bufB
(goto-char begB)
(set-mark endB)
(narrow-to-region begB endB)
)
;; (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 the selected regions. Continue? ")
+ "Please check regions selected for comparison. Continue? ")
(setq quit-now t))
- (ediff-eval-in-buffer bufA
+ (ediff-with-current-buffer bufA
(widen))
- (ediff-eval-in-buffer bufB
+ (ediff-with-current-buffer bufB
(widen))
(if quit-now
- (error "Thank you. Come back another day..."))
+ (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 ; startup hook
+ nil ; setup-hook
'ediff-regions-linewise ; job name
- nil) ; no word mode
+ nil ; no word mode
+ ;; setup param to pass to ediff-setup
+ (list (cons 'ediff-split-window-function ediff-split-window-function)))
))
(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)
(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))))
(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)
;; 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-eval-in-buffer (or ctl-buf (current-buffer))
+ (ediff-with-current-buffer (or ctl-buf (current-buffer))
(if (and (ediff-has-face-support-p)
ediff-use-faces
ediff-highlight-all-diffs)
(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)
(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))
(format "%s<%d>%s" prefix n suffix))))
-;; splits at a white space, returns a list
-(defun ediff-split-string (string)
- (let ((start 0)
- (result '())
- substr)
- (while (string-match "[ \t]+" string start)
- (let ((match (string-match "[ \t]+" string start)))
- (setq substr (substring string start match))
- (if (> (length substr) 0)
- (setq result (cons substr result)))
- (setq start (match-end 0))))
- (setq substr (substring string start nil))
- (if (> (length substr) 0)
- (setq result (cons substr result)))
- (nreverse result)))
-
(defun ediff-submit-report ()
"Submit bug report on Ediff."
(interactive)
(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-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-eval-in-buffer ediff-ancestor-buffer
+ (ediff-with-current-buffer ediff-ancestor-buffer
(ediff-save-variables ediff-protected-variables)))))
;; must execute in control buf
(values-B ediff-buffer-values-orig-B)
(values-C ediff-buffer-values-orig-C)
(values-Ancestor ediff-buffer-values-orig-Ancestor))
- (ediff-eval-in-buffer ediff-buffer-A
+ (ediff-with-current-buffer ediff-buffer-A
(ediff-restore-variables ediff-protected-variables values-A))
- (ediff-eval-in-buffer ediff-buffer-B
+ (ediff-with-current-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-with-current-buffer ediff-buffer-C
(ediff-restore-variables ediff-protected-variables values-C)))
(if (ediff-buffer-live-p ediff-ancestor-buffer)
- (ediff-eval-in-buffer 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-eval-in-buffer buffer
+ (ediff-with-current-buffer buffer
(write-file file)))
;;; Local Variables:
;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun)
-;;; eval: (put 'ediff-eval-in-buffer 'lisp-indent-hook 1)
-;;; eval: (put 'ediff-eval-in-buffer 'edebug-form-spec '(form body))
+;;; 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