X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/17fcf5c535a2f71d099225a1d297f6cf4b48a45a..cd30a521aa838f6bcf08ee6ffb62986cd2bf8daa:/lisp/ediff.el diff --git a/lisp/ediff.el b/lisp/ediff.el index a3ffdf0422..4e6cd8667f 100644 --- a/lisp/ediff.el +++ b/lisp/ediff.el @@ -1,11 +1,15 @@ -;;; ediff.el --- a visual interface to diff & patch -;;; Copyright (C) 1994 Free Software Foundation, Inc. +;;; ediff.el --- a comprehensive visual interface to diff & patch + +;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc. ;; Author: Michael Kifer ;; Created: February 2, 1994 -;; Version: 1.31 ;; Keywords: comparing, merging, patching, version control. +(defconst ediff-version "2.70.2" "The current version of Ediff") +(defconst ediff-date "May 21, 1998" "Date of last update") + + ;; This file is part of GNU Emacs. ;; GNU Emacs is free software; you can redistribute it and/or modify @@ -19,3037 +23,1311 @@ ;; 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. ;;; Commentary: -;; ---------- -;; Never read those diff outputs again! -;; Apply patch selectively, like a pro! +;; Never read that diff output again! +;; Apply patch interactively! +;; Merge with ease! + +;; This package provides a convenient way of simultaneous browsing through +;; the differences between a pair (or a triple) of files or buffers. The +;; files being compared, file-A, file-B, and file-C (if applicable) are +;; shown in separate windows (side by side, one above the another, or in +;; separate frames), and the differences are highlighted as you step +;; through them. You can also copy difference regions from one buffer to +;; another (and recover old differences if you change your mind). -;; This package provides a convenient way of simultaneous brousing through -;; the differences between a pair of files or buffers. The two files being -;; compared (file-A and file-B) are shown in separate windows (side by -;; side, one above the another, or in separate frames), and the differences -;; are highlighted as you step through them. You can also copy difference -;; regions from one buffer to another (and recover old differences if you -;; change your mind). +;; Ediff also supports merging operations on files and buffers, including +;; merging using ancestor versions. Both comparison and merging operations can +;; be performed on directories, i.e., by pairwise comparison of files in those +;; directories. ;; In addition, Ediff can apply a patch to a file and then let you step -;; though both files, the patched and the original one, simultateously, +;; though both files, the patched and the original one, simultaneously, ;; difference-by-difference. You can even apply a patch right out of a ;; mail buffer, i.e., patches received by mail don't even have to be saved. ;; Since Ediff lets you copy differences between buffers, you can, in ;; effect, apply patches selectively (i.e., you can copy a difference -;; region from file.orig to file, thereby undoing any particular patch that +;; region from file_orig to file, thereby undoing any particular patch that ;; you don't like). -;; This package is based on emerge.el. It uses a few utilities and -;; variables defined there and several other Ediff's functions are -;; adaptations from emerge.el. - -;; Ediff is complimentary to Emerge. While Emerge is better at heavy-duty -;; tasks that involve merging of files, Ediff is by far superior -;; for browsing through files compared via diff and for patching files -;; with patch. Furthermore, I feel that Ediff is more convenient for -;; merging tasks where one of the files is a designated output. This -;; situation arises while patching files or when comparing an old version -;; of a file with a newer version (in such cases, it is often desirable to -;; selectively revert some portions of the new file to its old state). - -;; This version of Ediff is much faster than the previous ones and than -;; Emerge (in Emacs 19.23, Emerge will become much faster as well). -;; The difference in startup time is dramatic for large files with many -;; differences. - -;; Window configuration: -;; ---------------------- - -;; By default, Ediff sets things up in one frame, splitting it between a -;; small control window and the two windows for file-A and file-B. The -;; split between these latter windows can be horizontal or vertical, which -;; can be changed interactively by hitting 's' while the cursor is in the -;; control window. -;; -;; In a multi-frame situation, Ediff would work as follows. When it starts, -;; it will place the control window in the frame that was selected at the -;; time of the invocation. If file-A or file-B is seen in one of the -;; frames, Ediff will leave it there. If a file (A/B) is not visible in any -;; frame, Ediff will arrange that it will share a frame with the control -;; window. (If none of the files is visible, then both will share the -;; control window frame.) The same algorithm works when you hit 'c' -;; (ediff-recenter), 'p' (ediff-previous-difference), 'n', etc. -;; -;; Thus, you can compare files in one frame or in different frames. -;; The former is done by default, while the latter can be achieved by -;; arranging files A and B to be seen in different frames. Ediff -;; respects these arrangements, automatically adapting itself to -;; the multi-frame mode. - - -;; A note to heavy-duty users: - -;; Ediff lets the user run multiple sessions at once, i.e., you can invoke -;; Ediff on different functions several times in a row, without exiting -;; the previous Ediff sessions. Different sessions may even operate on the -;; same pair of files. So, in principle, it is possible to do, say, -;; pairwise comparison of three (or more) different files. Each session -;; would have its own *ediff-control* buffer and all the regarding a -;; particular session is local to the associated *ediff-control* buffer. -;; You can switch between sessions by suspending one session and then -;; switching to another *ediff-control* buffer. (Different such buffers -;; are distinguished by a numerical suffix, e.g., *ediff-control*<3>.) -;; This, if you would like to compare three files pairwise, you can do -;; this by preparing three different frames, each with its own control -;; window. (This would require a very wide screen, and I never claimed -;; that such 3-way comparison is very easy to do.) -;; -;; If you need to conduct multiple Ediff sessions on the same file, one -;; thing should be kept in mind: each time you invoke Ediff on a buffer that -;; already participates in another Ediff session, that buffer should not -;; have any ASCII Ediff flags in it. (Highlighting with faces is OK.) If -;; flags are not removed, difference overlays won't be set correctly -;; for the second invocation of Ediff. The simplest way to remove ASCII -;; flags from an Ediff buffer is to switch to that buffer and try to insert -;; or delete something. If ASCII flags have been inserted by an Ediff -;; session, Ediff will ignore this first editing operation, but it will -;; remove all flags and notify you that this buffer can now be edited. -;; -;; To rehighlight Ediff buffers, hit 'c' in ediff-control buffer. - - -;;; Remarks: -;; ------- - -;; 1. Ediff is unlikely to run under Emacs 18 without some further work. -;; 2. If running Lucid Emacs, Ediff requires at least version 19.9. -;; 3. I didn't test Ediff on Emacs versions older than 19.19. -;; 4. The function vc-ediff requires the vc.el version that comes with -;; Emacs 19.22. +;; Ediff is aware of version control, which lets the user compare +;; files with their older versions. Ediff can also work with remote and +;; compressed files. Details are given below. +;; Finally, Ediff supports directory-level comparison, merging and patching. +;; See the on-line manual for details. -;;; Installation and use: -;; -------------------- +;; This package builds upon the ideas borrowed from emerge.el and several +;; Ediff's functions are adaptations from emerge.el. Much of the functionality +;; Ediff provides is also influenced by emerge.el. -;; You can invoke Ediff interactively using the following functions: -;; -;; ediff-buffers - compare buffers -;; ediff (alias for ediff-files) -;; ediff-files - compare files -;; ediff-patch-file - patch file then compare -;; epatch (alias for ediff-patch-file) -;; ediff-patch-buffer - patch buffer then compare -;; vc-ediff - compare buffer & version -;; using vc.el package -;; (Emacs 19.22 and up). -;; rcs-ediff - same using rcs.el; rcs.el -;; is not part of the -;; standard Emacs distribution. -;; -;; There is also the function ediff-files-remote, which can be invoked only -;; from within another Emacs Lisp function, i.e., non-interactively. -;; -;; To use Ediff, put this in your .emacs file: -;; -;; (autoload 'ediff-buffers "ediff" "Visual interface to diff" t) -;; (autoload 'ediff "ediff" "Visual interface to diff" t) -;; (autoload 'ediff-files "ediff" "Visual interface to diff" t) -;; (autoload 'ediff-files-remote "ediff" "Visual interface to diff") -;; (autoload 'epatch "ediff" "Visual interface to patch" t) -;; (autoload 'ediff-patch-file "ediff" "Visual interface to patch" t) -;; (autoload 'ediff-patch-buffer "ediff" "Visual interface to patch" t) -;; (autoload 'vc-ediff "ediff" -;; "Interface to diff & version control via vc.el" t) -;; (autoload 'rcs-ediff "ediff" -;; "Interface to diff & version control via rcs.el" t) -;; -;; -;; If you want Ediff to be loaded from the very beginning, you should have -;; -;; (require 'ediff) -;; -;; in your .emacs file. This way it is also easier to figure out changes -;; to the default Ediff setting, if such changes become necessary --- see -;; Customization. -;; - -;;; Compilation -;; ----------- -;; -;; When you byte-compile Ediff, you will get some warnings about functions -;; being undefined. These can be safely ignored. - -;;; Customization: -;; ------------- - -;; If you don't like the default setting, you can change it through the -;; various variables and hooks. In particular, the following hooks are -;; available: - -;; ediff-load-hooks -;; ediff-before-setup-windows-hooks -;; ediff-startup-hooks -;; ediff-select-hooks -;; ediff-unselect-hooks -;; ediff-suspend-hooks -;; ediff-quit-hooks -;; ediff-prepare-buffer-hooks - -;; The hooks in ediff-load-hooks can be used to change defaults after Ediff -;; is loaded. -;; The hooks in ediff-before-setup-windows-hooks, ediff-suspend-hooks, and -;; ediff-quit-hooks can be used to save and then restore whatever window -;; configuration you want. However, make sure you understand what you are -;; doing. Many variables that drive Ediff are local to the different -;; *ediff-control* buffers. Take a look at ediff-default-suspend-hook and -;; ediff-default-quit-hook to see what's involved. -;; The hooks in ediff-prepare-buffer-hooks are executed for each Ediff buffer -;; (A and B) right after these buffers are arranged. -;; -;; The second group of Ediff variables that could be changed, if you so -;; wish, is: -;; -;; ediff-before-flag-eol -;; ediff-after-flag-eol -;; ediff-before-flag-mol -;; ediff-after-flag-mol -;; -;; ediff-current-diff-face-A -;; ediff-current-diff-face-B -;; ediff-even-diff-face-A -;; ediff-even-diff-face-B -;; ediff-odd-diff-face-A -;; ediff-odd-diff-face-B -; -;; The first four are ASCII strings that mark the beginning and the end of -;; the differences found in file-A and file-B. Ediff uses different flags -;; to highlight regions that begin/end at the beginning of a line or in a -;; middle of a line. - -;; The rest are the faces used to highlight text on X displays. On X -;; displays, Ediff uses ediff-current-diff-face-A and -;; ediff-current-diff-face-B to highlight the current difference regions. -;; Other (non-current) difference regions are displayed in alternating -;; faces: ediff-even/odd-diff-face-A/B. The odd and the even -;; faces are actually identical on monochrome displays, because it is -;; rather poor in what you can do on such a display. So, I chose to use -;; italics to highlight other differences. Any ideas would be welcome. -;; -;; There are two ways to change the default setting for highlighting faces: -;; either change the variables, as in -;; -;; (setq ediff-current-diff-face-A (internal-get-face 'bold-italic)) -;; -;; (`internal-get-face' should be `get-face' if you are using Lucid Emacs) -;; or by selectively modifying the defaults: -;; -;; (add-hook 'ediff-load-hooks -;; (function (lambda () -;; (set-face-foreground ediff-current-diff-face-B "blue") -;; (set-face-background ediff-current-diff-face-B "red") -;; (make-face-italic ediff-current-diff-face-B)))) -;; -;; You may also want to take a look at how the above faces are defined in -;; Ediff. -;; -;; The last pair of variables in this group, -;; -;; ediff-want-faces -;; ediff-highlight-selected-only -;; -;; indicate whether---on a window system---you want differences to be -;; marked using ASCII strings (like on a dumb terminal) or using colors and -;; highlighting. If ediff-want-faces is t, then highlighting with faces is -;; used. Normally, Ediff highlights all differences, but the selected -;; difference is highlighted more visibly. If you prefer that unselected -;; differences won't be highlighted, you can set -;; ediff-highlight-selected-only to t. -;; -;; If you plan on changing these variables, they must be set -;; BEFORE ediff.el is loaded. -;; -;; Note: Ediff lets you switch between the two types of highlighting. That -;; is you can switch, interactively, from highlighting using faces to -;; highlighting using ASCII flags, and back. Of course, toggling has -;; effect only on a window system. On a dumb terminal or in an xterm -;; window, the only available option is highlighting with ASCII flags. -;; -;; The third group of variables controls miscellaneous functions: -;; -;; ediff-patch-program -;; ediff-patch-options -;; ediff-diff-program -;; ediff-diff-options -;; -;; These specify the functions that produce differences and do patching. -;; The *-options variables specify which options to pass to these programs. -;; It is unlikely that you would want to change these. One possible -;; exception is when you may want to generate differences with context -;; lines in order to send a patch file through email. Then, you might want -;; to set ediff-diff-options to '-c'. Sometimes, you may also want to tell -;; diff to ignore spaces and such. Use the option '-w' for that. Diff -;; has several other useful options (type 'man diff' to find out). -;; -;; The output from diff is found in *ediff-diff* buffer. However, this -;; makes sense only if you also intend to use Ediff to browse through the -;; diff'ed files before sending the patch. This is because diff.el is much -;; faster in yielding the output of diff ;; (Ediff is a big gun, if used -;; for this simple purpose). -;; -;; The last set of variables that can be modified is -;; -;; ediff-split-window-function -;; ediff-use-last-dir -;; ediff-nix-help-in-control-buffer -;; -;; ediff-split-window-function controls the way you want the window be -;; split between file-A and file-B. It defaults to vertical split, but you -;; can set it to 'split-window-horizontally, if you want. Ediff lets you -;; toggle the way windows are split, so you can try different settings -;; interactively. Note: if file-A and file-B are in different frames, -;; windows are not split, regardless of the value -;; ediff-split-window-function. Instead, other windows on these frames are -;; deleted and Ediff starts displaying file-A and file-B using these two -;; frames, one file per frame. You can then switch to one-frame mode -;; simply by hiding the file-A/B buffer that is displayed on a frame other -;; than the control-window frame. -;; -;; Note that if Ediff sees that the two buffers it compares are residing in -;; separate frames, it assumes that the user wants them to be so displayed -;; and stops splitting windows. Instead, it will arrange each buffer to -;; occupy its own frame (possibly shared with Ediff's help window). -;; -;; The variable ediff-use-last-dir controls the way Ediff presents the -;; default directory when it prompts the user for files to compare. If nil, -;; Ediff will use the default directory of the current buffer when it -;; prompts the user for file names. Otherwise, it will use the -;; directories it had previously used for file-A and file-B. -;; -;; The ediff-nix-help-in-control-buffer, if set to t, makes C-h behave like -;; the DEL key, i.e., it will move you back to the previous difference -;; rather than invoking help. This is useful when, in an xterm window or on -;; a dumb terminal, the Backspace key is bound to C-h and is positioned -;; more conveniently than the DEL key. +;; The present version of Ediff supersedes Emerge. It provides a superior user +;; interface and has numerous major features not found in Emerge. In +;; particular, it can do patching, and 2-way and 3-way file comparison, +;; merging, and directory operations. -;;; Commands -;; -------- - -;; All Ediff commands are displayed in a help window, unless you hit '?' to -;; shrink it to just one line. You can redisplay the help window by hitting -;; '?' again. -;; -;; Many Ediff commands take numeric prefix arguments. For instance, if you -;; hit a number, n, and then 'j' (ediff-jump-to-difference), Ediff will -;; take you to Nth difference. Hitting a number, n, and then 'ab' -;; (ediff-diff-to-diff) will copy Nth difference from buffer A to buffer B. -;; Hitting 'ba' does copying in the other direction. -;; Likewise, a number, n, followed by 'ra' will restore the Nth difference -;; region in buffer A (if it was previously saved as a result of copying -;; from B to A). -;; -;; Without the prefix argument, all commands operate on the current -;; difference region. -;; -;; The total number of differences and the current difference number are -;; always displayed in the mode line of the control window. - -;;; Display Modes -;; ------------- - -;; Ediff can display files in one frame, stacked side-by-side or one on top -;; of another; or it can display the files in different frames. When you -;; start Ediff, it assumes a 1-frame mode. You can toggle the side-by-side -;; and one-on-top-of-another displays by simply hitting 's'. -;; -;; Ediff switches to the multi-frame mode when: -;; -;; 1. file-A and file-B are in different frames (you have to put them into -;; different frames manually); or -;; 2. *ediff-control* buffer is visible in one frame and one other file (A -;; or B) is visible in another frame. If, say, fileA is visible in a -;; different frame than *ediff-control*, fileB doesn't have to be -;; visible. If it is, Ediff will continue displaying fileB in the frame -;; where it was visible before. If it isn't then Ediff will arrange for -;; fileB to share a frame with *ediff-control*. -;; -;; If all three buffers are in separate frames, Ediff will switch to a -;; 3-frame mode. If Ediff buffers are currently visible only in two -;; frames, Ediff will work in a 2-frame mode. In this mode, one of the -;; frames will be shared by *ediff-control* and file-A or file-B -;; (whichever is appropriate). - ;;; Bugs: -;; ---- ;; 1. The undo command doesn't restore deleted regions well. That is, if ;; you delete all characters in a difference region and then invoke -;; `undo', the reinserted text will most likely be reinserted outside of -;; what Ediff thinks is the current difference region. - -;; 2. You may get an error if your colormap doesn't have the colors requested -;; by Ediff (on a color display). If this happens, you should create your -;; own faces using available colors. See `ediff-current-diff-face-A', -;; ediff-current-diff-face-B, ediff-even-diff-face-A, ediff-even-diff-face-B, -;; ediff-odd-diff-face-A, and ediff-odd-diff-face-B to get an idea on how -;; to do this. - - -;;; Change Log: -;; ---------- - -;; Thu Feb 3, 1994 - -;; Added ediff-read-file-name, which is a stub that takes care of Lemacs -;; versions of Emerge. (Thanks to Alastair Burt .) -;; -;; Fixed a bug in ediff-setup-windows that caused control window to -;; appear in a wrong place when split-window-keep-point is nil -;; (Thanks to Kevin Broadey .) -;; -;; Added mechanism for using faces instead of before/after flags. This -;; looks much better on an X display, especially on a color one. -;; (Thanks to Boris Goldowsky for the code -;; that led to ediff-highlight-diff. -;; Also, thanks to Kevin Esler for suggestions -;; regarding highlighting differences on X displays.) -;; -;; Added functions to apply patches. -;; (Thanks to Kevin Broadey for this -;; suggestion.) - -;; Fri Feb 4, 1994 - -;; Added mechanism for toggling vertical/horizontal window split. -;; (Inspired by a suggestion from Allan Gottlieb -;; -- thanks.) +;; `undo', the reinstated text will most likely be inserted outside of +;; what Ediff thinks is the current difference region. (This problem +;; doesn't seem to exist with XEmacs.) ;; -;; Added mechanism for toggling between highlighting using faces and -;; highlighting using ASCII flags. -;; -;; Fixed a problem with undo. Now, Ediff has smartened up and doesn't -;; keep undo info on ASCII flags inserted in buffer-A and buffer-B. -;; So, if you edit the files while browsing through them, undo behaves -;; as you would expect, i.e., faces/flags don't get in the way. - -;; Sun Feb 6, 1994 - -;; Added horizontal scrolling. Added ediff-position-region to ensure -;; that difference regions in buffer-A and buffer-B are aligned with -;; each other. Disabled ediff-toggle-split when buffers are displayed -;; in different frames. - -;; Mon Feb 7, 1994 - -;; Added toggle-window help (Suggested by Boris Goldowsky -;; .) -;; Added functions to copy differences from one buffer to another and to -;; recover old differences. -;; Added prefix arguments to ediff-next-difference and -;; ediff-previous-difference. - -;; Tue Feb 8, 1994 - -;; Replaced text properties with overlays. Fixed ediff-setup-windows. -;; Added ediff-save-buffer to local-write-file-hooks to prevent user -;; from saving corrupted states. (Thanks to -;; for suggestion.) Instead, Ediff now has a pair of functions for -;; safe saving of buffers. -;; Changed ediff-read-file-name to be more intuitive on ediff-files. -;; Added ediff-prepare-buffer-hooks. (Thanks to Kevin Esler -;; for the idea.) - -;; Wed Feb 9, 1994 - -;; Cleanups in ediff-patch-file. Protected ediff-copy-diff against -;; a bug that Emacs has in kill-region. - -;; Thu Feb 10, 1994 - -;; Added support for Lemacs. (Thanks to Alastair Burt -;; for coercing Ediff into working under Lemacs.) -;; Added ediff-kill-buffer-carefully and other suggestions by Boris -;; Goldowsky . -;; Refined the protection against interference with highlighting caused -;; by Hilit19. Added the variable ediff-third-party-highlighting. -;; Added mechanisn for unhighlighting regions highlighted with Hilit19 -;; before hightlighting them with Ediff's overlays. (And for -;; rehighlighting them with Hilit19, when the current difference moves on.) - -;; Sun Feb 13, 1994 - -;; Added ediff-place-flags-in-buffer and ediff-remote-exit, which are -;; modifications of Emerge's similar functions. The difference is that -;; in Ediff they make ediff-before-flag and ediff-after-flag into -;; read-only regions, so the user can't change them by mistake. -;; -;; Adopted a suggestion by Boris Goldowsky -;; that led to a more elegant treatment of faces. -;; -;; Added protection against interference with Font-Lock highlighting -;; similar to that of Hilit19's protection. +;; If at any point you feel that difference regions are no longer correct, +;; you can hit '!' to recompute the differences. -;; Tue Feb 15, 1994 +;; 2. On a monochrome display, the repertoire of faces with which to +;; highlight fine differences is limited. By default, Ediff is using +;; underlining. However, if the region is already underlined by some other +;; overlays, there is no simple way to temporarily remove that residual +;; underlining. This problem occurs when a buffer is highlighted with +;; hilit19.el or font-lock.el packages. If this residual highlighting gets +;; in the way, you can do the following. Both font-lock.el and hilit19.el +;; provide commands for unhighlighting buffers. You can either place these +;; commands in `ediff-prepare-buffer-hook' (which will unhighlight every +;; buffer used by Ediff) or you can execute them interactively, at any time +;; and on any buffer. -;; Deleted spurious (auto-save-mode 1) in ediff-control-buffer, which -;; was causing this buffer to be auto-saved for no good reason. -;; Added read-only protection to ediff-before/after-flags in Lemacs. -;; (Thanks to Alastair Burt for help in testing.) - -;; Wed Feb 16, 1994 - -;; Further fixes in the Lemacs part. Changed highlighted region in -;; ediff-highlight-diff so that an extra character will be highlighted -;; only if a difference is empty (thereby allowing the user to see where an -;; insertion or a deletion has taken place). -;; -;; Simplified interaction with other highlighting packages by giving -;; Ediff overlays the highest priority. (Taking a cue from -;; ediff-highlight-diff-lemacs written by Alastair Burt -;; .) Zapped ediff-third-party-highlighting -;; variable and hooks that were previously used to -;; unhighlight/rehighlight buffers when hilit19/font-lock are on. -;; Fri Feb 18, 1994 - -;; Added a bit more sophistication to ediff-read-file-name. Now, -;; ediff-files remembers both, the file-A and the file-B directories. -;; They are offered as defaults when ediff-use-last-dir is set to t. - -;; Fri Feb 22, 1994 - -;; Added ediff-before-change-guard to remove ASCII highlighting when -;; the user attempts to change buffer-A/B. This is needed because -;; otherwise the undo info may become screwed up in those buffers. -;; Hitting 'h' (ediff-toggle-hilit) on a dumb terminal will toggle -;; between ASCII highlighting and no highlighting. - -;; Fri Feb 24, 1994 - -;; Fixed problems with multiple Ediff sessions running simultaneously. - -;; Tue Mar 1, 1994 - -;; Added vc-ediff, the Ediff interface to vc.el. (Thanks to Eric -;; Freudenthal for contributing this -;; function.) - -;; Sun Mar 6, 1994 - -;; Added rcs-ediff, an Ediff interface to RCS via rcs.el. (Thanks to -;; Alastair Burt .) -;; Some minor improvements. - -;; Tue March 15, 1994 - -;; Fixed a buglet in defining ediff-current-diff-face-A/B. -;; (Thanks to Job Ganzevoort .) - -;; Tue March 22, 1994 - -;; Fixed a bug with ediffing narrowed buffers, reported by Kevin -;; Broadey . -;; Made Ediff to work with files that have incomplete last line. -;; Made Ediff execute diff and patch using Bourne Shell, which -;; should eliminate problems with $prompt that some people had. - -;; Thu March 24, 1994 - -;; Achieved quadratic speedup in the size of the file by replacing the -;; slow goto-line by forward-line. Ediff is now *much* faster than -;; Emerge on large files. Converted demarkation of difference regions -;; from markers to overlays. This will later allow us to highlight all -;; diffs, not just the current one. - -;; Wed March 30, 1994 - -;; Under X, Ediff now highlights all differences in dim colors and the -;; current difference in bright colors. Improved Lucid Emacs support. - -;; Thu March 31, 1994 - -;; Changed toggle hilit to cycle through 3 states: highlighting all -;; diffs, highlighting only the current diff, and highlighting using -;; ASCII flags. -;; Added support for difference regions that are not full lines. - -;; Fri April 1, 1994 - -;; Fixed bugs related to writing buffers A and B. -;; Added commands 'ga', 'gb' to jump directly to the closest diff in -;; buffer A and B, respectively. +;;; Acknowledgements: +;; Ediff was inspired by Dale R. Worley's emerge.el. +;; Ediff would not have been possible without the help and encouragement of +;; its many users. See Ediff on-line Info for the full list of those who +;; helped. Improved defaults in Ediff file-name reading commands. ;;; Code: -(require 'emerge) ;; Ediff is based on emerge - - -;;; Macros -(defmacro ediff-if-lucid () - (` (string-match "Lucid" emacs-version))) -(defmacro ediff-odd-p (arg) - (` (eq (logand (, arg) 1) 1))) -(defmacro ediff-buffer-live-p (buf) - (` (and (, buf) (get-buffer (, buf)) (buffer-name (get-buffer (, buf)))))) - - -(defun ediff-mode () - "Ediff mode is used by the Ediff file-difference package. -It is entered only through one of the following commands: - `ediff' - `ediff-files' - `ediff-buffers' - `epatch' - `ediff-patch-file' - `ediff-patch-buffer' - `vc-ediff' - `rcs-ediff' -or through a non-interactive Emacs Lisp function - `ediff-files-remote' - -Commands: -\\{ediff-mode-map}" - (interactive) - (kill-all-local-variables) - (setq major-mode 'ediff-mode) - (setq mode-name "Ediff")) +(provide 'ediff) -(defvar ediff-version "1.31" - "The current version of Ediff.") +;; Compiler pacifier +(defvar cvs-cookie-handle) +(defvar ediff-last-dir-patch) +(defvar ediff-patch-default-directory) + +(and noninteractive + (eval-when-compile + (load-library "dired") + (load-library "info") + (load "pcl-cvs" 'noerror))) +(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-mult) + (load "ediff-mult.el" nil nil 'nosuffix)) + (or (featurep 'ediff-ptch) + (load "ediff-ptch.el" nil nil 'nosuffix)) + (or (featurep 'ediff-vers) + (load "ediff-vers.el" nil nil 'nosuffix)) + )) +;; end pacifier + +(require 'ediff-init) +(require 'ediff-mult) ; required because of the registry stuff + +(defgroup ediff nil + "A comprehensive visual interface to diff & patch" + :tag "Ediff" + :group 'tools) + + +(defcustom ediff-use-last-dir nil + "*If t, Ediff will use previous directory as default when reading file name." + :type 'boolean + :group 'ediff) + +;; Last directory used by an Ediff command for file-A. +(defvar ediff-last-dir-A nil) +;; Last directory used by an Ediff command for file-B. +(defvar ediff-last-dir-B nil) +;; Last directory used by an Ediff command for file-C. +(defvar ediff-last-dir-C nil) +;; Last directory used by an Ediff command for the ancestor file. +(defvar ediff-last-dir-ancestor nil) +;; Last directory used by an Ediff command as the output directory for merge. +(defvar ediff-last-merge-autostore-dir) + + +;; Used as a startup hook to set `_orig' patch file read-only. +(defun ediff-set-read-only-in-buf-A () + (ediff-with-current-buffer ediff-buffer-A + (toggle-read-only 1))) + +;; Return a plausible default for ediff's first file: +;; In dired, return the file name under the point, unless it is a directory +;; If the buffer has a file name, return that file name. +(defun ediff-get-default-file-name () + (cond ((eq major-mode 'dired-mode) + (let ((f (dired-get-filename nil 'no-error))) + (if (and (stringp f) (not (file-directory-p f))) + f))) + ((buffer-file-name (current-buffer)) + (file-name-nondirectory (buffer-file-name (current-buffer)))) + )) -(defun ediff-version () - "Return string describing the version of Ediff. -When called interactively, displays the version." - (interactive) - (if (interactive-p) - (message "Ediff version %s" (ediff-version)) - ediff-version)) - - -;; Hook variables - -(defvar ediff-before-setup-windows-hooks nil - "* Hooks to run before Ediff sets its own window config. -This can be used to save the previous window config, which can be -restored by `ediff-quit' or `ediff-suspend'.") - -(defvar ediff-startup-hooks nil - "*Hooks to run in the control buffer after Ediff has been set up.") -(defvar ediff-select-hooks nil - "*Hooks to run after a difference has been selected.") -(defvar ediff-unselect-hooks nil - "*Hooks to run after a difference has been unselected.") -(defvar ediff-prepare-buffer-hooks nil - "*Hooks called after buffers A and B are set up.") -(defvar ediff-load-hooks nil - "*Hook run after Ediff is loaded. Can be used to change defaults.") - -(defvar ediff-suspend-hooks 'ediff-default-suspend-hook - "*Hooks to run in the Ediff control buffer when Ediff is suspended.") -(defvar ediff-quit-hooks 'ediff-default-quit-hook - "*Hooks to run in the Ediff control buffer after finishing Ediff.") - -(make-variable-buffer-local 'local-write-file-hooks) -(make-variable-buffer-local 'before-change-function) - -;; Help messages - -(defconst ediff-help-message-long -"p,DEL - prev diff c - recenter ab - diff A to B l - line numbers -n,SPC - next diff v/V - scroll up/dn ba - diff B to A f - file names - j - jump to diff - scroll lt/rt ra - restore A z - suspend Ediff - ga - goto pt in A s - toggle split rb - restore B q - quit Ediff - gb - goto pt in B h - toggle hilit -wa/wb - save buf A/B A/B - toggle read-only buf A/B ? - toggle help") - -(defconst ediff-help-message-short -" ? - toggle help window") +;;; Compare files/buffers -(defvar ediff-help-message ediff-help-message-long - "*The actual help message.") - - -(defvar ediff-diff-program "diff" - "*Name of the program that compares two files.") -(defvar ediff-diff-options "" - "*Options to pass to `ediff-diff-program'.") +;;;###autoload +(defun ediff-files (file-A file-B &optional startup-hooks) + "Run Ediff on a pair of files, FILE-A and FILE-B." + (interactive + (let ((dir-A (if ediff-use-last-dir + ediff-last-dir-A + default-directory)) + dir-B f) + (list (setq f (ediff-read-file-name + "File A to compare" dir-A + (ediff-get-default-file-name))) + (ediff-read-file-name "File B to compare" + (setq dir-B + (if ediff-use-last-dir + ediff-last-dir-B + (file-name-directory f))) + (progn + (setq file-name-history + (cons (ediff-abbreviate-file-name + (expand-file-name + (file-name-nondirectory f) + dir-B)) + file-name-history)) + f)) + ))) + (ediff-files-internal file-A + (if (file-directory-p file-B) + (expand-file-name + (file-name-nondirectory file-A) file-B) + file-B) + nil ; file-C + startup-hooks + 'ediff-files)) +;;;###autoload +(defun ediff-files3 (file-A file-B file-C &optional startup-hooks) + "Run Ediff on three files, FILE-A, FILE-B, and FILE-C." + (interactive + (let ((dir-A (if ediff-use-last-dir + ediff-last-dir-A + default-directory)) + dir-B dir-C f ff) + (list (setq f (ediff-read-file-name + "File A to compare" dir-A + (ediff-get-default-file-name))) + (setq ff (ediff-read-file-name "File B to compare" + (setq dir-B + (if ediff-use-last-dir + ediff-last-dir-B + (file-name-directory f))) + (progn + (setq file-name-history + (cons + (ediff-abbreviate-file-name + (expand-file-name + (file-name-nondirectory f) + dir-B)) + file-name-history)) + f))) + (ediff-read-file-name "File C to compare" + (setq dir-C (if ediff-use-last-dir + ediff-last-dir-C + (file-name-directory ff))) + (progn + (setq file-name-history + (cons (ediff-abbreviate-file-name + (expand-file-name + (file-name-nondirectory ff) + dir-C)) + file-name-history)) + ff)) + ))) + (ediff-files-internal file-A + (if (file-directory-p file-B) + (expand-file-name + (file-name-nondirectory file-A) file-B) + file-B) + (if (file-directory-p file-C) + (expand-file-name + (file-name-nondirectory file-A) file-C) + file-C) + startup-hooks + 'ediff-files3)) -;; Support for patches - -(defvar ediff-patch-program "patch" - "*Name of the program that applies patches.") -(defvar ediff-patch-options "" - "*Options to pass to ediff-patch-program.") - -(defvar ediff-shell "sh" - "*The shell used to run diff and patch. -If user's .profile or .cshrc files are set up correctly, any shell will do. -However, some people set `$prompt' or other things incorrectly, which -leads to undesirable output messages. These may cause Ediff to fail. -In such a case, set `ediff-shell' to a shell that you are not using or, -better, fix your shell's startup file.") - -(defvar ediff-diff-ok-lines-regexp - "^\\([0-9,]+[acd][0-9,]+$\\|[<>] \\|---\\|Warning:\\)" - "*Regexp that matches normal output lines from `ediff-diff-program'. -This is mostly lifted from Emerge, except that Ediff also considers the -'Missing newline' message to be 'normal output.' -Lines that do not match are assumed to be error messages.") - -(defvar ediff-match-diff-line (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)")) - (concat "^" x "\\([acd]\\)" x "$")) - "*Pattern to match lines produced by diff that describe differences.") - -(defvar ediff-patch-buf nil - "The buffer of the patch file.") -(defvar ediff-patch-diagnostics nil - "The buffer where patch would display its diagnostics.") +;;;###autoload +(defalias 'ediff3 'ediff-files3) + + +;; Visit FILE and arrange its buffer to Ediff's liking. +;; FILE is actually a variable symbol that must contain a true file name. +;; BUFFER-NAME is a variable symbol, which will get the buffer object into +;; which FILE is read. +;; LAST-DIR is the directory variable symbol where FILE's +;; directory name should be returned. HOOKS-VAR is a variable symbol that will +;; be assigned the hook to be executed after `ediff-startup' is finished. +;; `ediff-find-file' arranges that the temp files it might create will be +;; deleted. +(defun ediff-find-file (file-var buffer-name &optional last-dir hooks-var) + (let* ((file (symbol-value file-var)) + (file-magic (ediff-filename-magic-p file)) + (temp-file-name-prefix (file-name-nondirectory file))) + (cond ((not (file-readable-p file)) + (error "File `%s' does not exist or is not readable" file)) + ((file-directory-p file) + (error "File `%s' is a directory" file))) + + ;; some of the commands, below, require full file name + (setq file (expand-file-name file)) - -;; Copying diffs betw buffers. - -(emerge-defvar-local ediff-killed-diffs-alist nil - "A list of killed diffs. -A diff is saved here if it is replaced by a diff -from another buffer. This alist has the form: -\((num (A . diff) (B . diff)) ...), -where A or B parts may be missing.") - - -;; Highlighting -(defvar ediff-before-flag-bol - ;"vvvvvvvvvvvvvvvv---- ediff ----vvvvvvvvvvvvvvv\n" - ">>--->>>\n" - "*Flag placed above the highlighted block of differences. -Must end with newline. Must be set before Ediff is loaded. -nil means use a default flag string.") -(defvar ediff-after-flag-bol - ;"^^^^^^^^^^^^^^^^---- ediff ----^^^^^^^^^^^^^^^\n" - "<<<---<<\n" - "*Flag placed below the highlighted block of differences. -Must end with newline. Must be set before Ediff is loaded. -nil means use a default flag string.") - -(defvar ediff-before-flag-mol ">>--->>>" - "*Like ediff-before-flag, used when a difference starts in mid-line.") -(defvar ediff-after-flag-mol "<<<---<<" - "*Like ediff-after-flag, used when a difference starts in mid-line.") - -(emerge-defvar-local ediff-before-flag-A nil - "This is the actual ASCII before-flag in effect in buffer A. -It is either `ediff-before-flag-mol' or `ediff-before-flag-bol' depending -on whether the selected difference region starts in the middle of a line -or at the beginning of a line.") -(emerge-defvar-local ediff-after-flag-A nil - "This is the actual ASCII after-flag in effect in buffer A. -It is either `ediff-before-flag-mol' or `ediff-before-flag-bol' depending -on whether the selected difference region starts in the middle of a line -or at the beginning of a line.") -(emerge-defvar-local ediff-before-flag-B nil - "This is the actual ASCII before-flag in effect in buffer B. -It is either `ediff-before-flag-mol' or `ediff-before-flag-bol' depending -on whether the selected difference region starts in the middle of a line -or at the beginning of a line.") -(emerge-defvar-local ediff-after-flag-B nil - "This is the actual ASCII after-flag in effect in buffer B. -It is either `ediff-before-flag-mol' or `ediff-before-flag-bol' depending -on whether the selected difference region starts in the middle of a line -or at the beginning of a line.") - + ;; Record the directory of the file + (if last-dir + (set last-dir (expand-file-name (file-name-directory file)))) + + ;; Setup the buffer + (set buffer-name (find-file-noselect file)) -(emerge-defvar-local ediff-want-faces t - "If t, differences are highlighted using faces on a window system. -If nil, they are highlighted using ASCII flags, ediff-before-flag -and ediff-after-flag. On a non-window system, differences are always -highlighted using ASCII flags. - -This is not a user option. Can be set either in .emacs or toggled -interactively, using ediff-toggle-hilit.") - -(emerge-defvar-local ediff-highlight-selected-only nil - "If t, only the selected differences are highlighted. -This is not a user option. Can be set either in `.emacs' or toggled -interactively, using `ediff-toggle-hilit'.") - -(emerge-defvar-local ediff-highlighting-style nil - "A var local to each ediff-control buffer. -Indicates highlighting style in effect for this buffer: `face', `ascii', -nil -- temporarily unhighlighted, `off' -- turned off \(on a dumb -terminal only\).") - + (ediff-with-current-buffer (symbol-value buffer-name) + (widen) ; Make sure the entire file is seen + (cond (file-magic ; file has a handler, such as jka-compr-handler or + ;;; ange-ftp-hook-function--arrange for temp file + (ediff-verify-file-buffer 'magic) + (setq file + (ediff-make-temp-file + (current-buffer) temp-file-name-prefix)) + (set hooks-var (cons (` (lambda () (delete-file (, file)))) + (symbol-value hooks-var)))) + ;; file processed via auto-mode-alist, a la uncompress.el + ((not (equal (file-truename file) + (file-truename (buffer-file-name)))) + (setq file + (ediff-make-temp-file + (current-buffer) temp-file-name-prefix)) + (set hooks-var (cons (` (lambda () (delete-file (, file)))) + (symbol-value hooks-var)))) + (t ;; plain file---just check that the file matches the buffer + (ediff-verify-file-buffer)))) + (set file-var file))) + +;; MERGE-BUFFER-FILE is the file to be associated with the merge buffer +(defun ediff-files-internal (file-A file-B file-C startup-hooks job-name + &optional merge-buffer-file) + (let (buf-A buf-B buf-C) + (message "Reading file %s ... " file-A) + ;;(sit-for 0) + (ediff-find-file 'file-A 'buf-A 'ediff-last-dir-A 'startup-hooks) + (message "Reading file %s ... " file-B) + ;;(sit-for 0) + (ediff-find-file 'file-B 'buf-B 'ediff-last-dir-B 'startup-hooks) + (if (stringp file-C) + (progn + (message "Reading file %s ... " file-C) + ;;(sit-for 0) + (ediff-find-file + 'file-C 'buf-C + (if (eq job-name 'ediff-merge-files-with-ancestor) + 'ediff-last-dir-ancestor 'ediff-last-dir-C) + 'startup-hooks))) + (ediff-setup buf-A file-A + buf-B file-B + buf-C file-C + startup-hooks + (list (cons 'ediff-job-name job-name)) + merge-buffer-file))) -;; Variables that control each Ediff session. They are local to the -;; control buffer. +;;;###autoload +(defalias 'ediff 'ediff-files) -;; Mode variables -(emerge-defvar-local ediff-A-buffer nil - "The buffer in which the A variant is stored.") -(emerge-defvar-local ediff-B-buffer nil - "The buffer in which the B variant is stored.") -(emerge-defvar-local ediff-control-buffer nil - "The control buffer of ediff. ") -(emerge-defvar-local ediff-control-buffer-suffix nil - "The suffix of the control buffer name. ") - -(defvar ediff-control-window nil - "The control window.") - - -(emerge-defvar-local ediff-A-buffer-values nil - "Keeps working values of ediff-saved-variables for ediff-A-buffer.") -(emerge-defvar-local ediff-B-buffer-values nil - "Keeps working values of ediff-saved-variables for ediff-B-buffer.") - -(emerge-defvar-local ediff-A-buffer-values-setup nil - "Remembers ediff-saved-variables for ediff-A-buffer as they were at setup.") -(emerge-defvar-local ediff-B-buffer-values-setup nil - "Remembers ediff-saved-variables for ediff-B-buffer as they were at setup.") - -(emerge-defvar-local ediff-difference-vector nil - "Vector of differences between the variants. -Each difference is represented by a vector of two overlays. The first -overlays the difference section in the A buffer and the second -overlays the diff in the B buffer. If a difference section is empty, -the corresponding overlay's endpoints councide. ") - -(emerge-defvar-local ediff-current-difference -1 - "The difference that is currently selected.") -(emerge-defvar-local ediff-number-of-differences nil - "Number of differences found.") - -(emerge-defvar-local ediff-diff-buffer nil - "Buffer containing the output of diff, used by Ediff to step through files.") -(emerge-defvar-local ediff-diff-error-buffer nil - "Buffer containing the output of diff, when diff returns errors.") - -(emerge-defvar-local ediff-this-buffer-control-sessions nil - "List of ediff-control buffers associated with each buffer A/B.") +;;;###autoload +(defun ediff-buffers (buffer-A buffer-B &optional startup-hooks job-name) + "Run Ediff on a pair of buffers, BUFFER-A and BUFFER-B." + (interactive + (let (bf) + (list (setq bf (read-buffer "Buffer A to compare: " + (ediff-other-buffer "") t)) + (read-buffer "Buffer B to compare: " + (progn + ;; realign buffers so that two visible bufs will be + ;; at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer bf)) + t)))) + (or job-name (setq job-name 'ediff-buffers)) + (ediff-buffers-internal buffer-A buffer-B nil startup-hooks job-name)) -(defvar ediff-disturbed-overlays nil - "List of difference overlays disturbed by working with the current diff.") - -(defvar ediff-shaded-overlay-priority - (if (ediff-if-lucid) - (1+ mouse-highlight-priority) - 100) ;; 100 is a kludge. There is a bug in insert-in-front-hooks - ;; in Emacs < 19.23. When this is fixed, I will get rid of - ;; this kludge. - "Priority of non-selected overlays.") - - -(if (ediff-if-lucid) - (progn - (fset 'ediff-overlayp (symbol-function 'extentp)) - (fset 'ediff-make-overlay (symbol-function 'make-extent)) - (fset 'ediff-delete-overlay (symbol-function 'delete-extent)) - (fset 'ediff-overlay-put (symbol-function 'set-extent-property)) - (fset 'ediff-move-overlay (symbol-function 'set-extent-endpoints)) - (fset 'ediff-overlay-start (symbol-function 'extent-start-position)) - (fset 'ediff-overlay-end (symbol-function 'extent-end-position)) - (fset 'ediff-overlay-get (symbol-function 'extent-property))) - (fset 'ediff-overlayp (symbol-function 'overlayp)) - (fset 'ediff-make-overlay (symbol-function 'make-overlay)) - (fset 'ediff-delete-overlay (symbol-function 'delete-overlay)) - (fset 'ediff-overlay-put (symbol-function 'overlay-put)) - (fset 'ediff-move-overlay (symbol-function 'move-overlay)) - (fset 'ediff-overlay-start (symbol-function 'overlay-start)) - (fset 'ediff-overlay-end (symbol-function 'overlay-end)) - (fset 'ediff-overlay-get (symbol-function 'overlay-get))) - -(if window-system - (if (ediff-if-lucid) - (progn - (fset 'ediff-select-frame (symbol-function 'select-screen)) - (fset 'ediff-window-frame (symbol-function 'window-screen)) - (fset 'ediff-display-color-p (symbol-function 'x-color-display-p)) - (fset 'ediff-get-face (symbol-function 'get-face))) - (fset 'ediff-window-frame (symbol-function 'window-frame)) - (fset 'ediff-select-frame (symbol-function 'select-frame)) - (fset 'ediff-display-color-p (symbol-function 'x-display-color-p)) - (fset 'ediff-get-face (symbol-function 'internal-get-face))) - ;; not a window system - (fset 'ediff-window-frame (function (lambda (wind) (if wind 1 nil)) )) - (fset 'ediff-select-frame (symbol-function 'identity)) - (fset 'ediff-make-current-diff-overlay (function (lambda (type) nil))) - (fset 'ediff-unhighlight-diffs-totally (function (lambda () nil)))) - +;;;###autoload +(defalias 'ebuffers 'ediff-buffers) -(if (not window-system) - () - (defvar ediff-current-diff-face-A - (progn - (make-face 'ediff-current-diff-face-A) - (cond ((ediff-display-color-p) - (set-face-foreground 'ediff-current-diff-face-A "firebrick") - (set-face-background 'ediff-current-diff-face-A "pale green")) - (t - (if (ediff-if-lucid) - (copy-face 'modeline 'ediff-current-diff-face-A) - (copy-face 'highlight 'ediff-current-diff-face-A)) - )) - (ediff-get-face 'ediff-current-diff-face-A)) - "Face for highlighting the currently selected difference in buffer A of -the Ediff display") - - (defvar ediff-current-diff-face-B - (progn - (make-face 'ediff-current-diff-face-B) - (cond ((ediff-display-color-p) - (set-face-foreground 'ediff-current-diff-face-B "DarkOrchid") - (set-face-background 'ediff-current-diff-face-B "Yellow")) - (t - (if (ediff-if-lucid) - (copy-face 'modeline 'ediff-current-diff-face-B) - (copy-face 'highlight 'ediff-current-diff-face-B)) - )) - (ediff-get-face 'ediff-current-diff-face-B)) - "Face for highlighting the currently selected difference in buffer B of -the Ediff display") - - (defvar ediff-even-diff-face-A - (progn - (make-face 'ediff-even-diff-face-A) - (cond ((ediff-display-color-p) - (set-face-background 'ediff-even-diff-face-A "light grey")) - (t - (if (ediff-if-lucid) - (progn - (copy-face 'highlight 'ediff-even-diff-face-A) - (invert-face 'ediff-even-diff-face-A)) - (make-face-italic 'ediff-even-diff-face-A)))) - (ediff-get-face 'ediff-even-diff-face-A)) - "Face used to highlight even-numbered differences in buffer A.") - - (defvar ediff-even-diff-face-B - (progn - (make-face 'ediff-even-diff-face-B) - (cond ((ediff-display-color-p) - (set-face-foreground 'ediff-even-diff-face-B "White") - (set-face-background 'ediff-even-diff-face-B "Gray")) - (t - (if (ediff-if-lucid) - (copy-face 'highlight 'ediff-even-diff-face-B) - (make-face-italic 'ediff-even-diff-face-B)))) - (ediff-get-face 'ediff-even-diff-face-B)) - "Face used to highlight even-numbered differences in buffer B.") - - (defvar ediff-odd-diff-face-A - (progn - (make-face 'ediff-odd-diff-face-A) - (cond ((ediff-display-color-p) - (set-face-foreground 'ediff-odd-diff-face-A "White") - (set-face-background 'ediff-odd-diff-face-A "Gray")) - (t - (if (ediff-if-lucid) - (copy-face 'highlight 'ediff-odd-diff-face-A) - (make-face-italic 'ediff-odd-diff-face-A)))) - (ediff-get-face 'ediff-odd-diff-face-A)) - "Face used to highlight odd-numbered differences in buffer A.") - - (defvar ediff-odd-diff-face-B - (progn - (make-face 'ediff-odd-diff-face-B) - (cond ((ediff-display-color-p) - (set-face-foreground 'ediff-odd-diff-face-B "Black") - (set-face-background 'ediff-odd-diff-face-B "light grey")) - (t - (if (ediff-if-lucid) - (progn - (copy-face 'highlight 'ediff-odd-diff-face-B) - (invert-face 'ediff-odd-diff-face-B)) - (make-face-italic 'ediff-odd-diff-face-B)))) - (ediff-get-face 'ediff-odd-diff-face-B)) - "Face used to highlight odd-numbered differences in buffer B.") - - - ;; Create *-var faces. These are the actual faces used to highlight - ;; odd-numbered difference regions. - ;; They are used as follows: when highlighting is turned on, - ;; ediff-odd/even-diff-face-A/B are copied - ;; into ediff-odd/even-diff-face-A/B-var, and all odd/even overlays become - ;; highlighted. When highlighting is turned off, then the face 'default is - ;; copied into ediff-odd/even-diff-face-A/B-var, thereby unhighlighting all - ;; difference regions. - (make-face 'ediff-even-diff-face-A-var) - (make-face 'ediff-even-diff-face-B-var) - (make-face 'ediff-odd-diff-face-A-var) - (make-face 'ediff-odd-diff-face-B-var) - - ;; initialize *-var faces - (defun ediff-init-var-faces () - (copy-face (if (and ediff-want-faces (null ediff-highlight-selected-only)) - ediff-even-diff-face-A 'default) - 'ediff-even-diff-face-A-var) - (copy-face (if (and ediff-want-faces (null ediff-highlight-selected-only)) - ediff-even-diff-face-B 'default) - 'ediff-even-diff-face-B-var) - (copy-face (if (and ediff-want-faces (null ediff-highlight-selected-only)) - ediff-odd-diff-face-A 'default) - 'ediff-odd-diff-face-A-var) - (copy-face (if (and ediff-want-faces (null ediff-highlight-selected-only)) - ediff-odd-diff-face-B 'default) - 'ediff-odd-diff-face-B-var)) +;;;###autoload +(defun ediff-buffers3 (buffer-A buffer-B buffer-C + &optional startup-hooks job-name) + "Run Ediff on three buffers, BUFFER-A, BUFFER-B, and BUFFER-C." + (interactive + (let (bf bff) + (list (setq bf (read-buffer "Buffer A to compare: " + (ediff-other-buffer "") t)) + (setq bff (read-buffer "Buffer B to compare: " + (progn + ;; realign buffers so that two visible + ;; bufs will be at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer bf)) + t)) + (read-buffer "Buffer C to compare: " + (progn + ;; realign buffers so that three visible + ;; bufs will be at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer (list bf bff))) + t) + ))) + (or job-name (setq job-name 'ediff-buffers3)) + (ediff-buffers-internal buffer-A buffer-B buffer-C startup-hooks job-name)) - ;;; Overlays +;;;###autoload +(defalias 'ebuffers3 'ediff-buffers3) + - (emerge-defvar-local ediff-current-diff-overlay-A nil - "Overlay in buffer A.") - (emerge-defvar-local ediff-current-diff-overlay-B nil - "Overlay in buffer B.") - - (defun ediff-make-current-diff-overlay (type) - (let ((overlay (if (eq type 'A) - 'ediff-current-diff-overlay-A - 'ediff-current-diff-overlay-B)) - (buffer (if (eq type 'A) ediff-A-buffer ediff-B-buffer)) - (face (if (eq type 'A) - (face-name ediff-current-diff-face-A) - (face-name ediff-current-diff-face-B)))) - (set overlay (ediff-make-overlay (point-max) (point-max) buffer)) - (ediff-overlay-put (eval overlay) 'face face) - (ediff-overlay-put (eval overlay) 'ediff ediff-control-buffer) - )) + +;; MERGE-BUFFER-FILE is the file to be associated with the merge buffer +(defun ediff-buffers-internal (buf-A buf-B buf-C startup-hooks job-name + &optional merge-buffer-file) + (let* ((buf-A-file-name (buffer-file-name (get-buffer buf-A))) + (buf-B-file-name (buffer-file-name (get-buffer buf-B))) + (buf-C-is-alive (ediff-buffer-live-p buf-C)) + (buf-C-file-name (if buf-C-is-alive + (buffer-file-name (get-buffer buf-B)))) + file-A file-B file-C) + (if (not (ediff-buffer-live-p buf-A)) + (error "Buffer %S doesn't exist" buf-A)) + (if (not (ediff-buffer-live-p buf-B)) + (error "Buffer %S doesn't exist" buf-B)) + (let ((ediff-job-name job-name)) + (if (and ediff-3way-comparison-job + (not buf-C-is-alive)) + (error "Buffer %S doesn't exist" buf-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))) - ;; Computes priority of ediff overlay. - (defun ediff-highest-priority (start end buffer) - (let ((pos (max 1 (1- start))) - ovr-list) - (if (ediff-if-lucid) - (+ 2 mouse-highlight-priority) - (emerge-eval-in-buffer - buffer - (while (< pos (min (point-max) (1+ end))) - (setq ovr-list (append (overlays-at pos) ovr-list)) - (setq pos (next-overlay-change pos))) - (1+ (eval - (cons '+ - (mapcar (function - (lambda (ovr) - (if ovr - (or (ediff-overlay-get ovr 'priority) 0) - 0))) - ovr-list) - ))) - )))) - -) ; end of window-system-only code. - - + (setq file-A (ediff-make-temp-file buf-A buf-A-file-name) + file-B (ediff-make-temp-file buf-B buf-B-file-name)) + (if buf-C-is-alive + (setq file-C (ediff-make-temp-file buf-C buf-C-file-name))) + + (ediff-setup (get-buffer buf-A) file-A + (get-buffer buf-B) file-B + (if buf-C-is-alive (get-buffer buf-C)) + file-C + (cons (` (lambda () + (delete-file (, file-A)) + (delete-file (, file-B)) + (if (stringp (, file-C)) (delete-file (, file-C))) + )) + startup-hooks) + (list (cons 'ediff-job-name job-name)) + merge-buffer-file))) -;;; Misc -(defvar ediff-split-window-function 'split-window-vertically - "*The function to split the main window between buffer-A and buffer-B. -You can set it to be split horizontally instead of the -default verstical split by setting this variable to -'split-window-horizontally. You can also have your own function for fancy -splits. This variable has no effect when buffer-A and buffer-B are shown in -different frames. In this case, Ediff will use those frames to display -these buffers.") - -(defconst ediff-saved-variables - '(buffer-read-only - buffer-auto-save-file-name) - "Buffer-local variables saved and restored during an Ediff session.") +;;; Directory and file group operations -(defconst ediff-working-values '(nil nil) - "Values to be assigned to `ediff-saved-variables' during diff.") - -(defvar ediff-use-last-dir nil - "*If t, Ediff uses previous directory as default when reading file name.") - -(defvar ediff-nix-help-in-control-buffer nil - "*Non-nil mean C-h should not to invoke Emacs help. -Instead, C-h jumps to previous difference.") - -(defvar ediff-temp-file-prefix - (let ((env (getenv "TMPDIR")) - d) - (setq d (if (and env (> (length env) 0)) - env - "/tmp")) - (if (= (aref d (1- (length d))) ?/) - (setq d (substring d 0 -1))) - (concat d "/ediff")) - "*Prefix to put on Ediff temporary file names. -Do not start with `~/' or `~user-name/'.") - -(defvar ediff-temp-file-mode 384 ; u=rw only - "*Mode for Ediff temporary files.") - -(defvar ediff-last-dir-A nil - "Last directory used by an Ediff command for file-A.") -(defvar ediff-last-dir-B nil - "Last directory used by an Ediff command for file-B.") - -;; Build keymaps +;; Get appropriate default name for directory: +;; If ediff-use-last-dir, use ediff-last-dir-A. +;; In dired mode, use the directory that is under the point (if any); +;; otherwise, use default-directory +(defun ediff-get-default-directory-name () + (cond (ediff-use-last-dir ediff-last-dir-A) + ((eq major-mode 'dired-mode) + (let ((f (dired-get-filename nil 'noerror))) + (if (and (stringp f) (file-directory-p f)) + f + default-directory))) + (t default-directory))) -(defvar ediff-mode-map nil - "Local keymap used in Ediff mode.") +;;;###autoload +(defun ediff-directories (dir1 dir2 regexp) + "Run Ediff on a pair of directories, DIR1 and DIR2, comparing files that have +the same name in both. The third argument, REGEXP, is a regular expression that +can be used to filter out certain file names." + (interactive + (let ((dir-A (ediff-get-default-directory-name)) + f) + (list (setq f (ediff-read-file-name "Directory A to compare:" dir-A nil)) + (ediff-read-file-name "Directory B to compare:" + (if ediff-use-last-dir + ediff-last-dir-B + (ediff-strip-last-dir f)) + nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) + ))) + (ediff-directories-internal + dir1 dir2 nil regexp 'ediff-files 'ediff-directories + )) + +;;;###autoload +(defalias 'edirs 'ediff-directories) -(defun ediff-setup-keymap () - "Set up the keymap used in the control buffer of Ediff." - (setq ediff-mode-map (make-sparse-keymap)) - (suppress-keymap ediff-mode-map) - - (define-key ediff-mode-map "p" 'ediff-previous-difference) - (define-key ediff-mode-map "\C-?" 'ediff-previous-difference) - (define-key ediff-mode-map "\C-h" (if ediff-nix-help-in-control-buffer - 'ediff-previous-difference nil)) - (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 "g" nil) - (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 "z" 'ediff-suspend) - (define-key ediff-mode-map "c" 'ediff-recenter) - (define-key ediff-mode-map "s" 'ediff-toggle-split) - (define-key ediff-mode-map "h" 'ediff-toggle-hilit) - (define-key ediff-mode-map "v" 'ediff-scroll-up) - (define-key ediff-mode-map "\C-v" 'ediff-scroll-up) - (define-key ediff-mode-map "^" 'ediff-scroll-down) - (define-key ediff-mode-map "\M-v" 'ediff-scroll-down) - (define-key ediff-mode-map "V" 'ediff-scroll-down) - (define-key ediff-mode-map "<" 'ediff-scroll-left) - (define-key ediff-mode-map ">" 'ediff-scroll-right) - (define-key ediff-mode-map "f" 'ediff-file-names) - (define-key ediff-mode-map "l" 'ediff-line-numbers) - (define-key ediff-mode-map "?" 'ediff-toggle-help) - (define-key ediff-mode-map "a" nil) - (define-key ediff-mode-map "ab" 'ediff-diff-to-diff) - (define-key ediff-mode-map "b" nil) - (define-key ediff-mode-map "ba" 'ediff-diff-to-diff) - (define-key ediff-mode-map "r" nil) - (define-key ediff-mode-map "ra" 'ediff-restore-diff) - (define-key ediff-mode-map "rb" 'ediff-restore-diff) - (define-key ediff-mode-map "o" nil) - (define-key ediff-mode-map "A" 'ediff-toggle-read-only) - (define-key ediff-mode-map "B" 'ediff-toggle-read-only) - (define-key ediff-mode-map "w" nil) - (define-key ediff-mode-map "wa" 'ediff-save-buffer) - (define-key ediff-mode-map "wb" 'ediff-save-buffer) - (define-key ediff-mode-map "k" nil) - (define-key ediff-mode-map "kkk" 'ediff-reload-keymap) ;; for debug - ;; Allow ediff-mode-map to be referenced indirectly - (fset 'ediff-mode-map ediff-mode-map)) - - -;;; Setup functions - -(defun ediff-find-file (file buffer &optional last-dir) - "Visits FILE for ediff. -BUFFER is a variable symbol that is supposed to -get the buffer into which FILE is read. LAST-DIR is the directory variable -symbol where FILE's dir name should be returned. -Arguments: (file 'buffer &optional 'last-dir)" - (if (not (file-readable-p file)) - (error "File `%s' does not exist or is not readable" file)) - - ;; Record the buffer - (set buffer (find-file-noselect file)) - ;; Record the directory of the file - (if last-dir - (set last-dir (expand-file-name (file-name-directory file)))) - - ;; Make sure the entire file is seen, and it reflects what is on disk - (emerge-eval-in-buffer - (eval buffer) - (widen) - (let ((temp (file-local-copy file)) - startup-hooks) - (if temp - (setq file temp - startup-hooks - (cons (` (lambda () (delete-file (, file)))) - startup-hooks)) - ;; Verify that the file matches the buffer - (emerge-verify-file-buffer))))) - -(defun ediff-files-internal (file-A file-B &optional startup-hooks) - (let (buffer-A buffer-B) - (message "Ediff: Reading file %s ... " file-A)(sit-for .5) - (ediff-find-file file-A 'buffer-A 'ediff-last-dir-A) - (message "Ediff: Reading file %s ... " file-B)(sit-for .5) - (ediff-find-file file-B 'buffer-B 'ediff-last-dir-B) - (ediff-setup buffer-A file-A buffer-B file-B startup-hooks))) - -(defun ediff-get-patch-buffer (dir) - "Obtain patch buffer. If patch is already in a buffer---use it. -Else, read patch file into a new buffer." - (if (y-or-n-p "Is the patch file already in a buffer? ") - (setq ediff-patch-buf - (get-buffer (read-buffer "Patch buffer name: " nil t))) ;must match - (setq ediff-patch-buf - (find-file-noselect (read-file-name "Patch file name: " - dir)))) - (emerge-eval-in-buffer - ediff-patch-buf - (toggle-read-only 1)) - (setq ediff-patch-diagnostics - (get-buffer-create "*ediff patch diagnostics*")) - (emerge-eval-in-buffer - ediff-patch-diagnostics - (insert-buffer ediff-patch-buf)) - ) - -;; Start up Ediff on two files -(defun ediff-setup (buffer-A file-A buffer-B file-B startup-hooks) - (setq file-A (expand-file-name file-A)) - (setq file-B (expand-file-name file-B)) - (let* ((control-buffer-name (emerge-unique-buffer-name "*ediff-control" "*")) - (control-buffer (emerge-eval-in-buffer - buffer-A - (get-buffer-create control-buffer-name)))) - (emerge-eval-in-buffer - control-buffer - (ediff-mode) ;; in control buffer only - (setq buffer-read-only nil) - (setq ediff-A-buffer buffer-A) - (setq ediff-B-buffer buffer-B) - (setq ediff-control-buffer control-buffer) - (setq ediff-control-buffer-suffix - (if (string-match "<[0-9]*>" control-buffer-name) - (substring control-buffer-name - (match-beginning 0) (match-end 0)) - "<1>")) - (ediff-remember-buffer-characteristics t) ;; remember at setup - - (ediff-set-keys) - (setq ediff-difference-vector (ediff-make-diff-list file-A file-B)) - (setq ediff-number-of-differences (length ediff-difference-vector)) - (setq ediff-current-difference -1) - (ediff-make-current-diff-overlay 'A) - (ediff-make-current-diff-overlay 'B) - (if window-system - (ediff-init-var-faces)) - (run-hooks 'ediff-before-setup-windows-hooks) - (ediff-setup-windows buffer-A buffer-B control-buffer t) - - ;; all these must be inside emerge-eval-in-buffer control-buffer, - ;; since these vars are local to control-buffer - ;; These won't run if there are errors in diff - (emerge-eval-in-buffer - ediff-A-buffer - (run-hooks 'ediff-prepare-buffer-hooks) - (add-hook 'local-write-file-hooks 'ediff-block-write-file) - (setq before-change-function 'ediff-before-change-guard) - ;; 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))) - (setq mode-line-buffer-identification '("A: %b"))) - (emerge-eval-in-buffer - ediff-B-buffer - (run-hooks 'ediff-prepare-buffer-hooks) - (add-hook 'local-write-file-hooks 'ediff-block-write-file) - (setq before-change-function 'ediff-before-change-guard) - ;; 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))) - (setq mode-line-buffer-identification '("B: %b"))) - - (emerge-eval-in-buffer control-buffer - (run-hooks 'startup-hooks 'ediff-startup-hooks) - (setq buffer-read-only t))))) - -;; Generate the Ediff difference list between two files -(defun ediff-make-diff-list (file-A file-B) - (setq ediff-diff-buffer - (get-buffer-create (emerge-unique-buffer-name "*ediff-diff" "*"))) - (emerge-eval-in-buffer - ediff-diff-buffer - (erase-buffer) - ;; shell-command tends to display old shell command buffers even when it - ;; puts output in another buffer---probably an Emacs bug. - (ediff-kill-buffer-carefully "*Shell Command Output*") - (let ((shell-file-name ediff-shell)) - (message "Ediff: Computing differences ...")(sit-for .5) - (shell-command - (format "%s %s %s %s" - ediff-diff-program ediff-diff-options - (emerge-protect-metachars file-A) - (emerge-protect-metachars file-B)) - t) - )) - (ediff-prepare-error-list ediff-diff-ok-lines-regexp) - (message "Ediff: Computing differences ... Done.")(sit-for .5) - (ediff-convert-diffs-to-overlays - ediff-A-buffer ediff-B-buffer - (ediff-extract-diffs ediff-diff-buffer ediff-A-buffer ediff-B-buffer))) - -(defun ediff-prepare-error-list (ok-regexp) - (let ((diff-buff ediff-diff-buffer)) - (setq ediff-diff-error-buffer - (get-buffer-create (emerge-unique-buffer-name - "*ediff-diff-errors" "*"))) - (emerge-eval-in-buffer - ediff-diff-error-buffer - (erase-buffer) - (insert-buffer diff-buff) - (delete-matching-lines ok-regexp)))) - -;;; Function to start Ediff by patching a file ;;;###autoload -(defun ediff-patch-file (file-to-patch &optional startup-hooks) - "Run Ediff by patching FILE-TO-PATCH." - (interactive "fFile to patch: ") - - (ediff-get-patch-buffer (file-name-directory file-to-patch)) - (let ((buf (get-file-buffer file-to-patch))) - (if buf - (progn - (emerge-eval-in-buffer - buf - (if (buffer-modified-p buf) - (if (y-or-n-p - (format - "File '%s' is already in buffer %s. Save before killing? " - file-to-patch (buffer-name buf))) - (save-buffer buf))) - (set-buffer-modified-p nil)) - (ediff-kill-buffer-carefully buf)))) - (emerge-eval-in-buffer - ediff-patch-diagnostics - (let ((shell-file-name ediff-shell)) - (message "Ediff: Applying patch ... ")(sit-for .5) - (shell-command-on-region - (point-min) (point-max) - (format "%s %s %s" - ediff-patch-program ediff-patch-options - (expand-file-name file-to-patch)) - t) - (message "Ediff: Applying patch ... Done.")(sit-for .5) - )) - (switch-to-buffer ediff-patch-diagnostics) - (sit-for 0) ;; synchronize - - (setq startup-hooks (cons 'ediff-toggle-read-only-A startup-hooks)) - (ediff-files (format "%s.orig" file-to-patch) file-to-patch startup-hooks) - - (bury-buffer ediff-patch-diagnostics) - (message "Patch diagnostics available in buffer %s." - (buffer-name ediff-patch-diagnostics))) +(defun ediff-directory-revisions (dir1 regexp) + "Run Ediff on a directory, DIR1, comparing its files with their revisions. +The second argument, REGEXP, is a regular expression that filters the file +names. Only the files that are under revision control are taken into account." + (interactive + (let ((dir-A (ediff-get-default-directory-name))) + (list (ediff-read-file-name + "Directory to compare with revision:" dir-A nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) + ))) + (ediff-directory-revisions-internal + dir1 regexp 'ediff-revision 'ediff-directory-revisions + )) -(defalias 'epatch 'ediff-patch-file) +;;;###autoload +(defalias 'edir-revisions 'ediff-directory-revisions) -;;; Function to start Ediff on files ;;;###autoload -(defun ediff-files (file-A file-B &optional startup-hooks) - "Run Ediff on a pair files, FILE-A and FILE-B." +(defun ediff-directories3 (dir1 dir2 dir3 regexp) + "Run Ediff on three directories, DIR1, DIR2, and DIR3, comparing files that +have the same name in all three. The last argument, REGEXP, is a regular +expression that can be used to filter out certain file names." (interactive - (let (f) - (list (setq f (ediff-read-file-name "File A to compare" + (let ((dir-A (ediff-get-default-directory-name)) + f) + (list (setq f (ediff-read-file-name "Directory A to compare:" dir-A nil)) + (setq f (ediff-read-file-name "Directory B to compare:" (if ediff-use-last-dir - ediff-last-dir-A - default-directory) - nil nil)) - (ediff-read-file-name "File B to compare" + ediff-last-dir-B + (ediff-strip-last-dir f)) + nil)) + (ediff-read-file-name "Directory C to compare:" (if ediff-use-last-dir - ediff-last-dir-B nil) - f f) + ediff-last-dir-C + (ediff-strip-last-dir f)) + nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) ))) - (ediff-files-internal file-A file-B startup-hooks)) + (ediff-directories-internal + dir1 dir2 dir3 regexp 'ediff-files3 'ediff-directories3 + )) +;;;###autoload +(defalias 'edirs3 'ediff-directories3) -(defalias 'ediff 'ediff-files) +;;;###autoload +(defun ediff-merge-directories (dir1 dir2 regexp) + "Run Ediff on a pair of directories, DIR1 and DIR2, merging files that have +the same name in both. The third argument, REGEXP, is a regular expression that +can be used to filter out certain file names." + (interactive + (let ((dir-A (ediff-get-default-directory-name)) + f) + (list (setq f (ediff-read-file-name "Directory A to merge:" dir-A nil)) + (ediff-read-file-name "Directory B to merge:" + (if ediff-use-last-dir + ediff-last-dir-B + (ediff-strip-last-dir f)) + nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) + ))) + (ediff-directories-internal + dir1 dir2 nil regexp 'ediff-merge-files 'ediff-merge-directories + )) +;;;###autoload +(defalias 'edirs-merge 'ediff-merge-directories) -;;; Function to start Ediff on buffers +;;;###autoload +(defun ediff-merge-directories-with-ancestor (dir1 dir2 ancestor-dir regexp) + "Merge files in directories DIR1 and DIR2 using files in ANCESTOR-DIR as ancestors. +Ediff merges files that have identical names in DIR1, DIR2. If a pair of files +in DIR1 and DIR2 doesn't have an ancestor in ANCESTOR-DIR, Ediff will merge +without ancestor. The fourth argument, REGEXP, is a regular expression that +can be used to filter out certain file names." + (interactive + (let ((dir-A (ediff-get-default-directory-name)) + f) + (list (setq f (ediff-read-file-name "Directory A to merge:" dir-A nil)) + (setq f (ediff-read-file-name "Directory B to merge:" + (if ediff-use-last-dir + ediff-last-dir-B + (ediff-strip-last-dir f)) + nil)) + (ediff-read-file-name "Ancestor directory:" + (if ediff-use-last-dir + ediff-last-dir-C + (ediff-strip-last-dir f)) + nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) + ))) + (ediff-directories-internal + dir1 dir2 ancestor-dir regexp + 'ediff-merge-files-with-ancestor 'ediff-merge-directories-with-ancestor + )) ;;;###autoload -(defun ediff-buffers (buffer-A buffer-B &optional startup-hooks) - "Run Ediff on a pair of buffers, BUFFER-A and BUFFER-B." - (interactive "bBuffer A to compare: \nbBuffer B to compare: ") - (let (ediff-file-A ediff-file-B) - (emerge-eval-in-buffer - buffer-A - (setq ediff-file-A - (ediff-make-temp-file - (format ".%s." (file-name-nondirectory (buffer-name))))) - (write-region (point-min) (point-max) ediff-file-A nil 'no-message)) - (emerge-eval-in-buffer - buffer-B - (setq ediff-file-B - (ediff-make-temp-file - (format ".%s." (file-name-nondirectory (buffer-name))))) - (write-region (point-min) (point-max) ediff-file-B nil 'no-message)) - (ediff-setup (get-buffer buffer-A) ediff-file-A - (get-buffer buffer-B) ediff-file-B - (cons (` (lambda () - (delete-file (, ediff-file-A)) - (delete-file (, ediff-file-B)))) - startup-hooks) - ))) - +(defun ediff-merge-directory-revisions (dir1 regexp) + "Run Ediff on a directory, DIR1, merging its files with their revisions. +The second argument, REGEXP, is a regular expression that filters the file +names. Only the files that are under revision control are taken into account." + (interactive + (let ((dir-A (ediff-get-default-directory-name))) + (list (ediff-read-file-name + "Directory to merge with revisions:" dir-A nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) + ))) + (ediff-directory-revisions-internal + dir1 regexp 'ediff-merge-revisions 'ediff-merge-directory-revisions + )) + ;;;###autoload -(defun ediff-patch-buffer (buffer-name &optional startup-hooks) - "Run Ediff by patching BUFFER-NAME." - (interactive "bBuffer to patch: ") - - (let* ((file-buffer (get-buffer buffer-name)) - (file-name (if file-buffer (buffer-file-name file-buffer)))) - (if (not file-name) - (error "Buffer %s doesn't exist or doesn't visit any file. Why patch?" - file-name)) - - (ediff-patch-file file-name startup-hooks))) - +(defalias 'edir-merge-revisions 'ediff-merge-directory-revisions) -;;; Versions Control functions - ;;;###autoload -(defun vc-ediff (rev) - "Run ediff on version REV of the current buffer in another window. -If the current buffer is named `F', the version is named `F.~REV~'. -If `F.~REV~' already exists, it is used instead of being re-created." - (interactive "sVersion to ediff with (default is the latest version): ") - (or (featurep 'vc) - (if (locate-library "vc") ;; if vc.el is available - (progn - (require 'vc-hooks) - (define-key vc-prefix-map "=" 'vc-ediff)) - (error "The VC package is apparently not installed."))) - (let ((newvers (current-buffer)) - (oldvers (vc-version-other-window rev))) - (ediff-buffers newvers oldvers) - )) - -(defun rcs-ediff-view-revision (&optional rev) - "View previous RCS revison of current file. -With prefix argument, prompts for a revision name." - (interactive (list (if current-prefix-arg - (read-string "Revision: ")))) - (let* ((filename (buffer-file-name (current-buffer))) - (switches (append '("-p") - (if rev (list (concat "-r" rev)) nil))) - (buff (concat (file-name-nondirectory filename) ".~" rev "~"))) - (message "Working...") - (setq filename (expand-file-name filename)) - (with-output-to-temp-buffer - buff - (let ((output-buffer (rcs-get-output-buffer filename buff))) - (delete-windows-on output-buffer) - (save-excursion - (set-buffer output-buffer) - (apply 'call-process "co" nil t nil - ;; -q: quiet (no diagnostics) - (append switches rcs-default-co-switches - (list "-q" filename))))) - (message "") - buff))) +(defun ediff-merge-directory-revisions-with-ancestor (dir1 regexp) + "Run Ediff on a directory, DIR1, merging its files with their revisions and ancestors. +The second argument, REGEXP, is a regular expression that filters the file +names. Only the files that are under revision control are taken into account." + (interactive + (let ((dir-A (ediff-get-default-directory-name))) + (list (ediff-read-file-name + "Directory to merge with revisions and ancestors:" dir-A nil) + (read-string "Filter through regular expression: " + nil 'ediff-filtering-regexp-history) + ))) + (ediff-directory-revisions-internal + dir1 regexp 'ediff-merge-revisions-with-ancestor + 'ediff-merge-directory-revisions-with-ancestor + )) ;;;###autoload -(defun rcs-ediff (&optional rev) - "Run Ediff on the current buffer, comparing it with previous RCS revison. -With prefix argument, prompts for revision name." - (interactive (list (if current-prefix-arg - (read-string "Revision: ")))) - (or (featurep 'rcs) - (if (locate-library "rcs") - (progn - (require 'rcs) - (global-set-key "\C-cD" 'rcs-ediff)) - (error "The RCS package is apparently not installed."))) - (let ((newvers (current-buffer)) - (oldvers (rcs-ediff-view-revision rev))) - (ediff-buffers newvers oldvers) +(defalias + 'edir-merge-revisions-with-ancestor + 'ediff-merge-directory-revisions-with-ancestor) + +;;;###autoload +(defalias 'edirs-merge-with-ancestor 'ediff-merge-directories-with-ancestor) + +;; Run ediff-action (ediff-files, ediff-merge, ediff-merge-with-ancestors) +;; on a pair of directories (three directories, in case of ancestor). +;; The third argument, REGEXP, is a regular expression that can be used to +;; filter out certain file names. +;; JOBNAME is the symbol indicating the meta-job to be performed. +;; MERGE-DIR is the directory in which to store merged files. +(defun ediff-directories-internal (dir1 dir2 dir3 regexp action jobname + &optional startup-hooks) + ;; ediff-read-file-name is set to attach a previously entered file name if + ;; the currently entered file is a directory. This code takes care of that. + (setq dir1 (if (file-directory-p dir1) dir1 (file-name-directory dir1)) + dir2 (if (file-directory-p dir2) dir2 (file-name-directory dir2))) + + (if (stringp dir3) + (setq dir3 (if (file-directory-p dir3) dir3 (file-name-directory dir3)))) + + (cond ((string= dir1 dir2) + (error "Directories A and B are the same: %s" dir1)) + ((and (eq jobname 'ediff-directories3) + (string= dir1 dir3)) + (error "Directories A and C are the same: %s" dir1)) + ((and (eq jobname 'ediff-directories3) + (string= dir2 dir3)) + (error "Directories B and C are the same: %s" dir1))) + + (let (diffs ; var where ediff-intersect-directories returns the diff list + merge-autostore-dir + file-list meta-buf) + (if (and ediff-autostore-merges (ediff-merge-metajob jobname)) + (setq merge-autostore-dir + (ediff-read-file-name "Directory to save merged files:" + (if ediff-use-last-dir + ediff-last-merge-autostore-dir + (ediff-strip-last-dir dir1)) + nil))) + ;; verify we are not merging into an orig directory + (if (stringp merge-autostore-dir) + (cond ((and (stringp dir1) (string= merge-autostore-dir dir1)) + (or (y-or-n-p "Merge directory same as directory A, sure? ") + (error "Directory merge aborted"))) + ((and (stringp dir2) (string= merge-autostore-dir dir2)) + (or (y-or-n-p "Merge directory same as directory B, sure? ") + (error "Directory merge aborted"))) + ((and (stringp dir3) (string= merge-autostore-dir dir3)) + (or (y-or-n-p + "Merge directory same as ancestor directory, sure? ") + (error "Directory merge aborted"))))) + + (setq file-list (ediff-intersect-directories + jobname 'diffs + regexp dir1 dir2 dir3 merge-autostore-dir)) + (setq startup-hooks + ;; this sets various vars in the meta buffer inside + ;; ediff-prepare-meta-buffer + (cons (` (lambda () + ;; tell what to do if the user clicks on a session record + (setq ediff-session-action-function (quote (, action))) + ;; set ediff-dir-difference-list + (setq ediff-dir-difference-list (quote (, diffs))))) + startup-hooks)) + (setq meta-buf (ediff-prepare-meta-buffer + 'ediff-filegroup-action + file-list + "*Ediff Session Group Panel" + 'ediff-redraw-directory-group-buffer + jobname + startup-hooks)) + (ediff-show-meta-buffer meta-buf) + )) + +(defun ediff-directory-revisions-internal (dir1 regexp action jobname + &optional startup-hooks) + (setq dir1 (if (file-directory-p dir1) dir1 (file-name-directory dir1))) + + (let (file-list meta-buf merge-autostore-dir) + (if (and ediff-autostore-merges (ediff-merge-metajob jobname)) + (setq merge-autostore-dir + (ediff-read-file-name "Directory to save merged files:" + (if ediff-use-last-dir + ediff-last-merge-autostore-dir + (ediff-strip-last-dir dir1)) + nil))) + ;; verify merge-autostore-dir != dir1 + (if (and (stringp merge-autostore-dir) + (stringp dir1) + (string= merge-autostore-dir dir1)) + (or (y-or-n-p + "Directory for saving merges is the same as directory A. Sure? ") + (error "Merge of directory revisions aborted"))) + + (setq file-list + (ediff-get-directory-files-under-revision + jobname regexp dir1 merge-autostore-dir)) + (setq startup-hooks + ;; this sets various vars in the meta buffer inside + ;; ediff-prepare-meta-buffer + (cons (` (lambda () + ;; tell what to do if the user clicks on a session record + (setq ediff-session-action-function (quote (, action))) + )) + startup-hooks)) + (setq meta-buf (ediff-prepare-meta-buffer + 'ediff-filegroup-action + file-list + "*Ediff Session Group Panel" + 'ediff-redraw-directory-group-buffer + jobname + startup-hooks)) + (ediff-show-meta-buffer meta-buf) )) -;;; Functions to start Ediff via remote request +;;; Compare regions and windows ;;;###autoload -(defun ediff-files-remote (file-a file-b) - "Run Ediff on remote files, FILE-A and FILE-B." - (ediff-files-internal file-a file-b nil) - (throw 'client-wait nil)) - - -(defun ediff-remote-exit (exit-func) - "Exit remote Ediff session." - (ediff-really-quit) - (funcall exit-func)) - - - -;; Select the lowest window on the frame. -(defun ediff-select-lowest-window () - (let* ((lowest-window (selected-window)) - (bottom-edge (car (cdr (cdr (cdr (window-edges)))))) - (last-window (previous-window)) - (window-search t)) - (while window-search - (let* ((this-window (next-window)) - (next-bottom-edge (car (cdr (cdr (cdr - (window-edges this-window))))))) - (if (< bottom-edge next-bottom-edge) - (progn - (setq bottom-edge next-bottom-edge) - (setq lowest-window this-window))) - - (select-window this-window) - (if (eq last-window this-window) - (progn - (select-window lowest-window) - (setq window-search nil))))))) - -;;; Common setup routines - -;; Set up the window configuration. If POS is given, set the points to -;; the beginnings of the buffers. -(defun ediff-setup-windows (buffer-A buffer-B control-buffer &optional pos) - ;; Make sure we are not in the minibuffer window when we try to delete - ;; all other windows. - (if (eq (selected-window) (minibuffer-window)) - (other-window 1)) - (delete-other-windows) - (switch-to-buffer control-buffer) - (ediff-refresh-mode-line) - - (ediff-arrange-buffer buffer-A buffer-B (current-buffer) pos) - (ediff-arrange-buffer buffer-B buffer-A (current-buffer) pos) - ;; ediff-arrange-buffer always leaves in ctl buffer - ;; setup ctl wind if it is not set. - (ediff-setup-control-window) - - ;; If diff reports errors, display them rather than then compare buffers. - (if (/= 0 (emerge-eval-in-buffer ediff-diff-error-buffer (buffer-size))) - (let ((diff-output-buf ediff-diff-buffer)) - (switch-to-buffer ediff-diff-error-buffer) - (ediff-kill-buffer-carefully control-buffer) - (error "Errors found in diff output. Diff output buffer is %s" - diff-output-buf)))) - - -;; Arranges goal-buf on the screen. -(defun ediff-arrange-buffer (goal-buf other-buf ctl-buf &optional pos) - (let* ((ctl-wind (get-buffer-window ctl-buf t)) - (goal-wind (get-buffer-window goal-buf t)) - (other-wind (get-buffer-window other-buf t)) - (ctl-frame (ediff-window-frame ctl-wind)) - (goal-frame (if goal-wind (ediff-window-frame goal-wind))) - (other-frame (if other-wind (ediff-window-frame other-wind))) - (ctl-frame-shared (or (eq ctl-frame goal-frame) - (eq ctl-frame other-frame)))) - - (cond ((and goal-frame (not (eq goal-wind other-wind))) - ;; goal buffer is visible and we are not comparing file - ;; against itself (by mistake). - ;; Note: goal-frame != ctl-frame, as we deleted other - ;; windows on ctl-frame. - (ediff-select-frame goal-frame) - (select-window goal-wind) - (delete-other-windows)) - - ;; goal-buf invisible, ctl-frame has only ctl-buf - ;; then put goal-buf on ctl-frame - ((null ctl-frame-shared) - (ediff-select-frame ctl-frame) - (split-window-vertically) - (ediff-select-lowest-window) - (setq ctl-wind (selected-window)) - (switch-to-buffer ctl-buf) - (ediff-setup-control-window) - (other-window 1) - (switch-to-buffer goal-buf)) ; goal-buf set - ;; goal-buf invisible, ctl-frame has ctl-buf and other-buf - ;; So, put everything in one frame - (other-frame ;; share with the other buf - (ediff-select-frame ctl-frame) - (select-window other-wind) - (funcall ediff-split-window-function) - (other-window 1) - (switch-to-buffer goal-buf)) - (t ;; debug - (error "Funny window combination (Ediff bug?)"))) - - (if pos - (goto-char (point-min))) - - (ediff-select-frame ctl-frame) - (select-window ctl-wind) - (switch-to-buffer ctl-buf))) +(defun ediff-windows-wordwise (dumb-mode &optional wind-A wind-B startup-hooks) + "Compare WIND-A and WIND-B, which are selected by clicking, wordwise. +With prefix argument, DUMB-MODE, or on a non-windowing display, works as +follows: +If WIND-A is nil, use selected window. +If WIND-B is nil, use window next to WIND-A." + (interactive "P") + (ediff-windows dumb-mode wind-A wind-B + startup-hooks 'ediff-windows-wordwise 'word-mode)) + +;;;###autoload +(defun ediff-windows-linewise (dumb-mode &optional wind-A wind-B startup-hooks) + "Compare WIND-A and WIND-B, which are selected by clicking, linewise. +With prefix argument, DUMB-MODE, or on a non-windowing display, works as +follows: +If WIND-A is nil, use selected window. +If WIND-B is nil, use window next to WIND-A." + (interactive "P") + (ediff-windows dumb-mode wind-A wind-B + startup-hooks 'ediff-windows-linewise nil)) -;; This function assumes that we are in the window where control buffer is -;; to reside. -(defun ediff-setup-control-window () - "Set up window for control buffer." - (erase-buffer) - (insert ediff-help-message) - (shrink-window-if-larger-than-buffer) - (setq ediff-control-window (selected-window)) - (goto-char (point-min)) - (skip-chars-forward " \t\n")) +;; Compare WIND-A and WIND-B, which are selected by clicking. +;; With prefix argument, DUMB-MODE, or on a non-windowing display, +;; works as follows: +;; If WIND-A is nil, use selected window. +;; If WIND-B is nil, use window next to WIND-A. +(defun ediff-windows (dumb-mode wind-A wind-B startup-hooks job-name word-mode) + (if (or dumb-mode (not (ediff-window-display-p))) + (setq wind-A (ediff-get-next-window wind-A nil) + wind-B (ediff-get-next-window wind-B wind-A)) + (setq wind-A (ediff-get-window-by-clicking wind-A nil 1) + wind-B (ediff-get-window-by-clicking wind-B wind-A 2))) - -;; Set up the keymap in the control buffer -(defun ediff-set-keys () - "Set up Ediff keymap, if necessary." - (if (null ediff-mode-map) - (ediff-setup-keymap)) - (use-local-map ediff-mode-map)) - -;; Reload Ediff keymap. For debugging only. -(defun ediff-reload-keymap () - (interactive) - (setq ediff-mode-map nil) - (ediff-set-keys)) - -(defun ediff-before-change-guard (start end) - "If buffer is highlighted with ASCII flags, remove highlighting. -Arguments, START and END are not used, but are provided -because this is required by `before-change-function'." - (let (notify) - (save-window-excursion - (mapcar - (function - (lambda (buf) - (if (ediff-buffer-live-p buf) - (emerge-eval-in-buffer - buf - (if (eq ediff-highlighting-style 'ascii) - (progn - (ediff-unselect-and-select-difference - ediff-current-difference - 'unselect-only 'no-recenter) - (setq notify t) - )))))) - ediff-this-buffer-control-sessions) - (if notify - (error "ASCII flags removed. You can edit now. Hit 'c' to rehighlight.")) - ))) - - -(defun ediff-remember-buffer-characteristics (&optional arg) - "Record certain properties of the buffers being compared. -Must be called in the control buffer. Saves `read-only', `modified', -and `auto-save' properties in buffer local variables. Turns off -`auto-save-mode'. These properties are restored via a call to -`ediff-restore-buffer-characteristics'." - - ;; remember and alter buffer characteristics - (set (if arg 'ediff-A-buffer-values-setup 'ediff-A-buffer-values) - (emerge-eval-in-buffer - ediff-A-buffer - (prog1 - (emerge-save-variables ediff-saved-variables) - (emerge-restore-variables ediff-saved-variables - ediff-working-values)))) - (set (if arg 'ediff-B-buffer-values-setup 'ediff-B-buffer-values) - (emerge-eval-in-buffer - ediff-B-buffer - (prog1 - (emerge-save-variables ediff-saved-variables) - (emerge-restore-variables ediff-saved-variables - ediff-working-values))))) - -(defun ediff-restore-buffer-characteristics (&optional arg) - "Restores properties saved by `ediff-remember-buffer-characteristics'." - (let ((A-values (if arg ediff-A-buffer-values-setup ediff-A-buffer-values)) - (B-values (if arg ediff-B-buffer-values-setup ediff-B-buffer-values))) - (emerge-eval-in-buffer ediff-A-buffer - (emerge-restore-variables ediff-saved-variables - A-values)) - (emerge-eval-in-buffer ediff-B-buffer - (emerge-restore-variables ediff-saved-variables - B-values)))) - - -(defun ediff-extract-diffs (diff-buffer A-buffer B-buffer) - (let (diff-list - (a-prev 1) ;; this is needed to set the first diff line correctly - (b-prev 1)) - (emerge-eval-in-buffer - A-buffer - (goto-char (point-min))) - (emerge-eval-in-buffer - B-buffer - (goto-char (point-min))) - (emerge-eval-in-buffer - diff-buffer - (goto-char (point-min)) - (while (re-search-forward ediff-match-diff-line nil t) - (let* ((a-begin (string-to-int (buffer-substring (match-beginning 1) - (match-end 1)))) - (a-end (let ((b (match-beginning 3)) - (e (match-end 3))) - (if b - (string-to-int (buffer-substring b e)) - a-begin))) - (diff-type (buffer-substring (match-beginning 4) (match-end 4))) - (b-begin (string-to-int (buffer-substring (match-beginning 5) - (match-end 5)))) - (b-end (let ((b (match-beginning 7)) - (e (match-end 7))) - (if b - (string-to-int (buffer-substring b e)) - b-begin))) - a-begin-pt a-end-pt b-begin-pt b-end-pt) - ;; fix the beginning and end numbers, because diff is somewhat - ;; strange about how it numbers lines - (if (string-equal diff-type "a") - (setq b-end (1+ b-end) - a-begin (1+ a-begin) - a-end a-begin) - (if (string-equal diff-type "d") - (setq a-end (1+ a-end) - b-begin (1+ b-begin) - b-end b-begin) - ;; (string-equal diff-type "c") - (setq a-end (1+ a-end) - b-end (1+ b-end)))) - ;; convert to relative line numbers - (emerge-eval-in-buffer - A-buffer - (forward-line (- a-begin a-prev)) - (setq a-begin-pt (point)) - (forward-line (- a-end a-begin)) - (setq a-end-pt (point) - a-prev a-end)) - (emerge-eval-in-buffer - B-buffer - (forward-line (- b-begin b-prev)) - (setq b-begin-pt (point)) - (forward-line (- b-end b-begin)) - (setq b-end-pt (point) - b-prev b-end)) - (setq diff-list (nconc diff-list (list (vector a-begin-pt a-end-pt - b-begin-pt b-end-pt)))) - ))) - diff-list - )) - -(defun ediff-convert-diffs-to-overlays (A-buffer B-buffer diff-list) - (let* ((current-diff -1) - (total-diffs (length diff-list)) - (control-buffer-suffix ediff-control-buffer-suffix) - diff-overlay-list list-element - a-begin a-end b-begin b-end - a-overlay b-overlay) - - (while diff-list - (setq current-diff (1+ current-diff) - list-element (car diff-list) - a-begin (aref list-element 0) - a-end (aref list-element 1) - b-begin (aref list-element 2) - b-end (aref list-element 3)) - - ;; place overlays at the appropriate places in the buffers - (setq a-overlay (ediff-make-overlay a-begin a-end A-buffer)) - ;; priority of a-overlay and b-overlay should be equal. otherwise it - ;; won't work due to Emacs bug---insert-in-front-hooks will be called - ;; only on behalf of the buffer with higher priority. - (ediff-overlay-put a-overlay 'priority ediff-shaded-overlay-priority) - (ediff-overlay-put a-overlay 'ediff-diff-num current-diff) - (ediff-overlay-put a-overlay - 'insert-in-front-hooks '(ediff-insert-in-front)) - (ediff-overlay-put a-overlay - 'ediff-control-buffer control-buffer-suffix) - (ediff-overlay-put a-overlay - 'face (if (ediff-odd-p current-diff) ;; odd diff - 'ediff-odd-diff-face-A-var - 'ediff-even-diff-face-A-var)) - - (setq b-overlay (ediff-make-overlay b-begin b-end B-buffer)) - (ediff-overlay-put b-overlay 'priority ediff-shaded-overlay-priority) - (ediff-overlay-put b-overlay 'ediff-diff-num current-diff) - (ediff-overlay-put b-overlay - 'insert-in-front-hooks '(ediff-insert-in-front)) - (ediff-overlay-put b-overlay - 'ediff-control-buffer control-buffer-suffix) - (ediff-overlay-put b-overlay - 'face (if (ediff-odd-p current-diff) ;; odd diff - 'ediff-odd-diff-face-B-var - 'ediff-even-diff-face-B-var)) - - (if (ediff-if-lucid) ;; chars inserted at end will be inside extent - (progn - (ediff-overlay-put a-overlay - 'ediff-marker - (move-marker (make-marker) a-begin A-buffer)) - (ediff-overlay-put b-overlay - 'ediff-marker - (move-marker (make-marker) b-begin B-buffer)) - (ediff-overlay-put a-overlay 'end-open nil) - (ediff-overlay-put b-overlay 'end-open nil))) - - ;; record all overlays for this difference - (setq diff-overlay-list - (nconc diff-overlay-list (list (vector a-overlay b-overlay))) - diff-list (cdr diff-list)) - (message "Ediff: Processing diff region %d of %d" - current-diff total-diffs) - ) ;; while - ;; this is just to avoid confusing the user with diff num < total-diffs - (message "Ediff: Processing diff region %d of %d" - (1+ current-diff) total-diffs) - ;; convert the list of difference information into a vector for - ;; fast access - (setq ediff-difference-vector - (apply 'vector diff-overlay-list)))) - - - -;;; Commands - -(defun ediff-recenter (&optional no-rehighlight) - "Bring the highlighted region of all buffers A and B into view. -Reestablish the default three-window display." - (interactive) - (setq ediff-disturbed-overlays nil) ;; clear after use - (let (buffer-read-only) - (ediff-setup-windows ediff-A-buffer ediff-B-buffer ediff-control-buffer)) - ;; Redisplay whatever buffers are showing, if there is a selected difference - (if (and (>= ediff-current-difference 0) - (< ediff-current-difference ediff-number-of-differences)) - (let* ( ;; context must be saved before switching to windows A/B - (buffer-A ediff-A-buffer) - (buffer-B ediff-B-buffer) - (wind (selected-window)) - (control-buf ediff-control-buffer) - (before-flag-shift-A (if (eq ediff-highlighting-style 'ascii) - (1- (length ediff-before-flag-A)) - 0)) - (after-flag-shift-A (if (eq ediff-highlighting-style 'ascii) - (1- (length ediff-after-flag-A)) - 0)) - (before-flag-shift-B (if (eq ediff-highlighting-style 'ascii) - (1- (length ediff-before-flag-B)) - 0)) - (after-flag-shift-B (if (eq ediff-highlighting-style 'ascii) - (1- (length ediff-after-flag-B)) - 0)) - (window-A (get-buffer-window buffer-A t)) - (window-B (get-buffer-window buffer-B t))) - - (or no-rehighlight - (ediff-operate-on-flags 'insert)) - - (if window-A (progn - (select-window window-A) - (ediff-position-region - (- (ediff-get-diff-posn 'A 'beg nil control-buf) - before-flag-shift-A) - (+ (ediff-get-diff-posn 'A 'end nil control-buf) - after-flag-shift-A) - (ediff-get-diff-posn 'A 'beg nil control-buf)))) - (if window-B (progn - (select-window window-B) - (ediff-position-region - (- (ediff-get-diff-posn 'B 'beg nil control-buf) - before-flag-shift-B) - (+ (ediff-get-diff-posn 'B 'end nil control-buf) - after-flag-shift-B) - (ediff-get-diff-posn 'B 'beg nil control-buf)))) - (select-window wind)))) - -(defun ediff-toggle-split () - "Toggle vertical/horizontal window split. -Does nothing if file-A and file-B are in different frames." - (interactive) - (let* ((wind-A (get-buffer-window ediff-A-buffer t)) - (wind-B (get-buffer-window ediff-B-buffer t)) - (frame-A (if wind-A (ediff-window-frame wind-A))) - (frame-B (if wind-B (ediff-window-frame wind-B)))) - (if (eq frame-A frame-B) - (setq ediff-split-window-function - (if (eq ediff-split-window-function 'split-window-vertically) - 'split-window-horizontally - 'split-window-vertically)) - (message "Buffers A and B are residing in different frames. Why split?")) - (ediff-recenter 'no-rehighlight))) - -(defun ediff-toggle-hilit () - "Switch between highlighting using ASCII flags and highlighting using faces. -On a dumb terminal, switches between ASCII highlighting and no highlighting." - (interactive) - (if (not window-system) - (if (eq ediff-highlighting-style 'ascii) - (progn - (message "ASCII highlighting flags removed.") - (ediff-unselect-and-select-difference ediff-current-difference - 'unselect-only) - (setq ediff-highlighting-style 'off)) - (ediff-unselect-and-select-difference ediff-current-difference - 'select-only)) - (ediff-unselect-and-select-difference ediff-current-difference - 'unselect-only) - ;; cycle through highlighting - (cond ((and ediff-want-faces (null ediff-highlight-selected-only)) - (message "Ediff: Unhighlighted unselected difference regions.") - (setq ediff-highlight-selected-only t)) - (ediff-want-faces - (message "Ediff: Now using ASCII flags only.") - (setq ediff-want-faces nil)) - (t - (message "Ediff: Re-highlighted all difference regions.") - (setq ediff-want-faces t - ediff-highlight-selected-only nil))) - - (if (and ediff-want-faces (null ediff-highlight-selected-only)) - (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-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 'default 'ediff-odd-diff-face-A-var) - (copy-face 'default 'ediff-odd-diff-face-B-var) - (copy-face 'default 'ediff-even-diff-face-A-var) - (copy-face 'default 'ediff-even-diff-face-B-var)) + (let ((buffer-A (window-buffer wind-A)) + (buffer-B (window-buffer wind-B)) + beg-A end-A beg-B end-B) - (ediff-unselect-and-select-difference - ediff-current-difference 'select-only)) - (ediff-operate-on-flags 'insert) - ) - -(defun ediff-toggle-help () - "Toggle short/long help message." - (interactive) - (let (buffer-read-only) - (erase-buffer) - (if (string= ediff-help-message ediff-help-message-long) - (setq ediff-help-message ediff-help-message-short) - (setq ediff-help-message ediff-help-message-long))) - (ediff-recenter 'no-rehighlight)) + (save-excursion + (save-window-excursion + (sit-for 0) ; sync before using window-start/end -- a precaution + (select-window wind-A) + (setq beg-A (window-start) + end-A (window-end)) + (select-window wind-B) + (setq beg-B (window-start) + end-B (window-end)))) + (ediff-regions-internal + buffer-A beg-A end-A buffer-B beg-B end-B + startup-hooks job-name word-mode nil))) + +;;;###autoload +(defun ediff-regions-wordwise (buffer-A buffer-B &optional startup-hooks) + "Run Ediff on a pair of regions in two different buffers. +Regions \(i.e., point and mark\) are assumed to be set in advance. +This function is effective only for relatively small regions, up to 200 +lines. For large regions, use `ediff-regions-linewise'." + (interactive + (let (bf) + (list (setq bf (read-buffer "Region's A buffer: " + (ediff-other-buffer "") t)) + (read-buffer "Region's B buffer: " + (progn + ;; realign buffers so that two visible bufs will be + ;; at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer bf)) + t)))) + (if (not (ediff-buffer-live-p buffer-A)) + (error "Buffer %S doesn't exist" buffer-A)) + (if (not (ediff-buffer-live-p buffer-B)) + (error "Buffer %S doesn't exist" buffer-B)) -(defun ediff-toggle-read-only-A () - "Used as a startup hook to set `.orig' patch file read-only." - (let ((last-command-char ?A)) - (ediff-toggle-read-only))) + (let (reg-A-beg reg-A-end reg-B-beg reg-B-end) + (save-excursion + (set-buffer buffer-A) + (setq reg-A-beg (region-beginning) + reg-A-end (region-end)) + (set-buffer buffer-B) + (setq reg-B-beg (region-beginning) + reg-B-end (region-end))) + + (ediff-regions-internal + (get-buffer buffer-A) reg-A-beg reg-A-end + (get-buffer buffer-B) reg-B-beg reg-B-end + startup-hooks 'ediff-regions-wordwise 'word-mode nil))) + +;;;###autoload +(defun ediff-regions-linewise (buffer-A buffer-B &optional startup-hooks) + "Run Ediff on a pair of regions in two different buffers. +Regions \(i.e., point and mark\) are assumed to be set in advance. +Each region is enlarged to contain full lines. +This function is effective for large regions, over 100-200 +lines. For small regions, use `ediff-regions-wordwise'." + (interactive + (let (bf) + (list (setq bf (read-buffer "Region A's buffer: " + (ediff-other-buffer "") t)) + (read-buffer "Region B's buffer: " + (progn + ;; realign buffers so that two visible bufs will be + ;; at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer bf)) + t)))) + (if (not (ediff-buffer-live-p buffer-A)) + (error "Buffer %S doesn't exist" buffer-A)) + (if (not (ediff-buffer-live-p buffer-B)) + (error "Buffer %S doesn't exist" buffer-B)) -(defun ediff-toggle-read-only () - "Toggles buffer-read-only for buffer buffers A and B." - (interactive) - (emerge-eval-in-buffer - (if (eq last-command-char ?A) ediff-A-buffer ediff-B-buffer) - (setq buffer-read-only (null buffer-read-only)))) - -;;; Window scrolling operations -;; These operations are designed to scroll all three windows the same amount, -;; so as to keep the text in them aligned. - -;; Perform some operation on two file windows (if they are showing). -;; Catches all errors on the operation in the A and B windows. -;; Usually, errors come from scrolling off the -;; beginning or end of the buffer, and this gives nice nice error messages. -(defun ediff-operate-on-windows (operation arg) - (let* ((buffer-A ediff-A-buffer) - (buffer-B ediff-B-buffer) - (wind (selected-window)) - (window-A (get-buffer-window buffer-A t)) - (window-B (get-buffer-window buffer-B t))) - (if window-A (progn - (select-window window-A) - (condition-case nil - (funcall operation arg) - (error)))) - (if window-B (progn - (select-window window-B) - (condition-case nil - (funcall operation arg) - (error)))) - (select-window wind) - )) - -(defun ediff-scroll-up (&optional arg) - "Scroll up buffers A and B, if they are in windows. -With optional argument ARG, scroll ARG lines; otherwise scroll by nearly -the height of window-A." - (interactive "P") - (ediff-operate-on-windows - 'scroll-up - ;; calculate argument to scroll-up - ;; if there is an explicit argument - (if (and arg (not (equal arg '-))) - ;; use it - (prefix-numeric-value arg) - ;; if not, see if we can determine a default amount (the window height) - (let* ((window-A (get-buffer-window ediff-A-buffer t)) - (window-B (get-buffer-window ediff-B-buffer t)) - default-amount) - (if (or (null window-A) (null window-B)) - (setq default-amount 0) - (setq default-amount - (- (min (window-height window-A) (window-height window-B)) - 1 next-screen-context-lines))) - ;; the window was found - (if arg - ;; C-u as argument means half of default amount - (/ default-amount 2) - ;; no argument means default amount - default-amount))))) - -(defun ediff-scroll-down (&optional arg) - "Scroll down buffers A and B, if they are in windows. -With optional argument ARG, scroll ARG lines; otherwise scroll by nearly -the height of window-A." - (interactive "P") - (ediff-operate-on-windows - 'scroll-down - ;; calculate argument to scroll-down - ;; if there is an explicit argument - (if (and arg (not (equal arg '-))) - ;; use it - (prefix-numeric-value arg) - ;; if not, see if we can determine a default amount (the window height) - (let* ((window-A (get-buffer-window ediff-A-buffer t)) - (window-B (get-buffer-window ediff-B-buffer t)) - default-amount) - (if (or (null window-A) (null window-B)) - (setq default-amount 0) - (setq default-amount - (- (min (window-height window-A) (window-height window-B)) - 1 next-screen-context-lines))) - ;; the window was found - (if arg - ;; C-u as argument means half of default amount - (/ default-amount 2) - ;; no argument means default amount - default-amount))))) - -(defun ediff-scroll-left (&optional arg) - "Scroll left buffer-A and buffer-B, if they are in windows. -If an argument is given, that is how many columns are scrolled, else nearly -the width of the A and B windows." - (interactive "P") - (ediff-operate-on-windows - 'scroll-left - ;; calculate argument to scroll-left - ;; if there is an explicit argument - (if (and arg (not (equal arg '-))) - ;; use it - (prefix-numeric-value arg) - ;; if not, see if we can determine a default amount - ;; (half the window width) - (if (null ediff-control-window) - ;; no control window, use nil - nil - (let ((default-amount - (- (/ (window-width ediff-control-window) 2) 3))) - ;; the window was found - (if arg - ;; C-u as argument means half of default amount - (/ default-amount 2) - ;; no argument means default amount - default-amount)))))) - -(defun ediff-scroll-right (&optional arg) - "Scroll right buffer-A and buffer-B, if they are in windows. -If an argument is given, that is how many columns are scrolled, else nearly -the width of the A and B windows." - (interactive "P") - (ediff-operate-on-windows - 'scroll-right - ;; calculate argument to scroll-right - ;; if there is an explicit argument - (if (and arg (not (equal arg '-))) - ;; use it - (prefix-numeric-value arg) - ;; if not, see if we can determine a default amount - ;; (half the window width) - (if (null ediff-control-window) - ;; no control window, use nil - nil - (let ((default-amount - (- (/ (window-width ediff-control-window) 2) 3))) - ;; the window was found - (if arg - ;; C-u as argument means half of default amount - (/ default-amount 2) - ;; no argument means default amount - default-amount)))))) - -(defun ediff-position-region (beg end pos) - "This is a variation on `emerge-position-region'. -The difference is that it always tries to align difference regions in -buffer-A and buffer-B, so that it will be easier to compare them." - (set-window-start (selected-window) beg) - (if (pos-visible-in-window-p end) - ;; Determine the number of lines that the region occupies - (let ((lines 0)) - (while (> end (progn - (move-to-window-line lines) - (point))) - (setq lines (1+ lines))) - ;; And position the beginning on the right line - (goto-char beg) - (recenter (/ (1+ (max (- (1- (window-height (selected-window))) - lines) - 1) - ) - 2)))) - (goto-char pos) - ) - - -(defun ediff-next-difference (arg) - "Advance to the next difference. -With a prefix argument, go back that many differences." - (interactive "P") - (if (< ediff-current-difference ediff-number-of-differences) - (let ((n (min ediff-number-of-differences - (+ ediff-current-difference (if arg arg 1)))) - (buffer-read-only nil)) - (ediff-unselect-and-select-difference n)) - (error "At end of the difference list."))) - -(defun ediff-previous-difference (arg) - "Go to the previous difference. -With a prefix argument, go back that many differences." - (interactive "P") - (if (> ediff-current-difference -1) - (let ((n (max -1 (- ediff-current-difference (if arg arg 1)))) - (buffer-read-only nil)) - (ediff-unselect-and-select-difference n)) - (error "At beginning of the difference list."))) - -(defun ediff-jump-to-difference (difference-number) - "Go to the difference specified as a prefix argument." - (interactive "p") - (let ((buffer-read-only nil)) - (setq difference-number (1- difference-number)) - (if (and (>= difference-number -1) - (< difference-number (1+ ediff-number-of-differences))) - (ediff-unselect-and-select-difference difference-number) - (error "Bad difference number")))) + (let (reg-A-beg reg-A-end reg-B-beg reg-B-end) + (save-excursion + (set-buffer buffer-A) + (setq reg-A-beg (region-beginning) + reg-A-end (region-end)) + ;; enlarge the region to hold full lines + (goto-char reg-A-beg) + (beginning-of-line) + (setq reg-A-beg (point)) + (goto-char reg-A-end) + (end-of-line) + (or (eobp) (forward-char)) ; include the newline char + (setq reg-A-end (point)) -(defun ediff-jump-to-difference-at-point () - "Go to the difference closest to the point in buffer A or B. -If this command is invoked via `ja' or `ga' then the point in buffer A is -used. Otherwise, buffer B is used." - (interactive) - (let ((buffer-read-only nil) - (buf-type (if (eq last-command-char ?a) 'A 'B))) - - (ediff-jump-to-difference (ediff-diff-at-point buf-type)))) + (set-buffer buffer-B) + (setq reg-B-beg (region-beginning) + reg-B-end (region-end)) + ;; enlarge the region to hold full lines + (goto-char reg-B-beg) + (beginning-of-line) + (setq reg-B-beg (point)) + (goto-char reg-B-end) + (end-of-line) + (or (eobp) (forward-char)) ; include the newline char + (setq reg-B-end (point)) + ) ; save excursion + + (ediff-regions-internal + (get-buffer buffer-A) reg-A-beg reg-A-end + (get-buffer buffer-B) reg-B-beg reg-B-end + startup-hooks 'ediff-regions-linewise nil nil))) ; no word mode - -;; find region "most related to the current point position - -(defun ediff-diff-at-point (buf-type) - (let ((buffer (if (eq buf-type 'A) ediff-A-buffer ediff-B-buffer)) - (ctl-buffer ediff-control-buffer) - (diff-no -1) - (prev-beg 0) - (beg 0)) +;; compare region beg-A to end-A of buffer-A +;; to regions beg-B -- end-B in buffer-B. +(defun ediff-regions-internal (buffer-A beg-A end-A buffer-B beg-B end-B + startup-hooks job-name word-mode + setup-parameters) + (let ((tmp-buffer (get-buffer-create ediff-tmp-buffer)) + overl-A overl-B + file-A file-B) - (emerge-eval-in-buffer - buffer - (while (or (< (point) prev-beg) (> (point) beg)) - (setq diff-no (1+ diff-no)) - (setq prev-beg beg) - (setq beg (ediff-get-diff-posn buf-type 'beg diff-no ctl-buffer))) - - (if (< (abs (- (point) prev-beg)) - (abs (- (point) beg))) - diff-no - (1+ diff-no)) ;; jump-to-diff works with diff nums higher by 1 - ))) - -;;; Copying diffs. - -(defun ediff-diff-to-diff (arg) - "Copy buffer-A'th diff to buffer B. -If numerical prefix argument, copy this diff specified in the arg. -Otherwise, copy the difference given by `ediff-current-difference'." - (interactive "P") - (if arg - (ediff-jump-to-difference arg)) - (ediff-copy-diff ediff-current-difference - (if (eq last-command-char ?a) 'B 'A)) - (ediff-recenter 'no-rehighlight)) - - -(defun ediff-copy-diff (n buf-type) - "Copy diff N from BUF-TYPE \(given as `A' or `B'\)." - (let* ((other-buf (if (eq buf-type 'A) - ediff-B-buffer ediff-A-buffer)) - (buf (if (eq buf-type 'A) - ediff-A-buffer ediff-B-buffer)) - (other-buf-type (if (eq buf-type 'A) 'B 'A)) - (ctrl-buf ediff-control-buffer) - reg-to-copy reg-to-delete - reg-to-delete-beg reg-to-delete-end) + ;; in case beg/end-A/B aren't markers--make them into markers + (ediff-with-current-buffer buffer-A + (setq beg-A (move-marker (make-marker) beg-A) + end-A (move-marker (make-marker) end-A))) + (ediff-with-current-buffer buffer-B + (setq beg-B (move-marker (make-marker) beg-B) + end-B (move-marker (make-marker) end-B))) - (ediff-operate-on-flags 'remove) - (setq reg-to-delete-beg - (ediff-get-diff-posn other-buf-type 'beg n ctrl-buf)) - (setq reg-to-delete-end - (ediff-get-diff-posn other-buf-type 'end n ctrl-buf)) - (setq reg-to-copy (emerge-eval-in-buffer - buf - (buffer-substring (ediff-get-diff-posn - buf-type 'beg n ctrl-buf) - (ediff-get-diff-posn - buf-type 'end n ctrl-buf)))) - (setq reg-to-delete (emerge-eval-in-buffer - other-buf - (buffer-substring reg-to-delete-beg - reg-to-delete-end))) - (setq ediff-disturbed-overlays nil) ;; clear before use - - (if (string= reg-to-delete reg-to-copy) + (if (and (eq buffer-A buffer-B) + (or (and (< beg-A end-B) (<= beg-B beg-A)) ; b-B b-A e-B + (and (< beg-B end-A) (<= end-A end-B)))) ; b-B e-A e-B (progn - (ding) - (message - "Diff regions %d are identical in buffers A and B. Nothing copied." - (1+ n))) - - ;; seems ok to copy - (if (ediff-test-save-region n other-buf-type) - (condition-case conds - (let (inhibit-read-only) - (emerge-eval-in-buffer - other-buf - ;; to prevent flags from interfering if buffer is writable - (setq inhibit-read-only (null buffer-read-only)) - (let ((before-change-function nil)) - (goto-char reg-to-delete-end) - (insert-before-markers reg-to-copy) - (if (ediff-if-lucid) - (progn - (ediff-collect-extents-lucid reg-to-delete-beg) - (if (> reg-to-delete-end reg-to-delete-beg) - (progn - (kill-region reg-to-delete-beg - reg-to-delete-end) - (if (string= reg-to-copy "") - (ediff-adjust-disturbed-extents-lucid - reg-to-delete-beg))))) - (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))) - )) - (ediff-save-diff-region n other-buf-type reg-to-delete)) - (error (message "%s %s" - (car conds) - (mapconcat 'prin1-to-string (cdr conds) " ")) - (beep 1)))) - ) - (ediff-operate-on-flags 'insert) - )) - -(defun ediff-save-diff-region (n buf-type reg) - "Save Nth diff of buffer BUF-TYPE \(`A' or `B'\). -That is to say, the Nth diff on the `ediff-killed-diffs-alist'. REG -is the region to save. It is redundant here,but is passed anyway, for -convenience." - - (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist)) - (this-buf-n-th-diff-saved (assoc buf-type (cdr n-th-diff-saved)))) - - (if this-buf-n-th-diff-saved - ;; either nothing saved for n-th diff and buffer or we OK'ed - ;; overriding - (setcdr this-buf-n-th-diff-saved reg) - (if n-th-diff-saved ;; n-th diff saved, but for another buffer - (nconc n-th-diff-saved (list (cons buf-type reg))) - (setq ediff-killed-diffs-alist ;; create record for n-th diff - (cons (list n (cons buf-type reg)) - ediff-killed-diffs-alist)))) - (message "Saved diff region #%d for buffer %S. To recover hit '%s'." - (1+ n) buf-type (if (eq buf-type 'A) "ra" "rb")))) - -(defun ediff-test-save-region (n buf-type) - "Test if saving Nth difference region of buffer BUF-TYPE is possible." - (let* ((n-th-diff-saved (assoc n ediff-killed-diffs-alist)) - (this-buf-n-th-diff-saved (assoc buf-type (cdr n-th-diff-saved)))) - - (if this-buf-n-th-diff-saved - (if (yes-or-no-p - (format - "You've previously copied diff %d from %S to %S. Confirm. " - (1+ n) (if (eq buf-type 'A) 'B 'A) buf-type)) - t - (error "Quit.")) - t))) - -(defun ediff-pop-diff (n buf-type) - "Pop last killed Nth diff region from buffer BUF-TYPE." - (let* ((n-th-record (assoc n ediff-killed-diffs-alist)) - (saved-rec (assoc buf-type (cdr n-th-record))) - (buf (if (eq buf-type 'A) ediff-A-buffer ediff-B-buffer)) - saved-diff reg-beg reg-end recovered) - - (if (cdr saved-rec) - (setq saved-diff (cdr saved-rec)) - (error "Nothing saved for diff %d in buffer %S." (1+ n) buf-type)) - - (ediff-operate-on-flags 'remove) - - (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 - (emerge-eval-in-buffer - buf - (let ((inhibit-read-only (null buffer-read-only)) - (before-change-function nil)) - (goto-char reg-end) - (insert-before-markers saved-diff) - - (if (ediff-if-lucid) - (progn - (ediff-collect-extents-lucid reg-beg) - (if (> reg-end reg-beg) - (progn - (kill-region reg-beg reg-end) - (if (string= saved-diff "") - (ediff-adjust-disturbed-extents-lucid reg-beg))))) - (if (> reg-end reg-beg) - (kill-region reg-beg reg-end) - (ediff-move-disturbed-overlays reg-beg))) - - (setq recovered t) - )) - (error (message "%s %s" - (car conds) - (mapconcat 'prin1-to-string (cdr conds) " ")) - (beep 1))) + (with-output-to-temp-buffer ediff-msg-buffer + (princ " +You have requested to compare overlapping regions of the same buffer. + +In this case, Ediff's highlighting may be confusing---in the same window, +you may see highlighted regions that belong to different regions. + +Continue anyway? (y/n) ")) + + (if (y-or-n-p "Continue anyway? ") + () + (error "%S aborted" job-name)))) + + ;; make file-A + (if word-mode + (ediff-wordify beg-A end-A buffer-A tmp-buffer) + (ediff-copy-to-buffer beg-A end-A buffer-A tmp-buffer)) + (setq file-A (ediff-make-temp-file tmp-buffer "regA")) - (ediff-operate-on-flags 'insert) - (if recovered - (progn - (setq n-th-record (delq saved-rec n-th-record)) - (message "Diff region %d restored for buffer %S." (1+ n) buf-type))) + ;; make file-B + (if word-mode + (ediff-wordify beg-B end-B buffer-B tmp-buffer) + (ediff-copy-to-buffer beg-B end-B buffer-B tmp-buffer)) + (setq file-B (ediff-make-temp-file tmp-buffer "regB")) + + (setq overl-A (ediff-make-bullet-proof-overlay beg-A end-A buffer-A)) + (setq overl-B (ediff-make-bullet-proof-overlay beg-B end-B buffer-B)) + (ediff-setup buffer-A file-A + buffer-B file-B + nil nil ; buffer & file C + (cons (` (lambda () + (delete-file (, file-A)) + (delete-file (, file-B)))) + startup-hooks) + (append + (list (cons 'ediff-word-mode word-mode) + (cons 'ediff-narrow-bounds (list overl-A overl-B)) + (cons 'ediff-job-name job-name)) + setup-parameters)) )) - -(defun ediff-restore-diff (arg) - "Restore ARGth diff from `ediff-killed-diffs-alist'. -ARG is a prefix argument. If ARG is nil, restore current-difference." - (interactive "P") - (if arg - (ediff-jump-to-difference arg)) - (ediff-pop-diff ediff-current-difference - (if (eq last-command-char ?a) 'A 'B)) - (ediff-recenter 'no-rehighlight)) + +;;; Merge files and buffers + +;;;###autoload +(defalias 'ediff-merge 'ediff-merge-files) + +(defsubst ediff-merge-on-startup () + (ediff-do-merge 0) + (ediff-with-current-buffer ediff-buffer-C + (set-buffer-modified-p nil))) -;;; Quitting, suspending, etc. -(defun ediff-quit () - "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 file-A and file-B\)." - (interactive) - (if (prog1 - (y-or-n-p "Do you really want to exit Ediff? ") - (message "")) - (ediff-really-quit))) - -;; Perform the quit operations. -(defun ediff-really-quit () - (setq buffer-read-only nil) - (ediff-unselect-and-select-difference -1) - ;; null out the difference overlays so they won't slow down future editing - ;; operations - (mapcar (function (lambda (d) - (ediff-delete-overlay (aref d 0)) - (ediff-delete-overlay (aref d 1)))) - ediff-difference-vector) - ;; allow them to be garbage collected - (setq ediff-difference-vector nil) - (setq ediff-help-message ediff-help-message-long) - (ediff-restore-buffer-characteristics t) ;; restore as they were at setup - (ediff-unhighlight-diffs-totally) +;;;###autoload +(defun ediff-merge-files (file-A file-B + ;; MERGE-BUFFER-FILE is the file to be + ;; associated with the merge buffer + &optional startup-hooks merge-buffer-file) + "Merge two files without ancestor." + (interactive + (let ((dir-A (if ediff-use-last-dir + ediff-last-dir-A + default-directory)) + dir-B f) + (list (setq f (ediff-read-file-name + "File A to merge" dir-A + (ediff-get-default-file-name))) + (ediff-read-file-name "File B to merge" + (setq dir-B + (if ediff-use-last-dir + ediff-last-dir-B + (file-name-directory f))) + (progn + (setq file-name-history + (cons (ediff-abbreviate-file-name + (expand-file-name + (file-name-nondirectory f) + dir-B)) + file-name-history)) + f)) + ))) + (setq startup-hooks (cons 'ediff-merge-on-startup startup-hooks)) + (ediff-files-internal file-A + (if (file-directory-p file-B) + (expand-file-name + (file-name-nondirectory file-A) file-B) + file-B) + nil ; file-C + startup-hooks + 'ediff-merge-files + merge-buffer-file)) + +;;;###autoload +(defun ediff-merge-files-with-ancestor (file-A file-B file-ancestor + &optional + startup-hooks + ;; MERGE-BUFFER-FILE is the file + ;; to be associated with the + ;; merge buffer + merge-buffer-file) + "Merge two files with ancestor." + (interactive + (let ((dir-A (if ediff-use-last-dir + ediff-last-dir-A + default-directory)) + dir-B dir-ancestor f ff) + (list (setq f (ediff-read-file-name + "File A to merge" dir-A + (ediff-get-default-file-name))) + (setq ff (ediff-read-file-name "File B to merge" + (setq dir-B + (if ediff-use-last-dir + ediff-last-dir-B + (file-name-directory f))) + (progn + (setq file-name-history + (cons + (ediff-abbreviate-file-name + (expand-file-name + (file-name-nondirectory f) + dir-B)) + file-name-history)) + f))) + (ediff-read-file-name "Ancestor file" + (setq dir-ancestor + (if ediff-use-last-dir + ediff-last-dir-ancestor + (file-name-directory ff))) + (progn + (setq file-name-history + (cons (ediff-abbreviate-file-name + (expand-file-name + (file-name-nondirectory ff) + dir-ancestor)) + file-name-history)) + ff)) + ))) + (setq startup-hooks (cons 'ediff-merge-on-startup startup-hooks)) + (ediff-files-internal file-A + (if (file-directory-p file-B) + (expand-file-name + (file-name-nondirectory file-A) file-B) + file-B) + file-ancestor + startup-hooks + 'ediff-merge-files-with-ancestor + merge-buffer-file)) + +;;;###autoload +(defalias 'ediff-merge-with-ancestor 'ediff-merge-files-with-ancestor) + +;;;###autoload +(defun ediff-merge-buffers (buffer-A buffer-B + &optional + ;; MERGE-BUFFER-FILE is the file to be + ;; associated with the merge buffer + startup-hooks job-name merge-buffer-file) + "Merge buffers without ancestor." + (interactive + (let (bf) + (list (setq bf (read-buffer "Buffer A to merge: " + (ediff-other-buffer "") t)) + (read-buffer "Buffer B to merge: " + (progn + ;; realign buffers so that two visible bufs will be + ;; at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer bf)) + t)))) - ;; restore buffer mode line id's in buffer-A/B - (let ((control-buffer ediff-control-buffer)) - (emerge-eval-in-buffer - ediff-A-buffer - (setq before-change-function nil) - (setq ediff-this-buffer-control-sessions - (delq control-buffer ediff-this-buffer-control-sessions)) - (if (null ediff-this-buffer-control-sessions) - (setq local-write-file-hooks - (delq 'ediff-block-write-file local-write-file-hooks))) - (kill-local-variable 'mode-line-buffer-identification)) - (emerge-eval-in-buffer - ediff-B-buffer - (setq ediff-this-buffer-control-sessions - (delq control-buffer ediff-this-buffer-control-sessions)) - (if (null ediff-this-buffer-control-sessions) - (setq local-write-file-hooks - (delq 'ediff-block-write-file local-write-file-hooks))) - (setq before-change-function nil) - (kill-local-variable 'mode-line-buffer-identification))) + (setq startup-hooks (cons 'ediff-merge-on-startup startup-hooks)) + (or job-name (setq job-name 'ediff-merge-buffers)) + (ediff-buffers-internal + buffer-A buffer-B nil startup-hooks job-name merge-buffer-file)) - (run-hooks 'ediff-quit-hooks)) +;;;###autoload +(defun ediff-merge-buffers-with-ancestor (buffer-A buffer-B buffer-ancestor + &optional + startup-hooks + job-name + ;; MERGE-BUFFER-FILE is the + ;; file to be associated + ;; with the merge buffer + merge-buffer-file) + "Merge buffers with ancestor." + (interactive + (let (bf bff) + (list (setq bf (read-buffer "Buffer A to merge: " + (ediff-other-buffer "") t)) + (setq bff (read-buffer "Buffer B to merge: " + (progn + ;; realign buffers so that two visible + ;; bufs will be at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer bf)) + t)) + (read-buffer "Ancestor buffer: " + (progn + ;; realign buffers so that three visible + ;; bufs will be at the top + (save-window-excursion (other-window 1)) + (ediff-other-buffer (list bf bff))) + t) + ))) -(defun ediff-kill-buffer-carefully (buf) - "Kill buffer BUF if it exists." - (if (ediff-buffer-live-p buf) - (kill-buffer (get-buffer buf)))) - -;; The default way of quitting Ediff. -;; Kills control buffers and leaves the -;; frame split between the two diff'ed files. -(defun ediff-default-quit-hook () - (let ((buff-A ediff-A-buffer) - (buff-B ediff-B-buffer)) - (ediff-kill-buffer-carefully ediff-diff-buffer) - (ediff-kill-buffer-carefully ediff-diff-error-buffer) - (ediff-kill-buffer-carefully ediff-control-buffer) - (ediff-kill-buffer-carefully ediff-patch-diagnostics) - (delete-other-windows) - (switch-to-buffer buff-B) - (split-window-vertically) - (switch-to-buffer buff-A))) + (setq startup-hooks (cons 'ediff-merge-on-startup startup-hooks)) + (or job-name (setq job-name 'ediff-merge-buffers-with-ancestor)) + (ediff-buffers-internal + buffer-A buffer-B buffer-ancestor startup-hooks job-name merge-buffer-file)) + + +;;;###autoload +(defun ediff-merge-revisions (&optional file startup-hooks merge-buffer-file) + ;; MERGE-BUFFER-FILE is the file to be associated with the merge buffer + "Run Ediff by merging two revisions of a file. +The file is the optional FILE argument or the file visited by the current +buffer." + (interactive) + (if (stringp file) (find-file file)) + (let (rev1 rev2) + (setq rev1 + (read-string + (format + "Version 1 to merge (default: %s's latest version): " + (if (stringp file) + (file-name-nondirectory file) "current buffer"))) + rev2 + (read-string + (format + "Version 2 to merge (default: %s): " + (if (stringp file) + (file-name-nondirectory file) "current buffer")))) + (ediff-load-version-control) + ;; ancestor-revision=nil + (funcall + (intern (format "ediff-%S-merge-internal" ediff-version-control-package)) + rev1 rev2 nil startup-hooks merge-buffer-file))) -;; The default way of suspending Ediff. -;; Buries Ediff buffers, kills all windows. -(defun ediff-default-suspend-hook () - (let ((buf-A ediff-A-buffer) - (buf-B ediff-B-buffer) - (buf-patch ediff-patch-buf) - (buf-patch-diag ediff-patch-diagnostics) - (buf-err ediff-diff-error-buffer) - (buf-diff ediff-diff-buffer)) - (bury-buffer) ;; ediff-control-buffer - (delete-other-windows) - (bury-buffer buf-err) - (bury-buffer buf-diff) - (bury-buffer buf-patch) - (bury-buffer buf-patch-diag) - (bury-buffer buf-A) - (bury-buffer buf-B))) + +;;;###autoload +(defun ediff-merge-revisions-with-ancestor (&optional + file startup-hooks + ;; MERGE-BUFFER-FILE is the file to + ;; be associated with the merge + ;; buffer + merge-buffer-file) + "Run Ediff by merging two revisions of a file with a common ancestor. +The file is the the optional FILE argument or the file visited by the current +buffer." + (interactive) + (if (stringp file) (find-file file)) + (let (rev1 rev2 ancestor-rev) + (setq rev1 + (read-string + (format + "Version 1 to merge (default: %s's latest version): " + (if (stringp file) + (file-name-nondirectory file) "current buffer"))) + rev2 + (read-string + (format + "Version 2 to merge (default: %s): " + (if (stringp file) + (file-name-nondirectory file) "current buffer"))) + ancestor-rev + (read-string + (format + "Ancestor version (default: %s): " + (if (stringp file) + (file-name-nondirectory file) "current buffer")))) + (ediff-load-version-control) + (funcall + (intern (format "ediff-%S-merge-internal" ediff-version-control-package)) + rev1 rev2 ancestor-rev startup-hooks merge-buffer-file))) + +;;;###autoload +(defun run-ediff-from-cvs-buffer (pos) + "Run Ediff-merge on appropriate revisions of the selected file. +First run after `M-x cvs-update'. Then place the cursor on a line describing a +file and then run `run-ediff-from-cvs-buffer'." + (interactive "d") + (ediff-load-version-control) + (let ((tin (tin-locate cvs-cookie-handle pos))) + (if tin + (cvs-run-ediff-on-file-descriptor tin) + (error "There is no file to merge")))) -(defun ediff-suspend () - "Suspend Ediff. -To resume, switch to the appropriate `*ediff-control*' -buffer and then type \\[ediff-recenter]. Ediff will automatically set -up an appropriate window config." - (interactive) - (run-hooks 'ediff-suspend-hooks) - (message - "To resume, switch to *ediff-control* and hit 'c' (ediff-recenter).")) +;;; Apply patch +;;;###autoload +(defun ediff-patch-file () + "Run Ediff by patching SOURCE-FILENAME." + ;; This now returns the control buffer + (interactive) + (let (source-dir source-file patch-buf) + (require 'ediff-ptch) + (setq patch-buf (ediff-get-patch-buffer)) + (setq source-dir (cond (ediff-use-last-dir ediff-last-dir-patch) + ((and (not ediff-patch-default-directory) + (buffer-file-name patch-buf)) + (file-name-directory + (expand-file-name + (buffer-file-name patch-buf)))) + (t default-directory))) + (setq source-file + ;; the default is the directory, not the visited file name + (ediff-read-file-name + "Which file to patch? " source-dir (ediff-get-default-file-name))) + (ediff-dispatch-file-patching-job patch-buf source-file))) -(defun ediff-file-names () - "Show the names of the buffers or files being operated on by Ediff. -Hit \\[ediff-recenter] to reset the windows afterward." +;;;###autoload +(defun ediff-patch-buffer () + "Run Ediff by patching BUFFER-NAME." (interactive) - (with-output-to-temp-buffer "*Help*" - (emerge-eval-in-buffer ediff-A-buffer - (if buffer-file-name - (progn - (princ "File A is: ") - (princ buffer-file-name)) - (progn - (princ "Buffer A is: ") - (princ (buffer-name)))) - (princ "\n")) - (emerge-eval-in-buffer ediff-B-buffer - (if buffer-file-name - (progn - (princ "File B is: ") - (princ buffer-file-name)) - (progn - (princ "Buffer B is: ") - (princ (buffer-name)))) - (princ "\n")) - )) + (let (patch-buf) + (require 'ediff-ptch) + (setq patch-buf (ediff-get-patch-buffer)) + (ediff-patch-buffer-internal + patch-buf + (read-buffer "Which buffer to patch? " + (cond ((eq patch-buf (current-buffer)) + (ediff-other-buffer (current-buffer))) + (t (current-buffer))) + 'must-match)))) + +;;;###autoload +(defalias 'epatch 'ediff-patch-file) +;;;###autoload +(defalias 'epatch-buffer 'ediff-patch-buffer) -(defun ediff-line-numbers () - "Display the current line numbers. -This function displays the line numbers of the points in the A, B." - (interactive) - (let* ((A-line (emerge-eval-in-buffer ediff-A-buffer - (count-lines (point-min) (point)))) - (B-line (emerge-eval-in-buffer ediff-B-buffer - (count-lines (point-min) (point))))) - (message "At lines: A = %d, B = %d" A-line B-line))) - - -;;; Support routines - -;; Select a difference by placing the ASCII flags around the appropriate -;; group of lines in the A, B buffers -(defun ediff-select-difference (n) - (if (and (>= n 0) (< n ediff-number-of-differences)) - (progn - (ediff-remember-buffer-characteristics) - (if (and window-system ediff-want-faces) - (progn - (ediff-highlight-diff n) - (setq ediff-highlighting-style 'face)) - (setq ediff-highlighting-style 'ascii) - (ediff-place-flags-in-buffer 'A ediff-A-buffer - ediff-control-buffer n) - (ediff-place-flags-in-buffer 'B ediff-B-buffer - ediff-control-buffer n)) - - (ediff-restore-buffer-characteristics) - (run-hooks 'ediff-select-hooks)))) - + +;;; Versions Control functions + +;;;###autoload +(defun ediff-revision (&optional file startup-hooks) + "Run Ediff by comparing versions of a file. +The file is an optional FILE argument or the file visited by the current +buffer. Use `vc.el' or `rcs.el' depending on `ediff-version-control-package'." + ;; if buffer is non-nil, use that buffer instead of the current buffer + (interactive "P") + (if (stringp file) (find-file file)) + (let (rev1 rev2) + (setq rev1 + (read-string + (format "Version 1 to compare (default: %s's latest version): " + (if (stringp file) + (file-name-nondirectory file) "current buffer"))) + rev2 + (read-string + (format "Version 2 to compare (default: %s): " + (if (stringp file) + (file-name-nondirectory file) "current buffer")))) + (ediff-load-version-control) + (funcall + (intern (format "ediff-%S-internal" ediff-version-control-package)) + rev1 rev2 startup-hooks) + )) -;; Unselect a difference by removing the ASCII flags in the buffers. -(defun ediff-unselect-difference (n) - (if (and (>= n 0) (< n ediff-number-of-differences)) - (progn - (ediff-remember-buffer-characteristics) - - (cond ((and window-system ediff-want-faces) - (ediff-unhighlight-diff)) - ((eq ediff-highlighting-style 'ascii) - (ediff-remove-flags-from-buffer - ediff-A-buffer - (ediff-get-diff-posn 'A 'beg n) - (ediff-get-diff-posn 'A 'end n) - ediff-before-flag-A ediff-after-flag-A) - (ediff-remove-flags-from-buffer - ediff-B-buffer - (ediff-get-diff-posn 'B 'beg n) - (ediff-get-diff-posn 'B 'end n) - ediff-before-flag-B ediff-after-flag-B))) - - (ediff-restore-buffer-characteristics) - (setq ediff-highlighting-style nil) - (run-hooks 'ediff-unselect-hooks)))) - -;; Unselects prev diff and selects a new one, if FLAG has value other than -;; 'select-only or 'unselect-only. If FLAG is 'select-only, the -;; next difference is selected, but the current selection is not -;; 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. -;; -;; Don't use `ediff-select-difference' and `ediff-unselect-difference' -;; directly,;; since this will screw up the undo info in the presence of -;; ASCII flags. -;; Instead, use `ediff-unselect-and-select-difference' with appropriate -;; flags. - -(defun ediff-unselect-and-select-difference (n &optional flag no-recenter) - (let ((wind (selected-window)) - ;; save buf modified info - (buf-A-modified (buffer-modified-p ediff-A-buffer)) - (buf-B-modified (buffer-modified-p ediff-B-buffer)) - ;; temporarily disable undo so highlighting won't confuse the user - buf-A-undo buf-B-undo) - - (emerge-eval-in-buffer - ediff-A-buffer - (setq buf-A-undo buffer-undo-list)) - (emerge-eval-in-buffer - ediff-B-buffer - (setq buf-B-undo buffer-undo-list)) - - (buffer-disable-undo ediff-A-buffer) - (buffer-disable-undo ediff-B-buffer) - - (unwind-protect ;; we don't want to lose undo info due to error +;;;###autoload +(defalias 'erevision 'ediff-revision) + + +;; Test if version control package is loaded and load if not +;; Is SILENT is non-nil, don't report error if package is not found. +(defun ediff-load-version-control (&optional silent) + (require 'ediff-vers) + (or (featurep ediff-version-control-package) + (if (locate-library (symbol-name ediff-version-control-package)) (progn - (or (eq flag 'select-only) - (ediff-unselect-difference ediff-current-difference)) - - ;; Auto-save buffers while Ediff flags are temporarily removed. - (emerge-eval-in-buffer - ediff-A-buffer - (if buf-A-modified - (do-auto-save))) - (emerge-eval-in-buffer - ediff-B-buffer - (if buf-B-modified - (do-auto-save))) - - (or (eq flag 'unselect-only) - (ediff-select-difference n)) - (setq ediff-current-difference n) - ) ;; end protected section - - (select-window wind) ;; must be before recenter! - (ediff-refresh-mode-line) - (or no-recenter - (ediff-recenter 'no-rehighlight)) - - ;; restore undo and buffer-modified info - (emerge-eval-in-buffer - ediff-A-buffer - (set-buffer-modified-p buf-A-modified) - (setq buffer-undo-list buf-A-undo)) - (emerge-eval-in-buffer - ediff-B-buffer - (set-buffer-modified-p buf-B-modified) - (setq buffer-undo-list buf-B-undo)) - ))) - -;; Revise the mode line to display which difference we have selected - -(defun ediff-refresh-mode-line () - (setq mode-line-buffer-identification - (list (format "Ediff: %%b diff %d of %d" - (1+ ediff-current-difference) - ediff-number-of-differences))) - ;; Force mode-line redisplay - (set-buffer-modified-p (buffer-modified-p))) - - - -;; Verify that we have a difference selected. -(defun ediff-validate-difference () - (if (not (and (>= ediff-current-difference 0) - (< ediff-current-difference ediff-number-of-differences))) - (error "No difference selected"))) - -;; The following is added to take care of Lemacs. - - -(defun ediff-read-file-name (prompt default-dir default-file A-file) -; This is a modified version of a similar function in `emerge.el'. -; PROMPT should not have trailing ': ', so that it can be modified -; according to context. -; If both A-FILE and default-dir are set, the file constructed our of -; default-dir and the non-directory part of A-FILE is used as default and as -; initial input. -; If A-FILE is set (but default-dir is not), it is used as default and -; initial input. -; If default-file is set, it should be used as the default value. -; If default-dir is non-nil, use it as the default directory. -; Otherwise, use the value in Emacs's var default-directory. - (cond - ((and A-file default-dir) - (read-file-name (format "%s (default %s%s): " - prompt - (abbreviate-file-name - (expand-file-name default-dir)) - (file-name-nondirectory A-file)) - (expand-file-name default-dir) - (concat (expand-file-name default-dir) - (file-name-nondirectory A-file)) - 'confirm (file-name-nondirectory A-file))) - (A-file - (read-file-name (format "%s (default %s): " - prompt (file-name-nondirectory A-file)) - (expand-file-name (file-name-directory A-file)) - A-file - 'confirm (file-name-nondirectory A-file))) - ;; If there is a default file, but no A-file, use it. - (default-file - (read-file-name (format "%s (default %s): " prompt default-file) - default-dir ;; if nil then default-directory. - nil 'confirm)) - (t - (read-file-name (concat prompt ": ") - default-dir ;; if nil then default-directory. - nil 'confirm)))) + (message "") ; kill the message from `locate-library' + (require ediff-version-control-package)) + (or silent + (error "Version control package %S.el not found. Use vc.el instead" + ediff-version-control-package))))) - -(defun ediff-make-temp-file (prefix) - (let ((f (make-temp-name (concat ediff-temp-file-prefix prefix)))) - ;; create the file - (write-region (point-min) (point-min) f nil 'no-message) - (set-file-modes f ediff-temp-file-mode) - f)) - -(defun ediff-block-write-file () - "Prevent writing files A and B directly." - (if (ediff-check-for-ascii-flags) - (error "Use 'wa' and 'wb' to save buffs A/B (first switch back to *ediff-control*."))) - -(defun ediff-check-for-ascii-flags () - (eval - (cons 'or - (mapcar (function (lambda (buf) - (emerge-eval-in-buffer - buf - (eq ediff-highlighting-style 'ascii)))) - ediff-this-buffer-control-sessions)))) - -(defun ediff-insert-in-front (overl beg end) - "Capture overlays that had insertions in the front. -Called when overlay OVERL gets insertion in front." - (if (ediff-overlay-get overl 'ediff-diff-num) - (setq ediff-disturbed-overlays - (cons overl ediff-disturbed-overlays))) - ) - -(defun ediff-collect-extents-lucid (pos) - "Collects all extents at POS having property `ediff-diff-num'. -Lucid Emacs causes headache by detaching empty extents, so I have to save -them before they disappear." - (let (lis elt) - (while (setq elt (extent-at pos nil 'ediff-diff-num elt)) - (setq lis (cons elt lis))) - (setq ediff-disturbed-overlays lis))) - -(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-adjust-disturbed-extents-lucid (posn &optional posn-type) -;; POSN-TYPE tells if POSN should become a new start of the extents -;; (if 'new-start) or a new end (if 'new-end). If POSN-TYPE is nil, then -;; POSN is both the new start and the new end. - (mapcar (function (lambda (overl) - (cond ((and (null posn-type) - (equal (ediff-overlay-start overl) - (ediff-overlay-end overl))) - (ediff-move-overlay overl posn posn)) - - (posn-type - (ediff-move-overlay - overl - (if (eq posn-type 'new-start) - posn - (ediff-overlay-start overl)) - (if (eq posn-type 'new-end) - posn - (ediff-overlay-end overl))))))) - ediff-disturbed-overlays) - (setq ediff-disturbed-overlays nil)) - -(defun ediff-save-buffer () - "Safe way of saving buffers A and B." - (interactive) - (let ((hooks local-write-file-hooks)) - (ediff-unselect-and-select-difference ediff-current-difference - 'unselect-only) - (unwind-protect - (emerge-eval-in-buffer - (if (eq last-command-char ?a) ediff-A-buffer ediff-B-buffer) - ;; temporarily remove writing block - (setq hooks (delq 'ediff-block-write-file hooks)) - (let ((local-write-file-hooks hooks)) - (save-buffer))) - (ediff-unselect-and-select-difference ediff-current-difference - 'select-only) - ))) - - -;; Essentially `emerge-remove-flags-in-buffer', modified to allow deletion -;; of read-only flags. -(defun ediff-remove-flags-from-buffer (buffer before-posn after-posn - before-flag after-flag) - (emerge-eval-in-buffer - buffer - (let ((buffer-read-only nil) - (before-change-function nil) - (inhibit-read-only t) - (before-flag-length (length before-flag)) - (after-flag-length (length after-flag)) - ) - (goto-char after-posn) - (setq after-posn (point-marker)) ;; after-posn is now a marker - ;; remove the flags, if they're there - (goto-char (- before-posn before-flag-length)) - (if (ediff-if-lucid) - (ediff-collect-extents-lucid (+ (point) before-flag-length))) - (if (looking-at (regexp-quote before-flag)) - (delete-region (point) (+ (point) before-flag-length)) - ;; the flag isn't there - (ding) - (message "Trouble removing ASCII flag")) - (if (ediff-if-lucid) - (ediff-adjust-disturbed-extents-lucid (point))) - - (if (ediff-if-lucid) - (ediff-collect-extents-lucid (point))) - (goto-char after-posn) - (if (looking-at (regexp-quote after-flag)) - (delete-region (point) (+ (point) after-flag-length)) - ;; the flag isn't there - (ding) - (message "Trouble removing ASCII flag")) - (if (ediff-if-lucid) - (ediff-adjust-disturbed-extents-lucid (point))) - (setq after-posn nil) ;; after has become a marker--garbage-collect - ))) - - -;; This is a modified `emerge-place-flags-in-buffer'. -(defun ediff-place-flags-in-buffer (buf-type buffer ctl-buffer difference) - (emerge-eval-in-buffer - buffer - (ediff-place-flags-in-buffer1 buf-type ctl-buffer difference))) - -;; Modified `emerge-place-flags-in-buffer1'. -(defun ediff-place-flags-in-buffer1 (buf-type ctl-buffer difference) - (let ((buffer-read-only nil) - (inhibit-read-only t) - (before-change-function nil) - (before-flag-name (if (eq buf-type 'A) - 'ediff-before-flag-A - 'ediff-before-flag-B)) - (after-flag-name (if (eq buf-type 'A) - 'ediff-after-flag-A - 'ediff-after-flag-B)) - beg-of-line flag) - - ;; insert the flag before the difference - (let ((before (ediff-get-diff-posn buf-type 'beg difference ctl-buffer))) - (goto-char before) - (setq beg-of-line (bolp)) - - (setq flag (emerge-eval-in-buffer - ctl-buffer - (if beg-of-line - (set before-flag-name ediff-before-flag-bol) - (set before-flag-name ediff-before-flag-mol)))) - - ;; insert the flag itself - (if (ediff-if-lucid) - (ediff-collect-extents-lucid (point))) - (insert-before-markers flag) - (if (ediff-if-lucid) - ;; Lucid's extent end-points behave strangely; they won't - ;; respect insert-before-markers - (ediff-adjust-disturbed-extents-lucid (point) 'new-start)) - ) - ;; insert the flag after the difference - (let* ((after (ediff-get-diff-posn buf-type 'end difference ctl-buffer))) - (goto-char after) - (setq beg-of-line (bolp)) - - (setq flag (emerge-eval-in-buffer - ctl-buffer - (if beg-of-line - (set after-flag-name ediff-after-flag-bol) - (set after-flag-name ediff-after-flag-mol)))) - - ;; insert the flag itself - (if (ediff-if-lucid) - (ediff-collect-extents-lucid (point))) - (insert flag) - (if (ediff-if-lucid) - (ediff-adjust-disturbed-extents-lucid after 'new-end)) - ))) +;;;###autoload +(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))) - -(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 of 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))) - - (emerge-eval-in-buffer - control-buf - (or n (setq n ediff-current-difference)) - (if (or (< n 0) (>= n ediff-number-of-differences)) - (error "There is no diff %d in this session. Valid diffs are 1 to %d." - (1+ n) ediff-number-of-differences)) - (setq diff-overlay (aref (aref ediff-difference-vector n) - (if (eq buf-type 'A) 0 1)))) - - (if (ediff-overlay-get diff-overlay 'detached) - (ediff-move-overlay diff-overlay - (ediff-overlay-get diff-overlay 'ediff-marker) - (ediff-overlay-get diff-overlay 'ediff-marker))) - (if (eq pos 'beg) - (ediff-overlay-start diff-overlay) - (ediff-overlay-end diff-overlay)) - )) - +;;;###autoload +(defun ediff-documentation (&optional node) + "Display Ediff's manual. +With optional NODE, goes to that node." + (interactive) + (let ((ctl-window ediff-control-window) + (ctl-buf ediff-control-buffer)) -;; These would highlight differences under X -(defun ediff-highlight-diff (n) - "Put face on diff N. Invoked for X displays only." - (let* ((last-A (emerge-eval-in-buffer ediff-A-buffer (point-max))) - (last-B (emerge-eval-in-buffer ediff-B-buffer (point-max))) - (begin-A (ediff-get-diff-posn 'A 'beg n)) - (end-A (ediff-get-diff-posn 'A 'end n)) - (xtraA (if (equal begin-A end-A) 1 0)) - (end-A-hilit (min last-A (+ end-A xtraA))) - - (begin-B (ediff-get-diff-posn 'B 'beg n)) - (end-B (ediff-get-diff-posn 'B 'end n)) - (xtraB (if (equal begin-B end-B) 1 0)) - (end-B-hilit (min last-B (+ end-B xtraB)))) - - (if (ediff-if-lucid) - (progn - (ediff-move-overlay - ediff-current-diff-overlay-A begin-A end-A-hilit) - (ediff-move-overlay - ediff-current-diff-overlay-B begin-B end-B-hilit)) - ;; Emacs 19.22 has a bug, which requires that ediff-move-overlay will - ;; have the buffer as a parameter. Believed fixed in 19.23. - (ediff-move-overlay ediff-current-diff-overlay-A - begin-A end-A-hilit ediff-A-buffer) - (ediff-move-overlay ediff-current-diff-overlay-B - begin-B end-B-hilit ediff-B-buffer)) - ;; giving priority of 0 and then changing it may look funny, but - ;; this is intended to overcome an Emacs bug. - (ediff-overlay-put ediff-current-diff-overlay-A 'priority 0) - (ediff-overlay-put ediff-current-diff-overlay-B 'priority 0) - (ediff-overlay-put ediff-current-diff-overlay-A 'priority - (ediff-highest-priority begin-A end-A-hilit ediff-A-buffer)) - (ediff-overlay-put ediff-current-diff-overlay-B 'priority - (ediff-highest-priority begin-B end-B-hilit ediff-B-buffer)) - - (if (and (not (face-differs-from-default-p 'ediff-odd-diff-face-A-var)) - (null ediff-highlight-selected-only)) + (ediff-skip-unsuitable-frames) + (condition-case nil (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-even-diff-face-A 'ediff-even-diff-face-A-var) - (copy-face ediff-even-diff-face-B 'ediff-even-diff-face-B-var))) - - ;; unhighlight the background overlay for the diff n so they won't - ;; interfere with the current diff overlay - (ediff-overlay-put (aref (aref ediff-difference-vector n) 0) 'face nil) - (ediff-overlay-put (aref (aref ediff-difference-vector n) 1) 'face nil) + (pop-to-buffer (get-buffer-create "*info*")) + (info (if ediff-xemacs-p "ediff.info" "ediff")) + (if node + (Info-goto-node node) + (message "Type `i' to search for a specific topic")) + (raise-frame (selected-frame))) + (error (beep 1) + (with-output-to-temp-buffer ediff-msg-buffer + (princ ediff-BAD-INFO)) + (if (window-live-p ctl-window) + (progn + (select-window ctl-window) + (set-window-buffer ctl-window ctl-buf))))))) - (sit-for 0) ;; needs to synch for some reason - )) -(defun ediff-unhighlight-diff () - "Remove overlays from buffers A and B." - - (ediff-move-overlay ediff-current-diff-overlay-A 1 1) - (ediff-move-overlay ediff-current-diff-overlay-B 1 1) - - ;; rehighlight the overlay in the background of the - ;; current difference region - (ediff-overlay-put (aref (aref ediff-difference-vector - ediff-current-difference) - 0) - 'face (if (ediff-odd-p ediff-current-difference) - 'ediff-odd-diff-face-A-var - 'ediff-even-diff-face-A-var)) - (ediff-overlay-put (aref (aref ediff-difference-vector - ediff-current-difference) - 1) - 'face (if (ediff-odd-p ediff-current-difference) - 'ediff-odd-diff-face-B-var - 'ediff-even-diff-face-B-var)) - ) - - -(defun ediff-unhighlight-diffs-totally () - (if (and window-system ediff-want-faces) - (let ((inhibit-quit t)) - (if (face-differs-from-default-p 'ediff-odd-diff-face-A-var) - (progn - (copy-face 'default 'ediff-odd-diff-face-A-var) - (copy-face 'default 'ediff-odd-diff-face-B-var) - (copy-face 'default 'ediff-even-diff-face-A-var) - (copy-face 'default 'ediff-even-diff-face-B-var))) - (if (ediff-overlayp ediff-current-diff-overlay-A) - (ediff-delete-overlay ediff-current-diff-overlay-A)) - (setq ediff-current-diff-overlay-A nil) - (if (ediff-overlayp ediff-current-diff-overlay-B) - (ediff-delete-overlay ediff-current-diff-overlay-B)) - (setq ediff-current-diff-overlay-B nil)))) - -(defun ediff-operate-on-flags (action) - "Re/unhighlights buffers A and B with all flags from all Ediff sessions. -This is usually needed only when a -buffer is involved in multiple Ediff sessions." - (let* ((A-sessions (emerge-eval-in-buffer - ediff-A-buffer - ediff-this-buffer-control-sessions)) - (B-sessions (emerge-eval-in-buffer - ediff-B-buffer - ediff-this-buffer-control-sessions)) - (sessions (ediff-union A-sessions B-sessions)) - (flag (if (eq action 'remove) 'unselect-only 'select-only))) - - (mapcar (function (lambda (buf) - (emerge-eval-in-buffer - buf - (or (if (eq action 'insert) - (memq ediff-highlighting-style '(ascii off)) - (not (eq ediff-highlighting-style 'ascii))) - (ediff-unselect-and-select-difference - ediff-current-difference - flag 'no-recenter)) - ))) - sessions))) - -(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-debug () - (interactive) - (with-output-to-temp-buffer "*ediff-debug*" - (princ - (format "Ctl buffer: %S\n\nediff-difference-vector:\n" - ediff-control-buffer)) - (mapcar (function - (lambda (overl-vec) - (princ (format "Diff %d: %S %S %S\n\t %S %S %S\n" - (1+ (ediff-overlay-get (aref overl-vec 0) - 'ediff-diff-num)) - (ediff-overlay-get (aref overl-vec 0) - 'ediff-control-buffer) - (ediff-overlay-get (aref overl-vec 0) - 'insert-in-front-hooks) - (aref overl-vec 0) - (ediff-overlay-get (aref overl-vec 1) - 'ediff-control-buffer) - (ediff-overlay-get (aref overl-vec 0) - 'insert-in-front-hooks) - (aref overl-vec 1) - )))) - ediff-difference-vector) - (princ "\nediff-disturbed-overlays:\n") - (mapcar (function - (lambda (overl) - (princ (format "%S %S\n" - (ediff-overlay-get overl 'ediff-control-buffer) - overl - )))) - ediff-disturbed-overlays))) +;;; Local Variables: +;;; eval: (put 'ediff-defvar-local 'lisp-indent-hook 'defun) +;;; eval: (put 'ediff-with-current-buffer 'lisp-indent-hook 1) +;;; eval: (put 'ediff-with-current-buffer 'edebug-form-spec '(form body)) +;;; End: - -(run-hooks 'ediff-load-hooks) - - -(provide 'ediff) +(require 'ediff-util) ;;; ediff.el ends here