Addition of CVScommand vim script as a base for HGcommand

contrib/vim/HGAnnotate.vim

@@ -0,0 +1,27 b''
+" $Id: CVSAnnotate.vim,v 1.5 2002/10/01 21:34:02 rhiestan Exp $
+" Vim syntax file
+" Language:	CVS annotate output
+" Maintainer:	Bob Hiestand <[e-mail]>
+" Last Change:	$Date: 2002/10/01 21:34:02 $
+" Remark:	Used by the cvscommand plugin.  Originally written by Mathieu
+" Clabaut
+if version < 600
+  syntax clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+syn match cvsDate 	/\S\S\S \S\+ \d\+ \d\+:\d\+:\d\+ \d\+ [+-]\?\d\+/ contained
+syn match cvsName  	/^\s*\S\+ / 		contained nextgroup=cvsVer
+syn match cvsVer 	/\d\+ / 		contained nextgroup=cvsDate
+syn region cvsHead 	start="^" end=":" 	contains=cvsVer,cvsName,cvsDate
+
+if !exists("did_cvsannotate_syntax_inits")
+let did_cvsannotate_syntax_inits = 1
+hi link cvsText 	String
+hi link cvsDate 	Comment
+hi link cvsName	Type
+hi link cvsVer	Statement
+endif
+
+let b:current_syntax="CVSAnnotate"

contrib/vim/hgcommand.txt

@@ -0,0 +1,617 b''
+*cvscommand.txt*	CVSCommand
+
+For instructions on installing this file, type
+	:help add-local-help
+inside Vim.
+
+Author:  Bob Hiestand <[e-mail]>
+Credits:  Benji Fisher's excellent MatchIt documentation
+
+==============================================================================
+1. Contents						*cvscommand-contents*
+
+	Installation		: |cvscommand-install|
+	CVSCommand Intro	: |cvscommand|
+	CVSCommand Manual	: |cvscommand-manual|
+	Customization		: |cvscommand-customize|
+	SSH "integration"	: |cvscommand-ssh|
+	Bugs			: |cvscommand-bugs|
+
+==============================================================================
+
+2. CVSCommand Installation				*cvscommand-install*
+
+The CVSCommand plugin comprises two files, cvscommand.vim and cvscommand.txt
+(this file).  In order to install the plugin, place the cvscommand.vim file
+into a plugin' directory in your runtime path (please see |add-global-plugin|
+and |'runtimepath'|.
+
+CVSCommand may be customized by setting variables, creating maps, and
+specifying event handlers.  Please see |cvscommand-customize| for more
+details.
+
+This help file can be included in the VIM help system by copying it into a
+'doc' directory in your runtime path and then executing the |:helptags|
+command, specifying the full path of the 'doc' directory.  Please see
+|add-local-help| for more details.
+
+==============================================================================
+
+3. CVSCommand Intro					*cvscommand*
+							*cvscommand-intro*
+
+The CVSCommand plugin provides global ex commands for manipulating
+CVS-controlled source files.  In general, each command operates on the current
+buffer and accomplishes a separate cvs function, such as update, commit, log,
+and others (please see |cvscommand-commands| for a list of all available
+commands).  The results of each operation are displayed in a scratch buffer.
+Several buffer variables are defined for those scratch buffers (please see
+|cvscommand-buffer-variables|).
+
+The notion of "current file" means either the current buffer, or, in the case
+of a directory buffer, the file on the current line within the buffer.
+
+For convenience, any CVSCommand invoked on a CVSCommand scratch buffer acts as
+though it was invoked on the original file and splits the screen so that the
+output appears in a new window.
+
+Many of the commands accept revisions as arguments.  By default, most operate
+on the most recent revision on the current branch if no revision is specified
+(though see |CVSCommandInteractive| to prompt instead).
+
+Each CVSCommand is mapped to a key sequence starting with the <Leader>
+keystroke.  The default mappings may be overridden by supplying different
+mappings before the plugin is loaded, such as in the vimrc, in the standard
+fashion for plugin mappings.  For examples, please see
+|cvscommand-mappings-override|.
+
+The CVSCommand plugin may be configured in several ways.  For more details,
+please see |cvscommand-customize|.
+
+==============================================================================
+
+4. CVSCommand Manual					*cvscommand-manual*
+
+4.1 CVSCommand commands					*cvscommand-commands*
+
+CVSCommand defines the following commands:
+
+|:CVSAdd|
+|:CVSAnnotate|
+|:CVSCommit|
+|:CVSDiff|
+|:CVSEdit|
+|:CVSEditors|
+|:CVSGotoOriginal|
+|:CVSLog|
+|:CVSRevert|
+|:CVSReview|
+|:CVSStatus|
+|:CVSUnedit|
+|:CVSUpdate|
+|:CVSVimDiff|
+|:CVSWatch|
+|:CVSWatchAdd|
+|:CVSWatchOn|
+|:CVSWatchOff|
+|:CVSWatchRemove|
+|:CVSWatchers|
+
+:CVSAdd							*:CVSAdd*
+
+This command performs "cvs add" on the current file.  Please note, this does
+not commit the newly-added file.
+
+:CVSAnnotate						*:CVSAnnotate*
+
+This command performs "cvs annotate" on the current file.  If an argument is
+given, the argument is used as a revision number to display.  If not given an
+argument, it uses the most recent version of the file on the current branch.
+Additionally, if the current buffer is a CVSAnnotate buffer already, the
+version number on the current line is used.
+
+If the |CVSCommandAnnotateParent| variable is set to a non-zero value, the
+version previous to the one on the current line is used instead.  This allows
+one to navigate back to examine the previous version of a line.
+
+The filetype of the CVSCommand scratch buffer is set to 'CVSAnnotate', to take
+advantage of the bundled syntax file.
+
+
+:CVSCommit[!]						*:CVSCommit*
+
+If called with arguments, this performs "cvs commit" using the arguments as
+the log message.
+
+If '!' is used with no arguments, an empty log message is committed.
+
+If called with no arguments, this is a two-step command.  The first step opens
+a buffer to accept a log message.  When that buffer is written, it is
+automatically closed and the file is committed using the information from that
+log message.  The commit can be abandoned if the log message buffer is deleted
+or wiped before being written.
+
+Alternatively, the mapping that is used to invoke :CVSCommit (by default
+<Leader>cc) can be used in the log message buffer to immediately commit.  This
+is useful if the |CVSCommandCommitOnWrite| variable is set to 0 to disable the
+normal commit-on-write behavior.
+
+:CVSDiff						*:CVSDiff*
+
+With no arguments, this performs "cvs diff" on the current file against the
+current repository version.
+
+With one argument, "cvs diff" is performed on the current file against the
+specified revision.
+
+With two arguments, cvs diff is performed between the specified
+revisions of the current file.
+
+This command uses the 'CVSCommandDiffOpt' variable to specify diff options.
+If that variable does not exist, then 'wbBc' is assumed.  If you wish to have
+no options, then set it to the empty string.
+
+:CVSEdit						*:CVSEdit*
+
+This command performs "cvs edit" on the current file.  Yes, the output buffer
+in this case is almost completely useless.
+
+:CVSEditors						*:CVSEditors*
+
+This command performs "cvs edit" on the current file.
+
+:CVSGotoOriginal					*:CVSGotoOriginal*
+
+This command returns the current window to the source buffer, if the current
+buffer is a CVS command output buffer.
+
+:CVSGotoOriginal!
+
+Like ":CVSGotoOriginal" but also executes :bufwipeout on all CVS command
+output buffers for the source buffer.
+
+:CVSLog							*:CVSLog*
+
+Performs "cvs log" on the current file.
+
+If an argument is given, it is passed as an argument to the "-r" option of
+"cvs log".
+
+:CVSRevert						*:CVSRevert*
+
+Replaces the current file with the most recent version from the repository in
+order to wipe out any undesired changes.
+
+:CVSReview						*:CVSReview*
+
+Retrieves a particular version of the current file.  If no argument is given,
+the most recent version of the file on the current branch is retrieved.
+Otherwise, the specified version is retrieved.
+
+:CVSStatus						*:CVSStatus*
+
+Performs "cvs status" on the current file.
+
+:CVSUnedit						*:CVSUnedit*
+
+Performs "cvs unedit" on the current file.  Again, yes, the output buffer here
+is basically useless.
+
+:CVSUpdate						*:CVSUpdate*
+
+Performs "cvs update" on the current file.  This intentionally does not
+automatically reload the current buffer, though vim should prompt the user to
+do so if the underlying file is altered by this command.
+
+:CVSVimDiff						*:CVSVimDiff*
+
+With no arguments, this prompts the user for a revision and then uses vimdiff
+to display the differences between the current file and the specified
+revision.  If no revision is specified, the most recent version of the file on
+the current branch is used.
+
+With one argument, that argument is used as the revision as above.  With two
+arguments, the differences between the two revisions is displayed using
+vimdiff.
+
+With either zero or one argument, the original buffer is used to perform the
+vimdiff.  When the other buffer is closed, the original buffer will be
+returned to normal mode.
+
+Once vimdiff mode is started using the above methods, additional vimdiff
+buffers may be added by passing a single version argument to the command.
+There may be up to 4 vimdiff buffers total.
+
+Using the 2-argument form of the command resets the vimdiff to only those 2
+versions.  Additionally, invoking the command on a different file will close
+the previous vimdiff buffers.
+
+:CVSWatch						*:CVSWatch*
+
+This command takes an argument which must be one of [on|off|add|remove].  The
+command performs "cvs watch" with the given argument on the current file.
+
+:CVSWatchAdd						*:CVSWatchAdd*
+
+This command is an alias for ":CVSWatch add"
+
+:CVSWatchOn						*:CVSWatchOn*
+
+This command is an alias for ":CVSWatch on"
+
+:CVSWatchOff						*:CVSWatchOff*
+
+This command is an alias for ":CVSWatch off"
+
+:CVSWatchRemove						*:CVSWatchRemove*
+
+This command is an alias for ":CVSWatch remove"
+
+:CVSWatchers						*:CVSWatchers*
+
+This command performs "cvs watchers" on the current file.
+
+4.2 Mappings						*cvscommand-mappings*
+
+By default, a mapping is defined for each command.  These mappings execute the
+default (no-argument) form of each command.
+
+<Leader>ca CVSAdd
+<Leader>cn CVSAnnotate
+<Leader>cc CVSCommit
+<Leader>cd CVSDiff
+<Leader>ce CVSEdit
+<Leader>ci CVSEditors
+<Leader>cg CVSGotoOriginal
+<Leader>cG CVSGotoOriginal!
+<Leader>cl CVSLog
+<Leader>cr CVSReview
+<Leader>cs CVSStatus
+<Leader>ct CVSUnedit
+<Leader>cu CVSUpdate
+<Leader>cv CVSVimDiff
+<Leader>cwv CVSWatchers
+<Leader>cwa CVSWatchAdd
+<Leader>cwn CVSWatchOn
+<Leader>cwf CVSWatchOff
+<Leader>cwf CVSWatchRemove
+
+						*cvscommand-mappings-override*
+
+The default mappings can be overriden by user-provided instead by mapping to
+<Plug>CommandName.  This is especially useful when these mappings collide with
+other existing mappings (vim will warn of this during plugin initialization,
+but will not clobber the existing mappings).
+
+For instance, to override the default mapping for :CVSAdd to set it to '\add',
+add the following to the vimrc:
+
+nmap \add <Plug>CVSAdd
+
+4.3 Automatic buffer variables			*cvscommand-buffer-variables*
+
+Several buffer variables are defined in each CVSCommand result buffer.	These
+may be useful for additional customization in callbacks defined in the event
+handlers (please see |cvscommand-events|).
+
+The following variables are automatically defined:
+
+b:cvsOrigBuffNR						*b:cvsOrigBuffNR*
+
+This variable is set to the buffer number of the source file.
+
+b:cvscmd						*b:cvscmd*
+
+This variable is set to the name of the cvs command that created the result
+buffer.
+==============================================================================
+
+5. Configuration and customization			*cvscommand-customize*
+							*cvscommand-config*
+
+The CVSCommand plugin can be configured in two ways:  by setting configuration
+variables (see |cvscommand-options|) or by defining CVSCommand event handlers
+(see |cvscommand-events|).  Additionally, the CVSCommand plugin provides
+several option for naming the CVS result buffers (see |cvscommand-naming|) and
+supported a customized status line (see |cvscommand-statusline| and
+|cvscommand-buffer-management|).
+
+5.1 CVSCommand configuration variables			*cvscommand-options*
+
+Several variables affect the plugin's behavior.  These variables are checked
+at time of execution, and may be defined at the window, buffer, or global
+level and are checked in that order of precedence.
+
+
+The following variables are available:
+
+|CVSCommandAnnotateParent|
+|CVSCommandCommitOnWrite|
+|CVSCommandCVSExec|
+|CVSCommandDeleteOnHide|
+|CVSCommandDiffOpt|
+|CVSCommandDiffSplit|
+|CVSCommandEdit|
+|CVSCommandEnableBufferSetup|
+|CVSCommandInteractive|
+|CVSCommandNameMarker|
+|CVSCommandNameResultBuffers|
+|CVSCommandSplit|
+
+CVSCommandAnnotateParent			*CVSCommandAnnotateParent*
+
+This variable, if set to a non-zero value, causes the zero-argument form of
+CVSAnnotate when invoked on a CVSAnnotate buffer to go to the version previous
+to that displayed on the current line.  If not set, it defaults to 0.
+
+CVSCommandCommitOnWrite				*CVSCommandCommitOnWrite*
+
+This variable, if set to a non-zero value, causes the pending cvs commit
+to take place immediately as soon as the log message buffer is written.
+If set to zero, only the CVSCommit mapping will cause the pending commit to
+occur.	If not set, it defaults to 1.
+
+CVSCommandCVSExec				*CVSCommandCVSExec*
+
+This variable controls the executable used for all CVS commands  If not set,
+it defaults to "cvs".
+
+CVSCommandDeleteOnHide				*CVSCommandDeleteOnHide*
+
+This variable, if set to a non-zero value, causes the temporary CVS result
+buffers to automatically delete themselves when hidden.
+
+CVSCommandDiffOpt				*CVSCommandDiffOpt*
+
+This variable, if set, determines the options passed to the diff command of
+CVS.  If not set, it defaults to 'wbBc'.
+
+CVSCommandDiffSplit				*CVSCommandDiffSplit*
+
+This variable overrides the |CVSCommandSplit| variable, but only for buffers
+created with |:CVSVimDiff|.
+
+CVSCommandEdit					*CVSCommandEdit*
+
+This variable controls whether the original buffer is replaced ('edit') or
+split ('split').  If not set, it defaults to 'edit'.
+
+CVSCommandEnableBufferSetup			*CVSCommandEnableBufferSetup*
+
+This variable, if set to a non-zero value, activates CVS buffer management
+mode see (|cvscommand-buffer-management|).  This mode means that two buffer
+variables, 'CVSRevision' and 'CVSBranch', are set if the file is
+CVS-controlled.  This is useful for displaying version information in the
+status bar.
+
+CVSCommandInteractive				*CVSCommandInteractive*
+
+This variable, if set to a non-zero value, causes appropriate commands (for
+the moment, only |:CVSReview|) to query the user for a revision to use instead
+of the current revision if none is specified.
+
+CVSCommandNameMarker				*CVSCommandNameMarker*
+
+This variable, if set, configures the special attention-getting characters
+that appear on either side of the cvs buffer type in the buffer name.  This
+has no effect unless |CVSCommandNameResultBuffers| is set to a true value.  If
+not set, it defaults to '_'.  
+
+CVSCommandNameResultBuffers			*CVSCommandNameResultBuffers*
+
+This variable, if set to a true value, causes the cvs result buffers to be
+named in the old way ('<source file name> _<cvs command>_').  If not set
+or set to a false value, the result buffer is nameless.
+
+CVSCommandSplit					*CVSCommandSplit*
+
+This variable controls the orientation of the various window splits that
+may occur (such as with CVSVimDiff, when using a CVS command on a CVS
+command buffer, or when the |CVSCommandEdit| variable is set to 'split'.
+If set to 'horizontal', the resulting windows will be on stacked on top of
+one another.  If set to 'vertical', the resulting windows will be
+side-by-side.  If not set, it defaults to 'horizontal' for all but
+CVSVimDiff windows.
+
+5.2 CVSCommand events				*cvscommand-events*
+
+For additional customization, CVSCommand can trigger user-defined events.
+Event handlers are provided by defining User event autocommands (see
+|autocommand|, |User|) in the CVSCommand group with patterns matching the
+event name.
+
+For instance, the following could be added to the vimrc to provide a 'q'
+mapping to quit a CVSCommand scratch buffer:
+
+augroup CVSCommand
+  au CVSCommand User CVSBufferCreated silent! nmap <unique> <buffer> q: bwipeout<cr>
+augroup END
+
+The following hooks are available:
+
+CVSBufferCreated		This event is fired just after a cvs command
+				result buffer is created and filled with the
+				result of a cvs command.  It is executed within
+				the context of the CVS command buffer.  The
+				CVSCommand buffer variables may be useful for
+				handlers of this event (please see
+				|cvscommand-buffer-variables|).
+
+CVSBufferSetup			This event is fired just after CVS buffer setup
+				occurs, if enabled.
+
+CVSPluginInit			This event is fired when the CVSCommand plugin
+				first loads.
+
+CVSPluginFinish			This event is fired just after the CVSCommand
+				plugin loads.
+
+CVSVimDiffFinish		This event is fired just after the CVSVimDiff
+				command executes to allow customization of,
+				for instance, window placement and focus.
+
+5.3 CVSCommand buffer naming				*cvscommand-naming*
+
+By default, the buffers containing the result of CVS commands are nameless
+scratch buffers.  It is intended that buffer variables of those buffers be
+used to customize the statusline option so that the user may fully control the
+display of result buffers.
+
+If the old-style naming is desired, please enable the
+|CVSCommandNameResultBuffers| variable.  Then, each result buffer will receive
+a unique name that includes the source file name, the CVS command, and any
+extra data (such as revision numbers) that were part of the command.
+
+5.4 CVSCommand status line support			*cvscommand-statusline*
+
+It is intended that the user will customize the |'statusline'| option to
+include CVS result buffer attributes.  A sample function that may be used in
+the |'statusline'| option is provided by the plugin, CVSGetStatusLine().  In
+order to use that function in the status line, do something like the
+following:
+
+set statusline=%<%f\ %{CVSGetStatusLine()}\ %h%m%r%=%l,%c%V\ %P
+
+of which %{CVSGetStatusLine()} is the relevant portion.
+
+The sample CVSGetStatusLine() function handles both CVS result buffers and
+CVS-managed files if CVSCommand buffer management is enabled (please see
+|cvscommand-buffer-management|).
+
+5.5 CVSCommand buffer management		*cvscommand-buffer-management*
+
+The CVSCommand plugin can operate in buffer management mode, which means that
+it attempts to set two buffer variables ('CVSRevision' and 'CVSBranch') upon
+entry into a buffer.  This is rather slow because it means that 'cvs status'
+will be invoked at each entry into a buffer (during the |BufEnter|
+autocommand).
+
+This mode is disabled by default.  In order to enable it, set the
+|CVSCommandEnableBufferSetup| variable to a true (non-zero) value.  Enabling
+this mode simply provides the buffer variables mentioned above.  The user must
+explicitly include those in the |'statusline'| option if they are to appear in
+the status line (but see |cvscommand-statusline| for a simple way to do that).
+
+==============================================================================
+
+6. SSH "integration"					*cvscommand-ssh*
+
+The following instructions are intended for use in integrating the
+cvscommand.vim plugin with an SSH-based CVS environment.
+
+Familiarity with SSH and CVS are assumed.
+
+These instructions assume that the intent is to have a message box pop up in
+order to allow the user to enter a passphrase.  If, instead, the user is
+comfortable using certificate-based authentication, then only instructions
+6.1.1 and 6.1.2 (and optionally 6.1.4) need to be followed; ssh should then
+work transparently.
+
+6.1 Environment settings				*cvscommand-ssh-env*
+
+6.1.1 CVSROOT should be set to something like:
+
+	:ext:user@host:/path_to_repository
+
+6.1.2 CVS_RSH should be set to:
+
+	ssh
+
+	Together, those settings tell CVS to use ssh as the transport when
+	performing CVS calls.
+
+6.1.3 SSH_ASKPASS should be set to the password-dialog program.  In my case,
+	running gnome, it's set to:
+
+	/usr/libexec/openssh/gnome-ssh-askpass
+
+	This tells SSH how to get passwords if no input is available.
+
+6.1.4 OPTIONAL.  You may need to set SSH_SERVER to the location of the cvs
+	executable on the remote (server) machine.
+
+6.2 CVS wrapper program				*cvscommand-ssh-wrapper*
+
+Now you need to convince SSH to use the password-dialog program.  This means
+you need to execute SSH (and therefore CVS) without standard input.  The
+following script is a simple perl wrapper that dissasociates the CVS command
+from the current terminal.  Specific steps to do this may vary from system to
+system; the following example works for me on linux.
+
+#!/usr/bin/perl -w
+use strict;
+use POSIX qw(setsid);
+open STDIN, '/dev/null';
+fork and do {wait; exit;};
+setsid;
+exec('cvs', @ARGV);
+
+6.3 Configuring cvscommand.vim			*cvscommand-ssh-config*
+
+At this point, you should be able to use your wrapper script to invoke CVS with
+various commands, and get the password dialog.  All that's left is to make CVS
+use your newly-created wrapper script.
+
+6.3.1 Tell cvscommand.vim what CVS executable to use.  The easiest way to do this
+	is globally, by putting the following in your .vimrc:
+
+	let CVSCommandCVSExec=/path/to/cvs/wrapper/script
+
+6.4 Where to go from here			*cvscommand-ssh-other*
+
+The script given above works even when non-SSH CVS connections are used,
+except possibly when interactively entering the message for CVS commit log
+(depending on the editor you use... VIM works fine).  Since the cvscommand.vim
+plugin handles that message without a terminal, the wrapper script can be used
+all the time.
+
+This allows mixed-mode operation, where some work is done with SSH-based CVS
+repositories, and others with pserver or local access.
+
+It is possible, though beyond the scope of the plugin, to dynamically set the
+CVS executable based on the CVSROOT for the file being edited.  The user
+events provided (such as CVSBufferCreated and CVSBufferSetup) can be used to
+set a buffer-local value (b:CVSCommandCVSExec) to override the CVS executable
+on a file-by-file basis.  Alternatively, much the same can be done (less
+automatically) by the various project-oriented plugins out there.
+
+It is highly recommended for ease-of-use that certificates with no passphrase
+or ssh-agent are employed so that the user is not given the password prompt
+too often.
+
+==============================================================================
+9. Tips							*cvscommand-tips*
+
+9.1 Split window annotation, by Michael Anderson
+
+:nmap <Leader>cN :vs<CR><C-w>h<Leader>cn:vertical res 40<CR>
+                 \ggdddd:set scb<CR>:set nowrap<CR><C-w>lgg:set scb<CR>
+                 \:set nowrap<CR>
+
+This splits the buffer vertically, puts an annotation on the left (minus the
+header) with the width set to 40. An editable/normal copy is placed on the
+right.  The two versions are scroll locked so they  move as one. and wrapping
+is turned off so that the lines line up correctly. The advantages are...
+
+1) You get a versioning on the right.
+2) You can still edit your own code.
+3) Your own code still has syntax highlighting.
+
+==============================================================================
+
+8. Known bugs						*cvscommand-bugs*
+
+Please let me know if you run across any.
+
+CVSUnedit may, if a file is changed from the repository, provide prompt text
+to determine whether the changes should be thrown away.  Currently, that text
+shows up in the CVS result buffer as information; there is no way for the user
+to actually respond to the prompt and the CVS unedit command does nothing.  If
+this really bothers anyone, please let me know.
+
+CVSVimDiff, when using the original (real) source buffer as one of the diff
+buffers, uses some hacks to try to restore the state of the original buffer
+when the scratch buffer containing the other version is destroyed.  There may
+still be bugs in here, depending on many configuration details.
+
+vim:tw=78:ts=8:ft=help

contrib/vim/hgcommand.vim

@@ -0,0 +1,1387 b''
+" vim600: set foldmethod=marker:
+"
+" Vim plugin to assist in working with CVS-controlled files.
+"
+" Last Change:   2006/02/22
+" Version:       1.76
+" Maintainer:    Bob Hiestand <[e-mail]>
+" License:       This file is placed in the public domain.
+" Credits: {{{1
+"                Mathieu Clabaut for many suggestions and improvements.
+"
+"                Suresh Govindachar and Jeeva Chelladhurai for finding waaaay
+"                too many bugs.
+"
+"                Suresh Govindachar (again!) for finding the
+"                fully-folded-last-line-delete bug.
+"
+"                Albrecht Gass for the Delete-on-Hide behavior suggestion.
+"
+"                Joe MacDonald for finding the CVS log message header bug and
+"                pointing out that buffer refreshes are needed after CVS
+"                \%(un\)\?edit.
+"
+"                Srinath Avadhanula for the suggestion and original patch for
+"                the CVSCommitOnWrite option and mapping hot key.
+"
+"                John Sivak for helping to debug Windows issues and suggesting
+"                the CVSEditors and CVSWatchers commands.
+"
+"                Igor Levko for the patch to recognize numerical sticky tags.
+"
+"                Domink Strasser for the patch to correct the status line for
+"                CVSAdd'd files.
+"
+"                Weerapong Sirikanya for finding a bug with CVSCommit and
+"                autochdir.
+"
+"                David Gotz for finding a bug with CVSVimDiff buffer splitting
+"                and original buffer restoration.
+"
+"                CJ van den Berg for the patch to not change working directory
+"                when editing a non-CVS file.
+"
+"                Luca Gerli for noticing bad behavior for keywords in files
+"                after commit if split windows are used.
+
+" Section: Documentation {{{1
+"
+" Provides functions to invoke various CVS commands on the current file
+" (either the current buffer, or, in the case of an directory buffer, the file
+" on the current line).  The output of the commands is captured in a new
+" scratch window.  For convenience, if the functions are invoked on a CVS
+" output window, the original file is used for the cvs operation instead after
+" the window is split.  This is primarily useful when running CVSCommit and
+" you need to see the changes made, so that CVSDiff is usable and shows up in
+" another window.
+"
+" Command documentation {{{2
+"
+" CVSAdd           Performs "cvs add" on the current file.
+"
+" CVSAnnotate      Performs "cvs annotate" on the current file.  If an
+"                  argument is given, the argument is used as a revision
+"                  number to display.  If not given an argument, it uses the
+"                  most recent version of the file on the current branch.
+"                  Additionally, if the current buffer is a CVSAnnotate buffer
+"                  already, the version number on the current line is used.
+"
+"                  If the 'CVSCommandAnnotateParent' variable is set to a
+"                  non-zero value, the version previous to the one on the
+"                  current line is used instead.  This allows one to navigate
+"                  back to examine the previous version of a line.
+"
+" CVSCommit[!]     If called with arguments, this performs "cvs commit" using
+"                  the arguments as the log message.
+"
+"                  If '!' is used, an empty log message is committed.
+"
+"                  If called with no arguments, this is a two-step command.
+"                  The first step opens a buffer to accept a log message.
+"                  When that buffer is written, it is automatically closed and
+"                  the file is committed using the information from that log
+"                  message.  The commit can be abandoned if the log message
+"                  buffer is deleted or wiped before being written.
+"
+" CVSDiff          With no arguments, this performs "cvs diff" on the current
+"                  file.  With one argument, "cvs diff" is performed on the
+"                  current file against the specified revision.  With two
+"                  arguments, cvs diff is performed between the specified
+"                  revisions of the current file.  This command uses the
+"                  'CVSCommandDiffOpt' variable to specify diff options.  If
+"                  that variable does not exist, then 'wbBc' is assumed.  If
+"                  you wish to have no options, then set it to the empty
+"                  string.
+"
+" CVSEdit          Performs "cvs edit" on the current file.
+"
+" CVSEditors       Performs "cvs editors" on the current file.
+"
+" CVSGotoOriginal  Returns the current window to the source buffer if the
+"                  current buffer is a CVS output buffer.
+"
+" CVSLog           Performs "cvs log" on the current file.
+"
+" CVSRevert        Replaces the modified version of the current file with the
+"                  most recent version from the repository.
+"
+" CVSReview        Retrieves a particular version of the current file.  If no
+"                  argument is given, the most recent version of the file on
+"                  the current branch is retrieved.  The specified revision is
+"                  retrieved into a new buffer.
+"
+" CVSStatus        Performs "cvs status" on the current file.
+"
+" CVSUnedit        Performs "cvs unedit" on the current file.
+"
+" CVSUpdate        Performs "cvs update" on the current file.
+"
+" CVSVimDiff       With no arguments, this prompts the user for a revision and
+"                  then uses vimdiff to display the differences between the
+"                  current file and the specified revision.  If no revision is
+"                  specified, the most recent version of the file on the
+"                  current branch is used.  With one argument, that argument
+"                  is used as the revision as above.  With two arguments, the
+"                  differences between the two revisions is displayed using
+"                  vimdiff.
+"
+"                  With either zero or one argument, the original buffer is used
+"                  to perform the vimdiff.  When the other buffer is closed, the
+"                  original buffer will be returned to normal mode.
+"
+"                  Once vimdiff mode is started using the above methods,
+"                  additional vimdiff buffers may be added by passing a single
+"                  version argument to the command.  There may be up to 4
+"                  vimdiff buffers total.
+"
+"                  Using the 2-argument form of the command resets the vimdiff
+"                  to only those 2 versions.  Additionally, invoking the
+"                  command on a different file will close the previous vimdiff
+"                  buffers.
+"
+" CVSWatch         Takes an argument which must be one of [on|off|add|remove].
+"                  Performs "cvs watch" with the given argument on the current
+"                  file.
+"
+" CVSWatchers      Performs "cvs watchers" on the current file.
+"
+" CVSWatchAdd      Alias for "CVSWatch add"
+"
+" CVSWatchOn       Alias for "CVSWatch on"
+"
+" CVSWatchOff      Alias for "CVSWatch off"
+"
+" CVSWatchRemove   Alias for "CVSWatch remove"
+"
+" Mapping documentation: {{{2
+"
+" By default, a mapping is defined for each command.  User-provided mappings
+" can be used instead by mapping to <Plug>CommandName, for instance:
+"
+" nnoremap ,ca <Plug>CVSAdd
+"
+" The default mappings are as follow:
+"
+"   <Leader>ca CVSAdd
+"   <Leader>cn CVSAnnotate
+"   <Leader>cc CVSCommit
+"   <Leader>cd CVSDiff
+"   <Leader>ce CVSEdit
+"   <Leader>ci CVSEditors
+"   <Leader>cg CVSGotoOriginal
+"   <Leader>cG CVSGotoOriginal!
+"   <Leader>cl CVSLog
+"   <Leader>cr CVSReview
+"   <Leader>cs CVSStatus
+"   <Leader>ct CVSUnedit
+"   <Leader>cu CVSUpdate
+"   <Leader>cv CVSVimDiff
+"   <Leader>cwv CVSWatchers
+"   <Leader>cwa CVSWatchAdd
+"   <Leader>cwn CVSWatchOn
+"   <Leader>cwa CVSWatchOff
+"   <Leader>cwr CVSWatchRemove
+"
+" Options documentation: {{{2
+"
+" Several variables are checked by the script to determine behavior as follow:
+"
+" CVSCommandAnnotateParent
+"   This variable, if set to a non-zero value, causes the zero-argument form
+"   of CVSAnnotate when invoked on a CVSAnnotate buffer to go to the version
+"   previous to that displayed on the current line.  If not set, it defaults
+"   to 0.
+"
+" CVSCommandCommitOnWrite
+"   This variable, if set to a non-zero value, causes the pending cvs commit
+"   to take place immediately as soon as the log message buffer is written.
+"   If set to zero, only the CVSCommit mapping will cause the pending commit
+"   to occur.  If not set, it defaults to 1.
+"
+" CVSCommandDeleteOnHide
+"   This variable, if set to a non-zero value, causes the temporary CVS result
+"   buffers to automatically delete themselves when hidden.
+"
+" CVSCommandDiffOpt
+"   This variable, if set, determines the options passed to the diff command
+"   of CVS.  If not set, it defaults to 'wbBc'.
+"
+" CVSCommandDiffSplit
+"   This variable overrides the CVSCommandSplit variable, but only for buffers
+"   created with CVSVimDiff.
+"
+" CVSCommandEdit
+"   This variable controls whether the original buffer is replaced ('edit') or
+"   split ('split').  If not set, it defaults to 'edit'.
+"
+" CVSCommandEnableBufferSetup
+"   This variable, if set to a non-zero value, activates CVS buffer management
+"   mode.  This mode means that two buffer variables, 'CVSRevision' and
+"   'CVSBranch', are set if the file is CVS-controlled.  This is useful for
+"   displaying version information in the status bar.
+"
+" CVSCommandInteractive
+"   This variable, if set to a non-zero value, causes appropriate functions (for
+"   the moment, only CVSReview) to query the user for a revision to use
+"   instead of the current revision if none is specified.
+"
+" CVSCommandNameMarker
+"   This variable, if set, configures the special attention-getting characters
+"   that appear on either side of the cvs buffer type in the buffer name.
+"   This has no effect unless 'CVSCommandNameResultBuffers' is set to a true
+"   value.  If not set, it defaults to '_'.  
+"
+" CVSCommandNameResultBuffers
+"   This variable, if set to a true value, causes the cvs result buffers to be
+"   named in the old way ('<source file name> _<cvs command>_').  If not set
+"   or set to a false value, the result buffer is nameless.
+"
+" CVSCommandSplit
+"   This variable controls the orientation of the various window splits that
+"   may occur (such as with CVSVimDiff, when using a CVS command on a CVS
+"   command buffer, or when the 'CVSCommandEdit' variable is set to 'split'.
+"   If set to 'horizontal', the resulting windows will be on stacked on top of
+"   one another.  If set to 'vertical', the resulting windows will be
+"   side-by-side.  If not set, it defaults to 'horizontal' for all but
+"   CVSVimDiff windows.
+"
+" Event documentation {{{2
+"   For additional customization, cvscommand.vim uses User event autocommand
+"   hooks.  Each event is in the CVSCommand group, and different patterns
+"   match the various hooks.
+"
+"   For instance, the following could be added to the vimrc to provide a 'q'
+"   mapping to quit a CVS buffer:
+"
+"   augroup CVSCommand
+"     au CVSCommand User CVSBufferCreated silent! nmap <unique> <buffer> q :bwipeout<cr> 
+"   augroup END
+"
+"   The following hooks are available:
+"
+"   CVSBufferCreated           This event is fired just after a cvs command
+"                              result buffer is created and filled with the
+"                              result of a cvs command.  It is executed within
+"                              the context of the new buffer.
+"
+"   CVSBufferSetup             This event is fired just after CVS buffer setup
+"                              occurs, if enabled.
+"
+"   CVSPluginInit              This event is fired when the CVSCommand plugin
+"                              first loads.
+"
+"   CVSPluginFinish            This event is fired just after the CVSCommand
+"                              plugin loads.
+"
+"   CVSVimDiffFinish           This event is fired just after the CVSVimDiff
+"                              command executes to allow customization of,
+"                              for instance, window placement and focus.
+"
+" Section: Plugin header {{{1
+
+" loaded_cvscommand is set to 1 when the initialization begins, and 2 when it
+" completes.  This allows various actions to only be taken by functions after
+" system initialization.
+
+if exists("loaded_cvscommand")
+   finish
+endif
+let loaded_cvscommand = 1
+
+if v:version < 602
+  echohl WarningMsg|echomsg "CVSCommand 1.69 or later requires VIM 6.2 or later"|echohl None
+  finish
+endif
+
+" Section: Event group setup {{{1
+
+augroup CVSCommand
+augroup END
+
+" Section: Plugin initialization {{{1
+silent do CVSCommand User CVSPluginInit
+
+" Section: Script variable initialization {{{1
+
+let s:CVSCommandEditFileRunning = 0
+unlet! s:vimDiffRestoreCmd
+unlet! s:vimDiffSourceBuffer
+unlet! s:vimDiffBufferCount
+unlet! s:vimDiffScratchList
+
+" Section: Utility functions {{{1
+
+" Function: s:CVSResolveLink() {{{2
+" Fully resolve the given file name to remove shortcuts or symbolic links.
+
+function! s:CVSResolveLink(fileName)
+  let resolved = resolve(a:fileName)
+  if resolved != a:fileName
+    let resolved = s:CVSResolveLink(resolved)
+  endif
+  return resolved
+endfunction
+
+" Function: s:CVSChangeToCurrentFileDir() {{{2
+" Go to the directory in which the current CVS-controlled file is located.
+" If this is a CVS command buffer, first switch to the original file.
+
+function! s:CVSChangeToCurrentFileDir(fileName)
+  let oldCwd=getcwd()
+  let fileName=s:CVSResolveLink(a:fileName)
+  let newCwd=fnamemodify(fileName, ':h')
+  if strlen(newCwd) > 0
+    execute 'cd' escape(newCwd, ' ')
+  endif
+  return oldCwd
+endfunction
+
+" Function: s:CVSGetOption(name, default) {{{2
+" Grab a user-specified option to override the default provided.  Options are
+" searched in the window, buffer, then global spaces.
+
+function! s:CVSGetOption(name, default)
+  if exists("s:" . a:name . "Override")
+    execute "return s:".a:name."Override"
+  elseif exists("w:" . a:name)
+    execute "return w:".a:name
+  elseif exists("b:" . a:name)
+    execute "return b:".a:name
+  elseif exists("g:" . a:name)
+    execute "return g:".a:name
+  else
+    return a:default
+  endif
+endfunction
+
+" Function: s:CVSEditFile(name, origBuffNR) {{{2
+" Wrapper around the 'edit' command to provide some helpful error text if the
+" current buffer can't be abandoned.  If name is provided, it is used;
+" otherwise, a nameless scratch buffer is used.
+" Returns: 0 if successful, -1 if an error occurs.
+
+function! s:CVSEditFile(name, origBuffNR)
+  "Name parameter will be pasted into expression.
+  let name = escape(a:name, ' *?\')
+
+  let editCommand = s:CVSGetOption('CVSCommandEdit', 'edit')
+  if editCommand != 'edit'
+    if s:CVSGetOption('CVSCommandSplit', 'horizontal') == 'horizontal'
+      if name == ""
+        let editCommand = 'rightbelow new'
+      else
+        let editCommand = 'rightbelow split ' . name
+      endif
+    else
+      if name == ""
+        let editCommand = 'vert rightbelow new'
+      else
+        let editCommand = 'vert rightbelow split ' . name
+      endif
+    endif
+  else
+    if name == ""
+      let editCommand = 'enew'
+    else
+      let editCommand = 'edit ' . name
+    endif
+  endif
+
+  " Protect against useless buffer set-up
+  let s:CVSCommandEditFileRunning = s:CVSCommandEditFileRunning + 1
+  try
+    execute editCommand
+  finally
+    let s:CVSCommandEditFileRunning = s:CVSCommandEditFileRunning - 1
+  endtry
+
+  let b:CVSOrigBuffNR=a:origBuffNR
+  let b:CVSCommandEdit='split'
+endfunction
+
+" Function: s:CVSCreateCommandBuffer(cmd, cmdName, statusText, filename) {{{2
+" Creates a new scratch buffer and captures the output from execution of the
+" given command.  The name of the scratch buffer is returned.
+
+function! s:CVSCreateCommandBuffer(cmd, cmdName, statusText, origBuffNR)
+  let fileName=bufname(a:origBuffNR)
+
+  let resultBufferName=''
+
+  if s:CVSGetOption("CVSCommandNameResultBuffers", 0)
+    let nameMarker = s:CVSGetOption("CVSCommandNameMarker", '_')
+    if strlen(a:statusText) > 0
+      let bufName=a:cmdName . ' -- ' . a:statusText
+    else
+      let bufName=a:cmdName
+    endif
+    let bufName=fileName . ' ' . nameMarker . bufName . nameMarker
+    let counter=0
+    let resultBufferName = bufName
+    while buflisted(resultBufferName)
+      let counter=counter + 1
+      let resultBufferName=bufName . ' (' . counter . ')'
+    endwhile
+  endif
+
+  let cvsCommand = s:CVSGetOption("CVSCommandCVSExec", "cvs") . " " . a:cmd
+  let cvsOut = system(cvsCommand)
+  " HACK:  diff command does not return proper error codes
+  if v:shell_error && a:cmdName != 'cvsdiff'
+    if strlen(cvsOut) == 0
+      echoerr "CVS command failed"
+    else
+      echoerr "CVS command failed:  " . cvsOut
+    endif
+    return -1
+  endif
+  if strlen(cvsOut) == 0
+    " Handle case of no output.  In this case, it is important to check the
+    " file status, especially since cvs edit/unedit may change the attributes
+    " of the file with no visible output.
+
+    echomsg "No output from CVS command"
+    checktime
+    return -1
+  endif
+
+  if s:CVSEditFile(resultBufferName, a:origBuffNR) == -1
+    return -1
+  endif
+
+  set buftype=nofile
+  set noswapfile
+  set filetype=
+
+  if s:CVSGetOption("CVSCommandDeleteOnHide", 0)
+    set bufhidden=delete
+  endif
+
+  silent 0put=cvsOut
+
+  " The last command left a blank line at the end of the buffer.  If the
+  " last line is folded (a side effect of the 'put') then the attempt to
+  " remove the blank line will kill the last fold.
+  "
+  " This could be fixed by explicitly detecting whether the last line is
+  " within a fold, but I prefer to simply unfold the result buffer altogether.
+
+  if has('folding')
+    normal zR
+  endif
+
+  $d
+  1
+
+  " Define the environment and execute user-defined hooks.
+
+  let b:CVSSourceFile=fileName
+  let b:CVSCommand=a:cmdName
+  if a:statusText != ""
+    let b:CVSStatusText=a:statusText
+  endif
+
+  silent do CVSCommand User CVSBufferCreated
+  return bufnr("%")
+endfunction
+
+" Function: s:CVSBufferCheck(cvsBuffer) {{{2
+" Attempts to locate the original file to which CVS operations were applied
+" for a given buffer.
+
+function! s:CVSBufferCheck(cvsBuffer)
+  let origBuffer = getbufvar(a:cvsBuffer, "CVSOrigBuffNR")
+  if origBuffer
+    if bufexists(origBuffer)
+      return origBuffer
+    else
+      " Original buffer no longer exists.
+      return -1 
+    endif
+  else
+    " No original buffer
+    return a:cvsBuffer
+  endif
+endfunction
+
+" Function: s:CVSCurrentBufferCheck() {{{2
+" Attempts to locate the original file to which CVS operations were applied
+" for the current buffer.
+
+function! s:CVSCurrentBufferCheck()
+  return s:CVSBufferCheck(bufnr("%"))
+endfunction
+
+" Function: s:CVSToggleDeleteOnHide() {{{2
+" Toggles on and off the delete-on-hide behavior of CVS buffers
+
+function! s:CVSToggleDeleteOnHide()
+  if exists("g:CVSCommandDeleteOnHide")
+    unlet g:CVSCommandDeleteOnHide
+  else
+    let g:CVSCommandDeleteOnHide=1
+  endif
+endfunction
+
+" Function: s:CVSDoCommand(cvscmd, cmdName, statusText) {{{2
+" General skeleton for CVS function execution.
+" Returns: name of the new command buffer containing the command results
+
+function! s:CVSDoCommand(cmd, cmdName, statusText)
+  let cvsBufferCheck=s:CVSCurrentBufferCheck()
+  if cvsBufferCheck == -1 
+    echo "Original buffer no longer exists, aborting."
+    return -1
+  endif
+
+  let fileName=bufname(cvsBufferCheck)
+  if isdirectory(fileName)
+    let fileName=fileName . "/" . getline(".")
+  endif
+  let realFileName = fnamemodify(s:CVSResolveLink(fileName), ':t')
+  let oldCwd=s:CVSChangeToCurrentFileDir(fileName)
+  try
+    if !filereadable('CVS/Root')
+      throw fileName . ' is not a CVS-controlled file.'
+    endif
+    let fullCmd = a:cmd . ' "' . realFileName . '"'
+    let resultBuffer=s:CVSCreateCommandBuffer(fullCmd, a:cmdName, a:statusText, cvsBufferCheck)
+    return resultBuffer
+  catch
+    echoerr v:exception
+    return -1
+  finally
+    execute 'cd' escape(oldCwd, ' ')
+  endtry
+endfunction
+
+
+" Function: s:CVSGetStatusVars(revision, branch, repository) {{{2
+"
+" Obtains a CVS revision number and branch name.  The 'revisionVar',
+" 'branchVar'and 'repositoryVar' arguments, if non-empty, contain the names of variables to hold
+" the corresponding results.
+"
+" Returns: string to be exec'd that sets the multiple return values.
+
+function! s:CVSGetStatusVars(revisionVar, branchVar, repositoryVar)
+  let cvsBufferCheck=s:CVSCurrentBufferCheck()
+  if cvsBufferCheck == -1 
+    return ""
+  endif
+  let fileName=bufname(cvsBufferCheck)
+  let realFileName = fnamemodify(s:CVSResolveLink(fileName), ':t')
+  let oldCwd=s:CVSChangeToCurrentFileDir(fileName)
+  try
+    if !filereadable('CVS/Root')
+      return ""
+    endif
+    let cvsCommand = s:CVSGetOption("CVSCommandCVSExec", "cvs") . " status " . escape(realFileName, ' *?\')
+    let statustext=system(cvsCommand)
+    if(v:shell_error)
+      return ""
+    endif
+    let revision=substitute(statustext, '^\_.*Working revision:\s*\(\d\+\%(\.\d\+\)\+\|New file!\)\_.*$', '\1', "")
+
+    " We can still be in a CVS-controlled directory without this being a CVS
+    " file
+    if match(revision, '^New file!$') >= 0 
+      let revision="NEW"
+    elseif match(revision, '^\d\+\.\d\+\%(\.\d\+\.\d\+\)*$') >=0
+    else
+      return ""
+    endif
+
+    let returnExpression = "let " . a:revisionVar . "='" . revision . "'"
+
+    if a:branchVar != ""
+      let branch=substitute(statustext, '^\_.*Sticky Tag:\s\+\(\d\+\%(\.\d\+\)\+\|\a[A-Za-z0-9-_]*\|(none)\).*$', '\1', "")
+      let returnExpression=returnExpression . " | let " . a:branchVar . "='" . branch . "'"
+    endif
+
+    if a:repositoryVar != ""
+      let repository=substitute(statustext, '^\_.*Repository revision:\s*\(\d\+\%(\.\d\+\)\+\|New file!\|No revision control file\)\_.*$', '\1', "")
+      let repository=substitute(repository, '^New file!\|No revision control file$', 'NEW', "")
+      let returnExpression=returnExpression . " | let " . a:repositoryVar . "='" . repository . "'"
+    endif
+
+    return returnExpression
+  finally
+    execute 'cd' escape(oldCwd, ' ')
+  endtry
+endfunction
+
+" Function: s:CVSSetupBuffer() {{{2
+" Attempts to set the b:CVSBranch, b:CVSRevision and b:CVSRepository variables.
+
+function! s:CVSSetupBuffer()
+  if (exists("b:CVSBufferSetup") && b:CVSBufferSetup)
+    " This buffer is already set up.
+    return
+  endif
+
+  if !s:CVSGetOption("CVSCommandEnableBufferSetup", 0)
+        \ || @% == ""
+        \ || s:CVSCommandEditFileRunning > 0
+        \ || exists("b:CVSOrigBuffNR")
+    unlet! b:CVSRevision
+    unlet! b:CVSBranch
+    unlet! b:CVSRepository
+    return
+  endif
+
+  if !filereadable(expand("%"))
+    return -1
+  endif
+
+  let revision=""
+  let branch=""
+  let repository=""
+
+  exec s:CVSGetStatusVars('revision', 'branch', 'repository')
+  if revision != ""
+    let b:CVSRevision=revision
+  else
+    unlet! b:CVSRevision
+  endif
+  if branch != ""
+    let b:CVSBranch=branch
+  else
+    unlet! b:CVSBranch
+  endif
+  if repository != ""
+     let b:CVSRepository=repository
+  else
+     unlet! b:CVSRepository
+  endif
+  silent do CVSCommand User CVSBufferSetup
+  let b:CVSBufferSetup=1
+endfunction
+
+" Function: s:CVSMarkOrigBufferForSetup(cvsbuffer) {{{2
+" Resets the buffer setup state of the original buffer for a given CVS buffer.
+" Returns:  The CVS buffer number in a passthrough mode.
+
+function! s:CVSMarkOrigBufferForSetup(cvsBuffer)
+  checktime
+  if a:cvsBuffer != -1
+    let origBuffer = s:CVSBufferCheck(a:cvsBuffer)
+    "This should never not work, but I'm paranoid
+    if origBuffer != a:cvsBuffer
+      call setbufvar(origBuffer, "CVSBufferSetup", 0)
+    endif
+  endif
+  return a:cvsBuffer
+endfunction
+
+" Function: s:CVSOverrideOption(option, [value]) {{{2
+" Provides a temporary override for the given CVS option.  If no value is
+" passed, the override is disabled.
+
+function! s:CVSOverrideOption(option, ...)
+  if a:0 == 0
+    unlet! s:{a:option}Override
+  else
+    let s:{a:option}Override = a:1
+  endif
+endfunction
+
+" Function: s:CVSWipeoutCommandBuffers() {{{2
+" Clears all current CVS buffers of the specified type for a given source.
+
+function! s:CVSWipeoutCommandBuffers(originalBuffer, cvsCommand)
+  let buffer = 1
+  while buffer <= bufnr('$')
+    if getbufvar(buffer, 'CVSOrigBuffNR') == a:originalBuffer
+      if getbufvar(buffer, 'CVSCommand') == a:cvsCommand
+        execute 'bw' buffer
+      endif
+    endif
+    let buffer = buffer + 1
+  endwhile
+endfunction
+
+" Section: Public functions {{{1
+
+" Function: CVSGetRevision() {{{2
+" Global function for retrieving the current buffer's CVS revision number.
+" Returns: Revision number or an empty string if an error occurs.
+
+function! CVSGetRevision()
+  let revision=""
+  exec s:CVSGetStatusVars('revision', '', '')
+  return revision
+endfunction
+
+" Function: CVSDisableBufferSetup() {{{2
+" Global function for deactivating the buffer autovariables.
+
+function! CVSDisableBufferSetup()
+  let g:CVSCommandEnableBufferSetup=0
+  silent! augroup! CVSCommandPlugin
+endfunction
+
+" Function: CVSEnableBufferSetup() {{{2
+" Global function for activating the buffer autovariables.
+
+function! CVSEnableBufferSetup()
+  let g:CVSCommandEnableBufferSetup=1
+  augroup CVSCommandPlugin
+    au!
+    au BufEnter * call s:CVSSetupBuffer()
+  augroup END
+
+  " Only auto-load if the plugin is fully loaded.  This gives other plugins a
+  " chance to run.
+  if g:loaded_cvscommand == 2
+    call s:CVSSetupBuffer()
+  endif
+endfunction
+
+" Function: CVSGetStatusLine() {{{2
+" Default (sample) status line entry for CVS files.  This is only useful if
+" CVS-managed buffer mode is on (see the CVSCommandEnableBufferSetup variable
+" for how to do this).
+
+function! CVSGetStatusLine()
+  if exists('b:CVSSourceFile')
+    " This is a result buffer
+    let value='[' . b:CVSCommand . ' ' . b:CVSSourceFile
+    if exists('b:CVSStatusText')
+      let value=value . ' ' . b:CVSStatusText
+    endif
+    let value = value . ']'
+    return value
+  endif
+
+  if exists('b:CVSRevision')
+        \ && b:CVSRevision != ''
+        \ && exists('b:CVSBranch')
+        \ && b:CVSBranch != ''
+        \ && exists('b:CVSRepository')
+        \ && b:CVSRepository != ''
+        \ && exists('g:CVSCommandEnableBufferSetup')
+        \ && g:CVSCommandEnableBufferSetup
+    if b:CVSRevision == b:CVSRepository
+      return '[CVS ' . b:CVSBranch . '/' . b:CVSRevision . ']'
+    else
+      return '[CVS ' . b:CVSBranch . '/' . b:CVSRevision . '/' . b:CVSRepository . ']'
+    endif
+  else
+    return ''
+  endif
+endfunction
+
+" Section: CVS command functions {{{1
+
+" Function: s:CVSAdd() {{{2
+function! s:CVSAdd()
+  return s:CVSMarkOrigBufferForSetup(s:CVSDoCommand('add', 'cvsadd', ''))
+endfunction
+
+" Function: s:CVSAnnotate(...) {{{2
+function! s:CVSAnnotate(...)
+  if a:0 == 0
+    if &filetype == "CVSAnnotate"
+      " This is a CVSAnnotate buffer.  Perform annotation of the version
+      " indicated by the current line.
+      let revision = substitute(getline("."),'\(^[0-9.]*\).*','\1','')
+      let revmin = substitute(revision,'^[0-9.]*\.\([0-9]\+\)','\1','')
+      let revmaj = substitute(revision,'^\([0-9.]*\)\.[0-9]\+','\1','')
+      if s:CVSGetOption('CVSCommandAnnotateParent', 0) != 0
+        let revmin = revmin - 1
+      endif
+      if revmin == 0
+        " Jump to ancestor branch
+        let revision = substitute(revmaj,'^\([0-9.]*\)\.[0-9]\+','\1','')
+      else
+        let revision=revmaj . "." .  revmin
+      endif
+    else
+      let revision=CVSGetRevision()
+      if revision == ""
+        echoerr "Unable to obtain CVS version information."
+        return -1
+      endif
+    endif
+  else
+    let revision=a:1
+  endif
+
+  if revision == "NEW"
+    echo "No annotatation available for new file."
+    return -1
+  endif
+
+  let resultBuffer=s:CVSDoCommand('-q annotate -r ' . revision, 'cvsannotate', revision) 
+  if resultBuffer !=  -1
+    set filetype=CVSAnnotate
+    " Remove header lines from standard error
+    silent v/^\d\+\%(\.\d\+\)\+/d
+  endif
+
+  return resultBuffer
+endfunction
+
+" Function: s:CVSCommit() {{{2
+function! s:CVSCommit(...)
+  " Handle the commit message being specified.  If a message is supplied, it
+  " is used; if bang is supplied, an empty message is used; otherwise, the
+  " user is provided a buffer from which to edit the commit message.
+  if a:2 != "" || a:1 == "!"
+    return s:CVSMarkOrigBufferForSetup(s:CVSDoCommand('commit -m "' . a:2 . '"', 'cvscommit', ''))
+  endif
+
+  let cvsBufferCheck=s:CVSCurrentBufferCheck()
+  if cvsBufferCheck ==  -1
+    echo "Original buffer no longer exists, aborting."
+    return -1
+  endif
+
+  " Protect against windows' backslashes in paths.  They confuse exec'd
+  " commands.
+
+  let shellSlashBak = &shellslash
+  try
+    set shellslash
+
+    let messageFileName = tempname()
+
+    let fileName=bufname(cvsBufferCheck)
+    let realFilePath=s:CVSResolveLink(fileName)
+    let newCwd=fnamemodify(realFilePath, ':h')
+    if strlen(newCwd) == 0
+      " Account for autochdir being in effect, which will make this blank, but
+      " we know we'll be in the current directory for the original file.
+      let newCwd = getcwd()
+    endif
+
+    let realFileName=fnamemodify(realFilePath, ':t')
+
+    if s:CVSEditFile(messageFileName, cvsBufferCheck) == -1
+      return
+    endif
+
+    " Protect against case and backslash issues in Windows.
+    let autoPattern = '\c' . messageFileName
+
+    " Ensure existance of group
+    augroup CVSCommit
+    augroup END
+
+    execute 'au CVSCommit BufDelete' autoPattern 'call delete("' . messageFileName . '")'
+    execute 'au CVSCommit BufDelete' autoPattern 'au! CVSCommit * ' autoPattern
+
+    " Create a commit mapping.  The mapping must clear all autocommands in case
+    " it is invoked when CVSCommandCommitOnWrite is active, as well as to not
+    " invoke the buffer deletion autocommand.
+
+    execute 'nnoremap <silent> <buffer> <Plug>CVSCommit '.
+          \ ':au! CVSCommit * ' . autoPattern . '<CR>'.
+          \ ':g/^CVS:/d<CR>'.
+          \ ':update<CR>'.
+          \ ':call <SID>CVSFinishCommit("' . messageFileName . '",' .
+          \                             '"' . newCwd . '",' .
+          \                             '"' . realFileName . '",' .
+          \                             cvsBufferCheck . ')<CR>'
+
+    silent 0put ='CVS: ----------------------------------------------------------------------'
+    silent put =\"CVS: Enter Log.  Lines beginning with `CVS:' are removed automatically\"
+    silent put ='CVS: Type <leader>cc (or your own <Plug>CVSCommit mapping)'
+
+    if s:CVSGetOption('CVSCommandCommitOnWrite', 1) == 1
+      execute 'au CVSCommit BufWritePre' autoPattern 'g/^CVS:/d'
+      execute 'au CVSCommit BufWritePost' autoPattern 'call s:CVSFinishCommit("' . messageFileName . '", "' . newCwd . '", "' . realFileName . '", ' . cvsBufferCheck . ') | au! * ' autoPattern
+      silent put ='CVS: or write this buffer'
+    endif
+
+    silent put ='CVS: to finish this commit operation'
+    silent put ='CVS: ----------------------------------------------------------------------'
+    $
+    let b:CVSSourceFile=fileName
+    let b:CVSCommand='CVSCommit'
+    set filetype=cvs
+  finally
+    let &shellslash = shellSlashBak
+  endtry
+
+endfunction
+
+" Function: s:CVSDiff(...) {{{2
+function! s:CVSDiff(...)
+  if a:0 == 1
+    let revOptions = '-r' . a:1
+    let caption = a:1 . ' -> current'
+  elseif a:0 == 2
+    let revOptions = '-r' . a:1 . ' -r' . a:2
+    let caption = a:1 . ' -> ' . a:2
+  else
+    let revOptions = ''
+    let caption = ''
+  endif
+
+  let cvsdiffopt=s:CVSGetOption('CVSCommandDiffOpt', 'wbBc')
+
+  if cvsdiffopt == ""
+    let diffoptionstring=""
+  else
+    let diffoptionstring=" -" . cvsdiffopt . " "
+  endif
+
+  let resultBuffer = s:CVSDoCommand('diff ' . diffoptionstring . revOptions , 'cvsdiff', caption)
+  if resultBuffer != -1 
+    set filetype=diff
+  endif
+  return resultBuffer
+endfunction
+
+" Function: s:CVSEdit() {{{2
+function! s:CVSEdit()
+  return s:CVSDoCommand('edit', 'cvsedit', '')
+endfunction
+
+" Function: s:CVSEditors() {{{2
+function! s:CVSEditors()
+  return s:CVSDoCommand('editors', 'cvseditors', '')
+endfunction
+
+" Function: s:CVSGotoOriginal(["!]) {{{2
+function! s:CVSGotoOriginal(...)
+  let origBuffNR = s:CVSCurrentBufferCheck()
+  if origBuffNR > 0
+    let origWinNR = bufwinnr(origBuffNR)
+    if origWinNR == -1
+      execute 'buffer' origBuffNR
+    else
+      execute origWinNR . 'wincmd w'
+    endif
+    if a:0 == 1
+      if a:1 == "!"
+        let buffnr = 1
+        let buffmaxnr = bufnr("$")
+        while buffnr <= buffmaxnr
+          if getbufvar(buffnr, "CVSOrigBuffNR") == origBuffNR
+            execute "bw" buffnr
+          endif
+          let buffnr = buffnr + 1
+        endwhile
+      endif
+    endif
+  endif
+endfunction
+
+" Function: s:CVSFinishCommit(messageFile, targetDir, targetFile) {{{2
+function! s:CVSFinishCommit(messageFile, targetDir, targetFile, origBuffNR)
+  if filereadable(a:messageFile)
+    let oldCwd=getcwd()
+    if strlen(a:targetDir) > 0
+      execute 'cd' escape(a:targetDir, ' ')
+    endif
+    let resultBuffer=s:CVSCreateCommandBuffer('commit -F "' . a:messageFile . '" "'. a:targetFile . '"', 'cvscommit', '', a:origBuffNR)
+    execute 'cd' escape(oldCwd, ' ')
+    execute 'bw' escape(a:messageFile, ' *?\')
+    silent execute 'call delete("' . a:messageFile . '")'
+    return s:CVSMarkOrigBufferForSetup(resultBuffer)
+  else
+    echoerr "Can't read message file; no commit is possible."
+    return -1
+  endif
+endfunction
+
+" Function: s:CVSLog() {{{2
+function! s:CVSLog(...)
+  if a:0 == 0
+    let versionOption = ""
+    let caption = ''
+  else
+    let versionOption=" -r" . a:1
+    let caption = a:1
+  endif
+
+  let resultBuffer=s:CVSDoCommand('log' . versionOption, 'cvslog', caption)
+  if resultBuffer != ""
+    set filetype=rcslog
+  endif
+  return resultBuffer
+endfunction
+
+" Function: s:CVSRevert() {{{2
+function! s:CVSRevert()
+  return s:CVSMarkOrigBufferForSetup(s:CVSDoCommand('update -C', 'cvsrevert', ''))
+endfunction
+
+" Function: s:CVSReview(...) {{{2
+function! s:CVSReview(...)
+  if a:0 == 0
+    let versiontag=""
+    if s:CVSGetOption('CVSCommandInteractive', 0)
+      let versiontag=input('Revision:  ')
+    endif
+    if versiontag == ""
+      let versiontag="(current)"
+      let versionOption=""
+    else
+      let versionOption=" -r " . versiontag . " "
+    endif
+  else
+    let versiontag=a:1
+    let versionOption=" -r " . versiontag . " "
+  endif
+
+  let resultBuffer = s:CVSDoCommand('-q update -p' . versionOption, 'cvsreview', versiontag)
+  if resultBuffer > 0
+    let &filetype=getbufvar(b:CVSOrigBuffNR, '&filetype')
+  endif
+
+  return resultBuffer
+endfunction
+
+" Function: s:CVSStatus() {{{2
+function! s:CVSStatus()
+  return s:CVSDoCommand('status', 'cvsstatus', '')
+endfunction
+
+" Function: s:CVSUnedit() {{{2
+function! s:CVSUnedit()
+  return s:CVSDoCommand('unedit', 'cvsunedit', '')
+endfunction
+
+" Function: s:CVSUpdate() {{{2
+function! s:CVSUpdate()
+  return s:CVSMarkOrigBufferForSetup(s:CVSDoCommand('update', 'update', ''))
+endfunction
+
+" Function: s:CVSVimDiff(...) {{{2
+function! s:CVSVimDiff(...)
+  let originalBuffer = s:CVSCurrentBufferCheck()
+  let s:CVSCommandEditFileRunning = s:CVSCommandEditFileRunning + 1
+  try
+    " If there's already a VimDiff'ed window, restore it.
+    " There may only be one CVSVimDiff original window at a time.
+
+    if exists("s:vimDiffSourceBuffer") && s:vimDiffSourceBuffer != originalBuffer
+      " Clear the existing vimdiff setup by removing the result buffers.
+      call s:CVSWipeoutCommandBuffers(s:vimDiffSourceBuffer, 'vimdiff')
+    endif
+
+    " Split and diff
+    if(a:0 == 2)
+      " Reset the vimdiff system, as 2 explicit versions were provided.
+      if exists('s:vimDiffSourceBuffer')
+        call s:CVSWipeoutCommandBuffers(s:vimDiffSourceBuffer, 'vimdiff')
+      endif
+      let resultBuffer = s:CVSReview(a:1)
+      if resultBuffer < 0
+        echomsg "Can't open CVS revision " . a:1
+        return resultBuffer
+      endif
+      let b:CVSCommand = 'vimdiff'
+      diffthis
+      let s:vimDiffBufferCount = 1
+      let s:vimDiffScratchList = '{'. resultBuffer . '}'
+      " If no split method is defined, cheat, and set it to vertical.
+      try
+        call s:CVSOverrideOption('CVSCommandSplit', s:CVSGetOption('CVSCommandDiffSplit', s:CVSGetOption('CVSCommandSplit', 'vertical')))
+        let resultBuffer=s:CVSReview(a:2)
+      finally
+        call s:CVSOverrideOption('CVSCommandSplit')
+      endtry
+      if resultBuffer < 0
+        echomsg "Can't open CVS revision " . a:1
+        return resultBuffer
+      endif
+      let b:CVSCommand = 'vimdiff'
+      diffthis
+      let s:vimDiffBufferCount = 2
+      let s:vimDiffScratchList = s:vimDiffScratchList . '{'. resultBuffer . '}'
+    else
+      " Add new buffer
+      try
+        " Force splitting behavior, otherwise why use vimdiff?
+        call s:CVSOverrideOption("CVSCommandEdit", "split")
+        call s:CVSOverrideOption("CVSCommandSplit", s:CVSGetOption('CVSCommandDiffSplit', s:CVSGetOption('CVSCommandSplit', 'vertical')))
+        if(a:0 == 0)
+          let resultBuffer=s:CVSReview()
+        else
+          let resultBuffer=s:CVSReview(a:1)
+        endif
+      finally
+        call s:CVSOverrideOption("CVSCommandEdit")
+        call s:CVSOverrideOption("CVSCommandSplit")
+      endtry
+      if resultBuffer < 0
+        echomsg "Can't open current CVS revision"
+        return resultBuffer
+      endif
+      let b:CVSCommand = 'vimdiff'
+      diffthis
+
+      if !exists('s:vimDiffBufferCount')
+        " New instance of vimdiff.
+        let s:vimDiffBufferCount = 2
+        let s:vimDiffScratchList = '{' . resultBuffer . '}'
+
+        " This could have been invoked on a CVS result buffer, not the
+        " original buffer.
+        wincmd W
+        execute 'buffer' originalBuffer
+        " Store info for later original buffer restore
+        let s:vimDiffRestoreCmd = 
+              \    "call setbufvar(".originalBuffer.", \"&diff\", ".getbufvar(originalBuffer, '&diff').")"
+              \ . "|call setbufvar(".originalBuffer.", \"&foldcolumn\", ".getbufvar(originalBuffer, '&foldcolumn').")"
+              \ . "|call setbufvar(".originalBuffer.", \"&foldenable\", ".getbufvar(originalBuffer, '&foldenable').")"
+              \ . "|call setbufvar(".originalBuffer.", \"&foldmethod\", '".getbufvar(originalBuffer, '&foldmethod')."')"
+              \ . "|call setbufvar(".originalBuffer.", \"&scrollbind\", ".getbufvar(originalBuffer, '&scrollbind').")"
+              \ . "|call setbufvar(".originalBuffer.", \"&wrap\", ".getbufvar(originalBuffer, '&wrap').")"
+              \ . "|if &foldmethod=='manual'|execute 'normal zE'|endif"
+        diffthis
+        wincmd w
+      else
+        " Adding a window to an existing vimdiff
+        let s:vimDiffBufferCount = s:vimDiffBufferCount + 1
+        let s:vimDiffScratchList = s:vimDiffScratchList . '{' . resultBuffer . '}'
+      endif
+    endif
+
+    let s:vimDiffSourceBuffer = originalBuffer
+
+    " Avoid executing the modeline in the current buffer after the autocommand.
+
+    let currentBuffer = bufnr('%')
+    let saveModeline = getbufvar(currentBuffer, '&modeline')
+    try
+      call setbufvar(currentBuffer, '&modeline', 0)
+      silent do CVSCommand User CVSVimDiffFinish
+    finally
+      call setbufvar(currentBuffer, '&modeline', saveModeline)
+    endtry
+    return resultBuffer
+  finally
+    let s:CVSCommandEditFileRunning = s:CVSCommandEditFileRunning - 1
+  endtry
+endfunction
+
+" Function: s:CVSWatch(onoff) {{{2
+function! s:CVSWatch(onoff)
+  if a:onoff !~ '^\c\%(on\|off\|add\|remove\)$'
+    echoerr "Argument to CVSWatch must be one of [on|off|add|remove]"
+    return -1
+  end
+  return s:CVSDoCommand('watch ' . tolower(a:onoff), 'cvswatch', '')
+endfunction
+
+" Function: s:CVSWatchers() {{{2
+function! s:CVSWatchers()
+  return s:CVSDoCommand('watchers', 'cvswatchers', '')
+endfunction
+
+" Section: Command definitions {{{1
+" Section: Primary commands {{{2
+com! CVSAdd call s:CVSAdd()
+com! -nargs=? CVSAnnotate call s:CVSAnnotate(<f-args>)
+com! -bang -nargs=? CVSCommit call s:CVSCommit(<q-bang>, <q-args>)
+com! -nargs=* CVSDiff call s:CVSDiff(<f-args>)
+com! CVSEdit call s:CVSEdit()
+com! CVSEditors call s:CVSEditors()
+com! -bang CVSGotoOriginal call s:CVSGotoOriginal(<q-bang>)
+com! -nargs=? CVSLog call s:CVSLog(<f-args>)
+com! CVSRevert call s:CVSRevert()
+com! -nargs=? CVSReview call s:CVSReview(<f-args>)
+com! CVSStatus call s:CVSStatus()
+com! CVSUnedit call s:CVSUnedit()
+com! CVSUpdate call s:CVSUpdate()
+com! -nargs=* CVSVimDiff call s:CVSVimDiff(<f-args>)
+com! -nargs=1 CVSWatch call s:CVSWatch(<f-args>)
+com! CVSWatchAdd call s:CVSWatch('add')
+com! CVSWatchOn call s:CVSWatch('on')
+com! CVSWatchOff call s:CVSWatch('off')
+com! CVSWatchRemove call s:CVSWatch('remove')
+com! CVSWatchers call s:CVSWatchers()
+
+" Section: CVS buffer management commands {{{2
+com! CVSDisableBufferSetup call CVSDisableBufferSetup()
+com! CVSEnableBufferSetup call CVSEnableBufferSetup()
+
+" Allow reloading cvscommand.vim
+com! CVSReload unlet! loaded_cvscommand | runtime plugin/cvscommand.vim
+
+" Section: Plugin command mappings {{{1
+nnoremap <silent> <Plug>CVSAdd :CVSAdd<CR>
+nnoremap <silent> <Plug>CVSAnnotate :CVSAnnotate<CR>
+nnoremap <silent> <Plug>CVSCommit :CVSCommit<CR>
+nnoremap <silent> <Plug>CVSDiff :CVSDiff<CR>
+nnoremap <silent> <Plug>CVSEdit :CVSEdit<CR>
+nnoremap <silent> <Plug>CVSEditors :CVSEditors<CR>
+nnoremap <silent> <Plug>CVSGotoOriginal :CVSGotoOriginal<CR>
+nnoremap <silent> <Plug>CVSClearAndGotoOriginal :CVSGotoOriginal!<CR>
+nnoremap <silent> <Plug>CVSLog :CVSLog<CR>
+nnoremap <silent> <Plug>CVSRevert :CVSRevert<CR>
+nnoremap <silent> <Plug>CVSReview :CVSReview<CR>
+nnoremap <silent> <Plug>CVSStatus :CVSStatus<CR>
+nnoremap <silent> <Plug>CVSUnedit :CVSUnedit<CR>
+nnoremap <silent> <Plug>CVSUpdate :CVSUpdate<CR>
+nnoremap <silent> <Plug>CVSVimDiff :CVSVimDiff<CR>
+nnoremap <silent> <Plug>CVSWatchers :CVSWatchers<CR>
+nnoremap <silent> <Plug>CVSWatchAdd :CVSWatchAdd<CR>
+nnoremap <silent> <Plug>CVSWatchOn :CVSWatchOn<CR>
+nnoremap <silent> <Plug>CVSWatchOff :CVSWatchOff<CR>
+nnoremap <silent> <Plug>CVSWatchRemove :CVSWatchRemove<CR>
+
+" Section: Default mappings {{{1
+if !hasmapto('<Plug>CVSAdd')
+  nmap <unique> <Leader>ca <Plug>CVSAdd
+endif
+if !hasmapto('<Plug>CVSAnnotate')
+  nmap <unique> <Leader>cn <Plug>CVSAnnotate
+endif
+if !hasmapto('<Plug>CVSClearAndGotoOriginal')
+  nmap <unique> <Leader>cG <Plug>CVSClearAndGotoOriginal
+endif
+if !hasmapto('<Plug>CVSCommit')
+  nmap <unique> <Leader>cc <Plug>CVSCommit
+endif
+if !hasmapto('<Plug>CVSDiff')
+  nmap <unique> <Leader>cd <Plug>CVSDiff
+endif
+if !hasmapto('<Plug>CVSEdit')
+  nmap <unique> <Leader>ce <Plug>CVSEdit
+endif
+if !hasmapto('<Plug>CVSEditors')
+  nmap <unique> <Leader>ci <Plug>CVSEditors
+endif
+if !hasmapto('<Plug>CVSGotoOriginal')
+  nmap <unique> <Leader>cg <Plug>CVSGotoOriginal
+endif
+if !hasmapto('<Plug>CVSLog')
+  nmap <unique> <Leader>cl <Plug>CVSLog
+endif
+if !hasmapto('<Plug>CVSRevert')
+  nmap <unique> <Leader>cq <Plug>CVSRevert
+endif
+if !hasmapto('<Plug>CVSReview')
+  nmap <unique> <Leader>cr <Plug>CVSReview
+endif
+if !hasmapto('<Plug>CVSStatus')
+  nmap <unique> <Leader>cs <Plug>CVSStatus
+endif
+if !hasmapto('<Plug>CVSUnedit')
+  nmap <unique> <Leader>ct <Plug>CVSUnedit
+endif
+if !hasmapto('<Plug>CVSUpdate')
+  nmap <unique> <Leader>cu <Plug>CVSUpdate
+endif
+if !hasmapto('<Plug>CVSVimDiff')
+  nmap <unique> <Leader>cv <Plug>CVSVimDiff
+endif
+if !hasmapto('<Plug>CVSWatchers')
+  nmap <unique> <Leader>cwv <Plug>CVSWatchers
+endif
+if !hasmapto('<Plug>CVSWatchAdd')
+  nmap <unique> <Leader>cwa <Plug>CVSWatchAdd
+endif
+if !hasmapto('<Plug>CVSWatchOn')
+  nmap <unique> <Leader>cwn <Plug>CVSWatchOn
+endif
+if !hasmapto('<Plug>CVSWatchOff')
+  nmap <unique> <Leader>cwf <Plug>CVSWatchOff
+endif
+if !hasmapto('<Plug>CVSWatchRemove')
+  nmap <unique> <Leader>cwr <Plug>CVSWatchRemove
+endif
+
+" Section: Menu items {{{1
+silent! aunmenu Plugin.CVS
+amenu <silent> &Plugin.CVS.&Add        <Plug>CVSAdd
+amenu <silent> &Plugin.CVS.A&nnotate   <Plug>CVSAnnotate
+amenu <silent> &Plugin.CVS.&Commit     <Plug>CVSCommit
+amenu <silent> &Plugin.CVS.&Diff       <Plug>CVSDiff
+amenu <silent> &Plugin.CVS.&Edit       <Plug>CVSEdit
+amenu <silent> &Plugin.CVS.Ed&itors    <Plug>CVSEditors
+amenu <silent> &Plugin.CVS.&Log        <Plug>CVSLog
+amenu <silent> &Plugin.CVS.Revert      <Plug>CVSRevert
+amenu <silent> &Plugin.CVS.&Review     <Plug>CVSReview
+amenu <silent> &Plugin.CVS.&Status     <Plug>CVSStatus
+amenu <silent> &Plugin.CVS.Unedi&t     <Plug>CVSUnedit
+amenu <silent> &Plugin.CVS.&Update     <Plug>CVSUpdate
+amenu <silent> &Plugin.CVS.&VimDiff    <Plug>CVSVimDiff
+amenu <silent> &Plugin.CVS.&Watchers   <Plug>CVSWatchers
+amenu <silent> &Plugin.CVS.WatchAdd    <Plug>CVSWatchAdd
+amenu <silent> &Plugin.CVS.WatchOn     <Plug>CVSWatchOn
+amenu <silent> &Plugin.CVS.WatchOff    <Plug>CVSWatchOff
+amenu <silent> &Plugin.CVS.WatchRemove <Plug>CVSWatchRemove
+
+" Section: Autocommands to restore vimdiff state {{{1
+function! s:CVSVimDiffRestore(vimDiffBuff)
+  let s:CVSCommandEditFileRunning = s:CVSCommandEditFileRunning + 1
+  try
+    if exists("s:vimDiffSourceBuffer")
+      if a:vimDiffBuff == s:vimDiffSourceBuffer
+        " Original file is being removed.
+        unlet! s:vimDiffSourceBuffer
+        unlet! s:vimDiffBufferCount
+        unlet! s:vimDiffRestoreCmd
+        unlet! s:vimDiffScratchList
+      elseif match(s:vimDiffScratchList, '{' . a:vimDiffBuff . '}') >= 0
+        let s:vimDiffScratchList = substitute(s:vimDiffScratchList, '{' . a:vimDiffBuff . '}', '', '')
+        let s:vimDiffBufferCount = s:vimDiffBufferCount - 1
+        if s:vimDiffBufferCount == 1 && exists('s:vimDiffRestoreCmd')
+          " All scratch buffers are gone, reset the original.
+          " Only restore if the source buffer is still in Diff mode
+
+          let sourceWinNR=bufwinnr(s:vimDiffSourceBuffer)
+          if sourceWinNR != -1
+            " The buffer is visible in at least one window
+            let currentWinNR = winnr()
+            while winbufnr(sourceWinNR) != -1
+              if winbufnr(sourceWinNR) == s:vimDiffSourceBuffer
+                execute sourceWinNR . 'wincmd w'
+                if getwinvar('', "&diff")
+                  execute s:vimDiffRestoreCmd
+                endif
+              endif
+              let sourceWinNR = sourceWinNR + 1
+            endwhile
+            execute currentWinNR . 'wincmd w'
+          else
+            " The buffer is hidden.  It must be visible in order to set the
+            " diff option.
+            let currentBufNR = bufnr('')
+            execute "hide buffer" s:vimDiffSourceBuffer
+            if getwinvar('', "&diff")
+              execute s:vimDiffRestoreCmd
+            endif
+            execute "hide buffer" currentBufNR
+          endif
+
+          unlet s:vimDiffRestoreCmd
+          unlet s:vimDiffSourceBuffer
+          unlet s:vimDiffBufferCount
+          unlet s:vimDiffScratchList
+        elseif s:vimDiffBufferCount == 0
+          " All buffers are gone.
+          unlet s:vimDiffSourceBuffer
+          unlet s:vimDiffBufferCount
+          unlet s:vimDiffScratchList
+        endif
+      endif
+    endif
+  finally
+    let s:CVSCommandEditFileRunning = s:CVSCommandEditFileRunning - 1
+  endtry
+endfunction
+
+augroup CVSVimDiffRestore
+  au!
+  au BufUnload * call s:CVSVimDiffRestore(expand("<abuf>"))
+augroup END
+
+" Section: Optional activation of buffer management {{{1
+
+if s:CVSGetOption('CVSCommandEnableBufferSetup', 0)
+  call CVSEnableBufferSetup()
+endif
+
+" Section: Plugin completion {{{1
+
+let loaded_cvscommand=2
+silent do CVSCommand User CVSPluginFinish