Initial revision

7 files changed, 4112 insertions, 0 deletions

diff --git a/lisp/emerge.el b/lisp/emerge.el
new file mode 100644
index 00000000000..659d50afcef
--- /dev/null
+++ b/lisp/emerge.el
@@ -0,0 +1,2979 @@
+;;; emerge.el   version 4
+
+;;; 13 Dec 1991
+
+;; LCD Archive Entry:
+;; emerge|Dale R. Worley|drw@math.mit.edu
+;; |File merge documentation
+;; |91-12-13|version 4|~/packages/emerge.doc.Z
+
+; - Changes from version 3 to version 4
+; 
+; More configuration variables are marked as user options.
+; 
+; Code is included for an improved version of make-auto-save-file-name
+; which eliminates many problems with the default version.  See the
+; documentation of emerge-make-auto-save-file-name to see how to
+; activate it.
+; 
+; Emerge now works with Gnu diff3, which can produce the groups of lines
+; from the various files in the order 1, 2, 3 or 1, 3, 2.
+; 
+; Added x f command to show what files or buffers are being operated on.
+; 
+; The merge buffer now starts read-only, which being in fast mode it
+; should be.
+; 
+; When merging buffers, Emerge writes their contents into temporary
+; files in the directory $TMPDIR (if it is defined), or /tmp by default.
+; 
+; Added x j command to join two differences.
+; 
+; Added x s command to split a difference into two differences.
+; 
+; Added emerge-version variable and function to report the version of Emerge
+; being run.
+; 
+; Added x t command to trim unchanged lines off top and bottom of
+; difference region.
+; 
+; Added x d, x a, and x b commands to locate the differences at or near
+; a given location in one of the buffers.
+; 
+; Emerge no longer tries to copy the minor modes from the A buffer to
+; the merge buffer, only the major mode.
+; 
+; The programs executed to find the differences between versions of the file
+; are no longer controlled by emerge-diff/diff3-command, but rather by:
+;   emerge-diff-program       
+;     Variable: *Name of the program which compares two files.
+;   emerge-diff3-program              
+;     Variable: *Name of the program which compares an ancestor file
+;     (first argument) and two variant files (second and third arguments).
+;   emerge-diff-options       
+;     Variable: *Options to be passed to emerge-diff/diff3-program.
+; 
+; The names of the files are expanded (see expand-file-name) before being
+; passed to emerge-diff/diff3-program, so diff need not invoked under a shell
+; that understands '~', for instance.
+; 
+; If the diff/diff3 program reports errors, the user is notified and the
+; errors are displayed.
+; 
+; The command "0j" can be used to suppress the flags from showing in the buffers.
+; 
+; A discussion of the effect of the merge flags on indentation of code
+; has been added to the documentation.
+; 
+; If kill-fix.el is loaded, Emerge control variables new have their
+; 'preserved' property set, so setting the major mode in the merge
+; buffer doesn't destroy Emerge's state.
+; 
+; Added x c, x C, and x x commands to allow the A and B versions to be
+; combined into #ifdef - #endif forms.
+; 
+; Replaced calls of "ding" to calls of "error" where appropriate.
+; 
+; Added x m command to allow major mode of merge buffer to be changed.
+; 
+; Added x 1 command to shrink the merge window to one line.
+; 
+; Added emerge-startup-hooks to allow customization.
+; 
+; Fixed a bug that is activated when a remote merge request is made when
+; the minibuffer window is selected.
+; 
+; - Changes from version 2 to version 3
+; 
+; The directory into which temporary files are written is now controlled
+; by a user option (emerge-temp-file-prefix).
+; 
+; The A and B versions of the difference can be loaded into the kill
+; ring with the "c a" and "c b" commands.
+; 
+; The A and B versions of the difference can be inserted into the merge
+; buffer with the "i a" and "i b" commands.
+; 
+; The difference region of the merge buffer can be surrounded by the
+; point and mark with the "m" command.
+; 
+; The three windows can be scrolled together with the "^", "v", "<",
+; ">", and "|" commands.
+; 
+; The "s s" and "s a" commands report the state of the option in the
+; echo area.  Similarly, the "f" and "e" commands report what they do in
+; the echo area.
+; 
+; The "q" command has been revamped, and its behavior is now controlled
+; by the manner in which Emerge is started.  In particular, if you wish
+; to write the merge buffer into a file upon exiting, invoke
+; emerge-files[-with-ancestor] with a prefix argument, and it will
+; prompt you for the file name.  Then exiting will write the merge
+; buffer to the file, unless "q" is given a prefix argument.
+; 
+; The "i a" and "i b" commands now work in fast mode.
+; 
+; The modifications that Emerge makes to save-buffer and write-file are
+; described.
+; 
+; Emerge now handles merging narrowed buffers correctly.
+; 
+; Emerge now isn't fooled when the buffer visiting a file is not the
+; same as the file on disk.
+; 
+; - Starting
+; 
+; To start Emerge, you must run one of four commands:
+; 
+;       emerge-files
+;       emerge-files-with-ancestor
+;       emerge-buffers
+;       emerge-buffers-with-ancestor
+; 
+; The "files" versions prompt you for two file names (the "A" and "B"
+; files), the "buffers" versions prompt you for two buffer names (the
+; "A" and "B" buffers).  Emerge then runs a "diff" of the two entities
+; (emerge-buffers writes the buffers into temporary files for input to
+; diff) and digests the output to form a list of the differences between
+; the two files.  Then three buffers are set up: two containing the
+; entities (emerge-files does a find-file (C-x C-f) on the files to get
+; them into buffers), and one, the "merge buffer", which contains the
+; working copy of the merged file that you are constructing.  The three
+; buffers are put up in a nice three-window display, showing the A and B
+; buffers in the upper half and the merge buffer in the lower half.
+; 
+; The versions of the command that say "with-ancestor" ask for a third
+; name, that of an entity which is a common ancestor from which the
+; versions being merged were derived.  These commands use "diff3" to
+; compare all three versions.  If one version of a difference agrees
+; with the ancestor, then it is presumed that the other version is the
+; "correct" version, and is said to be "preferred".
+; 
+; (Note that if you use emerge-files, Emerge attempts to make sure that
+; file on disk and the file in the buffer are the same.  If the file on
+; disk has been changed, Emerge offers to revert the buffer.  If the
+; buffer has been modified, Emerge offers to save the buffer.  If the
+; user declines the offer, or if the file on disk and the buffer have
+; both been modified, Emerge aborts with an error message.  Emerge is
+; careful to widen the buffers containing the files if they have been
+; narrowed.  If you use emerge-buffers, the buffers are not widened --
+; only the visible portion is used.)
+; 
+; During the merge, the A and B buffers are read-only, so you don't
+; damage them.  (This is because the A and B versions of the differences
+; are extracted from these buffers.)  When you quit the merge, the
+; read-only/read-write status and modified flag on the A and B buffers
+; are restored.  In addition, auto-saving of the A and B buffers is
+; suppressed during the merge.  This is because Emerge modifies the A
+; and B buffers to point out the text of the differences, and it would
+; be useless to save these changes.  (Just before suppressing
+; auto-saving, Emerge forces an auto-save.)
+; 
+; If you give a prefix argument to emerge-files or
+; emerge-files-with-ancestor, it prompts you for another file name,
+; which is the file into which the merged file is to be written when you
+; exit Emerge.  The output file name defaults to the A file name.  If
+; you successfully quit Emerge, the merge buffer will be written to the
+; output file, and the buffers for the A, B, and ancestor buffers will
+; be deleted (if they exist and are not modified).  If you abort Emerge,
+; the merge buffer will not be written and the buffers will not be
+; deleted.
+; 
+; You can have any number of merges going at once -- just don't use any
+; one buffer as input to more than one merge at once, since that will
+; cause the read-only/modified/auto-save status save-and-restore to
+; screw up.
+; 
+; Beware that when Emerge starts up, it does a diff or diff3 of the
+; files, which can take many minutes for long files with many
+; differences.  Emacs can't do anything else until diff finishes.
+; 
+; If diff or diff3 produces error messages, Emerge will beep and display
+; the error messages instead of the merge buffer.  There will be a
+; message in the echo area giving the name of the merge buffer.  Note
+; that this is really just an informational message -- you still have
+; switch to the merge buffer and abort the merge to restore the
+; conditions before you ran Emerge.  (Emerge considers any output line
+; that does not match the regexp emerge-diff/diff3-ok-lines to be an
+; error message.)
+; 
+; After the merge has been set up, Emerge runs the hooks in
+; emerge-startup-hooks.
+; 
+; - Merging
+; 
+; Once you have started the merge, you manipulate the merge buffer with
+; special commands issued in the merge buffer.  You may also edit the
+; buffer with ordinary Emacs commands.  Emerge keeps track of each
+; difference between the A and B buffers and the corresponding section
+; of the merge buffer.  Initially, all differences show the A version,
+; except those for which B is preferred (because A agrees with the
+; ancestor), which show the B version.  Emerge always has its attention
+; focused on one particular difference, which is marked off in the three
+; buffers by "vvvvvvvvvvvvvvvvvvvv" above and "^^^^^^^^^^^^^^^^^^^^"
+; below.  The number of the difference is shown in the mode line.
+; 
+; A merge buffer can be in two modes: "fast" mode and "edit" mode.  In
+; fast mode, emerge commands are single characters, and ordinary Emacs
+; commands are disabled.  This makes Emerge operations fast, but
+; prevents you from doing more than selecing the A or the B version of
+; differences.  In edit mode, all emerge commands must be prefixed with
+; C-c, and all (non-conflicting) Emacs commands are available.  This
+; allows editing the merge buffer, but slows down Emerge operations.
+; Edit and fast modes are indicated by "F" and "E" in the minor modes in
+; the mode line.
+; 
+; The Emerge commands are:
+; 
+;       p       go to the previous difference
+;       n       go to the next difference
+;       a       select the A version of this difference
+;       b       select the B version of this difference
+;       j       go to a particular difference (prefix argument
+;               specifies which difference) (0j suppresses display of
+;               the flags)
+;       q       quit - finish the merge*
+;       f       go into fast mode
+;       e       go into edit mode
+;       s a     set/clear auto-advance mode*
+;       s s     set/clear skip-prefers mode*
+;       l       recenter (C-l) all three windows*
+;       - and 0 through 9
+;               prefix numeric arguments
+;       d a     select the A version as the default from here down in
+;               the merge buffer*
+;       d b     select the B version as the default from here down in
+;               the merge buffer*
+;       c a     copy the A version of the difference into the kill
+;               ring
+;       c b     copy the B version of the difference into the kill
+;               ring
+;       i a     insert the A version of the difference at the point
+;       i b     insert the B version of the difference at the point
+;       m       put the point and mark around the difference region
+;       ^       scroll-down (like M-v) the three windows*
+;       v       scroll-up (like C-v) the three windows*
+;       <       scroll-left (like C-x <) the three windows*
+;       >       scroll-right (like C-x >) the three windows*
+;       |       reset horizontal scroll on the three windows*
+;       x 1     shrink the merge window to one line (use C-u l to restore it
+;               to full size)
+;       x a     find the difference containing a location in the A buffer*
+;       x b     find the difference containing a location in the B buffer*
+;       x c     combine the two versions of this difference*
+;       x C     combine the two versions of this difference, using a
+;               register's value as the template*
+;       x d     find the difference containing a location in the merge buffer*
+;       x f     show the files/buffers Emerge is operating on in Help window
+;               (use C-u l to restore windows)
+;       x j     join this difference with the following one
+;               (C-u x j joins this difference with the previous one)
+;       x l     show line numbers of points in A, B, and merge buffers
+;       x m     change major mode of merge buffer*
+;       x s     split this difference into two differences
+;               (first position the point in all three buffers to the places
+;               to split the difference)
+;       x t     trim identical lines off top and bottom of difference
+;               (such lines occur when the A and B versions are
+;               identical but differ from the ancestor version)
+;       x x     set the template for the x c command*
+; 
+; * - more details on these commands are given below
+; 
+; emerge-version is a variable giving the version number of Emerge.  It
+; is also a function which displays emerge-version (when called
+; interactively) or returns it (when called from a program).
+; 
+; - Differences and their states
+; 
+; A difference can have one of seven states:
+; 
+; A:  the difference is showing the A version.
+; 
+; B:  the difference is showing the B version.
+; 
+; default-A and default-B: the difference is showing the A or B state,
+; but has never been selected by the user.  All differences start in the
+; default-A state (and thus the merge buffer is a copy of the A buffer),
+; except those for which one buffer or another is preferred.  When the
+; user selects the difference, it changes to the A or B state.
+; 
+; prefer-A and prefer-B: the difference is showing the A or B state.  In
+; addition, the other buffer (that is, for prefer-A, the B buffer; for
+; prefer-B, the A buffer) agrees with the ancestor buffer.  Thus,
+; presumably, the displayed version is the correct one.  The "a" and "b"
+; commands override these states, and turn them into the A and B states.
+; 
+; combined: the difference is showing a combination of the A and B
+; states that was constructed by the "x c" or "x C" commands.  Since
+; this state is neither the A or B states, the "a" and "b" commands
+; won't alter the difference unless they are given a prefix argument.
+; 
+; The state of the currently selected difference is shown in the mode
+; line of the merge window:
+; 
+;       state           display
+; 
+;       A               A
+;       B               B
+;       prefer-A        A*
+;       prefer-B        B*
+;       combined        comb
+; 
+; - Select default commands (d a and d b)
+; 
+; The d a and d b commands change all default-A's to default-B's (or
+; vice-versa) from the selected difference on down to the end of the
+; file to default-A or default-B, respectively.  (Since a difference
+; that has been selected can not have state default-A or default-B, it
+; will never be affected by d a or d b.  This leads to the unexpected
+; result that d a or d b never affects the difference selected at the
+; moment, but prevents differences that you have already looked at from
+; changing unexpectedly.)
+; 
+; If you work your way down from the top of the file, using d a and d b
+; at judicious points, you can effectivly make the A version the default
+; for some sections of the merge buffer and the B version the default
+; for others.
+; 
+; - Exiting (q)
+; 
+; The quit command finishes the merge session by restoring the state of
+; the A and B buffers and removing the markers around the currently
+; selected difference.  It also disables the Emerge commands in the
+; merge buffer, since executing them later could damage the contents of
+; the various buffers.
+; 
+; The action of "q" depends on how Emerge was started and whether "q"
+; was given a prefix argument.  If there was no prefix argument, it is
+; considered a "successful" finish.  If there was a prefix argument, it
+; is considered an "unsuccessful" finish.  In either case, you are asked
+; to cofirm the exit, and the confirmation message tells which sort of
+; exit you are confirming.
+; 
+; If Emerge was started by some other process, success/failure is
+; reported to the caller.
+; 
+; If Emerge was started with emerge-files or emerge-files-with-ancestor,
+; if a prefix argument was given to that command, then you specified a
+; file into which the merge is to be written.  A successful exit writes
+; the merge into the output file and then kills the A, B, and ancestor
+; buffers (so they aren't lying around to confuse you, since they
+; probably all have similar names).
+; 
+; - Auto-advance mode (s a)
+; 
+; If auto-advance mode is set, the "a" and "b" commands perform an "n"
+; (select next difference) afterward.  When auto-advance mode is set,
+; it is indicated by "A" in the minor modes in the mode line.
+; "s a" with a positive argument sets auto-advance, with a non-positive
+; argument clears it, and with no argument toggles it.
+; 
+; - Skip-prefers mode (s s)
+; 
+; If skip-prefers mode is set, the "n" and "p" commands skip over
+; differences with states prefer-A and prefer-B.  Thus you will only see
+; differences for which one version isn't presumed "correct".  When
+; skip-prefers mode is set, it is indicated by "S" in the minor modes in
+; the mode line.  "s s" with a positive argument sets auto-advance, with
+; a non-positive argument clears it, and with no argument toggles it.
+; 
+; - Recenter (l)
+; 
+; The Emerge "l" command causes the selected difference to be brought
+; into view in the three windows, or at least, whichever of the three
+; merge buffers are visible at the moment.  If a prefix argument is
+; given, then the original three-window display is set up before the
+; difference texts are shown.
+; 
+; - Scrolling the text (^, v, <, >, and |)
+; 
+; Emerge has several commands which scroll all three windows by the same
+; amount, thus allowing you to easily compare the versions of the text.
+; The commands are "^" (scroll-up), "v" (scroll-down), "<"
+; (scroll-left), ">" (scroll-right), and "|" (reset horizontal
+; scrolling).  (Remember that Emacs names scrolling commands by the
+; motion of the text with respect to the window, so C-v is called
+; "scroll-up".)
+; 
+; If these commands (except "|") are given an argument, that is the
+; number of lines or characters by which the windows are scrolled.
+; Otherwise, the amount of motion is computed based on the dimensions of
+; the merge buffer window -- the height of the merge buffer window
+; (minus next-screen-context-lines), or half the width of the merge
+; buffer window.  (The A and B version windows are assumed to be as high
+; as the merge window, but half as wide.)  If the argument is just `C-u
+; -', then the scrolling is half the default amount.
+; 
+; - Finding the difference at or near a location (x d, x a, and x b)
+; 
+; The "x d" command selects the difference containing the current point
+; in the merge buffer.  If there is no difference containing the point,
+; an error is given.  An argument can be given to the command to change
+; this behavior: if the argument is positive (e.g., C-u), the next
+; following difference is selected; if the argument is negative (e.g.,
+; C-u -), the previous difference is selected.
+; 
+; The "x a" and "x b" commands select the difference containing the
+; current point in the A and B buffers, respectively.  Otherwise, they
+; act like the "x d" command.  Note that although the point used in the
+; commands is not the merge buffer point, the commands can only be
+; issued in the merge buffer, because it is the only buffer with the
+; Emerge keymap.
+; 
+; - Combining the two versions (x c, x C, and x x)
+; 
+; Sometimes one wants to combine the two versions of a difference.  For
+; instance, when merging two versions of a program, one wants to make
+; something like this:
+; 
+;       #ifdef NEW
+;               ...new version of code...
+;       #else /* NEW */
+;               ...old version of code...
+;       #endif /* NEW */
+; 
+; The "x c" command will make such a combined version.  (Note that any
+; combined version is not the same as either the A or B versions, and so
+; the "a" and "b" commands will refuse to alter it unless they are given
+; a prefix argument.)  The combination is made under control of a
+; template, which is a character string with the following
+; interpolations:
+; 
+;       %a      the A version of the difference
+;       %b      the B version of the difference
+;       %%      the character '%'
+; 
+; Thus, the template used above is 
+; 
+;       #ifdef NEW\n%b#else /* NEW */\n%a#endif /* NEW */\n
+; 
+; (using \n here to represent newlines).  The template is stored in the
+; variable emerge-combine-versions-template, and its initial value is
+; the one given above.  The template can be set (from the current
+; region) by the "x x" command.  (Be careful to get the newlines in the
+; template in the right places!)  ("x x" was chosen by analogy with "C-x
+; x".)  ("x x" is only available in the merge buffer, of course.
+; Elsewhere, M-x emerge-set-combine-versions-template can be used.)  If
+; "x x" is given a prefix argument, emerge-combine-versions-template is
+; localized in the merge buffer before its value is set, so the "x x"
+; command's effect (and the effect of any later "x x" command in the
+; merge buffer) is only on the merge buffer.
+; 
+; The "x C" command is like "x c", but it prompts for a character
+; which is the register whose value is to be used as the template.
+; This allows one to use multiple templates conveniently.
+; 
+; - Changing the major mode of the edit buffer (x m)
+; 
+; The "x m" command prompts for the name of a major-mode-setting command
+; and executes it.  Ordinarily, major-mode-setting commands change the
+; mode line and local keymap, so the "x m" command then resets the
+; Emerge mode line and the fast or edit mode local keymap, as
+; appropriate.
+; 
+; If you have already changed the major mode of the merge buffer and
+; lost the Emerge keymap, you can use M-x emerge-set-merge-mode to
+; execute this command.
+; 
+; Beware that "x m" accepts any command name, not just
+; major-mode-setting commands.
+; 
+; - Writing the merge buffer manually
+; 
+; Emerge places a wrapper (emerge-query-and-call) on the key bindings of
+; save-buffer (usually "C-x C-s") and write-file (usually "C-x C-w"), in
+; order to protect the user from writing out the merge before it is
+; finished.  Emerge-query-and-call asks the user if he is sure he wants
+; to write out the incomplete merge.  If he answers yes, the buffer is
+; written out.  The flags are suppressed while the write is being done.
+; As a result of this, the displayed portions of the buffers are
+; recentered (equivalent to "l").
+; 
+; - Running Emerge standalone
+; 
+; If you invoke emacs with the following arguments, you can execute
+; Emerge as a standalone program:
+; 
+;       emacs -l emerge -f emerge-files-command file-a file-b file-out
+; 
+;       emacs -l emerge -f emerge-files-with-ancestor-command
+;               file-a file-b file-ancestor file-out
+; 
+; When the user gives the "q" (quit) command, Emerge will write out the
+; merge buffer in file-out and terminate Emacs.  If a prefix argument is
+; given, Emacs will terminate with an unsuccessful return code (1), if
+; not, it will terminate with a successful return code (0).
+; 
+; - Invoking Emerge remotely
+; 
+; If you use the Emacs client/server code that supports remote
+; execution, then you can invoke Emerge remotely by executing one of the
+; Lisp calls:
+; 
+;       (emerge-files-remote "file A" "file B" "output file")
+; 
+;       (emerge-files-with-ancestor-remote "file A" "file B"
+;               "ancestor file" "output file")
+; 
+; Returning a successful/unsuccessful return code is not yet supported
+; by the Emacs client/server code.
+; 
+; Beware that in systems of networked workstations, even though all user
+; directories are shared between all the workstations, the /tmp
+; directory on each workstation is not shared, so writing files into
+; /tmp and then remotely invoking Emerge is not likely to work.
+; 
+; - Effect of merge flags on indenting code
+; 
+; The presence of the flags confuses the indentation code of C and
+; Emacs-Lisp modes.  Starting the flag strings
+; (emerge-{before,after}-flag) with '#' (for C) or ';' (for Lisp)
+; prevents the indentation code from noticing the flags.  Remember to
+; change the flag strings before loading Emerge, or to execute
+; emerge-new-flags after changing them.  But never change the flag
+; strings while a merge is being performed.
+; 
+; - Autoloading
+; 
+; The following autoloads will make all top-level Emerge files
+; autoloading.  Make sure that "emerge" is in a directory on load-path.
+; 
+; (autoload 'emerge-files "emerge"
+;         "Run Emerge on two files."
+;         t)
+; (autoload 'emerge-files-with-ancestor "emerge"
+;         "Run Emerge on two files, giving another file as the ancestor."
+;         t)
+; (autoload 'emerge-buffers "emerge"
+;         "Run Emerge on two buffers."
+;         t)
+; (autoload 'emerge-buffers-with-ancestor "emerge"
+;         "Run Emerge on two buffers, giving another buffer as the ancestor."
+;         t)
+; (autoload 'emerge-files-command "emerge")
+; (autoload 'emerge-files-with-ancestor-command "emerge")
+; (autoload 'emerge-files-remote "emerge")
+; (autoload 'emerge-files-with-ancestor-remote "emerge")
+; 
+; ================================================================
+
+;; Declare that we've got the subsystem loaded
+;; LCD Archive Entry:
+;; emerge|Dale R. Worley|drw@math.mit.edu
+;; |File merge
+;; |91-12-13|version 4|~/packages/emerge.el.Z
+
+;;; Macros
+
+(defmacro emerge-eval-in-buffer (buffer &rest forms)
+  "Macro to switch to BUFFER, evaluate FORMS, returns to original buffer.
+Differs from  save-excursion  in that it doesn't save the point and mark."
+  (` (let ((StartBuffer (current-buffer)))
+    (unwind-protect
+        (progn
+          (set-buffer (, buffer))
+          (,@ forms))
+      (set-buffer StartBuffer)))))
+
+(defmacro emerge-defvar-local (var value doc) 
+  "Defines SYMBOL as an advertised variable.  Performs a defvar, then
+executes make-variable-buffer-local on the variable.  Also sets the
+'preserved' property, so that kill-all-local-variables (called by major-mode
+setting commands) won't destroy Emerge control variables."
+  (` (progn
+       (defvar (, var) (, value) (, doc))
+       (make-variable-buffer-local '(, var))
+       (put '(, var) 'preserved t))))
+
+;; Add entries to minor-mode-alist so that emerge modes show correctly
+(setq emerge-minor-modes-list '((emerge-mode " Emerge")
+                                (emerge-fast-mode " F")
+                                (emerge-edit-mode " E")
+                                (emerge-auto-advance " A")
+                                (emerge-skip-prefers " S")))
+(if (not (assq 'emerge-mode minor-mode-alist))
+    (setq minor-mode-alist (append emerge-minor-modes-list
+                                   minor-mode-alist)))
+
+;; We need to define this function so describe-mode can describe Emerge mode.
+(defun emerge-mode ()
+  "Emerge mode is used by the Emerge file-merging package.  It is entered only
+through one of the functions:
+        emerge-files
+        emerge-files-with-ancestor
+        emerge-buffers
+        emerge-buffers-with-ancestor
+        emerge-files-command
+        emerge-files-with-ancestor-command
+        emerge-files-remote
+        emerge-files-with-ancestor-remote
+
+Commands:
+\\{emerge-basic-keymap}
+Commands must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in 'edit' mode, but can be invoked directly
+in 'fast' mode.")
+
+(defvar emerge-version "4"
+  "The version of Emerge.")
+
+(defun emerge-version ()
+  "Return string describing the version of Emerge.  When called interactively,
+displays the version."
+  (interactive)
+  (if (interactive-p)
+      (message "Emerge version %s" (emerge-version))
+    emerge-version))
+
+;;; Emerge configuration variables
+
+;; Commands that produce difference files
+;; All that can be configured is the name of the programs to execute
+;; (emerge-diff-program and emerge-diff3-program) and the options
+;; to be provided (emerge-diff-options).  The order in which the file names
+;; are given is fixed.
+;; The file names are always expanded (see expand-file-name) before being
+;; passed to diff, thus they need not be invoked under a shell that 
+;; understands '~'.
+;; The code which processes the diff/diff3 output depends on all the
+;; finicky details of their output, including the somewhat strange
+;; way they number lines of a file.
+(defvar emerge-diff-program "diff"
+  "*Name of the program which compares two files.")
+(defvar emerge-diff3-program "diff3"
+  "*Name of the program which compares an ancestor file (first argument)
+and two variant files (second and third arguments).")
+(defvar emerge-diff-options ""
+  "*Options to be passed to emerge-diff/diff3-program.")
+(defvar emerge-match-diff-line (let ((x "\\([0-9]+\\)\\(\\|,\\([0-9]+\\)\\)"))
+                                 (concat "^" x "\\([acd]\\)" x "$"))
+  "*Pattern to match lines produced by diff that describe differences (as
+opposed to lines from the source files).")
+(defvar emerge-diff-ok-lines
+  "^\\([0-9,]+[acd][0-9,]+$\\|[<>] \\|---\\)"
+  "*Regexp that matches normal output lines from  emerge-diff-program .
+Lines that do not match are assumed to be error output.")
+(defvar emerge-diff3-ok-lines
+  "^\\([1-3]:\\|====\\|  \\)"
+  "*Regexp that matches normal output lines from  emerge-diff3-program .
+Lines that do not match are assumed to be error output.")
+
+;; The flags used to mark differences in the buffers.
+
+;; These function definitions need to be up here, because they are used
+;; during loading.
+(defun emerge-new-flags ()
+  "Function to be called after emerge-{before,after}-flag are changed to
+compute values that depend on the flags."
+  (setq emerge-before-flag-length (length emerge-before-flag))
+  (setq emerge-before-flag-lines
+        (count-matches-string emerge-before-flag "\n"))
+  (setq emerge-before-flag-match (regexp-quote emerge-before-flag))
+  (setq emerge-after-flag-length (length emerge-after-flag))
+  (setq emerge-after-flag-lines
+        (count-matches-string emerge-after-flag "\n"))
+  (setq emerge-after-flag-match (regexp-quote emerge-after-flag)))
+(defun count-matches-string (string regexp)
+  "Return the number of matches in STRING for REGEXP."
+  (let ((i 0)
+        (count 0))
+    (while (string-match regexp string i)
+      (setq count (1+ count))
+      (setq i (match-end 0)))
+    count))
+
+(defvar emerge-before-flag "vvvvvvvvvvvvvvvvvvvv\n"
+  "*Flag placed above the highlighted block of code.  Must end with newline.
+Must be set before Emerge is loaded, or  emerge-new-flags  must be run
+after setting.")
+(defvar emerge-after-flag "^^^^^^^^^^^^^^^^^^^^\n"
+  "*Flag placed below the highlighted block of code.  Must end with newline.
+Must be set before Emerge is loaded, or  emerge-new-flags  must be run
+after setting.")
+
+;; Calculate dependent variables
+(emerge-new-flags)
+
+(defvar emerge-min-visible-lines 3
+  "*Number of lines that we want to show above and below the flags when we are
+displaying a difference.")
+
+(defvar emerge-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 "/emerge"))
+  "*Prefix to put on Emerge temporary file names.
+Do not start with '~/' or '~user-name/'.")
+
+(defvar emerge-temp-file-mode 384       ; u=rw only
+  "*Mode for Emerge temporary files.")
+
+(defvar emerge-combine-versions-template
+  "#ifdef NEW\n%b#else /* NEW */\n%a#endif /* NEW */\n"
+  "*Template for  emerge-combine-versions  to combine the two versions.
+The template is inserted as a string, with the following interpolations:
+        %a      the A version of the difference
+        %b      the B version of the difference
+        %%      the character '%'
+Don't forget to end the template with a newline.
+Note that this variable can be made local to a particular merge buffer by
+giving a prefix argument to  emerge-set-combine-versions-template .")
+
+;; Build keymaps
+
+(defvar emerge-basic-keymap nil
+  "Keymap of Emerge commands.
+Directly available in 'fast' mode;
+must be prefixed by \\<emerge-fast-keymap>\\[emerge-basic-keymap] in 'edit' mode.")
+
+(defvar emerge-fast-keymap nil
+  "Local keymap used in Emerge 'fast' mode.
+Makes Emerge commands directly available.")
+
+(defvar emerge-command-prefix "\C-c"
+  "*Command prefix for Emerge commands in 'edit' mode.
+Must be set before Emerge is loaded.")
+
+;; This function sets up the fixed keymaps.  It is executed when the first
+;; Emerge is done to allow the user maximum time to set up the global keymap.
+(defun emerge-setup-fixed-keymaps ()
+  ;; Set up the basic keymap
+  (setq emerge-basic-keymap (make-keymap))
+  (suppress-keymap emerge-basic-keymap) ; this sets 0..9 to digit-argument and
+                                        ; - to negative-argument
+  (define-key emerge-basic-keymap "p" 'emerge-previous-difference)
+  (define-key emerge-basic-keymap "n" 'emerge-next-difference)
+  (define-key emerge-basic-keymap "a" 'emerge-select-A)
+  (define-key emerge-basic-keymap "b" 'emerge-select-B)
+  (define-key emerge-basic-keymap "j" 'emerge-jump-to-difference)
+  (define-key emerge-basic-keymap "q" 'emerge-quit)
+  (define-key emerge-basic-keymap "f" 'emerge-fast-mode)
+  (define-key emerge-basic-keymap "e" 'emerge-edit-mode)
+  (define-key emerge-basic-keymap "s" nil)
+  (define-key emerge-basic-keymap "sa" 'emerge-auto-advance)
+  (define-key emerge-basic-keymap "ss" 'emerge-skip-prefers)
+  (define-key emerge-basic-keymap "l" 'emerge-recenter)
+  (define-key emerge-basic-keymap "d" nil)
+  (define-key emerge-basic-keymap "da" 'emerge-default-A)
+  (define-key emerge-basic-keymap "db" 'emerge-default-B)
+  (define-key emerge-basic-keymap "c" nil)
+  (define-key emerge-basic-keymap "ca" 'emerge-copy-as-kill-A)
+  (define-key emerge-basic-keymap "cb" 'emerge-copy-as-kill-B)
+  (define-key emerge-basic-keymap "i" nil)
+  (define-key emerge-basic-keymap "ia" 'emerge-insert-A)
+  (define-key emerge-basic-keymap "ib" 'emerge-insert-B)
+  (define-key emerge-basic-keymap "m" 'emerge-mark-difference)
+  (define-key emerge-basic-keymap "v" 'emerge-scroll-up)
+  (define-key emerge-basic-keymap "^" 'emerge-scroll-down)
+  (define-key emerge-basic-keymap "<" 'emerge-scroll-left)
+  (define-key emerge-basic-keymap ">" 'emerge-scroll-right)
+  (define-key emerge-basic-keymap "|" 'emerge-scroll-reset)
+  (define-key emerge-basic-keymap "x" nil)
+  (define-key emerge-basic-keymap "x1" 'emerge-one-line-window)
+  (define-key emerge-basic-keymap "xa" 'emerge-find-difference-A)
+  (define-key emerge-basic-keymap "xb" 'emerge-find-difference-B)
+  (define-key emerge-basic-keymap "xc" 'emerge-combine-versions)
+  (define-key emerge-basic-keymap "xC" 'emerge-combine-versions-register)
+  (define-key emerge-basic-keymap "xd" 'emerge-find-difference)
+  (define-key emerge-basic-keymap "xf" 'emerge-file-names)
+  (define-key emerge-basic-keymap "xj" 'emerge-join-differences)
+  (define-key emerge-basic-keymap "xl" 'emerge-line-numbers)
+  (define-key emerge-basic-keymap "xm" 'emerge-set-merge-mode)
+  (define-key emerge-basic-keymap "xs" 'emerge-split-difference)
+  (define-key emerge-basic-keymap "xt" 'emerge-trim-difference)
+  (define-key emerge-basic-keymap "xx" 'emerge-set-combine-versions-template)
+  ;; Allow emerge-basic-keymap to be referenced indirectly
+  (fset 'emerge-basic-keymap emerge-basic-keymap)
+  ;; Set up the fast mode keymap
+  (setq emerge-fast-keymap (copy-keymap emerge-basic-keymap))
+  ;; Allow prefixed commands to work in fast mode
+  (define-key emerge-fast-keymap emerge-command-prefix 'emerge-basic-keymap)
+  ;; Allow emerge-fast-keymap to be referenced indirectly
+  (fset 'emerge-fast-keymap emerge-fast-keymap)
+  ;; Suppress write-file and save-buffer
+  (emerge-shadow-key-definition 'write-file 'emerge-query-write-file
+                                (current-global-map) emerge-fast-keymap)
+  (emerge-shadow-key-definition 'save-buffer 'emerge-query-save-buffer
+                                (current-global-map) emerge-fast-keymap))
+
+;; Variables which control each merge.  They are local to the merge buffer.
+
+;; Mode variables
+(emerge-defvar-local emerge-mode nil
+  "Indicator for emerge-mode.")
+(emerge-defvar-local emerge-fast-mode nil
+  "Indicator for emerge-mode fast submode.")
+(emerge-defvar-local emerge-edit-mode nil
+  "Indicator for emerge-mode edit submode.")
+(emerge-defvar-local emerge-A-buffer nil
+  "The buffer in which the A variant is stored.")
+(emerge-defvar-local emerge-B-buffer nil
+  "The buffer in which the B variant is stored.")
+(emerge-defvar-local emerge-merge-buffer nil
+  "The buffer in which the merged file is manipulated.")
+(emerge-defvar-local emerge-ancestor-buffer nil
+  "The buffer in which the ancestor variant is stored,
+or nil if there is none.")
+
+(defconst emerge-saved-variables
+  '((buffer-modified-p set-buffer-modified-p)
+    buffer-read-only
+    buffer-auto-save-file-name)
+  "Variables and properties of a buffer which are saved, modified and restored
+during a merge.")
+(defconst emerge-merging-values '(nil t nil)
+  "Values to be assigned to emerge-saved-variables during a merge.")
+
+(emerge-defvar-local emerge-A-buffer-values nil
+  "Remembers emerge-saved-variables for emerge-A-buffer.")
+(emerge-defvar-local emerge-B-buffer-values nil
+  "Remembers emerge-saved-variables for emerge-B-buffer.")
+
+(emerge-defvar-local emerge-difference-list nil
+  "Vector of differences between the variants, and markers in the buffers to
+show where they are.  Each difference is represented by a vector of seven
+elements.  The first two are markers to the beginning and end of the difference
+section in the A buffer, the second two are markers for the B buffer, the third
+two are markers for the merge buffer, and the last element is the \"state\" of
+that difference in the merge buffer.
+  A section of a buffer is described by two markers, one to the beginning of
+the first line of the section, and one to the beginning of the first line
+after the section.  (If the section is empty, both markers point to the same
+point.)  If the section is part of the selected difference, then the markers
+are moved into the flags, so the user can edit the section without disturbing
+the markers.
+  The \"states\" are:
+        A               the merge buffer currently contains the A variant
+        B               the merge buffer currently contains the B variant
+        default-A       the merge buffer contains the A variant by default,
+                        but this difference hasn't been selected yet, so
+                        change-default commands can alter it
+        default-B       the merge buffer contains the B variant by default,
+                        but this difference hasn't been selected yet, so
+                        change-default commands can alter it
+        prefer-A        in a three-file merge, the A variant is the prefered
+                        choice
+        prefer-B        in a three-file merge, the B variant is the prefered
+                        choice")
+(emerge-defvar-local emerge-current-difference -1
+  "The difference that is currently selected.")
+(emerge-defvar-local emerge-number-of-differences nil
+  "Number of differences found.")
+(emerge-defvar-local emerge-edit-keymap nil
+  "The local keymap for the merge buffer, with the emerge commands defined in
+it.  Used to save the local keymap during fast mode, when the local keymap is
+replaced by emerge-fast-keymap.")
+(emerge-defvar-local emerge-old-keymap nil
+  "The original local keymap for the merge buffer.")
+(emerge-defvar-local emerge-auto-advance nil
+  "*If non-nil, emerge-select-A and emerge-select-B automatically advance to
+the next difference.")
+(emerge-defvar-local emerge-skip-prefers nil
+  "*If non-nil, differences for which there is a preference are automatically
+skipped.")
+(emerge-defvar-local emerge-startup-hooks nil
+  "*Hooks to run in the merge buffer after the merge has been set up.")
+(emerge-defvar-local emerge-quit-hooks nil
+  "Hooks to run in the merge buffer after the merge has been finished.
+emerge-prefix-argument will be bound to the prefix argument of the emerge-quit
+command.
+This is  not  a user option, since Emerge uses it for its own processing.")
+(emerge-defvar-local emerge-output-description nil
+  "Describes output destination of the merge, for the use of
+emerge-file-names.")
+
+;;; Setup functions for two-file mode.
+
+(defun emerge-files-internal (file-A file-B &optional startup-hooks quit-hooks
+                                     output-file)
+  (let ((buffer-A (find-file-noselect file-A))
+        (buffer-B (find-file-noselect file-B)))
+    ;; Make sure the entire files are seen, and they reflect what is on disk
+    (emerge-eval-in-buffer buffer-A
+                           (widen)
+                           (emerge-verify-file-buffer))
+    (emerge-eval-in-buffer buffer-B
+                           (widen)
+                           (emerge-verify-file-buffer))
+    (emerge-setup buffer-A file-A buffer-B file-B startup-hooks quit-hooks
+                  output-file)))
+
+;; Start up Emerge on two files
+(defun emerge-setup (buffer-A file-A buffer-B file-B startup-hooks quit-hooks
+                              output-file)
+  (setq file-A (expand-file-name file-A))
+  (setq file-B (expand-file-name file-B))
+  (setq output-file (and output-file (expand-file-name output-file)))
+  (let* ((merge-buffer-name (emerge-unique-buffer-name "*merge" "*"))
+         ;; create the merge buffer from buffer A, so it inherits buffer A's
+         ;; default directory, etc.
+         (merge-buffer (emerge-eval-in-buffer
+                        buffer-A
+                        (get-buffer-create merge-buffer-name))))
+    (emerge-eval-in-buffer
+     merge-buffer
+     (emerge-copy-modes buffer-A)
+     (setq buffer-read-only nil)
+     (auto-save-mode 1)
+     (setq emerge-mode t)
+     (setq emerge-A-buffer buffer-A)
+     (setq emerge-B-buffer buffer-B)
+     (setq emerge-ancestor-buffer nil)
+     (setq emerge-merge-buffer merge-buffer)
+     (setq emerge-output-description
+           (if output-file
+               (concat "Output to file: " output-file)
+             (concat "Output to buffer: " (buffer-name merge-buffer))))
+     (insert-buffer emerge-A-buffer)
+     (emerge-set-keys)
+     (setq emerge-difference-list (emerge-make-diff-list file-A file-B))
+     (setq emerge-number-of-differences (length emerge-difference-list))
+     (setq emerge-current-difference -1)
+     (setq emerge-quit-hooks quit-hooks)
+     (emerge-remember-buffer-characteristics))
+    (emerge-setup-windows buffer-A buffer-B merge-buffer t)
+    (emerge-eval-in-buffer merge-buffer
+                           (run-hooks 'startup-hooks 'emerge-startup-hooks)
+                           (setq buffer-read-only t))))
+
+;; Generate the Emerge difference list between two files
+(defun emerge-make-diff-list (file-A file-B)
+  (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
+  (emerge-eval-in-buffer
+   emerge-diff-buffer
+   (erase-buffer)
+   (shell-command
+    (format "%s %s %s %s"
+            emerge-diff-program emerge-diff-options file-A file-B)
+    t))
+  (emerge-prepare-error-list emerge-diff-ok-lines)
+  (emerge-convert-diffs-to-markers
+   emerge-A-buffer emerge-B-buffer emerge-merge-buffer
+   (emerge-extract-diffs emerge-diff-buffer)))
+
+(defun emerge-extract-diffs (diff-buffer)
+  (let (list)
+    (emerge-eval-in-buffer
+     diff-buffer
+     (goto-char (point-min))
+     (while (re-search-forward emerge-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))))
+         ;; fix the beginning and end numbers, because diff is somewhat
+         ;; strange about how it numbers lines
+         (if (string-equal diff-type "a")
+             (progn
+               (setq b-end (1+ b-end))
+               (setq a-begin (1+ a-begin))
+               (setq a-end a-begin))
+           (if (string-equal diff-type "d")
+               (progn
+                 (setq a-end (1+ a-end))
+                 (setq b-begin (1+ b-begin))
+                 (setq b-end b-begin))
+             ;; (string-equal diff-type "c")
+             (progn
+               (setq a-end (1+ a-end))
+               (setq b-end (1+ b-end)))))
+         (setq list (cons (vector a-begin a-end
+                                  b-begin b-end
+                                  'default-A)
+                          list)))))
+    (nreverse list)))
+
+;; Set up buffer of diff/diff3 error messages.
+(defun emerge-prepare-error-list (ok-regexp)
+  (setq emerge-diff-error-buffer (get-buffer-create "*emerge-diff-errors*"))
+  (emerge-eval-in-buffer
+   emerge-diff-error-buffer
+   (erase-buffer)
+   (insert-buffer emerge-diff-buffer)
+   (delete-matching-lines ok-regexp)))
+
+;;; Top-level and setup functions for three-file mode.
+
+(defun emerge-files-with-ancestor-internal (file-A file-B file-ancestor
+                                          &optional startup-hooks quit-hooks
+                                          output-file)
+  (let ((buffer-A (find-file-noselect file-A))
+        (buffer-B (find-file-noselect file-B))
+        (buffer-ancestor (find-file-noselect file-ancestor)))
+    ;; Make sure the entire files are seen, and they reflect what is on disk
+    (emerge-eval-in-buffer buffer-A
+                           (widen)
+                           (emerge-verify-file-buffer))
+    (emerge-eval-in-buffer buffer-B
+                           (widen)
+                           (emerge-verify-file-buffer))
+    (emerge-eval-in-buffer buffer-ancestor
+                           (widen)
+                           (emerge-verify-file-buffer))
+    (emerge-setup-with-ancestor buffer-A file-A buffer-B file-B
+                                buffer-ancestor file-ancestor
+                                startup-hooks quit-hooks output-file)))
+
+;; Start up Emerge on two files with an ancestor
+(defun emerge-setup-with-ancestor (buffer-A file-A buffer-B file-B
+                                            buffer-ancestor file-ancestor
+                                            &optional startup-hooks quit-hooks
+                                            output-file)
+  (setq file-A (expand-file-name file-A))
+  (setq file-B (expand-file-name file-B))
+  (setq file-ancestor (expand-file-name file-ancestor))
+  (setq output-file (and output-file (expand-file-name output-file)))
+  (let* ((merge-buffer-name (emerge-unique-buffer-name "*merge" "*"))
+         ;; create the merge buffer from buffer A, so it inherits buffer A's
+         ;; default directory, etc.
+         (merge-buffer (emerge-eval-in-buffer
+                        buffer-A
+                        (get-buffer-create merge-buffer-name))))
+    (emerge-eval-in-buffer
+     merge-buffer
+     (emerge-copy-modes buffer-A)
+     (setq buffer-read-only nil)
+     (auto-save-mode 1)
+     (setq emerge-mode t)
+     (setq emerge-A-buffer buffer-A)
+     (setq emerge-B-buffer buffer-B)
+     (setq emerge-ancestor-buffer buffer-ancestor)
+     (setq emerge-merge-buffer merge-buffer)
+     (setq emerge-output-description
+           (if output-file
+               (concat "Output to file: " output-file)
+             (concat "Output to buffer: " (buffer-name merge-buffer))))
+     (insert-buffer emerge-A-buffer)
+     (emerge-set-keys)
+     (setq emerge-difference-list
+           (emerge-make-diff3-list file-A file-B file-ancestor))
+     (setq emerge-number-of-differences (length emerge-difference-list))
+     (setq emerge-current-difference -1)
+     (setq emerge-quit-hooks quit-hooks)
+     (emerge-remember-buffer-characteristics)
+     (emerge-select-prefer-Bs))
+    (emerge-setup-windows buffer-A buffer-B merge-buffer t)
+    (emerge-eval-in-buffer merge-buffer
+                           (run-hooks 'startup-hooks 'emerge-startup-hooks)
+                           (setq buffer-read-only t))))
+
+;; Generate the Emerge difference list between two files with an ancestor
+(defun emerge-make-diff3-list (file-A file-B file-ancestor)
+  (setq emerge-diff-buffer (get-buffer-create "*emerge-diff*"))
+  (emerge-eval-in-buffer
+   emerge-diff-buffer
+   (erase-buffer)
+   (shell-command
+    (format "%s %s %s %s %s"
+            emerge-diff3-program emerge-diff-options
+            file-ancestor file-A file-B)
+    t))
+  (emerge-prepare-error-list emerge-diff3-ok-lines)
+  (emerge-convert-diffs-to-markers
+   emerge-A-buffer emerge-B-buffer emerge-merge-buffer
+   (emerge-extract-diffs3 emerge-diff-buffer)))
+
+(defun emerge-extract-diffs3 (diff-buffer)
+  (let (list)
+    (emerge-eval-in-buffer
+     diff-buffer
+     (while (re-search-forward "^====\\(.?\\)$" nil t)
+       ;; leave point after matched line
+       (beginning-of-line 2)
+       (let ((agreement (buffer-substring (match-beginning 1) (match-end 1))))
+         ;; if the A and B files are the same, ignore the difference
+         (if (not (string-equal agreement "1"))
+             (setq list
+                   (cons 
+                    (let ((group-2 (emerge-get-diff3-group "2"))
+                          (group-3 (emerge-get-diff3-group "3")))
+                      (vector (car group-2) (car (cdr group-2))
+                              (car group-3) (car (cdr group-3))
+                              (cond ((string-equal agreement "2") 'prefer-A)
+                                    ((string-equal agreement "3") 'prefer-B)
+                                    (t 'default-A))))
+                    list))))))
+    (nreverse list)))
+
+(defun emerge-get-diff3-group (file)
+  ;; This save-excursion allows emerge-get-diff3-group to be called for the
+  ;; various groups of lines (1, 2, 3) in any order, and for the lines to
+  ;; appear in any order.  The reason this is necessary is that Gnu diff3
+  ;; can produce the groups in the order 1, 2, 3 or 1, 3, 2.
+  (save-excursion
+    (re-search-forward
+     (concat "^" file ":\\([0-9]+\\)\\(,\\([0-9]+\\)\\)?\\([ac]\\)$"))
+    (beginning-of-line 2)
+    ;; treatment depends on whether it is an "a" group or a "c" group
+    (if (string-equal (buffer-substring (match-beginning 4) (match-end 4)) "c")
+        ;; it is a "c" group
+        (if (match-beginning 2)
+            ;; it has two numbers
+            (list (string-to-int
+                   (buffer-substring (match-beginning 1) (match-end 1)))
+                  (1+ (string-to-int
+                       (buffer-substring (match-beginning 3) (match-end 3)))))
+          ;; it has one number
+          (let ((x (string-to-int
+                    (buffer-substring (match-beginning 1) (match-end 1)))))
+            (list x (1+ x))))
+      ;; it is an "a" group
+      (let ((x (1+ (string-to-int
+                    (buffer-substring (match-beginning 1) (match-end 1))))))
+        (list x x)))))
+
+;;; Functions to start Emerge on files
+
+(defun emerge-files (arg file-A file-B file-out &optional startup-hooks
+                     quit-hooks)
+  "Run Emerge on two files."
+  (interactive
+   (let (f)
+     (list current-prefix-arg
+           (setq f (read-file-name "File A to merge: " nil nil 'confirm))
+           (read-file-name "File B to merge: " nil nil 'confirm)
+           (and current-prefix-arg
+                (read-file-name
+                 (format "Output file: (default %s) " f)
+                 nil f nil)))))
+  (emerge-files-internal
+   file-A file-B startup-hooks
+   (if arg
+       (cons (` (lambda () (emerge-files-exit (, file-out))))
+             quit-hooks)
+     quit-hooks)
+   file-out))
+
+(defun emerge-files-with-ancestor (arg file-A file-B file-ancestor file-out
+                                   &optional startup-hooks quit-hooks)
+  "Run Emerge on two files, giving another file as the ancestor."
+  (interactive
+   (let (f)
+     (list current-prefix-arg
+           (setq f (read-file-name "File A to merge: " nil nil 'confirm))
+           (read-file-name "File B to merge: " nil nil 'confirm)
+           (read-file-name "Ancestor file: " nil nil 'confirm)
+           (and current-prefix-arg
+                (read-file-name
+                 (format "Output file: (default %s) " f)
+                 nil f nil)))))
+  (emerge-files-with-ancestor-internal
+   file-A file-B file-ancestor startup-hooks
+   (if arg
+       (cons (` (lambda () (emerge-files-exit (, file-out))))
+             quit-hooks)
+     quit-hooks)
+   file-out))
+
+;; Write the merge buffer out in place of the file the A buffer is visiting.
+(defun emerge-files-exit (file-out)
+  ;; if merge was successful was given, save to disk
+  (if (not emerge-prefix-argument)
+      (emerge-write-and-delete file-out)))
+
+;;; Functions to start Emerge on buffers
+
+(defun emerge-buffers (buffer-A buffer-B &optional startup-hooks quit-hooks)
+  "Run Emerge on two buffers."
+  (interactive "bBuffer A to merge: \nbBuffer B to merge: ")
+  (let ((emerge-file-A (emerge-make-temp-file "A"))
+        (emerge-file-B (emerge-make-temp-file "B")))
+    (emerge-eval-in-buffer
+     buffer-A
+     (write-region (point-min) (point-max) emerge-file-A nil 'no-message))
+    (emerge-eval-in-buffer
+     buffer-B
+     (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
+    (emerge-setup (get-buffer buffer-A) emerge-file-A
+                  (get-buffer buffer-B) emerge-file-B
+                  (cons (function (lambda ()
+                                    (delete-file emerge-file-A)
+                                    (delete-file emerge-file-B)))
+                        startup-hooks)
+                  quit-hooks
+                  nil)))
+
+(defun emerge-buffers-with-ancestor (buffer-A buffer-B buffer-ancestor
+                                              &optional startup-hooks
+                                              quit-hooks)
+  "Run Emerge on two buffers, giving another buffer as the ancestor."
+  (interactive
+   "bBuffer A to merge: \nbBuffer B to merge: \nbAncestor buffer: ")
+  (let ((emerge-file-A (emerge-make-temp-file "A"))
+        (emerge-file-B (emerge-make-temp-file "B"))
+        (emerge-file-ancestor (emerge-make-temp-file "anc")))
+    (emerge-eval-in-buffer
+     buffer-A
+     (write-region (point-min) (point-max) emerge-file-A nil 'no-message))
+    (emerge-eval-in-buffer
+     buffer-B
+     (write-region (point-min) (point-max) emerge-file-B nil 'no-message))
+    (emerge-eval-in-buffer
+     buffer-ancestor
+     (write-region (point-min) (point-max) emerge-file-ancestor nil
+                   'no-message))
+    (emerge-setup-with-ancestor (get-buffer buffer-A) emerge-file-A
+                                (get-buffer buffer-B) emerge-file-B
+                                (get-buffer buffer-ancestor)
+                                emerge-file-ancestor
+                                (cons (function (lambda ()
+                                                  (delete-file emerge-file-A)
+                                                  (delete-file emerge-file-B)
+                                                  (delete-file
+                                                   emerge-file-ancestor)))
+                                      startup-hooks)
+                                quit-hooks
+                                nil)))
+
+;;; Functions to start Emerge from the command line
+
+(defun emerge-files-command ()
+  (let ((file-a (nth 0 command-line-args-left))
+        (file-b (nth 1 command-line-args-left))
+        (file-out (nth 2 command-line-args-left)))
+    (setq command-line-args-left (nthcdr 3 command-line-args-left))
+    (emerge-files-internal
+     file-a file-b nil
+     (list (` (lambda () (emerge-command-exit (, file-out))))))))
+
+(defun emerge-files-with-ancestor-command ()
+  (let (file-a file-b file-anc file-out)
+    ;; check for a -a flag, for filemerge compatibility
+    (if (string= (car command-line-args-left) "-a")
+        ;; arguments are "-a ancestor file-a file-b file-out"
+        (progn
+          (setq file-a (nth 2 command-line-args-left))
+          (setq file-b (nth 3 command-line-args-left))
+          (setq file-anc (nth 1 command-line-args-left))
+          (setq file-out (nth 4 command-line-args-left))
+          (setq command-line-args-left (nthcdr 5 command-line-args-left)))
+      ;; arguments are "file-a file-b ancestor file-out"
+      (setq file-a (nth 0 command-line-args-left))
+      (setq file-b (nth 1 command-line-args-left))
+      (setq file-anc (nth 2 command-line-args-left))
+      (setq file-out (nth 3 command-line-args-left))
+      (setq command-line-args-left (nthcdr 4 command-line-args-left)))
+    (emerge-files-with-ancestor-internal
+     file-a file-b file-anc nil
+     (list (` (lambda () (emerge-command-exit (, file-out))))))))
+      
+(defun emerge-command-exit (file-out)
+  (emerge-write-and-delete file-out)
+  (kill-emacs (if emerge-prefix-argument 1 0)))
+
+;;; Functions to start Emerge via remote request
+
+(defun emerge-files-remote (file-a file-b file-out)
+  (setq emerge-file-out file-out)
+  (emerge-files-internal
+   file-a file-b nil
+   (list (` (lambda () (emerge-remote-exit (, file-out) '(, exit-func)))))
+   file-out)
+  (throw 'client-wait nil))
+
+(defun emerge-files-with-ancestor-remote (file-a file-b file-anc file-out)
+  (setq emerge-file-out file-out)
+  (emerge-files-with-ancestor-internal
+   file-a file-b file-anc nil
+   (list (` (lambda () (emerge-remote-exit (, file-out) '(, exit-func)))))
+   file-out)
+  (throw 'client-wait nil))
+
+(defun emerge-remote-exit (file-out exit-func)
+  (emerge-write-and-delete file-out)
+  (kill-buffer emerge-merge-buffer)
+  (funcall exit-func (if emerge-prefix-argument 1 0)))
+
+;;; Common setup routines
+
+;; Set up the window configuration.  If POS is given, set the points to
+;; the beginnings of the buffers.
+(defun emerge-setup-windows (buffer-A buffer-B merge-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 merge-buffer)
+  (emerge-refresh-mode-line)
+  (split-window-vertically)
+  (split-window-horizontally)
+  (switch-to-buffer buffer-A)
+  (if pos
+      (goto-char (point-min)))
+  (other-window 1)
+  (switch-to-buffer buffer-B)
+  (if pos
+      (goto-char (point-min)))
+  (other-window 1)
+  (if pos
+      (goto-char (point-min)))
+  ;; If diff/diff3 reports errors, display them rather than the merge buffer.
+  (if (/= 0 (emerge-eval-in-buffer emerge-diff-error-buffer (buffer-size)))
+      (progn
+        (ding)
+        (message "Errors found in diff/diff3 output.  Merge buffer is %s."
+                 (buffer-name emerge-merge-buffer))
+        (switch-to-buffer emerge-diff-error-buffer))))
+
+;; Set up the keymap in the merge buffer
+(defun emerge-set-keys ()
+  ;; Set up fixed keymaps if necessary
+  (if (not emerge-basic-keymap)
+      (emerge-setup-fixed-keymaps))
+  ;; Save the old local map
+  (setq emerge-old-keymap (current-local-map))
+  ;; Construct the edit keymap
+  (setq emerge-edit-keymap (if emerge-old-keymap
+                               (copy-keymap emerge-old-keymap)
+                             (make-sparse-keymap)))
+  ;; Install the Emerge commands
+  (emerge-force-define-key emerge-edit-keymap emerge-command-prefix
+                           'emerge-basic-keymap)
+  ;; Suppress write-file and save-buffer
+  (emerge-recursively-substitute-key-definition 'write-file
+                                                'emerge-query-write-file
+                                                emerge-edit-keymap)
+  (emerge-recursively-substitute-key-definition 'save-buffer
+                                                'emerge-query-save-buffer
+                                                emerge-edit-keymap)
+  (emerge-shadow-key-definition 'write-file 'emerge-query-write-file
+                                (current-global-map) emerge-edit-keymap)
+  (emerge-shadow-key-definition 'save-buffer 'emerge-query-save-buffer
+                                (current-global-map) emerge-edit-keymap)
+  (use-local-map emerge-fast-keymap)
+  (setq emerge-edit-mode nil)
+  (setq emerge-fast-mode t))
+
+(defun emerge-remember-buffer-characteristics ()
+  "Must be called in the merge buffer.  Remembers certain properties of the
+buffers being merged (read-only, modified, auto-save), and saves them in
+buffer local variables.  Sets the buffers read-only and turns off auto-save.
+These characteristics are restored by emerge-restore-buffer-characteristics."
+  ;; force auto-save, because we will turn off auto-saving in buffers for the
+  ;; duration
+  (do-auto-save)
+  ;; remember and alter buffer characteristics
+  (setq emerge-A-buffer-values
+        (emerge-eval-in-buffer
+         emerge-A-buffer
+         (prog1
+             (emerge-save-variables emerge-saved-variables)
+           (emerge-restore-variables emerge-saved-variables
+                                     emerge-merging-values))))
+  (setq emerge-B-buffer-values
+        (emerge-eval-in-buffer
+         emerge-B-buffer
+         (prog1
+             (emerge-save-variables emerge-saved-variables)
+           (emerge-restore-variables emerge-saved-variables
+                                     emerge-merging-values)))))
+
+(defun emerge-restore-buffer-characteristics ()
+  "Restores the characteristics remembered by
+emerge-remember-buffer-characteristics."
+  (let ((A-values emerge-A-buffer-values)
+        (B-values emerge-B-buffer-values))
+    (emerge-eval-in-buffer emerge-A-buffer
+                           (emerge-restore-variables emerge-saved-variables
+                                                     A-values))
+    (emerge-eval-in-buffer emerge-B-buffer
+                           (emerge-restore-variables emerge-saved-variables
+                                                     B-values))))
+
+(defun emerge-convert-diffs-to-markers (A-buffer
+                                        B-buffer
+                                        merge-buffer
+                                        lineno-list)
+  (let* (marker-list
+         (A-point-min (emerge-eval-in-buffer A-buffer (point-min)))
+         (offset (1- A-point-min))
+         (A-hidden-lines (emerge-eval-in-buffer
+                          A-buffer
+                          (save-restriction
+                            (widen)
+                            (count-lines 1 A-point-min))))
+         (B-point-min (emerge-eval-in-buffer B-buffer (point-min)))
+         (B-hidden-lines (emerge-eval-in-buffer
+                          B-buffer
+                          (save-restriction
+                            (widen)
+                            (count-lines 1 B-point-min)))))
+    (while lineno-list
+      (let* ((list-element (car lineno-list))
+             a-begin-marker
+             a-end-marker
+             b-begin-marker
+             b-end-marker
+             (a-begin (aref list-element 0))
+             (a-end (aref list-element 1))
+             (b-begin (aref list-element 2))
+             (b-end (aref list-element 3))
+             (state (aref list-element 4)))
+        ;; place markers at the appropriate places in the buffers
+        (emerge-eval-in-buffer
+         A-buffer
+         (goto-line (+ a-begin A-hidden-lines))
+         (setq a-begin-marker (point-marker))
+         (goto-line (+ a-end A-hidden-lines))
+         (setq a-end-marker (point-marker)))
+        (emerge-eval-in-buffer
+         B-buffer
+         (goto-line (+ b-begin B-hidden-lines))
+         (setq b-begin-marker (point-marker))
+         (goto-line (+ b-end B-hidden-lines))
+         (setq b-end-marker (point-marker)))
+        (setq merge-begin-marker (set-marker
+                                  (make-marker)
+                                  (- (marker-position a-begin-marker)
+                                     offset)
+                                  merge-buffer))
+        (setq merge-end-marker (set-marker
+                                (make-marker)
+                                (- (marker-position a-end-marker)
+                                   offset)
+                                merge-buffer))
+        ;; record all the markers for this difference
+        (setq marker-list (cons (vector a-begin-marker a-end-marker
+                                        b-begin-marker b-end-marker
+                                        merge-begin-marker merge-end-marker
+                                        state)
+                                marker-list)))
+      (setq lineno-list (cdr lineno-list)))
+    ;; convert the list of difference information into a vector for
+    ;; fast access
+    (setq emerge-difference-list (apply 'vector (nreverse marker-list)))))
+
+;; If we have an ancestor, select all B variants that we prefer 
+(defun emerge-select-prefer-Bs ()
+  (let ((n 0))
+    (while (< n emerge-number-of-differences)
+      (if (eq (aref (aref emerge-difference-list n) 6) 'prefer-B)
+          (progn
+            (emerge-unselect-and-select-difference n t)
+            (emerge-select-B)
+            (aset (aref emerge-difference-list n) 6 'prefer-B)))
+      (setq n (1+ n))))
+  (emerge-unselect-and-select-difference -1))
+
+;;; Common exit routines
+
+(defun emerge-write-and-delete (file-out)
+  ;; clear screen format
+  (delete-other-windows)
+  ;; delete A, B, and ancestor buffers, if they haven't been changed
+  (if (not (buffer-modified-p emerge-A-buffer))
+      (kill-buffer emerge-A-buffer))
+  (if (not (buffer-modified-p emerge-B-buffer))
+      (kill-buffer emerge-B-buffer))
+  (if (and emerge-ancestor-buffer
+           (not (buffer-modified-p emerge-ancestor-buffer)))
+      (kill-buffer emerge-ancestor-buffer))
+  ;; Write merge buffer to file
+  (write-file file-out))
+
+;;; Commands
+
+(defun emerge-recenter (&optional arg)
+  "Bring the highlighted region of all three merge buffers into view,
+if they are in windows.  If an ARGUMENT is given, the default three-window
+display is reestablished."
+  (interactive "P")
+  ;; If there is an argument, rebuild the window structure
+  (if arg
+      (emerge-setup-windows emerge-A-buffer emerge-B-buffer
+                            emerge-merge-buffer))
+  ;; Redisplay whatever buffers are showing, if there is a selected difference
+  (if (and (>= emerge-current-difference 0)
+           (< emerge-current-difference emerge-number-of-differences))
+      (let* ((merge-buffer emerge-merge-buffer)
+             (buffer-A emerge-A-buffer)
+             (buffer-B emerge-B-buffer)
+             (window-A (get-buffer-window buffer-A))
+             (window-B (get-buffer-window buffer-B))
+             (merge-window (get-buffer-window merge-buffer))
+             (diff-vector
+              (aref emerge-difference-list emerge-current-difference)))
+        (if window-A (progn
+                       (select-window window-A)
+                       (emerge-position-region
+                        (- (aref diff-vector 0)
+                           (1- emerge-before-flag-length))
+                        (+ (aref diff-vector 1)
+                           (1- emerge-after-flag-length))
+                        (1+ (aref diff-vector 0)))))
+        (if window-B (progn
+                       (select-window window-B)
+                       (emerge-position-region
+                        (- (aref diff-vector 2)
+                           (1- emerge-before-flag-length))
+                        (+ (aref diff-vector 3)
+                           (1- emerge-after-flag-length))
+                        (1+ (aref diff-vector 2)))))
+        (if merge-window (progn
+                           (select-window merge-window)
+                           (emerge-position-region
+                            (- (aref diff-vector 4)
+                               (1- emerge-before-flag-length))
+                            (+ (aref diff-vector 5)
+                               (1- emerge-after-flag-length))
+                            (1+ (aref diff-vector 4))))))))
+
+;;; 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 all three windows (if they are showing).
+;; Catches all errors on the operation in the A and B windows, but not
+;; in the merge window.  Usually, errors come from scrolling off the
+;; beginning or end of the buffer, and this gives a nice error message:
+;; End of buffer is reported in the merge buffer, but if the scroll was
+;; possible in the A or B windows, it is performed there before the error
+;; is reported.
+(defun emerge-operate-on-windows (operation arg)
+  (let* ((merge-buffer emerge-merge-buffer)
+         (buffer-A emerge-A-buffer)
+         (buffer-B emerge-B-buffer)
+         (window-A (get-buffer-window buffer-A))
+         (window-B (get-buffer-window buffer-B))
+         (merge-window (get-buffer-window merge-buffer)))
+    (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))))
+    (if merge-window (progn
+                       (select-window merge-window)
+                       (funcall operation arg)))))
+
+(defun emerge-scroll-up (&optional arg)
+  "Scroll up all three merge buffers, if they are in windows.
+If an ARGUMENT is given, that is how many lines are scrolled, else nearly
+the size of the merge window.  `C-u -' alone as argument scrolls half the
+size of the merge window."
+  (interactive "P")
+  (emerge-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 ((merge-window (get-buffer-window emerge-merge-buffer)))
+       (if (null merge-window)
+           ;; no window, use nil
+           nil
+         (let ((default-amount
+                 (- (window-height merge-window) 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 emerge-scroll-down (&optional arg)
+  "Scroll down all three merge buffers, if they are in windows.
+If an ARGUMENT is given, that is how many lines are scrolled, else nearly
+the size of the merge window.  `C-u -' alone as argument scrolls half the
+size of the merge window."
+  (interactive "P")
+  (emerge-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 ((merge-window (get-buffer-window emerge-merge-buffer)))
+       (if (null merge-window)
+           ;; no window, use nil
+           nil
+         (let ((default-amount
+                 (- (window-height merge-window) 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 emerge-scroll-left (&optional arg)
+  "Scroll left all three merge buffers, 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.  `C-u -' alone as argument scrolls half the
+width of the A and B windows."
+  (interactive "P")
+  (emerge-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)
+     (let ((merge-window (get-buffer-window emerge-merge-buffer)))
+       (if (null merge-window)
+           ;; no window, use nil
+           nil
+         (let ((default-amount
+                 (- (/ (window-width merge-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 emerge-scroll-right (&optional arg)
+  "Scroll right all three merge buffers, 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.  `C-u -' alone as argument scrolls half the
+width of the A and B windows."
+  (interactive "P")
+  (emerge-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)
+     (let ((merge-window (get-buffer-window emerge-merge-buffer)))
+       (if (null merge-window)
+           ;; no window, use nil
+           nil
+         (let ((default-amount
+                 (- (/ (window-width merge-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 emerge-scroll-reset ()
+  "Reset horizontal scrolling of all three merge buffers to the left margin,
+if they are in windows."
+  (interactive)
+  (emerge-operate-on-windows
+   (function (lambda (x) (set-window-hscroll (selected-window) 0)))
+   nil))
+
+;; Attempt to show the region nicely.
+;; If there are min-lines lines above and below the region, then don't do
+;; anything.
+;; If not, recenter the region to make it so.
+;; If that isn't possible, remove context lines balancedly from top and botton
+;; so the entire region shows.
+;; If that isn't possible, show the top of the region.
+;; BEG must be at the beginning of a line.
+(defun emerge-position-region (beg end pos)
+  ;; First test whether the entire region is visible with
+  ;; emerge-min-visible-lines above and below it
+  (if (not (and (<= (progn
+                      (move-to-window-line emerge-min-visible-lines)
+                      (point))
+                    beg)
+                (<= end (progn
+                          (move-to-window-line
+                           (- (1+ emerge-min-visible-lines)))
+                          (point)))))
+      ;; We failed that test, see if it fits at all
+      ;; Meanwhile positioning it correctly in case it doesn't fit
+      (progn
+        (set-window-start (selected-window) beg)
+        (setq fits (pos-visible-in-window-p end))
+        (if fits
+            ;; 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+ (- (1- (window-height (selected-window)))
+                                  lines))
+                           2))))))
+  (goto-char pos))
+
+(defun emerge-next-difference ()
+  "Advance to the next difference."
+  (interactive)
+  (if (< emerge-current-difference emerge-number-of-differences)
+      (let ((n (1+ emerge-current-difference)))
+        (while (and emerge-skip-prefers
+                    (< n emerge-number-of-differences)
+                    (memq (aref (aref emerge-difference-list n) 6)
+                          '(prefer-A prefer-B)))
+          (setq n (1+ n)))
+        (let ((buffer-read-only nil))
+          (emerge-unselect-and-select-difference n)))
+    (error "At end")))
+
+(defun emerge-previous-difference ()
+  "Go to the previous difference."
+  (interactive)
+  (if (> emerge-current-difference -1)
+      (let ((n (1- emerge-current-difference)))
+        (while (and emerge-skip-prefers
+                    (> n -1)
+                    (memq (aref (aref emerge-difference-list n) 6)
+                          '(prefer-A prefer-B)))
+          (setq n (1- n)))
+        (let ((buffer-read-only nil))
+          (emerge-unselect-and-select-difference n)))
+    (error "At beginning")))
+
+(defun emerge-jump-to-difference (difference-number)
+  "Go to the N-th difference."
+  (interactive "p")
+  (let ((buffer-read-only nil))
+    (setq difference-number (1- difference-number))
+    (if (and (>= difference-number -1)
+             (< difference-number (1+ emerge-number-of-differences)))
+        (emerge-unselect-and-select-difference difference-number)
+      (error "Bad difference number"))))
+
+(defun emerge-quit (arg)
+  "Finish an Emerge session.  Prefix ARGUMENT means to abort rather than
+successfully finish.  The difference depends on how the merge was started,
+but usually means to not write over one of the original files, or to signal
+to some process which invoked Emerge a failure code.
+
+Unselects the selected difference, if any, restores the read-only and modified
+flags of the merged file buffers, restores the local keymap of the merge
+buffer, and sets off various emerge flags.  Using Emerge commands in this
+buffer after this will cause serious problems."
+  (interactive "P")
+  (if (prog1
+          (y-or-n-p
+           (if (not arg)
+               "Do you really want to successfully finish this merge? "
+             "Do you really want to abort this merge? "))
+        (message ""))
+      (emerge-really-quit arg)))
+
+;; Perform the quit operations.
+(defun emerge-really-quit (arg)
+  (setq buffer-read-only nil)
+  (emerge-unselect-and-select-difference -1)
+  (emerge-restore-buffer-characteristics)
+  ;; null out the difference markers so they don't slow down future editing
+  ;; operations
+  (mapcar (function (lambda (d)
+                      (set-marker (aref d 0) nil)
+                      (set-marker (aref d 1) nil)
+                      (set-marker (aref d 2) nil)
+                      (set-marker (aref d 3) nil)
+                      (set-marker (aref d 4) nil)
+                      (set-marker (aref d 5) nil)))
+          emerge-difference-list)
+  ;; allow them to be garbage collected
+  (setq emerge-difference-list nil)
+  ;; restore the local map
+  (use-local-map emerge-old-keymap)
+  ;; turn off all the emerge modes
+  (setq emerge-mode nil)
+  (setq emerge-fast-mode nil)
+  (setq emerge-edit-mode nil)
+  (setq emerge-auto-advance nil)
+  (setq emerge-skip-prefers nil)
+  ;; restore mode line
+  (kill-local-variable 'mode-line-buffer-identification)
+  (let ((emerge-prefix-argument arg))
+    (run-hooks 'emerge-quit-hooks)))
+
+(defun emerge-select-A (&optional force)
+  "Select the A variant of this difference.  Refuses to function if this
+difference has been edited, i.e., if it is neither the A nor the B variant.
+An ARGUMENT forces the variant to be selected even if the difference has
+been edited."
+  (interactive "P")
+  (let ((operate
+         (function (lambda ()
+                     (emerge-select-A-edit merge-begin merge-end A-begin A-end)
+                     (if emerge-auto-advance
+                         (emerge-next-difference)))))
+        (operate-no-change
+         (function (lambda ()
+                     (if emerge-auto-advance
+                         (emerge-next-difference))))))
+    (emerge-select-version force operate-no-change operate operate)))
+
+;; Actually select the A variant
+(defun emerge-select-A-edit (merge-begin merge-end A-begin A-end)
+  (emerge-eval-in-buffer
+   emerge-merge-buffer
+   (delete-region merge-begin merge-end)
+   (goto-char merge-begin)
+   (insert-buffer-substring emerge-A-buffer A-begin A-end)
+   (goto-char merge-begin)
+   (aset diff-vector 6 'A)
+   (emerge-refresh-mode-line)))
+
+(defun emerge-select-B (&optional force)
+  "Select the B variant of this difference.  Refuses to function if this
+difference has been edited, i.e., if it is neither the A nor the B variant.
+An ARGUMENT forces the variant to be selected even if the difference has
+been edited."
+  (interactive "P")
+  (let ((operate
+         (function (lambda ()
+                     (emerge-select-B-edit merge-begin merge-end B-begin B-end)
+                     (if emerge-auto-advance
+                         (emerge-next-difference)))))
+        (operate-no-change
+         (function (lambda ()
+                     (if emerge-auto-advance
+                         (emerge-next-difference))))))
+    (emerge-select-version force operate operate-no-change operate)))
+
+;; Actually select the B variant
+(defun emerge-select-B-edit (merge-begin merge-end B-begin B-end)
+  (emerge-eval-in-buffer
+   emerge-merge-buffer
+   (delete-region merge-begin merge-end)
+   (goto-char merge-begin)
+   (insert-buffer-substring emerge-B-buffer B-begin B-end)
+   (goto-char merge-begin)
+   (aset diff-vector 6 'B)
+   (emerge-refresh-mode-line)))
+
+(defun emerge-default-A ()
+  "Selects the A variant for all differences from here down in the buffer
+which are still defaulted, i.e., which the user has not selected and for
+which there is no preference."
+  (interactive)
+  (let ((buffer-read-only nil))
+    (let ((selected-difference emerge-current-difference)
+          (n (max emerge-current-difference 0)))
+      (while (< n emerge-number-of-differences)
+        (let ((diff-vector (aref emerge-difference-list n)))
+          (if (eq (aref diff-vector 6) 'default-B)
+              (progn
+                (emerge-unselect-and-select-difference n t)
+                (emerge-select-A)
+                (aset diff-vector 6 'default-A))))
+        (setq n (1+ n))
+        (if (= (* (/ n 10) 10) n)
+            (message "Setting default to A...%d" n)))
+      (emerge-unselect-and-select-difference selected-difference)))
+  (message "Default A set"))
+
+(defun emerge-default-B ()
+  "Selects the B variant for all differences from here down in the buffer
+which are still defaulted, i.e., which the user has not selected and for
+which there is no preference."
+  (interactive)
+  (let ((buffer-read-only nil))
+    (let ((selected-difference emerge-current-difference)
+          (n (max emerge-current-difference 0)))
+      (while (< n emerge-number-of-differences)
+        (let ((diff-vector (aref emerge-difference-list n)))
+          (if (eq (aref diff-vector 6) 'default-A)
+              (progn
+                (emerge-unselect-and-select-difference n t)
+                (emerge-select-B)
+                (aset diff-vector 6 'default-B))))
+        (setq n (1+ n))
+        (if (= (* (/ n 10) 10) n)
+            (message "Setting default to B...%d" n)))
+      (emerge-unselect-and-select-difference selected-difference)))
+  (message "Default B set"))
+
+(defun emerge-fast-mode ()
+  "Set fast mode, in which ordinary Emacs commands are disabled, and Emerge
+commands are need not be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
+  (interactive)
+  (setq buffer-read-only t)
+  (use-local-map emerge-fast-keymap)
+  (setq emerge-mode t)
+  (setq emerge-fast-mode t)
+  (setq emerge-edit-mode nil)
+  (message "Fast mode set")
+  ;; force mode line redisplay
+  (set-buffer-modified-p (buffer-modified-p)))
+
+(defun emerge-edit-mode ()
+  "Set edit mode, in which ordinary Emacs commands are available, and Emerge
+commands must be prefixed with \\<emerge-fast-keymap>\\[emerge-basic-keymap]."
+  (interactive)
+  (setq buffer-read-only nil)
+  (use-local-map emerge-edit-keymap)
+  (setq emerge-mode t)
+  (setq emerge-fast-mode nil)
+  (setq emerge-edit-mode t)
+  (message "Edit mode set")
+  ;; force mode line redisplay
+  (set-buffer-modified-p (buffer-modified-p)))
+
+(defun emerge-auto-advance (arg)
+  "Toggle auto-advance mode, which causes  emerge-select-A  and
+ emerge-select-B  to automatically advance to the next difference.  (See
+emerge-auto-advance.)  
+If a positive ARGUMENT is given, it turns on auto-advance mode.
+If a negative ARGUMENT is given, it turns off auto-advance mode."
+  (interactive "P")
+  (setq emerge-auto-advance (if (null arg)
+                                (not emerge-auto-advance)
+                              (> (prefix-numeric-value arg) 0)))
+  (message (if emerge-skip-prefers
+               "Auto-advance set"
+             "Auto-advance cleared"))
+  ;; force mode line redisplay
+  (set-buffer-modified-p (buffer-modified-p)))
+
+(defun emerge-skip-prefers (arg)
+  "Toggle skip-prefers mode, which causes  emerge-next-difference  and
+ emerge-previous-difference  to automatically skip over differences for which
+there is a preference.  (See emerge-skip-prefers.)  
+If a positive ARGUMENT is given, it turns on skip-prefers mode.
+If a negative ARGUMENT is given, it turns off skip-prefers mode."
+  (interactive "P")
+  (setq emerge-skip-prefers (if (null arg)
+                                (not emerge-skip-prefers)
+                              (> (prefix-numeric-value arg) 0)))
+  (message (if emerge-skip-prefers
+               "Skip-prefers set"
+             "Skip-prefers cleared"))
+  ;; force mode line redisplay
+  (set-buffer-modified-p (buffer-modified-p)))
+
+(defun emerge-copy-as-kill-A ()
+  "Put the A variant of this difference in the kill ring."
+  (interactive)
+  (emerge-validate-difference)
+  (let* ((diff-vector
+          (aref emerge-difference-list emerge-current-difference))
+         (A-begin (1+ (aref diff-vector 0)))
+         (A-end (1- (aref diff-vector 1)))
+         ;; so further kills don't append
+         this-command)
+    (save-excursion
+      (set-buffer emerge-A-buffer)
+      (copy-region-as-kill A-begin A-end))))
+
+(defun emerge-copy-as-kill-B ()
+  "Put the B variant of this difference in the kill ring."
+  (interactive)
+  (emerge-validate-difference)
+  (let* ((diff-vector
+          (aref emerge-difference-list emerge-current-difference))
+         (B-begin (1+ (aref diff-vector 2)))
+         (B-end (1- (aref diff-vector 3)))
+         ;; so further kills don't append
+         this-command)
+    (save-excursion
+      (set-buffer emerge-B-buffer)
+      (copy-region-as-kill B-begin B-end))))
+
+(defun emerge-insert-A (arg)
+  "Insert the A variant of this difference at the point.
+Leaves point after text, mark before.
+With prefix argument, puts point before, mark after."
+  (interactive "P")
+  (emerge-validate-difference)
+  (let* ((diff-vector
+          (aref emerge-difference-list emerge-current-difference))
+         (A-begin (1+ (aref diff-vector 0)))
+         (A-end (1- (aref diff-vector 1)))
+         (opoint (point))
+         (buffer-read-only nil))
+    (insert-buffer-substring emerge-A-buffer A-begin A-end)
+    (if (not arg)
+        (set-mark opoint)
+      (set-mark (point))
+      (goto-char opoint))))
+
+(defun emerge-insert-B (arg)
+  "Insert the B variant of this difference at the point.
+Leaves point after text, mark before.
+With prefix argument, puts point before, mark after."
+  (interactive "P")
+  (emerge-validate-difference)
+  (let* ((diff-vector
+          (aref emerge-difference-list emerge-current-difference))
+         (B-begin (1+ (aref diff-vector 2)))
+         (B-end (1- (aref diff-vector 3)))
+         (opoint (point))
+         (buffer-read-only nil))
+    (insert-buffer-substring emerge-B-buffer B-begin B-end)
+    (if (not arg)
+        (set-mark opoint)
+      (set-mark (point))
+      (goto-char opoint))))
+
+(defun emerge-mark-difference (arg)
+  "Leaves the point before this difference and the mark after it.
+With prefix argument, puts mark before, point after."
+  (interactive "P")
+  (emerge-validate-difference)
+  (let* ((diff-vector
+          (aref emerge-difference-list emerge-current-difference))
+         (merge-begin (1+ (aref diff-vector 4)))
+         (merge-end (1- (aref diff-vector 5))))
+    (if (not arg)
+        (progn
+          (goto-char merge-begin)
+          (set-mark merge-end))
+      (goto-char merge-end)
+      (set-mark merge-begin))))
+
+(defun emerge-file-names ()
+  "Show the names of the buffers or files being operated on by Emerge.
+Use ^U L to reset the windows afterward."
+  (interactive)
+  (delete-other-windows)
+  (let ((temp-buffer-show-hook
+         (function (lambda (buf)
+                     (split-window-vertically)
+                     (switch-to-buffer buf)
+                     (other-window 1)))))
+    (with-output-to-temp-buffer "*Help*"
+      (emerge-eval-in-buffer emerge-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 emerge-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"))
+      (if emerge-ancestor-buffer
+            (emerge-eval-in-buffer emerge-ancestor-buffer
+                                   (if buffer-file-name
+                                       (progn
+                                         (princ "Ancestor file is: ")
+                                         (princ buffer-file-name))
+                                     (progn
+                                       (princ "Ancestor buffer is: ")
+                                       (princ (buffer-name))))
+                                   (princ "\n")))
+      (princ emerge-output-description))))
+
+(defun emerge-join-differences (arg)
+  "Join the selected difference with the following one.  With a prefix
+argument, join with the preceeding one."
+  (interactive "P")
+  (let ((n emerge-current-difference))
+    ;; adjust n to be first difference to join
+    (if arg
+        (setq n (1- n)))
+    ;; n and n+1 are the differences to join
+    ;; check that they are both differences
+    (if (or (< n 0) (>= n (1- emerge-number-of-differences)))
+        (error "Incorrect differences to join"))
+    ;; remove the flags
+    (emerge-unselect-difference emerge-current-difference)
+    ;; decrement total number of differences
+    (setq emerge-number-of-differences (1- emerge-number-of-differences))
+    ;; build new differences vector
+    (let ((i 0)
+          (new-differences (make-vector emerge-number-of-differences nil)))
+      (while (< i emerge-number-of-differences)
+        (aset new-differences i
+              (cond
+               ((< i n) (aref emerge-difference-list i))
+               ((> i n) (aref emerge-difference-list (1+ i)))
+               (t (let ((prev (aref emerge-difference-list i))
+                        (next (aref emerge-difference-list (1+ i))))
+                    (vector (aref prev 0)
+                            (aref next 1)
+                            (aref prev 2)
+                            (aref next 3)
+                            (aref prev 4)
+                            (aref next 5)
+                            (let ((ps (aref prev 6))
+                                  (ns (aref next 6)))
+                              (cond
+                               ((eq ps ns)
+                                ps)
+                               ((and (or (eq ps 'B) (eq ps 'prefer-B))
+                                     (or (eq ns 'B) (eq ns 'prefer-B)))
+                                'B)
+                               (t 'A))))))))
+        (setq i (1+ i)))
+      (setq emerge-difference-list new-differences))
+    ;; set the current difference correctly
+    (setq emerge-current-difference n)
+    ;; fix the mode line
+    (emerge-refresh-mode-line)
+    ;; reinsert the flags
+    (emerge-select-difference emerge-current-difference)
+    (emerge-recenter)))
+
+(defun emerge-split-difference ()
+  "Split the current difference where the points are in the three windows."
+  (interactive)
+  (let ((n emerge-current-difference))
+    ;; check that this is a valid difference
+    (emerge-validate-difference)
+    ;; get the point values and old difference
+    (let ((A-point (emerge-eval-in-buffer emerge-A-buffer
+                                          (point-marker)))
+          (B-point (emerge-eval-in-buffer emerge-B-buffer
+                                          (point-marker)))
+          (merge-point (point-marker))
+          (old-diff (aref emerge-difference-list n)))
+      ;; check location of the points, give error if they aren't in the
+      ;; differences
+      (if (or (< A-point (aref old-diff 0))
+              (> A-point (aref old-diff 1)))
+          (error "Point outside of difference in A buffer"))
+      (if (or (< B-point (aref old-diff 2))
+              (> B-point (aref old-diff 3)))
+          (error "Point outside of difference in B buffer"))
+      (if (or (< merge-point (aref old-diff 4))
+              (> merge-point (aref old-diff 5)))
+          (error "Point outside of difference in merge buffer"))
+      ;; remove the flags
+      (emerge-unselect-difference emerge-current-difference)
+      ;; increment total number of differences
+      (setq emerge-number-of-differences (1+ emerge-number-of-differences))
+      ;; build new differences vector
+      (let ((i 0)
+            (new-differences (make-vector emerge-number-of-differences nil)))
+        (while (< i emerge-number-of-differences)
+          (aset new-differences i
+                (cond
+                 ((< i n)
+                  (aref emerge-difference-list i))
+                 ((> i (1+ n))
+                  (aref emerge-difference-list (1- i)))
+                 ((= i n)
+                  (vector (aref old-diff 0)
+                          A-point
+                          (aref old-diff 2)
+                          B-point
+                          (aref old-diff 4)
+                          merge-point
+                          (aref old-diff 6)))
+                 (t
+                  (vector (copy-marker A-point)
+                          (aref old-diff 1)
+                          (copy-marker B-point)
+                          (aref old-diff 3)
+                          (copy-marker merge-point)
+                          (aref old-diff 5)
+                          (aref old-diff 6)))))
+          (setq i (1+ i)))
+        (setq emerge-difference-list new-differences))
+      ;; set the current difference correctly
+      (setq emerge-current-difference n)
+      ;; fix the mode line
+      (emerge-refresh-mode-line)
+      ;; reinsert the flags
+      (emerge-select-difference emerge-current-difference)
+      (emerge-recenter))))
+
+(defun emerge-trim-difference ()
+  "Trim lines off the top and bottom of a difference that are the same in
+both the A and B versions.  (This can happen when the A and B versions
+have common lines that the ancestor version does not share.)"
+  (interactive)
+  ;; make sure we are in a real difference
+  (emerge-validate-difference)
+  ;; remove the flags
+  (emerge-unselect-difference emerge-current-difference)
+  (let* ((diff (aref emerge-difference-list emerge-current-difference))
+         (top-a (marker-position (aref diff 0)))
+         (bottom-a (marker-position (aref diff 1)))
+         (top-b (marker-position (aref diff 2)))
+         (bottom-b (marker-position (aref diff 3)))
+         (top-m (marker-position (aref diff 4)))
+         (bottom-m (marker-position (aref diff 5)))
+         size success sa sb sm)
+    ;; move down the tops of the difference regions as much as possible
+    ;; Try advancing comparing 1000 chars at a time.
+    ;; When that fails, go 500 chars at a time, and so on.
+    (setq size 1000)
+    (while (> size 0)
+      (setq success t)
+      (while success
+        (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
+                        (- bottom-m top-m)))
+        (setq sa (emerge-eval-in-buffer emerge-A-buffer
+                                        (buffer-substring top-a
+                                                          (+ size top-a))))
+        (setq sb (emerge-eval-in-buffer emerge-B-buffer
+                                        (buffer-substring top-b
+                                                          (+ size top-b))))
+        (setq sm (buffer-substring top-m (+ size top-m)))
+        (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
+        (if success
+            (setq top-a (+ top-a size)
+                  top-b (+ top-b size)
+                  top-m (+ top-m size))))
+      (setq size (/ size 2)))
+    ;; move up the bottoms of the difference regions as much as possible
+    ;; Try advancing comparing 1000 chars at a time.
+    ;; When that fails, go 500 chars at a time, and so on.
+    (setq size 1000)
+    (while (> size 0)
+      (setq success t)
+      (while success
+        (setq size (min size (- bottom-a top-a) (- bottom-b top-b)
+                        (- bottom-m top-m)))
+        (setq sa (emerge-eval-in-buffer emerge-A-buffer
+                                        (buffer-substring (- bottom-a size)
+                                                          bottom-a)))
+        (setq sb (emerge-eval-in-buffer emerge-B-buffer
+                                        (buffer-substring (- bottom-b size)
+                                                          bottom-b)))
+        (setq sm (buffer-substring (- bottom-m size) bottom-m))
+        (setq success (and (> size 0) (equal sa sb) (equal sb sm)))
+        (if success
+            (setq bottom-a (- bottom-a size)
+                  bottom-b (- bottom-b size)
+                  bottom-m (- bottom-m size))))
+      (setq size (/ size 2)))
+    ;; {top,bottom}-{a,b,m} are now set at the new beginnings and ends
+    ;; of the difference regions.  Move them to the beginning of lines, as
+    ;; appropriate.
+    (emerge-eval-in-buffer emerge-A-buffer
+                           (goto-char top-a)
+                           (beginning-of-line)
+                           (aset diff 0 (point-marker))
+                           (goto-char bottom-a)
+                           (beginning-of-line 2)
+                           (aset diff 1 (point-marker)))
+    (emerge-eval-in-buffer emerge-B-buffer
+                           (goto-char top-b)
+                           (beginning-of-line)
+                           (aset diff 2 (point-marker))
+                           (goto-char bottom-b)
+                           (beginning-of-line 2)
+                           (aset diff 3 (point-marker)))
+    (goto-char top-m)
+    (beginning-of-line)
+    (aset diff 4 (point-marker))
+    (goto-char bottom-m)
+    (beginning-of-line 2)
+    (aset diff 5 (point-marker))
+    ;; put the flags back in, recenter the display
+    (emerge-select-difference emerge-current-difference)
+    (emerge-recenter)))
+
+(defun emerge-find-difference (arg)
+  "Find the difference containing the current position of the point.
+If there is no containing difference and the prefix argument is positive,
+it finds the nearest following difference.  A negative prefix argument finds
+the nearest previous difference."
+  (interactive "P")
+  ;; search for the point in the merge buffer, using the markers
+  ;; for the beginning and end of the differences in the merge buffer
+  (emerge-find-difference1 arg (point) 4 5))
+
+(defun emerge-find-difference-A (arg)
+  "Find the difference containing the current position of the point in the
+A buffer.  (Nonetheless, this command must be executed in the merge buffer.)
+If there is no containing difference and the prefix argument is positive,
+it finds the nearest following difference.  A negative prefix argument finds
+the nearest previous difference."
+  (interactive "P")
+  ;; search for the point in the A buffer, using the markers
+  ;; for the beginning and end of the differences in the A buffer
+  (emerge-find-difference1 arg
+                           (emerge-eval-in-buffer emerge-A-buffer (point))
+                           0 1))
+
+(defun emerge-find-difference-B (arg)
+  "Find the difference containing the current position of the point in the
+B buffer.  (Nonetheless, this command must be executed in the merge buffer.)
+If there is no containing difference and the prefix argument is positive,
+it finds the nearest following difference.  A negative prefix argument finds
+the nearest previous difference."
+  (interactive "P")
+  ;; search for the point in the B buffer, using the markers
+  ;; for the beginning and end of the differences in the B buffer
+  (emerge-find-difference1 arg
+                           (emerge-eval-in-buffer emerge-B-buffer (point))
+                           2 3))
+
+(defun emerge-find-difference1 (arg location begin end)
+  (let* ((index
+          ;; find first difference containing or after the current position
+          (catch 'search
+            (let ((n 0))
+              (while (< n emerge-number-of-differences)
+                (let ((diff-vector (aref emerge-difference-list n)))
+                  (if (<= location (marker-position (aref diff-vector end)))
+                      (throw 'search n)))
+                (setq n (1+ n))))
+            emerge-number-of-differences))
+         (contains
+          ;; whether the found difference contains the current position
+          (and (< index emerge-number-of-differences)
+               (<= (marker-position (aref (aref emerge-difference-list index)
+                                          begin))
+                   location)))
+         (arg-value
+          ;; numeric value of prefix argument
+          (prefix-numeric-value arg)))
+    (emerge-unselect-and-select-difference
+     (cond
+      ;; if the point is in a difference, select it
+      (contains index)
+      ;; if the arg is nil and the point is not in a difference, error
+      ((null arg) (error "No difference contains point"))
+      ;; if the arg is positive, select the following difference
+      ((> arg-value 0)
+       (if (< index emerge-number-of-differences)
+           index
+         (error "No difference contains or follows point")))
+      ;; if the arg is negative, select the preceeding difference
+      (t
+       (if (> index 0)
+           (1- index)
+         (error "No difference contains or preceeds point")))))))
+
+(defun emerge-line-numbers ()
+  "Display the current line numbers of the points in the A, B, and
+merge buffers."
+  (interactive)
+  (let* ((valid-diff
+         (and (>= emerge-current-difference 0)
+              (< emerge-current-difference emerge-number-of-differences)))
+        (diff (and valid-diff
+                   (aref emerge-difference-list emerge-current-difference)))
+        (merge-line (emerge-line-number-in-buf 4 5))
+        (A-line (emerge-eval-in-buffer emerge-A-buffer
+                                       (emerge-line-number-in-buf 0 1)))
+        (B-line (emerge-eval-in-buffer emerge-B-buffer
+                                       (emerge-line-number-in-buf 2 3))))
+    (message "At lines: merge = %d, A = %d, B = %d"
+             merge-line A-line B-line)))
+
+(defun emerge-line-number-in-buf (begin-marker end-marker)
+  (let (temp)
+    (setq temp (save-excursion
+                 (beginning-of-line)
+                 (1+ (count-lines 1 (point)))))
+    (if valid-diff
+        (progn
+          (if (> (point) (aref diff begin-marker))
+              (setq temp (- temp emerge-before-flag-lines)))
+          (if (> (point) (aref diff end-marker))
+              (setq temp (- temp emerge-after-flag-lines)))))
+    temp))
+
+(defun emerge-set-combine-versions-template (start end &optional localize)
+  "Copy region into  emerge-combine-versions-template  which controls how
+emerge-combine-versions  will combine the two versions.
+With prefix argument,  emerge-combine-versions  is made local to this
+merge buffer.  Localization is permanent for any particular merge buffer."
+  (interactive "r\nP")
+  (if localize
+      (make-local-variable 'emerge-combine-versions-template))
+  (setq emerge-combine-versions-template (buffer-substring start end))
+  (message
+   (if (assq 'emerge-combine-versions-template (buffer-local-variables))
+       "emerge-set-combine-versions-template set locally."
+     "emerge-set-combine-versions-template set.")))
+
+(defun emerge-combine-versions (&optional force)
+  "Combine the two versions using the template in
+emerge-combine-versions-template.
+Refuses to function if this difference has been edited, i.e., if it is
+neither the A nor the B variant.
+An ARGUMENT forces the variant to be selected even if the difference has
+been edited."
+  (interactive "P")
+  (emerge-combine-versions-internal emerge-combine-versions-template force))
+
+(defun emerge-combine-versions-register (char &optional force)
+  "Combine the two versions using the template in register REG.
+See documentation of the variable  emerge-combine-versions-template
+for how the template is interpreted.
+Refuses to function if this difference has been edited, i.e., if it is
+neither the A nor the B variant.
+An ARGUMENT forces the variant to be selected even if the difference has
+been edited."
+  (interactive "cRegister containing template: \nP")
+  (let ((template (get-register char)))
+    (if (not (stringp template))
+        (error "Register does not contain text"))
+    (emerge-combine-versions-internal template force)))
+
+(defun emerge-combine-versions-internal (template force)
+  (let ((operate
+         (function (lambda ()
+                     (emerge-combine-versions-edit merge-begin merge-end
+                                                   A-begin A-end B-begin B-end)
+                     (if emerge-auto-advance
+                         (emerge-next-difference))))))
+    (emerge-select-version force operate operate operate)))
+
+(defun emerge-combine-versions-edit (merge-begin merge-end
+                                     A-begin A-end B-begin B-end)
+  (emerge-eval-in-buffer
+   emerge-merge-buffer
+   (delete-region merge-begin merge-end)
+   (goto-char merge-begin)
+   (let ((i 0))
+     (while (< i (length template))
+       (let ((c (aref template i)))
+         (if (= c ?%)
+             (progn
+               (setq i (1+ i))
+               (setq c 
+                     (condition-case nil
+                         (aref template i)
+                       (error ?%)))
+               (cond ((= c ?a)
+                      (insert-buffer-substring emerge-A-buffer A-begin A-end))
+                     ((= c ?b) 
+                      (insert-buffer-substring emerge-B-buffer B-begin B-end))
+                     ((= c ?%) 
+                      (insert ?%)
+                      (t
+                       (insert c)))))
+           (insert c)))
+       (setq i (1+ i))))
+   (goto-char merge-begin)
+   (aset diff-vector 6 'combined)
+   (emerge-refresh-mode-line)))
+
+(defun emerge-set-merge-mode (mode)
+  "Set the major mode in a merge buffer.  Overrides any change that the mode
+might make to the mode line or local keymap.  Leaves merge in fast mode."
+  (interactive
+   (list (intern (completing-read "New major mode for merge buffer: "
+                                  obarray 'commandp t nil))))
+  (funcall mode)
+  (emerge-refresh-mode-line)
+  (if emerge-fast-mode
+      (emerge-fast-mode)
+    (emerge-edit-mode)))
+
+(defun emerge-one-line-window ()
+  (interactive)
+  (let ((window-min-height 1))
+    (shrink-window (- (window-height) 2))))
+
+;;; Support routines
+
+;; Select a difference by placing the visual flags around the appropriate
+;; group of lines in the A, B, and merge buffers
+(defun emerge-select-difference (n)
+  (let ((diff-vector (aref emerge-difference-list n)))
+    (emerge-place-flags-in-buffer emerge-A-buffer
+                                  (aref diff-vector 0) (aref diff-vector 1))
+    (emerge-place-flags-in-buffer emerge-B-buffer
+                                  (aref diff-vector 2) (aref diff-vector 3))
+    (emerge-place-flags-in-buffer emerge-merge-buffer
+                                  (aref diff-vector 4) (aref diff-vector 5))))
+
+(defun emerge-place-flags-in-buffer (buffer before after)
+  (if (eq buffer emerge-merge-buffer)
+      (emerge-place-flags-in-buffer1 buffer before after)
+    (emerge-eval-in-buffer
+     buffer
+     (emerge-place-flags-in-buffer1 buffer before after))))
+
+(defun emerge-place-flags-in-buffer1 (buffer before after)
+  (let ((buffer-read-only nil))
+    ;; insert the flags
+    (goto-char before)
+    (insert-before-markers emerge-before-flag)
+    (goto-char after)
+    (insert emerge-after-flag)
+    ;; put the markers into the flags, so alterations above or below won't move
+    ;; them
+    ;; before marker is one char before the end of the before flag
+    ;; after marker is one char after the beginning of the after flag
+    (set-marker before (1- before))
+    (set-marker after (1+ after))))
+
+;; Unselect a difference by removing the visual flags in the buffers.
+(defun emerge-unselect-difference (n)
+  (let ((diff-vector (aref emerge-difference-list n)))
+    (emerge-remove-flags-in-buffer emerge-A-buffer
+                                   (aref diff-vector 0) (aref diff-vector 1))
+    (emerge-remove-flags-in-buffer emerge-B-buffer
+                                   (aref diff-vector 2) (aref diff-vector 3))
+    (emerge-remove-flags-in-buffer emerge-merge-buffer
+                                   (aref diff-vector 4) (aref diff-vector 5))))
+
+(defun emerge-remove-flags-in-buffer (buffer before after)
+  (emerge-eval-in-buffer
+   buffer
+   (let ((buffer-read-only nil))
+     ;; put the markers at the beginning of the flags
+     (set-marker before (- before (1- emerge-before-flag-length)))
+     (set-marker after (1- after))
+     ;; remove the flags
+     (goto-char before)
+     (if (looking-at emerge-before-flag-match)
+         (delete-char emerge-before-flag-length)
+       ;; the flag isn't there
+       (ding)
+       (message "Trouble removing flag."))
+     (goto-char after)
+     (if (looking-at emerge-after-flag-match)
+         (delete-char emerge-after-flag-length)
+       ;; the flag isn't there
+       (ding)
+       (message "Trouble removing flag.")))))
+
+;; Select a difference, removing an flags that exist now.
+(defun emerge-unselect-and-select-difference (n &optional suppress-display)
+  (if (and (>= emerge-current-difference 0)
+           (< emerge-current-difference emerge-number-of-differences))
+      (emerge-unselect-difference emerge-current-difference))
+  (if (and (>= n 0) (< n emerge-number-of-differences))
+      (progn
+        (emerge-select-difference n)
+        (let* ((diff-vector (aref emerge-difference-list n))
+               (selection-type (aref diff-vector 6)))
+          (if (eq selection-type 'default-A)
+              (aset diff-vector 6 'A)
+            (if (eq selection-type 'default-B)
+                (aset diff-vector 6 'B))))))
+  (setq emerge-current-difference n)
+  (if (not suppress-display)
+      (progn
+        (emerge-recenter)
+        (emerge-refresh-mode-line))))
+
+;; Perform tests to see whether user should be allowed to select a version
+;; of this difference:
+;;   a valid difference has been selected; and
+;;   the difference text in the merge buffer is:
+;;     the A version (execute a-version), or
+;;     the B version (execute b-version), or
+;;     empty (execute neither-version), or
+;;     argument FORCE is true (execute neither-version)
+;; Otherwise, signal an error.
+(defun emerge-select-version (force a-version b-version neither-version)
+  (emerge-validate-difference)
+  (let ((buffer-read-only nil))
+    (let* ((diff-vector
+            (aref emerge-difference-list emerge-current-difference))
+           (A-begin (1+ (aref diff-vector 0)))
+           (A-end (1- (aref diff-vector 1)))
+           (B-begin (1+ (aref diff-vector 2)))
+           (B-end (1- (aref diff-vector 3)))
+           (merge-begin (1+ (aref diff-vector 4)))
+           (merge-end (1- (aref diff-vector 5))))
+      (if (emerge-compare-buffers emerge-A-buffer A-begin A-end
+                                  emerge-merge-buffer merge-begin
+                                  merge-end)
+          (funcall a-version)
+        (if (emerge-compare-buffers emerge-B-buffer B-begin B-end
+                                    emerge-merge-buffer merge-begin
+                                    merge-end)
+            (funcall b-version)
+          (if (or force (= merge-begin merge-end))
+              (funcall neither-version)
+            (error "This difference region has been edited.")))))))
+
+;; Revise the mode line to display which difference we have selected
+
+(defun emerge-refresh-mode-line ()
+  (setq mode-line-buffer-identification
+        (list (format "Emerge: %%b   diff %d of %d%s"
+                      (1+ emerge-current-difference)
+                      emerge-number-of-differences
+                      (if (and (>= emerge-current-difference 0)
+                               (< emerge-current-difference
+                                  emerge-number-of-differences))
+                          (cdr (assq (aref (aref emerge-difference-list
+                                                 emerge-current-difference)
+                                           6)
+                                     '((A . " - A")
+                                       (B . " - B")
+                                       (prefer-A . " - A*")
+                                       (prefer-B . " - B*")
+                                       (combined . " - comb"))))
+                        ""))))
+  ;; Force mode-line redisplay
+  (set-buffer-modified-p (buffer-modified-p)))
+
+;; compare two regions in two buffers for containing the same text
+(defun emerge-compare-buffers (buffer-x x-begin x-end buffer-y y-begin y-end)
+  ;; first check that the two regions are the same length
+  (if (not (and (= (- x-end x-begin) (- y-end y-begin))))
+      nil
+    (catch 'exit
+      (while (< x-begin x-end)
+        ;; bite off and compare no more than 1000 characters at a time
+        (let* ((compare-length (min (- x-end x-begin) 1000))
+               (x-string (emerge-eval-in-buffer 
+                          buffer-x
+                          (buffer-substring x-begin
+                                            (+ x-begin compare-length))))
+               (y-string (emerge-eval-in-buffer
+                          buffer-y
+                          (buffer-substring y-begin
+                                            (+ y-begin compare-length)))))
+          (if (not (string-equal x-string y-string))
+              (throw 'exit nil)
+            (setq x-begin (+ x-begin compare-length))
+            (setq y-begin (+ y-begin compare-length)))))
+      t)))
+
+;; Construct a unique buffer name.
+;; The first one tried is prefixsuffix, then prefix<2>suffix, 
+;; prefix<3>suffix, etc.
+(defun emerge-unique-buffer-name (prefix suffix)
+  (if (null (get-buffer (concat prefix suffix)))
+      (concat prefix suffix)
+    (let ((n 2))
+      (while (get-buffer (format "%s<%d>%s" prefix n suffix))
+        (setq n (1+ n)))
+      (format "%s<%d>%s" prefix n suffix))))
+
+;; Verify that we have a difference selected.
+(defun emerge-validate-difference ()
+  (if (not (and (>= emerge-current-difference 0)
+                (< emerge-current-difference emerge-number-of-differences)))
+      (error "No difference selected")))
+
+;;; Functions for saving and restoring a batch of variables
+
+;; These functions save (get the values of) and restore (set the values of)
+;; a list of variables.  The argument is a list of symbols (the names of
+;; the variables).  A list element can also be a list of two functions,
+;; the first of which (when called with no arguments) gets the value, and
+;; the second (when called with a value as an argment) sets the value.
+;; A "function" is anything that funcall can handle as an argument.
+
+(defun emerge-save-variables (vars)
+  (mapcar (function (lambda (v) (if (symbolp v)
+                                    (symbol-value v)
+                                  (funcall (car v)))))
+          vars))
+
+(defun emerge-restore-variables (vars values)
+  (while vars
+    (let ((var (car vars))
+          (value (car values)))
+      (if (symbolp var)
+          (set var value)
+        (funcall (car (cdr var)) value)))
+    (setq vars (cdr vars))
+    (setq values (cdr values))))
+
+;; Make a temporary file that only we have access to.
+;; PREFIX is appended to emerge-temp-file-prefix to make the filename prefix.
+(defun emerge-make-temp-file (prefix)
+  (let ((f (make-temp-name (concat emerge-temp-file-prefix prefix))))
+    ;; create the file
+    (write-region (point-min) (point-min) f nil 'no-message)
+    (set-file-modes f emerge-temp-file-mode)
+    f))
+
+;;; Functions that query the user before he can write out the current buffer.
+
+(defun emerge-query-write-file ()
+  "Query the user if he really wants to write out the incomplete merge.
+If he says yes, call  write-file  to do so.  See  emerge-query-and-call
+for details of the querying process."
+  (interactive)
+  (emerge-query-and-call 'write-file))
+
+(defun emerge-query-save-buffer ()
+  "Query the user if he really wants to write out the incomplete merge.
+If he says yes, call  save-buffer  to do so.  See  emerge-query-and-call
+for details of the querying process."
+  (interactive)
+  (emerge-query-and-call 'save-buffer))
+
+(defun emerge-query-and-call (command)
+  "Query the user if he really wants to write out the incomplete merge.
+If he says yes, call COMMAND interactively.  During the call, the flags
+around the current difference are removed."
+  (if (yes-or-no-p "Do you really write to write out this unfinished merge? ")
+      ;; He really wants to do it -- unselect the difference for the duration
+      (progn
+        (if (and (>= emerge-current-difference 0)
+                 (< emerge-current-difference emerge-number-of-differences))
+            (emerge-unselect-difference emerge-current-difference))
+        ;; call-interactively takes the value of current-prefix-arg as the
+        ;; prefix argument value to be passed to the command.  Thus, we have
+        ;; to do nothing special to make sure the prefix argument is
+        ;; transmitted to the command.
+        (call-interactively command)
+        (if (and (>= emerge-current-difference 0)
+                 (< emerge-current-difference emerge-number-of-differences))
+            (progn
+              (emerge-select-difference emerge-current-difference)
+              (emerge-recenter))))
+    ;; He's being smart and not doing it
+    (message "Not written")))
+
+;; Make sure the current buffer (for a file) has the same contents as the
+;; file on disk, and attempt to remedy the situation if not.
+;; Signal an error if we can't make them the same, or the user doesn't want
+;; to do what is necessary to make them the same.
+(defun emerge-verify-file-buffer ()
+  ;; First check if the file has been modified since the buffer visited it.
+  (if (verify-visited-file-modtime (current-buffer))
+      (if (buffer-modified-p)
+          ;; If buffer is not obsolete and is modified, offer to save
+          (if (yes-or-no-p (format "Save file %s? " buffer-file-name))
+              (save-buffer)
+            (error "Buffer out of sync for file %s" buffer-file-name))
+        ;; If buffer is not obsolete and is not modified, do nothing
+        nil)
+    (if (buffer-modified-p)
+        ;; If buffer is obsolete and is modified, give error
+        (error "Buffer out of sync for file %s" buffer-file-name)
+      ;; If buffer is obsolete and is not modified, offer to revert
+      (if (yes-or-no-p (format "Revert file %s? " buffer-file-name))
+              (revert-buffer t t)
+        (error "Buffer out of sync for file %s" buffer-file-name)))))
+
+;; Utilities that might have value outside of Emerge.
+
+;; Set up the mode in the current buffer to duplicate the mode in another
+;; buffer.
+(defun emerge-copy-modes (buffer)
+  ;; Set the major mode
+  (funcall (emerge-eval-in-buffer buffer major-mode)))
+
+;; Define a key, even if a prefix of it is defined
+(defun emerge-force-define-key (keymap key definition)
+  "Like define-key, but is not stopped if a prefix of KEY is a defined 
+command."
+  ;; Find out if a prefix of key is defined
+  (let ((v (lookup-key keymap key)))
+    ;; If so, undefine it
+    (if (integerp v)
+        (define-key keymap (substring key 0 v) nil)))
+  ;; Now define the key
+  (define-key keymap key definition))
+
+;;; Improvements to describe-mode, so that it describes minor modes as well
+;;; as the major mode
+(defun describe-mode (&optional minor)
+  "Display documentation of current major mode.
+If optional MINOR is non-nil (or prefix argument is given if interactive),
+display documentation of acive minor modes as well.
+For this to work correctly for a minor mode, the mode's indicator variable
+(listed in minor-mode-alist) must also be a function whose documentation
+describes the minor mode."
+  (interactive)
+  (with-output-to-temp-buffer "*Help*"
+    (princ mode-name)
+    (princ " Mode:\n")
+    (princ (documentation major-mode))
+    (let ((minor-modes minor-mode-alist)
+          (locals (buffer-local-variables)))
+      (while minor-modes
+        (let* ((minor-mode (car (car minor-modes)))
+               (indicator (car (cdr (car minor-modes))))
+               (local-binding (assq minor-mode locals)))
+          ;; Document a minor mode if it is listed in minor-mode-alist,
+          ;; bound locally in this buffer, non-nil, and has a function
+          ;; definition.
+          (if (and local-binding
+                   (cdr local-binding)
+                   (fboundp minor-mode))
+              (progn
+                (princ (format "\n\n\n%s minor mode (indicator%s):\n"
+                               minor-mode indicator))
+                (princ (documentation minor-mode)))))
+        (setq minor-modes (cdr minor-modes))))
+    (print-help-return-message)))
+
+;; Adjust things so that keyboard macro definitions are documented correctly.
+(fset 'defining-kbd-macro (symbol-function 'start-kbd-macro))
+
+;; Function to shadow a definition in a keymap with definitions in another.
+(defun emerge-shadow-key-definition (olddef newdef keymap shadowmap)
+  "Shadow OLDDEF with NEWDEF for any keys in KEYMAP with entries in SHADOWMAP.
+In other words, SHADOWMAP will now shadow all definitions of OLDDEF in KEYMAP
+with NEWDEF.  Does not affect keys that are already defined in SHADOWMAP,
+including those whose definition is OLDDEF."
+  ;; loop through all keymaps accessible from keymap
+  (let ((maps (accessible-keymaps keymap)))
+    (while maps
+      (let ((prefix (car (car maps)))
+            (map (cdr (car maps))))
+        ;; examine a keymap
+        (if (arrayp map)
+            ;; array keymap
+            (let ((len (length map))
+                  (i 0))
+              (while (< i len)
+                (if (eq (aref map i) olddef)
+                    ;; set the shadowing definition
+                    (let ((key (concat prefix (char-to-string i))))
+                      (emerge-define-key-if-possible shadowmap key newdef)))
+                (setq i (1+ i))))
+          ;; sparse keymap
+          (while map
+            (if (eq (cdr-safe (car-safe map)) olddef)
+                ;; set the shadowing definition
+                (let ((key
+                       (concat prefix (char-to-string (car (car map))))))
+                      (emerge-define-key-if-possible shadowmap key newdef)))
+            (setq map (cdr map)))))
+      (setq maps (cdr maps)))))
+
+;; Define a key if it (or a prefix) is not already defined in the map.
+(defun emerge-define-key-if-possible (keymap key definition)
+  ;; look up the present definition of the key
+  (let ((present (lookup-key keymap key)))
+    (if (integerp present)
+        ;; if it is "too long", look up the valid prefix
+        (if (not (lookup-key keymap (substring key 0 present)))
+            ;; if the prefix isn't defined, define it
+            (define-key keymap key definition))
+      ;; if there is no present definition, define it
+      (if (not present)
+          (define-key keymap key definition)))))
+
+(defun emerge-recursively-substitute-key-definition (olddef newdef keymap)
+  "Like substitute-key-definition, but examines and substitutes in all
+keymaps accessible from KEYMAP.  Make sure that subordinate keymaps aren't
+shared with other keymaps!  (copy-keymap will suffice.)"
+  ;; Loop through all keymaps accessible from keymap
+  (let ((maps (accessible-keymaps keymap)))
+    (while maps
+      ;; Substitute in this keymap
+      (substitute-key-definition olddef newdef (cdr (car maps)))
+      (setq maps (cdr maps)))))
+
+;; Show the name of the file in the buffer.
+(defun emerge-show-file-name ()
+  "Displays the name of the file loaded into the current buffer.
+If the name won't fit on one line, the minibuffer is expanded to hold it,
+and the command waits for a keystroke from the user.  If the keystroke is
+SPC, it is ignored; if it is anything else, it is processed as a command."
+  (interactive)
+  (let ((name (buffer-file-name)))
+    (or name
+        (setq name "Buffer has no file name."))
+    (save-window-excursion
+      (select-window (minibuffer-window))
+      (erase-buffer)
+      (insert name)
+      (if (not (pos-visible-in-window-p))
+          (let ((echo-keystrokes 0))
+            (while (and (not (pos-visible-in-window-p))
+                        (> (1- (screen-height)) (window-height)))
+              (enlarge-window 1))
+            (let ((c (read-char)))
+              (if (/= c 32)
+                  (setq unread-command-char c))))))))
+
+;; Improved auto-save file names.
+;; This function fixes many problems with the standard auto-save file names:
+;; Auto-save files for non-file buffers get put in the default directory
+;; for the buffer, whether that makes sense or not.
+;; Auto-save files for file buffers get put in the directory of the file,
+;; regardless of whether we can write into it or not.
+;; Auto-save files for non-file buffers don't use the process id, so if a
+;; user runs more than on Emacs, they can make auto-save files that overwrite
+;; each other.
+;; To use this function, do:
+;;      (fset 'make-auto-save-file-name
+;;            (symbol-function 'emerge-make-auto-save-file-name))
+(defun emerge-make-auto-save-file-name ()
+  "Return file name to use for auto-saves of current buffer.
+Does not consider auto-save-visited-file-name; that is checked
+before calling this function.
+You can redefine this for customization.
+See also auto-save-file-name-p."
+  (if buffer-file-name
+      ;; if buffer has a file, try the format <file directory>/#<file name>#
+      (let ((f (concat (file-name-directory buffer-file-name)
+                       "#"
+                       (file-name-nondirectory buffer-file-name)
+                       "#")))
+        (if (file-writable-p f)
+            ;; the file is writable, so use it
+            f
+          ;; the file isn't writable, so use the format
+          ;; ~/#&<file name>&<hash of directory>#
+          (concat (getenv "HOME")
+                  "/#&"
+                  (file-name-nondirectory buffer-file-name)
+                  "&"
+                  (hash-string-into-string
+                   (file-name-directory buffer-file-name))
+                  "#")))
+    ;; if buffer has no file, use the format ~/#%<buffer name>%<process id>#
+    (expand-file-name (concat (getenv "HOME")
+                              "/#%"
+                              ;; quote / into \! and \ into \\
+                              (unslashify-name (buffer-name))
+                              "%"
+                              (make-temp-name "")
+                              "#"))))
+
+;; Hash a string into five characters more-or-less suitable for use in a file
+;; name.  (Allowed characters are ! through ~, except /.)
+(defun hash-string-into-string (s)
+  (let ((bins (vector 0 0 0 0 0))
+        (i 0))
+    (while (< i (length s))
+      (aset bins (% i 5) (% (+ (* (aref bins (% i 5)) 35)
+                               (aref s i))
+                            65536))
+      (setq i (1+ i)))
+    (mapconcat (function (lambda (b)
+                           (setq b (+ (% b 93) ?!))
+                           (if (>= b ?/)
+                               (setq b (1+ b)))
+                           (char-to-string b)))
+               bins "")))
+
+;; Quote any /s in a string by replacing them with \!.
+;; Also, replace any \s by \\, to make it one-to-one.
+(defun unslashify-name (s)
+  (let ((limit 0))
+    (while (string-match "[/\\]" s limit)
+      (setq s (concat (substring s 0 (match-beginning 0))
+                      (if (string= (substring s (match-beginning 0)
+                                              (match-end 0))
+                                   "/")
+                          "\\!"
+                        "\\\\")
+                      (substring s (match-end 0))))
+      (setq limit (1+ (match-end 0)))))
+  s)
+
+;;;;;;;;;;;;;;;; end emerge.el ;;;;;;;;;;;;;;;;
+
+(provide 'emerge)
+
diff --git a/lisp/international/iso-ascii.el b/lisp/international/iso-ascii.el
new file mode 100644
index 00000000000..13aeaaa8c76
--- /dev/null
+++ b/lisp/international/iso-ascii.el
@@ -0,0 +1,126 @@
+;; Set up char tables for ISO 8859/1 character set for ASCII terminals.
+;; Copyright (C) 1987 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU 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.
+
+
+;; Written by Howard Gayle.  See display-table.el for details.
+
+;; This code sets up to display ISO 8859/1 characters on plain
+;; ASCII terminals.  The display strings for the characters are
+;; more-or-less based on TeX.
+
+(require 'disp-table)
+
+(standard-display-ascii 160 "{_}")   ; NBSP (no-break space)
+(standard-display-ascii 161 "{!}")   ; inverted exclamation mark
+(standard-display-ascii 162 "{c}")   ; cent sign
+(standard-display-ascii 163 "{GBP}") ; pound sign
+(standard-display-ascii 164 "{$}")   ; general currency sign
+(standard-display-ascii 165 "{JPY}") ; yen sign
+(standard-display-ascii 166 "{|}")   ; broken vertical line
+(standard-display-ascii 167 "{S}")   ; section sign
+(standard-display-ascii 168 "{\"}")  ; diaeresis
+(standard-display-ascii 169 "{C}")   ; copyright sign
+(standard-display-ascii 170 "{_a}")  ; ordinal indicator, feminine
+(standard-display-ascii 171 "{<<}")  ; left angle quotation mark
+(standard-display-ascii 172 "{~}")   ; not sign
+(standard-display-ascii 173 "{-}")   ; soft hyphen
+(standard-display-ascii 174 "{R}")   ; registered sign
+(standard-display-ascii 175 "{=}")   ; macron
+(standard-display-ascii 176 "{o}")   ; degree sign
+(standard-display-ascii 177 "{+-}")  ; plus or minus sign
+(standard-display-ascii 178 "{2}")   ; superscript two
+(standard-display-ascii 179 "{3}")   ; superscript three
+(standard-display-ascii 180 "{'}")   ; acute accent
+(standard-display-ascii 181 "{u}")   ; micro sign
+(standard-display-ascii 182 "{P}")   ; pilcrow
+(standard-display-ascii 183 "{.}")   ; middle dot
+(standard-display-ascii 184 "{,}")   ; cedilla
+(standard-display-ascii 185 "{1}")   ; superscript one
+(standard-display-ascii 186 "{_o}")  ; ordinal indicator, masculine
+(standard-display-ascii 187 "{>>}")  ; right angle quotation mark
+(standard-display-ascii 188 "{1/4}") ; fraction one-quarter
+(standard-display-ascii 189 "{1/2}") ; fraction one-half
+(standard-display-ascii 190 "{3/4}") ; fraction three-quarters
+(standard-display-ascii 191 "{?}")   ; inverted question mark
+(standard-display-ascii 192 "{`A}")  ; A with grave accent
+(standard-display-ascii 193 "{'A}")  ; A with acute accent
+(standard-display-ascii 194 "{^A}")  ; A with circumflex accent
+(standard-display-ascii 195 "{~A}")  ; A with tilde
+(standard-display-ascii 196 "{\"A}") ; A with diaeresis or umlaut mark
+(standard-display-ascii 197 "{AA}")  ; A with ring
+(standard-display-ascii 198 "{AE}")  ; AE diphthong
+(standard-display-ascii 199 "{,C}")  ; C with cedilla
+(standard-display-ascii 200 "{`E}")  ; E with grave accent
+(standard-display-ascii 201 "{'E}")  ; E with acute accent
+(standard-display-ascii 202 "{^E}")  ; E with circumflex accent
+(standard-display-ascii 203 "{\"E}") ; E with diaeresis or umlaut mark
+(standard-display-ascii 204 "{`I}")  ; I with grave accent
+(standard-display-ascii 205 "{'I}")  ; I with acute accent
+(standard-display-ascii 206 "{^I}")  ; I with circumflex accent
+(standard-display-ascii 207 "{\"I}") ; I with diaeresis or umlaut mark
+(standard-display-ascii 208 "{-D}")  ; D with stroke, Icelandic eth
+(standard-display-ascii 209 "{~N}")  ; N with tilde
+(standard-display-ascii 210 "{`O}")  ; O with grave accent
+(standard-display-ascii 211 "{'O}")  ; O with acute accent
+(standard-display-ascii 212 "{^O}")  ; O with circumflex accent
+(standard-display-ascii 213 "{~O}")  ; O with tilde
+(standard-display-ascii 214 "{\"O}") ; O with diaeresis or umlaut mark
+(standard-display-ascii 215 "{x}")   ; multiplication sign
+(standard-display-ascii 216 "{/O}")  ; O with slash
+(standard-display-ascii 217 "{`U}")  ; U with grave accent
+(standard-display-ascii 218 "{'U}")  ; U with acute accent
+(standard-display-ascii 219 "{^U}")  ; U with circumflex accent
+(standard-display-ascii 220 "{\"U}") ; U with diaeresis or umlaut mark
+(standard-display-ascii 221 "{'Y}")  ; Y with acute accent
+(standard-display-ascii 222 "{TH}")  ; capital thorn, Icelandic
+(standard-display-ascii 223 "{ss}")  ; small sharp s, German
+(standard-display-ascii 224 "{`a}")  ; a with grave accent
+(standard-display-ascii 225 "{'a}")  ; a with acute accent
+(standard-display-ascii 226 "{^a}")  ; a with circumflex accent
+(standard-display-ascii 227 "{~a}")  ; a with tilde
+(standard-display-ascii 228 "{\"a}") ; a with diaeresis or umlaut mark
+(standard-display-ascii 229 "{aa}")  ; a with ring
+(standard-display-ascii 230 "{ae}")  ; ae diphthong
+(standard-display-ascii 231 "{,c}")  ; c with cedilla
+(standard-display-ascii 232 "{`e}")  ; e with grave accent
+(standard-display-ascii 233 "{'e}")  ; e with acute accent
+(standard-display-ascii 234 "{^e}")  ; e with circumflex accent
+(standard-display-ascii 235 "{\"e}") ; e with diaeresis or umlaut mark
+(standard-display-ascii 236 "{`i}")  ; i with grave accent
+(standard-display-ascii 237 "{'i}")  ; i with acute accent
+(standard-display-ascii 238 "{^i}")  ; i with circumflex accent
+(standard-display-ascii 239 "{\"i}") ; i with diaeresis or umlaut mark
+(standard-display-ascii 240 "{-d}")  ; d with stroke, Icelandic eth
+(standard-display-ascii 241 "{~n}")  ; n with tilde
+(standard-display-ascii 242 "{`o}")  ; o with grave accent
+(standard-display-ascii 243 "{'o}")  ; o with acute accent
+(standard-display-ascii 244 "{^o}")  ; o with circumflex accent
+(standard-display-ascii 245 "{~o}")  ; o with tilde
+(standard-display-ascii 246 "{\"o}") ; o with diaeresis or umlaut mark
+(standard-display-ascii 247 "{/}")   ; division sign
+(standard-display-ascii 248 "{/o}")  ; o with slash
+(standard-display-ascii 249 "{`u}")  ; u with grave accent
+(standard-display-ascii 250 "{'u}")  ; u with acute accent
+(standard-display-ascii 251 "{^u}")  ; u with circumflex accent
+(standard-display-ascii 252 "{\"u}") ; u with diaeresis or umlaut mark
+(standard-display-ascii 253 "{'y}")  ; y with acute accent
+(standard-display-ascii 254 "{th}")  ; small thorn, Icelandic
+(standard-display-ascii 255 "{\"y}") ; small y with diaeresis or umlaut mark
+
+(provide 'iso8859-1-ascii)
diff --git a/lisp/international/iso-insert.el b/lisp/international/iso-insert.el
new file mode 100644
index 00000000000..3ea2e8530e8
--- /dev/null
+++ b/lisp/international/iso-insert.el
@@ -0,0 +1,620 @@
+;; Insert functions for ISO 8859/1.
+;; Copyright (C) 1987 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU 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.
+
+
+;; Written by Howard Gayle.  See case-table.el for details.
+
+(defun insert-no-break-space ()
+   (interactive "*")
+   (insert 160)
+)
+
+(defun insert-inverted-exclamation-mark ()
+   (interactive "*")
+   (insert 161)
+)
+
+(defun insert-cent-sign ()
+   (interactive "*")
+   (insert 162)
+)
+
+(defun insert-pound-sign ()
+   (interactive "*")
+   (insert 163)
+)
+
+(defun insert-general-currency-sign ()
+   (interactive "*")
+   (insert 164)
+)
+
+(defun insert-yen-sign ()
+   (interactive "*")
+   (insert 165)
+)
+
+(defun insert-broken-vertical-line ()
+   (interactive "*")
+   (insert 166)
+)
+
+(defun insert-section-sign ()
+   (interactive "*")
+   (insert 167)
+)
+
+(defun insert-diaeresis ()
+   (interactive "*")
+   (insert 168)
+)
+
+(defun insert-copyright-sign ()
+   (interactive "*")
+   (insert 169)
+)
+
+(defun insert-ordinal-indicator-feminine ()
+   (interactive "*")
+   (insert 170)
+)
+
+(defun insert-angle-quotation-mark-left ()
+   (interactive "*")
+   (insert 171)
+)
+
+(defun insert-not-sign ()
+   (interactive "*")
+   (insert 172)
+)
+
+(defun insert-soft-hyphen ()
+   (interactive "*")
+   (insert 173)
+)
+
+(defun insert-registered-sign ()
+   (interactive "*")
+   (insert 174)
+)
+
+(defun insert-macron ()
+   (interactive "*")
+   (insert 175)
+)
+
+(defun insert-degree-sign ()
+   (interactive "*")
+   (insert 176)
+)
+
+(defun insert-plus-or-minus-sign ()
+   (interactive "*")
+   (insert 177)
+)
+
+(defun insert-superscript-two ()
+   (interactive "*")
+   (insert 178)
+)
+
+(defun insert-superscript-three ()
+   (interactive "*")
+   (insert 179)
+)
+
+(defun insert-acute-accent ()
+   (interactive "*")
+   (insert 180)
+)
+
+(defun insert-micro-sign ()
+   (interactive "*")
+   (insert 181)
+)
+
+(defun insert-pilcrow ()
+   (interactive "*")
+   (insert 182)
+)
+
+(defun insert-middle-dot ()
+   (interactive "*")
+   (insert 183)
+)
+
+(defun insert-cedilla ()
+   (interactive "*")
+   (insert 184)
+)
+
+(defun insert-superscript-one ()
+   (interactive "*")
+   (insert 185)
+)
+
+(defun insert-ordinal-indicator-masculine ()
+   (interactive "*")
+   (insert 186)
+)
+
+(defun insert-angle-quotation-mark-right ()
+   (interactive "*")
+   (insert 187)
+)
+
+(defun insert-fraction-one-quarter ()
+   (interactive "*")
+   (insert 188)
+)
+
+(defun insert-fraction-one-half ()
+   (interactive "*")
+   (insert 189)
+)
+
+(defun insert-fraction-three-quarters ()
+   (interactive "*")
+   (insert 190)
+)
+
+(defun insert-inverted-question-mark ()
+   (interactive "*")
+   (insert 191)
+)
+
+(defun insert-A-grave ()
+   (interactive "*")
+   (insert 192)
+)
+
+(defun insert-A-acute ()
+   (interactive "*")
+   (insert 193)
+)
+
+(defun insert-A-circumflex ()
+   (interactive "*")
+   (insert 194)
+)
+
+(defun insert-A-tilde ()
+   (interactive "*")
+   (insert 195)
+)
+
+(defun insert-A-umlaut ()
+   (interactive "*")
+   (insert 196)
+)
+
+(defun insert-A-ring ()
+   (interactive "*")
+   (insert 197)
+)
+
+(defun insert-AE ()
+   (interactive "*")
+   (insert 198)
+)
+
+(defun insert-C-cedilla ()
+   (interactive "*")
+   (insert 199)
+)
+
+(defun insert-E-grave ()
+   (interactive "*")
+   (insert 200)
+)
+
+(defun insert-E-acute ()
+   (interactive "*")
+   (insert 201)
+)
+
+(defun insert-E-circumflex ()
+   (interactive "*")
+   (insert 202)
+)
+
+(defun insert-E-umlaut ()
+   (interactive "*")
+   (insert 203)
+)
+
+(defun insert-I-grave ()
+   (interactive "*")
+   (insert 204)
+)
+
+(defun insert-I-acute ()
+   (interactive "*")
+   (insert 205)
+)
+
+(defun insert-I-circumflex ()
+   (interactive "*")
+   (insert 206)
+)
+
+(defun insert-I-umlaut ()
+   (interactive "*")
+   (insert 207)
+)
+
+(defun insert-D-stroke ()
+   (interactive "*")
+   (insert 208)
+)
+
+(defun insert-N-tilde ()
+   (interactive "*")
+   (insert 209)
+)
+
+(defun insert-O-grave ()
+   (interactive "*")
+   (insert 210)
+)
+
+(defun insert-O-acute ()
+   (interactive "*")
+   (insert 211)
+)
+
+(defun insert-O-circumflex ()
+   (interactive "*")
+   (insert 212)
+)
+
+(defun insert-O-tilde ()
+   (interactive "*")
+   (insert 213)
+)
+
+(defun insert-O-umlaut ()
+   (interactive "*")
+   (insert 214)
+)
+
+(defun insert-multiplication-sign ()
+   (interactive "*")
+   (insert 215)
+)
+
+(defun insert-O-slash ()
+   (interactive "*")
+   (insert 216)
+)
+
+(defun insert-U-grave ()
+   (interactive "*")
+   (insert 217)
+)
+
+(defun insert-U-acute ()
+   (interactive "*")
+   (insert 218)
+)
+
+(defun insert-U-circumflex ()
+   (interactive "*")
+   (insert 219)
+)
+
+(defun insert-U-umlaut ()
+   (interactive "*")
+   (insert 220)
+)
+
+(defun insert-Y-acute ()
+   (interactive "*")
+   (insert 221)
+)
+
+(defun insert-THORN ()
+   (interactive "*")
+   (insert 222)
+)
+
+(defun insert-ss ()
+   (interactive "*")
+   (insert 223)
+)
+
+(defun insert-a-grave ()
+   (interactive "*")
+   (insert 224)
+)
+
+(defun insert-a-acute ()
+   (interactive "*")
+   (insert 225)
+)
+
+(defun insert-a-circumflex ()
+   (interactive "*")
+   (insert 226)
+)
+
+(defun insert-a-tilde ()
+   (interactive "*")
+   (insert 227)
+)
+
+(defun insert-a-umlaut ()
+   (interactive "*")
+   (insert 228)
+)
+
+(defun insert-a-ring ()
+   (interactive "*")
+   (insert 229)
+)
+
+(defun insert-ae ()
+   (interactive "*")
+   (insert 230)
+)
+
+(defun insert-c-cedilla ()
+   (interactive "*")
+   (insert 231)
+)
+
+(defun insert-e-grave ()
+   (interactive "*")
+   (insert 232)
+)
+
+(defun insert-e-acute ()
+   (interactive "*")
+   (insert 233)
+)
+
+(defun insert-e-circumflex ()
+   (interactive "*")
+   (insert 234)
+)
+
+(defun insert-e-umlaut ()
+   (interactive "*")
+   (insert 235)
+)
+
+(defun insert-i-grave ()
+   (interactive "*")
+   (insert 236)
+)
+
+(defun insert-i-acute ()
+   (interactive "*")
+   (insert 237)
+)
+
+(defun insert-i-circumflex ()
+   (interactive "*")
+   (insert 238)
+)
+
+(defun insert-i-umlaut ()
+   (interactive "*")
+   (insert 239)
+)
+
+(defun insert-d-stroke ()
+   (interactive "*")
+   (insert 240)
+)
+
+(defun insert-n-tilde ()
+   (interactive "*")
+   (insert 241)
+)
+
+(defun insert-o-grave ()
+   (interactive "*")
+   (insert 242)
+)
+
+(defun insert-o-acute ()
+   (interactive "*")
+   (insert 243)
+)
+
+(defun insert-o-circumflex ()
+   (interactive "*")
+   (insert 244)
+)
+
+(defun insert-o-tilde ()
+   (interactive "*")
+   (insert 245)
+)
+
+(defun insert-o-umlaut ()
+   (interactive "*")
+   (insert 246)
+)
+
+(defun insert-division-sign ()
+   (interactive "*")
+   (insert 247)
+)
+
+(defun insert-o-slash ()
+   (interactive "*")
+   (insert 248)
+)
+
+(defun insert-u-grave ()
+   (interactive "*")
+   (insert 249)
+)
+
+(defun insert-u-acute ()
+   (interactive "*")
+   (insert 250)
+)
+
+(defun insert-u-circumflex ()
+   (interactive "*")
+   (insert 251)
+)
+
+(defun insert-u-umlaut ()
+   (interactive "*")
+   (insert 252)
+)
+
+(defun insert-y-acute ()
+   (interactive "*")
+   (insert 253)
+)
+
+(defun insert-thorn ()
+   (interactive "*")
+   (insert 254)
+)
+
+(defun insert-y-umlaut ()
+   (interactive "*")
+   (insert 255)
+)
+
+(defvar 8859-1-map nil "Keymap for ISO 8859/1 character insertion.")
+(if 8859-1-map nil
+   (setq 8859-1-map (make-keymap))
+   (define-key 8859-1-map " "    'insert-no-break-space)
+   (define-key 8859-1-map "!"    'insert-inverted-exclamation-mark)
+   (define-key 8859-1-map "\""   (make-sparse-keymap))
+   (define-key 8859-1-map "\"\"" 'insert-diaeresis)
+   (define-key 8859-1-map "\"A"  'insert-A-umlaut)
+   (define-key 8859-1-map "\"E"  'insert-E-umlaut)
+   (define-key 8859-1-map "\"I"  'insert-I-umlaut)
+   (define-key 8859-1-map "\"O"  'insert-O-umlaut)
+   (define-key 8859-1-map "\"U"  'insert-U-umlaut)
+   (define-key 8859-1-map "\"a"  'insert-a-umlaut)
+   (define-key 8859-1-map "\"e"  'insert-e-umlaut)
+   (define-key 8859-1-map "\"i"  'insert-i-umlaut)
+   (define-key 8859-1-map "\"o"  'insert-o-umlaut)
+   (define-key 8859-1-map "\"u"  'insert-u-umlaut)
+   (define-key 8859-1-map "\"y"  'insert-y-umlaut)
+   (define-key 8859-1-map "'"    (make-sparse-keymap))
+   (define-key 8859-1-map "''"   'insert-acute-accent)
+   (define-key 8859-1-map "'A"   'insert-A-acute)
+   (define-key 8859-1-map "'E"   'insert-E-acute)
+   (define-key 8859-1-map "'I"   'insert-I-acute)
+   (define-key 8859-1-map "'O"   'insert-O-acute)
+   (define-key 8859-1-map "'U"   'insert-U-acute)
+   (define-key 8859-1-map "'Y"   'insert-Y-acute)
+   (define-key 8859-1-map "'a"   'insert-a-acute)
+   (define-key 8859-1-map "'e"   'insert-e-acute)
+   (define-key 8859-1-map "'i"   'insert-i-acute)
+   (define-key 8859-1-map "'o"   'insert-o-acute)
+   (define-key 8859-1-map "'u"   'insert-u-acute)
+   (define-key 8859-1-map "'y"   'insert-y-acute)
+   (define-key 8859-1-map "$"    'insert-general-currency-sign)
+   (define-key 8859-1-map "+"    'insert-plus-or-minus-sign)
+   (define-key 8859-1-map ","    (make-sparse-keymap))
+   (define-key 8859-1-map ",,"   'insert-cedilla)
+   (define-key 8859-1-map ",C"   'insert-C-cedilla)
+   (define-key 8859-1-map ",c"   'insert-c-cedilla)
+   (define-key 8859-1-map "-"    'insert-soft-hyphen)
+   (define-key 8859-1-map "."    'insert-middle-dot)
+   (define-key 8859-1-map "/"    (make-sparse-keymap))
+   (define-key 8859-1-map "//"   'insert-division-sign)
+   (define-key 8859-1-map "/O"   'insert-O-slash)
+   (define-key 8859-1-map "/o"   'insert-o-slash)
+   (define-key 8859-1-map "1"    (make-sparse-keymap))
+   (define-key 8859-1-map "1/"   (make-sparse-keymap))
+   (define-key 8859-1-map "1/2"  'insert-fraction-one-half)
+   (define-key 8859-1-map "1/4"  'insert-fraction-one-quarter)
+   (define-key 8859-1-map "3"    (make-sparse-keymap))
+   (define-key 8859-1-map "3/"   (make-sparse-keymap))
+   (define-key 8859-1-map "3/4"  'insert-fraction-three-quarters)
+   (define-key 8859-1-map "<"    'insert-angle-quotation-mark-left)
+   (define-key 8859-1-map "="    'insert-macron)
+   (define-key 8859-1-map ">"    'insert-angle-quotation-mark-right)
+   (define-key 8859-1-map "?"    'insert-inverted-question-mark)
+   (define-key 8859-1-map "A"    (make-sparse-keymap))
+   (define-key 8859-1-map "AA"   'insert-A-ring)
+   (define-key 8859-1-map "AE"   'insert-AE)
+   (define-key 8859-1-map "C"    'insert-copyright-sign)
+   (define-key 8859-1-map "D"    'insert-D-stroke)
+   (define-key 8859-1-map "L"    'insert-pound-sign)
+   (define-key 8859-1-map "P"    'insert-pilcrow)
+   (define-key 8859-1-map "R"    'insert-registered-sign)
+   (define-key 8859-1-map "S"    'insert-section-sign)
+   (define-key 8859-1-map "T"    'insert-THORN)
+   (define-key 8859-1-map "Y"    'insert-yen-sign)
+   (define-key 8859-1-map "^"    (make-sparse-keymap))
+   (define-key 8859-1-map "^1"   'insert-superscript-one)
+   (define-key 8859-1-map "^2"   'insert-superscript-two)
+   (define-key 8859-1-map "^3"   'insert-superscript-three)
+   (define-key 8859-1-map "^A"   'insert-A-circumflex)
+   (define-key 8859-1-map "^E"   'insert-E-circumflex)
+   (define-key 8859-1-map "^I"   'insert-I-circumflex)
+   (define-key 8859-1-map "^O"   'insert-O-circumflex)
+   (define-key 8859-1-map "^U"   'insert-U-circumflex)
+   (define-key 8859-1-map "^a"   'insert-a-circumflex)
+   (define-key 8859-1-map "^e"   'insert-e-circumflex)
+   (define-key 8859-1-map "^i"   'insert-i-circumflex)
+   (define-key 8859-1-map "^o"   'insert-o-circumflex)
+   (define-key 8859-1-map "^u"   'insert-u-circumflex)
+   (define-key 8859-1-map "_"    (make-sparse-keymap))
+   (define-key 8859-1-map "_a"   'insert-ordinal-indicator-feminine)
+   (define-key 8859-1-map "_o"   'insert-ordinal-indicator-masculine)
+   (define-key 8859-1-map "`"    (make-sparse-keymap))
+   (define-key 8859-1-map "`A"   'insert-A-grave)
+   (define-key 8859-1-map "`E"   'insert-E-grave)
+   (define-key 8859-1-map "`I"   'insert-I-grave)
+   (define-key 8859-1-map "`O"   'insert-O-grave)
+   (define-key 8859-1-map "`U"   'insert-U-grave)
+   (define-key 8859-1-map "`a"   'insert-a-grave)
+   (define-key 8859-1-map "`e"   'insert-e-grave)
+   (define-key 8859-1-map "`i"   'insert-i-grave)
+   (define-key 8859-1-map "`o"   'insert-o-grave)
+   (define-key 8859-1-map "`u"   'insert-u-grave)
+   (define-key 8859-1-map "a"    (make-sparse-keymap))
+   (define-key 8859-1-map "aa"   'insert-a-ring)
+   (define-key 8859-1-map "ae"   'insert-ae)
+   (define-key 8859-1-map "c"    'insert-cent-sign)
+   (define-key 8859-1-map "d"    'insert-d-stroke)
+   (define-key 8859-1-map "o"    'insert-degree-sign)
+   (define-key 8859-1-map "s"    'insert-ss)
+   (define-key 8859-1-map "t"    'insert-thorn)
+   (define-key 8859-1-map "u"    'insert-micro-sign)
+   (define-key 8859-1-map "x"    'insert-multiplication-sign)
+   (define-key 8859-1-map "|"    'insert-broken-vertical-line)
+   (define-key 8859-1-map "~"    (make-sparse-keymap))
+   (define-key 8859-1-map "~A"   'insert-A-tilde)
+   (define-key 8859-1-map "~N"   'insert-N-tilde)
+   (define-key 8859-1-map "~O"   'insert-O-tilde)
+   (define-key 8859-1-map "~a"   'insert-a-tilde)
+   (define-key 8859-1-map "~n"   'insert-n-tilde)
+   (define-key 8859-1-map "~o"   'insert-o-tilde)
+   (define-key 8859-1-map "~~"   'insert-not-sign)
+   (if (not (lookup-key global-map "\C-x8"))
+      (define-key global-map "\C-x8" 8859-1-map))
+)
+
+(provide 'iso8859-1-insert)
diff --git a/lisp/international/iso-swed.el b/lisp/international/iso-swed.el
new file mode 100644
index 00000000000..9ab2134381a
--- /dev/null
+++ b/lisp/international/iso-swed.el
@@ -0,0 +1,140 @@
+;; Set up char tables for ISO 8859/1 for Swedish/Finnish terminals.
+;; Copyright (C) 1987 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU 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.
+
+
+;; Written by Howard Gayle.  See case-table.el for details.
+
+;; This code sets up to display ISO 8859/1 characters on
+;; terminals that have ASCII in the G0 set and a Swedish/Finnish
+;; version of ISO 646 in the G1 set.  The G1 set differs from
+;; ASCII as follows:
+;; 
+;; ASCII G1
+;;     $ general currency sign
+;;     @ capital E with acute accent
+;;     [ capital A with diaeresis or umlaut mark
+;;     \ capital O with diaeresis or umlaut mark
+;;     ] capital A with ring
+;;     ^ capital U with diaeresis or umlaut mark
+;;     ` small e with acute accent
+;;     { small a with diaeresis or umlaut mark
+;;     | small o with diaeresis or umlaut mark
+;;     } small a with ring
+;;     ~ small u with diaeresis or umlaut mark
+
+(require 'disp-table)
+
+(standard-display-ascii 160 "{_}")   ; NBSP (no-break space)
+(standard-display-ascii 161 "{!}")   ; inverted exclamation mark
+(standard-display-ascii 162 "{c}")   ; cent sign
+(standard-display-ascii 163 "{GBP}") ; pound sign
+(standard-display-g1    164 ?$)      ; general currency sign
+(standard-display-ascii 165 "{JPY}") ; yen sign
+(standard-display-ascii 166 "{|}")   ; broken vertical line
+(standard-display-ascii 167 "{S}")   ; section sign
+(standard-display-ascii 168 "{\"}")  ; diaeresis
+(standard-display-ascii 169 "{C}")   ; copyright sign
+(standard-display-ascii 170 "{_a}")  ; ordinal indicator, feminine
+(standard-display-ascii 171 "{<<}")  ; left angle quotation mark
+(standard-display-ascii 172 "{~}")   ; not sign
+(standard-display-ascii 173 "{-}")   ; soft hyphen
+(standard-display-ascii 174 "{R}")   ; registered sign
+(standard-display-ascii 175 "{=}")   ; macron
+(standard-display-ascii 176 "{o}")   ; degree sign
+(standard-display-ascii 177 "{+-}")  ; plus or minus sign
+(standard-display-ascii 178 "{2}")   ; superscript two
+(standard-display-ascii 179 "{3}")   ; superscript three
+(standard-display-ascii 180 "{'}")   ; acute accent
+(standard-display-ascii 181 "{u}")   ; micro sign
+(standard-display-ascii 182 "{P}")   ; pilcrow
+(standard-display-ascii 183 "{.}")   ; middle dot
+(standard-display-ascii 184 "{,}")   ; cedilla
+(standard-display-ascii 185 "{1}")   ; superscript one
+(standard-display-ascii 186 "{_o}")  ; ordinal indicator, masculine
+(standard-display-ascii 187 "{>>}")  ; right angle quotation mark
+(standard-display-ascii 188 "{1/4}") ; fraction one-quarter
+(standard-display-ascii 189 "{1/2}") ; fraction one-half
+(standard-display-ascii 190 "{3/4}") ; fraction three-quarters
+(standard-display-ascii 191 "{?}")   ; inverted question mark
+(standard-display-ascii 192 "{`A}")  ; A with grave accent
+(standard-display-ascii 193 "{'A}")  ; A with acute accent
+(standard-display-ascii 194 "{^A}")  ; A with circumflex accent
+(standard-display-ascii 195 "{~A}")  ; A with tilde
+(standard-display-g1    196 ?[)      ; A with diaeresis or umlaut mark
+(standard-display-g1    197 ?])      ; A with ring
+(standard-display-ascii 198 "{AE}")  ; AE diphthong
+(standard-display-ascii 199 "{,C}")  ; C with cedilla
+(standard-display-ascii 200 "{`E}")  ; E with grave accent
+(standard-display-g1    201 ?@)      ; E with acute accent
+(standard-display-ascii 202 "{^E}")  ; E with circumflex accent
+(standard-display-ascii 203 "{\"E}") ; E with diaeresis or umlaut mark
+(standard-display-ascii 204 "{`I}")  ; I with grave accent
+(standard-display-ascii 205 "{'I}")  ; I with acute accent
+(standard-display-ascii 206 "{^I}")  ; I with circumflex accent
+(standard-display-ascii 207 "{\"I}") ; I with diaeresis or umlaut mark
+(standard-display-ascii 208 "{-D}")  ; D with stroke, Icelandic eth
+(standard-display-ascii 209 "{~N}")  ; N with tilde
+(standard-display-ascii 210 "{`O}")  ; O with grave accent
+(standard-display-ascii 211 "{'O}")  ; O with acute accent
+(standard-display-ascii 212 "{^O}")  ; O with circumflex accent
+(standard-display-ascii 213 "{~O}")  ; O with tilde
+(standard-display-g1    214 ?\\)     ; O with diaeresis or umlaut mark
+(standard-display-ascii 215 "{x}")   ; multiplication sign
+(standard-display-ascii 216 "{/O}")  ; O with slash
+(standard-display-ascii 217 "{`U}")  ; U with grave accent
+(standard-display-ascii 218 "{'U}")  ; U with acute accent
+(standard-display-ascii 219 "{^U}")  ; U with circumflex accent
+(standard-display-g1    220 ?^)      ; U with diaeresis or umlaut mark
+(standard-display-ascii 221 "{'Y}")  ; Y with acute accent
+(standard-display-ascii 222 "{TH}")  ; capital thorn, Icelandic
+(standard-display-ascii 223 "{ss}")  ; small sharp s, German
+(standard-display-ascii 224 "{`a}")  ; a with grave accent
+(standard-display-ascii 225 "{'a}")  ; a with acute accent
+(standard-display-ascii 226 "{^a}")  ; a with circumflex accent
+(standard-display-ascii 227 "{~a}")  ; a with tilde
+(standard-display-g1    228 ?{)      ; a with diaeresis or umlaut mark
+(standard-display-g1    229 ?})      ; a with ring
+(standard-display-ascii 230 "{ae}")  ; ae diphthong
+(standard-display-ascii 231 "{,c}")  ; c with cedilla
+(standard-display-ascii 232 "{`e}")  ; e with grave accent
+(standard-display-g1    233 ?`)      ; e with acute accent
+(standard-display-ascii 234 "{^e}")  ; e with circumflex accent
+(standard-display-ascii 235 "{\"e}") ; e with diaeresis or umlaut mark
+(standard-display-ascii 236 "{`i}")  ; i with grave accent
+(standard-display-ascii 237 "{'i}")  ; i with acute accent
+(standard-display-ascii 238 "{^i}")  ; i with circumflex accent
+(standard-display-ascii 239 "{\"i}") ; i with diaeresis or umlaut mark
+(standard-display-ascii 240 "{-d}")  ; d with stroke, Icelandic eth
+(standard-display-ascii 241 "{~n}")  ; n with tilde
+(standard-display-ascii 242 "{`o}")  ; o with grave accent
+(standard-display-ascii 243 "{'o}")  ; o with acute accent
+(standard-display-ascii 244 "{^o}")  ; o with circumflex accent
+(standard-display-ascii 245 "{~o}")  ; o with tilde
+(standard-display-g1    246 ?|)      ; o with diaeresis or umlaut mark
+(standard-display-ascii 247 "{/}")   ; division sign
+(standard-display-ascii 248 "{/o}")  ; o with slash
+(standard-display-ascii 249 "{`u}")  ; u with grave accent
+(standard-display-ascii 250 "{'u}")  ; u with acute accent
+(standard-display-ascii 251 "{^u}")  ; u with circumflex accent
+(standard-display-g1    252 ?~)      ; u with diaeresis or umlaut mark
+(standard-display-ascii 253 "{'y}")  ; y with acute accent
+(standard-display-ascii 254 "{th}")  ; small thorn, Icelandic
+(standard-display-ascii 255 "{\"y}") ; small y with diaeresis or umlaut mark
+
+(provide 'iso8859-1-swedish)
diff --git a/lisp/international/swedish.el b/lisp/international/swedish.el
new file mode 100644
index 00000000000..bda8a7183a4
--- /dev/null
+++ b/lisp/international/swedish.el
@@ -0,0 +1,145 @@
+;; Miscellaneous functions for dealing with Swedish.
+;; Copyright (C) 1988 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU 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.
+
+
+;; Written by Howard Gayle.  See case-table.el for details.
+
+;; See iso-swed.el for a description of the character set.
+
+(require 'iso-syntax)
+
+(defvar swedish-re
+  "[ \t\n]\\(och\\|att\\|en\\|{r\\|\\[R\\|p}\\|P\\]\\|som\\|det\\|av\\|den\\|f|r\\|F\\\\R\\)[ \t\n.,?!:;'\")}]"
+  "Regular expression for common Swedish words.")
+
+(defvar swascii-to-8859-trans
+  (let ((string (make-string 256 ? ))
+        (i 0))
+    (while (< i 256)
+      (aset string i i)
+      (setq i (1+ i)))
+    (aset string ?\[ 196)
+    (aset string ?\] 197)
+    (aset string ?\\ 214)
+    (aset string ?^ 220)
+    (aset string ?\{ 228)
+    (aset string ?\} 229)
+    (aset string ?\` 233)
+    (aset string ?\| 246)
+    (aset string ?~ 252)
+    string)
+  "Trans table from SWASCII to 8859.")
+
+; $ is not converted because it almost always means US
+; dollars, not general currency sign.  @ is not converted
+; because it is more likely to be an at sign in a mail address
+; than an E with acute accent.
+
+(defun swascii-to-8859-buffer ()
+  "Convert characters in buffer from Swedish/Finnish-ascii to ISO 8859/1.
+Works even on read-only buffers.  `$' and `@' are not converted."
+  (interactive)
+  (let  ((buffer-read-only nil))
+    (translate-region (point-min) (point-max) swascii-to-8859-trans)))
+
+(defun swascii-to-8859-buffer-maybe ()
+  "Call swascii-to-8859-buffer if the buffer looks like Swedish-ascii.
+Leaves point just after the word that looks Swedish."
+  (interactive)
+  (let ((case-fold-search t))
+    (if (re-search-forward swedish-re nil t)
+        (swascii-to-8859-buffer))))
+
+(setq rmail-show-message-hook 'swascii-to-8859-buffer-maybe)
+
+(or (boundp 'news-group-hook-alist) (setq news-group-hook-alist nil))
+(setq news-group-hook-alist
+      (append '(("^swnet." . swascii-to-8859-buffer-maybe))
+              news-group-hook-alist))
+
+(defvar 8859-to-swascii-trans
+  (let ((string (make-string 256 ? ))
+        (i 0))
+    (while (< i 256)
+      (aset string i i)
+      (setq i (1+ i)))
+    (aset string 164 ?$)
+    (aset string 196 ?\[)
+    (aset string 197 ?\])
+    (aset string 201 ?@)
+    (aset string 214 ?\\)
+    (aset string 220 ?^)
+    (aset string 228 ?\{)
+    (aset string 229 ?\})
+    (aset string 233 ?\`)
+    (aset string 246 ?\|)
+    (aset string 252 ?~)
+    string)
+  "8859 to SWASCII trans table.")
+
+(defun 8859-to-swascii-buffer ()
+   "Convert characters in buffer from ISO 8859/1 to Swedish/Finnish-ascii."
+   (interactive "*")
+   (translate-region (point-min) (point-max) 8859-to-swascii-trans))
+
+(setq mail-send-hook  '8859-to-swascii-buffer)
+(setq news-inews-hook '8859-to-swascii-buffer)
+
+;; It's not clear what purpose is served by a separate
+;; Swedish mode that differs from Text mode only in having
+;; a separate abbrev table.  Nothing says that the abbrevs you
+;; define in Text mode have to be English!
+
+;(defvar swedish-mode-abbrev-table nil
+;   "Abbrev table used while in swedish mode.")
+;(define-abbrev-table 'swedish-mode-abbrev-table ())
+
+;(defun swedish-mode ()
+;   "Major mode for editing Swedish text intended for humans to
+;read.  Special commands:\\{text-mode-map}
+;Turning on swedish-mode calls the value of the variable
+;text-mode-hook, if that value is non-nil."
+;   (interactive)
+;   (kill-all-local-variables)
+;   (use-local-map text-mode-map)
+;   (setq mode-name "Swedish")
+;   (setq major-mode 'swedish-mode)
+;   (setq local-abbrev-table swedish-mode-abbrev-table)
+;   (set-syntax-table text-mode-syntax-table)
+;   (run-hooks 'text-mode-hook))
+
+;(defun indented-swedish-mode ()
+;   "Major mode for editing indented Swedish text intended for
+;humans to read.\\{indented-text-mode-map}
+;Turning on indented-swedish-mode calls the value of the
+;variable text-mode-hook, if that value is non-nil."
+;   (interactive)
+;   (kill-all-local-variables)
+;   (use-local-map text-mode-map)
+;   (define-abbrev-table 'swedish-mode-abbrev-table ())
+;   (setq local-abbrev-table swedish-mode-abbrev-table)
+;   (set-syntax-table text-mode-syntax-table)
+;   (make-local-variable 'indent-line-function)
+;   (setq indent-line-function 'indent-relative-maybe)
+;   (use-local-map indented-text-mode-map)
+;   (setq mode-name "Indented Swedish")
+;   (setq major-mode 'indented-swedish-mode)
+;   (run-hooks 'text-mode-hook))
+
+(provide 'swedish)
diff --git a/lisp/rot13.el b/lisp/rot13.el
new file mode 100644
index 00000000000..1a884d087de
--- /dev/null
+++ b/lisp/rot13.el
@@ -0,0 +1,41 @@
+;; Display a buffer in rot13.
+;; Copyright (C) 1988 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU 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.
+
+
+;; Written by Howard Gayle.  See case-table.el for details.
+
+;; This hack is mainly to show off the char table stuff.
+
+(defvar rot13-display-table
+  (let ((table (make-display-table))
+        (i 0))
+    (while (< i 26)
+      (aset table (+ i ?a) (make-rope (+ (% (+ i 13) 26) ?a)))
+      (aset table (+ i ?A) (make-rope (+ (% (+ i 13) 26) ?A)))
+      (setq i (1+ i)))
+    table)
+  "Char table for rot 13 display.")
+
+(defun rot13-other-window ()
+  "Display current buffer in rot 13 in another window."
+  (interactive)
+  (let ((w (display-buffer (current-buffer) t)))
+    (set-window-display-table w rot13-display-table)))
+
+(provide 'rot13)
diff --git a/lisp/vt100-led.el b/lisp/vt100-led.el
new file mode 100644
index 00000000000..e8f370835f1
--- /dev/null
+++ b/lisp/vt100-led.el
@@ -0,0 +1,61 @@
+;; Functions for controlling the LEDs on VT-100 terminals & clones.
+;; Copyright (C) 1988 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU 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.
+
+
+;; Written by Howard Gayle.
+
+(defvar led-state (make-vector 5 nil)
+   "The internal state of the LEDs.  Choices are nil, t, `flash.
+Element 0 is not used.")
+
+(defun led-flash (l)
+  "Flash LED l."
+  (aset led-state l 'flash)
+  (led-update))
+
+(defun led-off (&optional l)
+  "Turn off vt100 led number L.  With no argument, turn them all off."
+  (interactive "P")
+  (if l
+      (aset led-state (prefix-numeric-value l) nil)
+    (fillarray led-state nil))
+  (led-update))
+
+(defun led-on (l)
+  "Turn on LED l."
+  (aset led-state l t)
+  (led-update))
+
+(defun led-update ()
+  "Update the terminal's LEDs to reflect the internal state."
+  (let ((f "\e[?0")                     ; String to flash.
+        (o "\e[0")                      ; String for steady on.
+        (l 1))                          ; Current LED number.
+    (while (/= l 5)
+      (let ((s (aref led-state l)))
+        (cond
+         ((eq s 'flash)
+          (setq f (concat f ";" (int-to-string l))))
+         (s
+          (setq o (concat o ";" (int-to-string l))))))
+      (setq l (1+ l)))
+    (setq o (concat o "q" f "t"))
+    (send-string-to-terminal o)))
+
+(provide 'vt100-led)