Go to the first, previous, next, last section, table of contents.


6. Commands

This chapter describes all the commands that you can use in pcl-cvs.

6.1 Updating the directory

M-x cvs-update
Run a `cvs update' command. You will be asked for the directory in which the `cvs update' will be run. The output will be parsed by pcl-cvs, and the result printed in the `*cvs*' buffer (see see section 5. Buffer contents for a description of the contents). By default, `cvs-update' will descend recursively into subdirectories. You can avoid that behavior by giving a prefix argument to it (e.g., by typing C-u M-x cvs-update RET). All other commands in pcl-cvs requires that you have a `*cvs*' buffer. This is the command that you use to get one. CVS uses lock files in the repository to ensure the integrity of the data files in the repository. They might be left behind i.e. if a workstation crashes in the middle of a CVS operation. CVS outputs a message when it is waiting for a lock file to go away. Pcl-cvs will show the same message in the *cvs* buffer, together with instructions for deleting the lock files. You should normally not have to delete them manually -- just wait a little while and the problem should fix itself. But if the lock files doesn't disappear you can delete them with M-x cvs-mode-delete-lock RET.
g
This will run `cvs update' again. It will always use the same buffer that was used with the previous `cvs update'. Give a prefix argument to avoid descending into subdirectories. This runs the command `cvs-mode-update-no-prompt'.

6.2 Movement Commands

You can use most normal Emacs commands to move forward and backward in the buffer. Some keys are rebound to functions that take advantage of the fact that the buffer is a pcl-cvs buffer:

SPC
C-n
n
These keys move the cursor one file forward, towards the end of the buffer (cookie-next-cookie).
C-p
p
These keys move one file backward, towards the beginning of the buffer (cookie-previous-cookie).

6.3 Marking files

Pcl-cvs works on a set of selected files (see section 5.2 Selected files). You can mark and unmark files with these commands:

m
This marks the file that the cursor is positioned on. If the cursor is positioned on a directory all files in that directory will be marked. (cvs-mode-mark).
u
Unmark the file that the cursor is positioned on. If the cursor is on a directory, all files in that directory will be unmarked. (cvs-mode-unmark).
M
Mark all files in the buffer (cvs-mode-mark-all-files).
ESC DEL
Unmark all files (cvs-mode-unmark-all-files).
DEL
Unmark the file on the previous line, and move point to that line (cvs-mode-unmark-up).

6.4 Committing changes

c
All files that have a "need to be checked in"-marker (see section 5. Buffer contents) can be checked in with the c command. It checks in all selected files (see section 5.2 Selected files) (except those who lack the "ci"-marker - they are ignored). Pressing c causes cvs-mode-commit to be run. When you press c you will get a buffer called `*cvs-commit-message*'. Enter the log message for the file(s) in it. When you are ready you should press C-c C-c to actually commit the files (using cvs-edit-done). Normally the `*cvs-commit-message*' buffer will retain the log message from the previous commit, but if the variable cvs-erase-input-buffer is set to a non-nil value the buffer will be erased. Point and mark will always be located around the entire buffer so that you can easily erase it with C-w (`kill-region'). If you are editing the files in your emacs an automatic `revert-buffer' will be performed. (If the file contains `$Id$' keywords `cvs commit' will write a new file with the new values substituted. The auto-revert makes sure that you get them into your buffer). The revert will not occur if you have modified your buffer, or if `cvs-auto-revert-after-commit' is set to `nil'.

6.5 Editing files

There are currently three commands that can be used to find a file (that is, load it into a buffer and start editing it there). These commands work on the line that the cursor is situated at. They ignore any marked files.

f
Find the file that the cursor points to. Run `dired' if the cursor points to a directory (cvs-mode-find-file).
o
Like f, but use another window (cvs-mode-find-file-other-window).
A
Invoke `add-change-log-entry-other-window' to edit a `ChangeLog' file. The `ChangeLog' will be found in the directory of the file the cursor points to. (cvs-mode-add-change-log-entry-other-window).

6.6 Getting info about files

Both of the following commands can be customized. See section 7. Customization.

l
Run `cvs log' on all selected files, and show the result in a temporary buffer (cvs-mode-log).
s
Run `cvs status' on all selected files, and show the result in a temporary buffer (cvs-mode-status).

6.7 Adding and removing files

The following commands are available to make it easy to add and remove files from the CVS repository.

a
Add all selected files. This command can be used on `Unknown' files (see see section 5.1 File status). The status of the file will change to `Added', and you will have to use c (`cvs-mode-commit', see see section 6.4 Committing changes) to really add the file to the repository. This command can also be used on `Removed' files (before you commit them) to resurrect them. Selected files that are neither `Unknown' nor `Removed' will be ignored by this command. The command that is run is cvs-mode-add.
r
This command removes the selected files (after prompting for confirmation). The files are `rm'ed from your directory and (unless the status was `Unknown'; see section 5.1 File status) they will also be `cvs remove'd. If the files were `Unknown' they will disappear from the buffer. Otherwise their status will change to `Removed', and you must use c (`cvs-mode-commit', see section 6.4 Committing changes) to commit the removal. The command that is run is cvs-mode-remove-file.

6.8 Undoing changes

U
If you have modified a file, and for some reason decide that you don't want to keep the changes, you can undo them with this command. It works by removing your working copy of the file and then getting the latest version from the repository (cvs-mode-undo-local-changes.

6.9 Removing handled entries

x
This command allows you to remove all entries that you have processed. More specifically, the lines for `Updated' files (see section 5.1 File status and files that have been checked in (see section 6.4 Committing changes) are removed from the buffer. If a directory becomes empty the heading for that directory is also removed. This makes it easier to get an overview of what needs to be done. The command is called cvs-mode-remove-handled. If `cvs-auto-remove-handled' is set to non-nil this will automatically be performed after every commit.
C-k
This command can be used for lines that `cvs-mode-remove-handled' would not delete, but that you want to delete (cvs-mode-acknowledge).

6.10 Ignoring files

i
Arrange so that CVS will ignore the selected files. The file names are added to the `.cvsignore' file in the corresponding directory. If the `.cvsignore' doesn't exist it will be created. The `.cvsignore' file should normally be added to the repository, but you could ignore it also if you like it better that way. This runs cvs-mode-ignore.

6.11 Viewing differences

d
Display a `cvs diff' between the selected files and the RCS version that they are based on. See section 7. Customization describes how you can send flags to `cvs diff'. If cvs-diff-ignore-marks is set to a non-nil value or if a prefix argument is given (but not both) any marked files will not be considered to be selected. (cvs-mode-diff-cvs).
b
If CVS finds a conflict while merging two versions of a file (during a `cvs update', see section 6.1 Updating the directory) it will save the original file in a file called `.#FILE.VERSION' where FILE is the name of the file, and VERSION is the RCS version number that your file was based on. With the b command you can run a `diff' on the files `.#FILE.VERSION' and `FILE'. You can get a context- or Unidiff by setting `cvs-diff-flags' - see section 7. Customization. This command only works on files that have status `Conflict' or `Merged'. If cvs-diff-ignore-marks is set to a non-nil value or if a prefix argument is given (but not both) any marked files will not be considered to be selected. (cvs-mode-diff-backup).

6.12 Running emerge

e
Invoke `emerge' on one file. This command works slightly different depending on the file status.
`Modified'
Run `emerge-files' with your working file as file A, and the latest revision in the repository as file B.
`Merged'
`Conflict'
Run `emerge-files-with-ancestor' with your working file (as it was prior to your invocation of `cvs-update') as file A, the latest revision in the repository as file B, and the revision that you based your local modifications on as ancestor.
Note: CVS has already performed a merge. The resulting file is not used in any way if you use this command. If you use the q command inside `emerge' (to successfully terminate the merge) the file that CVS created will be overwritten.

6.13 Reverting your buffers

R
If you are editing (or just viewing) a file in a buffer, and that file is changed by CVS during a `cvs-update', all you have to do is type R in the *cvs* buffer to read in the new versions of the files. All files that are `Updated', `Merged' or in `Conflict' are reverted from the disk. Any other files are ignored. Only files that you were already editing are read. An error is signalled if you have modified the buffer since it was last changed. (cvs-mode-revert-updated-buffers).

6.14 Miscellaneous commands

M-x cvs-mode-byte-compile-files
Byte compile all selected files that end in .el.
M-x cvs-mode-delete-lock
This command deletes the lock files that the *cvs* buffer informs you about. You should normally never have to use this command since CVS tries very carefully to always remove the lock files itself. You can only use this command when a message in the *cvs* buffer tells you so. You should wait a while before using this command in case someone else is running a cvs command.
q
Bury the *cvs* buffer. (bury-buffer).


Go to the first, previous, next, last section, table of contents.