This is Info file ../info/ediff.info, produced by Makeinfo-1.63 from
the input file ediff.texi.

   This file documents Ediff, a comprehensive visual interface to Unix
diff and patch utilities.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.


File: ediff.info,  Node: Patch and Diff Programs,  Next: Merging and diff3,  Prev: Refinement of Difference Regions,  Up: Customization

Patch and Diff Programs
=======================

   This section describes variables that specify the programs to be
used for applying patches and for computing the main difference regions
(not the fine difference regions):

`ediff-patch-program'
`ediff-diff-program'
`ediff-diff3-program'
     These variables specify the programs to use to produce differences
     and do patching.

`ediff-patch-options'
`ediff-diff-options'
`ediff-diff3-options'
     These variables specify the options to pass to the above utilities.

     In `ediff-diff-options', it may be useful to specify options such
     as `-w' that ignore certain kinds of changes.  However, Ediff does
     not let you use the option `-c', as it doesn't recognize this
     format yet.

`ediff-custom-diff-program'
`ediff-custom-diff-options'
     Because Ediff limits the options you may want to pass to the `diff'
     program, it partially makes up for this drawback by letting you
     save the output from `diff' in your preferred format, which is
     specified via the above two variables.

     The output generated by `ediff-custom-diff-program' (which doesn't
     even have to be a standard-style `diff'!) is not used by Ediff. It
     is provided exclusively so that you can refer to it later, send it
     over email, etc.  For instance, after reviewing the differences,
     you may want to send context differences to a colleague.  Since
     Ediff ignores the `-c' option in `ediff-diff-program', you would
     have to run `diff -c' separately just to produce the list of
     differences. Fortunately, `ediff-custom-diff-program' and
     `ediff-custom-diff-options' eliminate this nuisance by keeping a
     copy of a difference list in the desired format in a buffer that
     can be displayed via the command `D'.

`ediff-patch-default-directory'
     Specifies the default directory to look for patches.

*Warning:* Ediff does not support the output format of VMS `diff'.
Instead, make sure to use some implementation of POSIX `diff', such as
`gnudiff'.


File: ediff.info,  Node: Merging and diff3,  Next: Support for Version Control,  Prev: Patch and Diff Programs,  Up: Customization

Merging and diff3
=================

   Ediff supports three-way comparison via the functions `ediff-files3'
and `ediff-buffers3'.  The interface is the same as for two-way
comparison.  In three-way comparison and merging, Ediff reports if any
two difference regions are identical.  For instance, if the current
region in buffer A is the same as the region in buffer C, then the mode
line of buffer A will display `[=diff(C)]' and the mode line of buffer
C will display `[=diff(A)]'.

   Merging is done according to the following algorithm.

   If a difference region in one of the buffers, say B, differs from
the ancestor file while the region in the other buffer, A, doesn't,
then the merge buffer, C, gets B's region.  Similarly when buffer A's
region differs from the ancestor and B's doesn't, A's region is used.

   If both regions in buffers A and B differ from the ancestor file,
Ediff chooses the region according to the value of the variable
`ediff-default-variant'.  If its value is `default-A' then A's region
is chosen.  If it is `default-B' then B's region is chosen.  If it is
`combined' then the region in buffer C will look like this:

     #ifdef NEW  /* variant A */
     difference region from buffer A
     #else  /* variant B */
     difference region from buffer B
     #endif  /* NEW */

   The actual strings that separate the regions copied from buffer A
and B are controlled by the variable `ediff-combination-pattern'.  Its
value should be a list of three strings.  The first is inserted before
the difference region of buffer A; the second string goes between the
regions; the third goes after region B, as shown in the above example.

   In addition to the state of the difference, during merging Ediff
displays the state of the merge for each region. If a difference came
from buffer A by default (because both regions A and B were different
from the ancestor and `ediff-default-variant' was set to `default-A')
then `[=diff(A) default-A]' is displayed in the mode line.  If the
difference in buffer C came, say, from buffer B because the difference
region in that buffer differs from the ancestor, but the region in
buffer A does not (if merging with an ancestor) then `[=diff(B)
prefer-B]' is displayed.  The indicators default-A/B and prefer-A/B are
inspired by Emerge and have the same meaning.

   Another indicator of the state of merge is `combined'.  It appears
with any difference region in buffer C that was obtained by combining
the difference regions in buffers A and B as explained above.

   In addition to state of merge and difference indicator, while
merging with an ancestor file or buffer, Ediff informs the user when
the current difference region in the (normally invisible) ancestor
buffer is empty via the *AncestorEmpty* indicator. This helps determine
if the changes made to the original in variants A and B represent pure
insertion or deletion of text: if the mode line shows *AncestorEmpty*
and the corresponding region in buffers A or B is not empty, this means
that new text was inserted. If this indicator is not present and the
difference regions in buffers A or B are non-empty, this means that
text was modified. Otherwise, the original text was deleted.

   Although the ancestor buffer is normally invisible, Ediff maintains
difference regions there and advances the current difference region
accordingly. All highlighting of difference regions is provided in the
ancestor buffer, except for the fine differences.  Therefore, if
desired, the user can put the ancestor buffer in a separate frame and
watch it there. However, on a TTY, only one frame can be visible at any
given time, and Ediff doesn't support any single-frame window
configuration where all buffers, including the ancestor buffer, would
be visible. However, the ancestor buffer can be displayed by typing `/'
to the control window. (Type `C-l' to hide it again.)

   Note that the state-of-difference indicators `=diff(A)' and
`=diff(B)' above are not redundant, even in the presence of a
state-of-merge indicator.  In fact, the two serve different purposes.

   For instance, if the mode line displays `=diff(B) prefer(B)' and you
copy a difference region from buffer A to buffer C then `=diff(B)' will
change to `diff-A' and the mode line will display `=diff(A) prefer-B'.
This indicates that the difference region in buffer C is identical to
that in buffer A, but originally buffer C's region came from buffer B.
This is useful to know because you can recover the original difference
region in buffer C by typing `r'.

   Ediff never changes the state-of-merge indicator, except in response
to the `!' command (see below), in which case the indicator is lost.
On the other hand, the state-of-difference indicator is changed
automatically by the copying/recovery commands, `a', `b', `r', `+'.

   The `!' command loses the information about origins of the regions
in the merge buffer (default-A, prefer-B, or combined).  This is because
recomputing differences in this case means running `diff3' on buffers
A, B, and the merge buffer, not on the ancestor buffer.  (It makes no
sense to recompute differences using the ancestor file, since in the
merging mode Ediff assumes that you have not edited buffers A and B,
but that you may have edited buffer C, and these changes are to be
preserved.)  Since some difference regions may disappear as a result of
editing buffer C and others may arise, there is generally no simple way
to tell where the various regions in the merge buffer came from.

   In three-way comparison, Ediff tries to disregard regions that
consist entirely of white space.  For instance, if, say, the current
region in buffer A consists of the white space only (or if it is
empty), Ediff will not take it into account for the purpose of
computing fine differences. The result is that Ediff can provide a
better visual information regarding the actual fine differences in the
non-white regions in buffers B and C. Moreover, if the regions in
buffers B and C differ in the white space only, then a message to this
effect will be displayed.

   In the merge mode, the share of the split between window C (the
window displaying the merge-buffer) and the windows displaying buffers
A and B is controlled by the variable `ediff-merge-window-share'.  Its
default value is 0.5.  To make the merge-buffer window smaller, reduce
this amount.

   We don't recommend increasing the size of the merge-window to more
than half the frame (i.e., to increase the value of
`ediff-merge-window-share') to more than 0.5, since it would be hard to
see the contents of buffers A and B.

   You can temporarily shrink the merge window to just one line by
typing `s'.  This change is temporary, until Ediff finds a reason to
redraw the screen.  Typing `s' again restores the original window size.

   With a positive prefix argument, the `s' command will make the merge
window slightly taller.  This change is persistent.  With ``-'' or with
a negative prefix argument, the command `s' makes the merge window
slightly shorter.  This change also persistent.

   Ediff lets you automatically ignore the regions where only one of the
buffers A and B disagrees with the ancestor.  To do this, set the
variable `ediff-show-clashes-only' to non-`nil'.

   You can toggle this feature interactively by typing `$'.

   Note that this variable controls only how Ediff chooses the
next/previous difference to show.  You can still jump directly to any
difference using the command `j' (with a prefix argument specifying the
difference number).


File: ediff.info,  Node: Support for Version Control,  Next: Customizing the Mode Line,  Prev: Merging and diff3,  Up: Customization

Support for Version Control
===========================

   Ediff supports version control and lets you compare versions of files
visited by Emacs buffers via the function `ediff-revision'. This
feature is controlled by the following variables:

`ediff-version-control-package'
     A symbol. The default is `vc'.

     If you are like most Emacs users, Ediff will use VC as the version
     control package. This is the standard Emacs interface to RCS, CVS,
     and SCCS.

     However, if your needs are better served by other interfaces, you
     will have to tell Ediff which version control package you are
     using, e.g.,
          (setq ediff-version-control-package 'rcs)

     Apart from the standard `vc.el', Ediff supports three other
     interfaces to version control: `rcs.el', `pcl-cvs.el', and
     `generic-sc.el'.  The package `rcs.el' is written by Sebastian
     Kremer <sk@thp.Uni-Koeln.DE> and is available as
          `ftp.cs.buffalo.edu:pub/Emacs/rcs.tar.Z'
          `ftp.uni-koeln.de:/pub/gnu/emacs/rcs.tar.Z'
     The packages `pcl-cvs.el' and `generic-sc.el' are found in XEmacs
     distribution.

   Ediff's interface to the above packages allows the user to compare
the versions of the current buffer or to merge them (with or without an
ancestor-version). These operations can also be performed on directories
containing files under version control.

   In case of `pcl-cvs.el', Ediff can also be invoked via the function
`run-ediff-from-cvs-buffer'--see the documentation string for this
function.


File: ediff.info,  Node: Customizing the Mode Line,  Next: Miscellaneous,  Prev: Support for Version Control,  Up: Customization

Customizing the Mode Line
=========================

   When Ediff is running, the mode line of `Ediff Control Panel' buffer
shows the current difference number and the total number of difference
regions in the two files.

   The mode line of the buffers being compared displays the type of the
buffer (`A:', `B:', or `C:') and (usually) the file name.  Ediff tries
to be intelligent in choosing the mode line buffer identification.  In
particular, it works well with the `uniquify.el' and `mode-line.el'
packages (which improve on the default way in which Emacs displays
buffer identification).  If you don't like the way Ediff changes the
mode line, you can use `ediff-prepare-buffer-hook' to modify the mode
line.


File: ediff.info,  Node: Miscellaneous,  Next: Notes on Heavy-duty Customization,  Prev: Customizing the Mode Line,  Up: Customization

Miscellaneous
=============

   Here are a few other variables for customizing Ediff:

`ediff-split-window-function'
     Controls the way you want the window be split between file-A and
     file-B (and file-C, if applicable).  It defaults to the vertical
     split (`split-window-vertically', but you can set it to
     `split-window-horizontally', if you so wish.  Ediff also lets you
     switch from vertical to horizontal split and back interactively.

     Note that if Ediff detects that all the buffers it compares are
     displayed in separate frames, it assumes that the user wants them
     to be so displayed and stops splitting windows.  Instead, it
     arranges for each buffer to be displayed in a separate frame. You
     can switch to the one-frame mode by hiding one of the buffers
     A/B/C.

     You can also swap the windows where buffers are displayed by typing
     `~'.

`ediff-merge-split-window-function'
     Controls how windows are split between buffers A and B in the
     merge mode.  This variable is like `ediff-split-window-function',
     but it defaults to `split-window-horizontally' instead of
     `split-window-vertically'.

`ediff-make-wide-display-function'
     The value is a function to be called to widen the frame for
     displaying the Ediff buffers.  See the on-line documentation for
     `ediff-make-wide-display-function' for details.  It is also
     recommended to look into the source of the default function
     `ediff-make-wide-display'.

     You can toggle wide/regular display by typing `m'.  In the wide
     display mode, buffers A, B (and C, when applicable) are displayed
     in a single frame that is as wide as the entire workstation
     screen.  This is useful when files are compared side-by-side.  By
     default, the display is widened without changing its height.

`ediff-use-last-dir'
     Controls the way Ediff presents the default directory when it
     prompts the user for files to compare.  If `nil', Ediff uses 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 files A, B, or C, respectively.

`ediff-no-emacs-help-in-control-buffer'
     If `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 a text-only terminal,
     the Backspace key is bound to `C-h' and is positioned more
     conveniently than the DEL key.

`ediff-toggle-read-only-function'
     This variable's value is a function that Ediff uses to toggle the
     read-only property in its buffers.

     The default function that Ediff uses simply toggles the read-only
     property, unless the file is under version control.  For a
     checked-in file under version control, Ediff first tries to check
     the file out.

`ediff-keep-variants'
     The default is `t', meaning that the buffers being compared or
     merged will be preserved when Ediff quits. Setting this to `nil'
     causes Ediff to offer the user a chance to delete these buffers
     (if they are not modified).  Supplying a prefix argument to the
     quit command (`q') temporarily reverses the meaning of this
     variable. This is convenient when the user prefers one of the
     behaviors most of the time, but occasionally needs the other
     behavior.

     However, Ediff temporarily resets this variable to `t' if it is
     invoked via one of the "buffer" jobs, such as `ediff-buffers'.
     This is because it is all too easy to loose day's work otherwise.
     Besides, in a "buffer" job, the variant buffers have already been
     loaded prior to starting Ediff, so Ediff just preserves status quo
     here.

     Using `ediff-cleanup-hook', one can make Ediff delete the variants
     unconditionally (e.g., by making `ediff-janitor' into one of these
     hooks).

`ediff-grab-mouse'
     Default is `t'.  Normally, Ediff grabs mouse and puts it in its
     control frame.  This is useful since the user can be sure that
     when he needs to type an Ediff command the focus will be in an
     appropriate Ediff's frame.  However, some users prefer to move the
     mouse by themselves.  The above variable, if set to `maybe', will
     prevent Ediff from grabbing the mouse in many situations, usually
     after commands that may take more time than usual. In other
     situation, Ediff will continue grabbing the mouse and putting it
     where it believes is appropriate.  If the value is `nil', then
     mouse is entirely user's responsibility.  Try different settings
     and see which one is for you.


File: ediff.info,  Node: Notes on Heavy-duty Customization,  Prev: Miscellaneous,  Up: Customization

Notes on Heavy-duty Customization
=================================

   Some users need to customize Ediff in rather sophisticated ways,
which requires different defaults for different kinds of files (e.g.,
SGML, etc.).  Ediff supports this kind of customization in several
ways.  First, most customization variables are buffer-local. Those that
aren't are usually accessible from within Ediff Control Panel, so one
can make them local to the panel by calling make-local-variable from
within `ediff-startup-hook'.

   Second, the function `ediff-setup' accepts an optional sixth
argument which has the form `((VAR-NAME-1 . VAL-1) (VAR-NAME-2 . VAL-2)
...)'.  The function `ediff-setup' sets the variables in the list to
the respective values, locally in the Ediff control buffer.  This is an
easy way to throw in custom variables (which usually should be
buffer-local) that can then be tested in various hooks.

   Make sure the variable `ediff-job-name' and `ediff-word-mode' are set
properly in this case, as some things in Ediff depend on this.

   Finally, if you want custom-tailored help messages, you can set the
variables `ediff-brief-help-message-function' and
`ediff-long-help-message-function' to functions that return help
strings.

   When customizing Ediff, some other variables are useful, although
they are not user-definable. They are local to the Ediff control
buffer, so this buffer must be current when you access these variables.
The control buffer is accessible via the variable
`ediff-control-buffer', which is also local to that buffer. It is
usually used for checking if the current buffer is also the control
buffer.

   Other variables of interest are:
`ediff-buffer-A'
     The first of the data buffers being compared.

`ediff-buffer-B'
     The second of the data buffers being compared.

`ediff-buffer-C'
     In three-way comparisons, this is the third buffer being compared.
     In merging, this is the merge buffer.  In two-way comparison, this
     variable is nil.

`ediff-window-A'
     The window displaying buffer A. If buffer A is not visible, this
     variable is nil or it may be a dead window.

`ediff-window-B'
     The window displaying buffer B.

`ediff-window-C'
     The window displaying buffer C, if any.

`ediff-control-frame'
     A dedicated frame displaying the control buffer, if it exists.  It
     is non-nil only if Ediff uses the multiframe display, i.e., when
     the control buffer is in its own frame.


File: ediff.info,  Node: Credits,  Next: Index,  Prev: Customization,  Up: Top

Credits
*******

   Ediff was written by Michael Kifer <kifer@cs.sunysb.edu>. It was
inspired by emerge.el written by Dale R. Worley <drw@math.mit.edu>.  An
idea due to Boris Goldowsky <boris@cs.rochester.edu> made it possible
to highlight fine differences in Ediff buffers. Alastair Burt
<burt@dfki.uni-kl.de> ported Ediff to XEmacs, and Eric Freudenthal
<freudent@jan.ultra.nyu.edu> made it work with VC.

   Many people provided help with bug reports, patches, and advice.
Without them, Ediff would not be nearly as useful as it is today.  Here
is a full list of contributors (I hope I didn't miss anyone):

     Neal Becker (neal@ctd.comsat.com),
     Alastair Burt (burt@dfki.uni-kl.de), Paul Bibilo (peb@delcam.co.uk),
     Kevin Broadey (KevinB@bartley.demon.co.uk),
     Harald Boegeholz (hwb@machnix.mathematik.uni-stuttgart.de),
     Bradley A. Bosch (brad@lachman.com),
     Michael D. Carney  (carney@ltx-tr.com),
     Jin S. Choi (jin@atype.com),
     Albert Dvornik (bert@mit.edu),
     Eric Eide (eeide@asylum.cs.utah.edu),
     Kevin Esler (esler@ch.hp.com), Robert Estes (estes@ece.ucdavis.edu),
     Xavier Fornari (xavier@europe.cma.fr),
     Eric Freudenthal (freudent@jan.ultra.nyu.edu),
     Job Ganzevoort (Job.Ganzevoort@cwi.nl),
     Boris Goldowsky (boris@cs.rochester.edu),
     Allan Gottlieb (gottlieb@allan.ultra.nyu.edu), Xiaoli Huang (hxl@epic.com),
     Larry Gouge (larry@itginc.com), Karl Heuer (kwzh@gnu.ai.mit.edu),
     (irvine@lks.csi.com), (jaffe@chipmunk.cita.utoronto.ca),
     David Karr (dkarr@nmo.gtegsc.com),
     Norbert Kiesel (norbert@i3.informatik.rwth-aachen.de),
     Leigh L Klotz (klotz@adoc.xerox.com), Fritz Knabe (Fritz.Knabe@ecrc.de),
     Heinz Knutzen (hk@informatik.uni-kiel.d400.de),
     Andrew Koenig (ark@research.att.com),
     Ken Laprade (laprade@dw3f.ess.harris.com), Will C Lauer (wcl@cadre.com),
     Richard Levitte (levitte@e.kth.se), Mike Long (mike.long@analog.com),
     Martin Maechler (maechler@stat.math.ethz.ch),
     Simon Marshall (Simon.Marshall@mail.esrin.esa.it),
     Richard Mlynarik (mly@adoc.xerox.com),
     Chris Murphy (murphycm@sun.aston.ac.uk),
     Erik Naggum (erik@naggum.no),
     Eyvind Ness (Eyvind.Ness@hrp.no), Ray Nickson (nickson@cs.uq.oz.au),
     David Petchey (petchey_david@jpmorgan.com),
     Benjamin Pierce (benjamin.pierce@cl.cam.ac.uk),
     Tibor Polgar (tlp00@spg.amdahl.com),
     David Prince (dave0d@fegs.co.uk),
     Paul Raines (raines@slac.stanford.edu),
     C.S. Roberson (roberson@aur.alcatel.com),
     Kevin Rodgers (kevin.rodgers@ihs.com),
     Sandy Rutherford (sandy@ibm550.sissa.it),
     Heribert Schuetz (schuetz@ecrc.de), Andy Scott (ascott@pcocd2.intel.com),
     Axel Seibert (axel@tumbolia.ppp.informatik.uni-muenchen.de),
     Richard Stallman (rms@gnu.ai.mit.edu),
     Richard Stanton (stanton@haas.berkeley.edu),
     Ake Stenhoff (etxaksf@aom.ericsson.se), Stig (stig@hackvan.com),
     Peter Stout (Peter_Stout@cs.cmu.edu), Chuck Thompson (cthomp@cs.uiuc.edu),
     Ray Tomlinson (tomlinso@bbn.com),
     Raymond Toy (toy@rtp.ericsson.se),
     Ben Wing (wing@666.com),
     Ilya Zakharevich (ilya@math.ohio-state.edu),
     Eli Zaretskii (eliz@is.elta.co.il)


File: ediff.info,  Node: Index,  Prev: Credits,  Up: Top

Index
*****

* Menu:

* ediff-grab-mouse:                     Miscellaneous.
* ediff-keep-variants:                  Miscellaneous.
* ediff-use-last-dir:                   Major Entry Points.
* generic-sc.el:                        Support for Version Control.
* mode-line.el:                         Customizing the Mode Line.
* pcl-cvs.el:                           Support for Version Control.
* rcs.el:                               Support for Version Control.
* uniquify.el:                          Customizing the Mode Line.
* vc.el:                                Support for Version Control.
* Comparing files and buffers:          Introduction.
* ediff:                                Major Entry Points.
* ediff-after-flag-eol:                 Highlighting Difference Regions.
* ediff-after-flag-mol:                 Highlighting Difference Regions.
* ediff-after-setup-control-frame-hook: Hooks.
* ediff-after-setup-windows-hook:       Hooks.
* ediff-auto-refine:                    Refinement of Difference Regions.
* ediff-auto-refine-limit:              Refinement of Difference Regions.
* ediff-before-flag-bol:                Highlighting Difference Regions.
* ediff-before-flag-mol:                Highlighting Difference Regions.
* ediff-before-setup-control-frame-hook: Hooks.
* ediff-before-setup-windows-hook:      Hooks.
* ediff-brief-help-message-function:    Notes on Heavy-duty Customization.
* ediff-buffers:                        Major Entry Points.
* ediff-buffers3:                       Major Entry Points.
* ediff-cleanup-hook:                   Hooks.
* ediff-combination-pattern:            Merging and diff3.
* ediff-control-buffer:                 Quick Help.
* ediff-control-frame-parameters:       Window and Frame Configuration.
* ediff-control-frame-position-function: Window and Frame Configuration.
* ediff-control-frame-upward-shift:     Window and Frame Configuration.
* ediff-current-diff-face-A:            Highlighting Difference Regions.
* ediff-current-diff-face-B:            Highlighting Difference Regions.
* ediff-current-diff-face-C:            Highlighting Difference Regions.
* ediff-custom-diff-options:            Patch and Diff Programs.
* ediff-custom-diff-program:            Patch and Diff Programs.
* ediff-default-variant:                Merging and diff3.
* ediff-diff-options:                   Patch and Diff Programs.
* ediff-diff-program <1>:               Patch and Diff Programs.
* ediff-diff-program:                   Refinement of Difference Regions.
* ediff-diff3-options:                  Patch and Diff Programs.
* ediff-diff3-program:                  Patch and Diff Programs.
* ediff-directories:                    Major Entry Points.
* ediff-directories3:                   Major Entry Points.
* ediff-directory-revisions:            Major Entry Points.
* ediff-display-help-hook:              Hooks.
* ediff-even-diff-face-A:               Highlighting Difference Regions.
* ediff-even-diff-face-B:               Highlighting Difference Regions.
* ediff-even-diff-face-C:               Highlighting Difference Regions.
* ediff-files:                          Major Entry Points.
* ediff-files3:                         Major Entry Points.
* ediff-fine-diff-face-A:               Highlighting Difference Regions.
* ediff-fine-diff-face-B:               Highlighting Difference Regions.
* ediff-fine-diff-face-C:               Highlighting Difference Regions.
* ediff-force-faces:                    Highlighting Difference Regions.
* ediff-forward-word:                   Refinement of Difference Regions.
* ediff-forward-word-function:          Refinement of Difference Regions.
* ediff-help-message:                   Quick Help.
* ediff-highlight-all-diffs:            Highlighting Difference Regions.
* ediff-ignore-similar-regions:         Selective Browsing.
* ediff-janitor:                        Hooks.
* ediff-job-name:                       Notes on Heavy-duty Customization.
* ediff-keymap-setup-hook:              Hooks.
* ediff-load-hook:                      Hooks.
* ediff-long-help-message-function:     Notes on Heavy-duty Customization.
* ediff-make-frame-position:            Window and Frame Configuration.
* ediff-make-wide-display-function:     Miscellaneous.
* ediff-merge:                          Major Entry Points.
* ediff-merge-buffers:                  Major Entry Points.
* ediff-merge-buffers-with-ancestor:    Major Entry Points.
* ediff-merge-directories:              Major Entry Points.
* ediff-merge-directories-with-ancestor: Major Entry Points.
* ediff-merge-directory-revisions:      Major Entry Points.
* ediff-merge-directory-revisions-with-ancestor: Major Entry Points.
* ediff-merge-files:                    Major Entry Points.
* ediff-merge-files-with-ancestor:      Major Entry Points.
* ediff-merge-revisions:                Major Entry Points.
* ediff-merge-revisions-with-ancestor:  Major Entry Points.
* ediff-merge-split-window-function:    Miscellaneous.
* ediff-merge-window-share:             Merging and diff3.
* ediff-merge-with-ancestor:            Major Entry Points.
* ediff-mode-hook:                      Hooks.
* ediff-narrow-control-frame-leftward-shift: Window and Frame Configuration.
* ediff-no-emacs-help-in-control-buffer: Miscellaneous.
* ediff-odd-diff-face-A:                Highlighting Difference Regions.
* ediff-odd-diff-face-B:                Highlighting Difference Regions.
* ediff-odd-diff-face-C:                Highlighting Difference Regions.
* ediff-patch-buffer:                   Major Entry Points.
* ediff-patch-default-directory:        Patch and Diff Programs.
* ediff-patch-file:                     Major Entry Points.
* ediff-patch-options:                  Patch and Diff Programs.
* ediff-patch-program:                  Patch and Diff Programs.
* ediff-prefer-iconified-control-frame: Window and Frame Configuration.
* ediff-prepare-buffer-hook <1>:        Customizing the Mode Line.
* ediff-prepare-buffer-hook:            Hooks.
* ediff-profile:                        Commands.
* ediff-quit-hook:                      Hooks.
* ediff-quit-widened:                   Narrowing.
* ediff-regions-linewise:               Major Entry Points.
* ediff-regions-wordwise:               Major Entry Points.
* ediff-registry-setup-hook:            Hooks.
* ediff-revert-buffers-then-recompute-diffs: Commands.
* ediff-revision:                       Major Entry Points.
* ediff-save-buffer:                    Patch and Diff Programs.
* ediff-select-hook:                    Hooks.
* ediff-session-group-setup-hook:       Hooks.
* ediff-setup:                          Notes on Heavy-duty Customization.
* ediff-setup-windows:                  Window and Frame Configuration.
* ediff-setup-windows-multiframe:       Window and Frame Configuration.
* ediff-setup-windows-plain:            Window and Frame Configuration.
* ediff-show-clashes-only:              Merging and diff3.
* ediff-show-registry:                  Commands.
* ediff-split-window-function:          Miscellaneous.
* ediff-start-narrowed:                 Narrowing.
* ediff-startup-hook <1>:               Quick Help.
* ediff-startup-hook <1>:               Notes on Heavy-duty Customization.
* ediff-startup-hook:                   Hooks.
* ediff-suspend-hook:                   Hooks.
* ediff-toggle-multiframe <1>:          Commands.
* ediff-toggle-multiframe:              Window and Frame Configuration.
* ediff-toggle-read-only-function:      Miscellaneous.
* ediff-unselect-hook:                  Hooks.
* ediff-use-last-dir:                   Miscellaneous.
* ediff-use-long-help-message:          Quick Help.
* ediff-version-control-package:        Support for Version Control.
* ediff-wide-control-frame-rightward-shift: Window and Frame Configuration.
* ediff-window-setup-function:          Window and Frame Configuration.
* ediff-windows-linewise:               Major Entry Points.
* ediff-windows-wordwise:               Major Entry Points.
* ediff-word-1:                         Refinement of Difference Regions.
* ediff-word-2:                         Refinement of Difference Regions.
* ediff-word-3:                         Refinement of Difference Regions.
* ediff-word-4:                         Refinement of Difference Regions.
* ediff-word-mode:                      Notes on Heavy-duty Customization.
* ediff3:                               Major Entry Points.
* edir-merge-revisions:                 Major Entry Points.
* edir-merge-revisions-with-ancestor:   Major Entry Points.
* edir-revisions:                       Major Entry Points.
* edirs:                                Major Entry Points.
* edirs-merge:                          Major Entry Points.
* edirs-merge-with-ancestor:            Major Entry Points.
* edirs3:                               Major Entry Points.
* epatch:                               Major Entry Points.
* eregistry:                            Commands.
* Finding differences:                  Introduction.
* Merging files and buffers:            Introduction.
* Multi-file patches:                   Session Groups.
* Patching files and buffers:           Introduction.


