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

# Revisions

For many uses of CVS, one doesn't need to worry too much about revision numbers; CVS assigns numbers such as `1.1`, `1.2`, and so on, and that is all one needs to know. However, some people prefer to have more knowledge and control concerning how CVS assigns revision numbers.

If one wants to keep track of a set of revisions involving more than one file, such as which revisions went into a particular release, one uses a tag, which is a symbolic revision which can be assigned to a numeric revision in each file.

- Revision numbers: The meaning of a revision number
- Versions revisions releases: Terminology used in this manual
- Assigning revisions: Assigning revisions
- Tags: Tags--Symbolic revisions
- Sticky tags: Certain tags are persistent

## Revision numbers

Each version of a file has a unique revision number. Revision numbers look like ``1.1'`, ``1.2'`, ``1.3.2.2'` or even ``1.3.2.2.4.5'`. A revision number always has an even number of period-separated decimal integers. By default revision 1.1 is the first revision of a file. Each successive revision is given a new number by increasing the rightmost number by one. The following figure displays a few revisions, with newer revisions to the right.

           +-----+    +-----+    +-----+    +-----+    +-----+
           ! 1.1 !----! 1.2 !----! 1.3 !----! 1.4 !----! 1.5 !
           +-----+    +-----+    +-----+    +-----+    +-----+

It is also possible to end up with numbers containing more than one period, for example ``1.3.2.2'`. Such revisions represent revisions on branches (see section Branching and merging); such revision numbers are explained in detail in section Branches and revisions.

## Versions, revisions and releases

A file can have several versions, as described above. Likewise, a software product can have several versions. A software product is often given a version number such as ``4.1.1'`.

Versions in the first sense are called revisions in this document, and versions in the second sense are called releases. To avoid confusion, the word version is almost never used in this document.

## Assigning revisions

By default, CVS will assign numeric revisions by leaving the first number the same and incrementing the second number. For example, `1.1`, `1.2`, `1.3`, etc.

When adding a new file, the second number will always be one and the first number will equal the highest first number of any file in that directory. For example, the current directory contains files whose highest numbered revisions are `1.7`, `3.1`, and `4.12`, then an added file will be given the numeric revision `4.1`.

Normally there is no reason to care about the revision numbers--it is easier to treat them as internal numbers that CVS maintains, and tags provide a better way to distinguish between things like release 1 versus release 2 of your product (see section Tags--Symbolic revisions). However, if you want to set the numeric revisions, the ``-r'` option to `cvs commit` can do that. The ``-r'` option implies the ``-f'` option, in the sense that it causes the files to be committed even if they are not modified.

For example, to bring all your files up to revision 3.0 (including those that haven't changed), you might invoke:

    $ cvs commit -r 3.0

Note that the number you specify with ``-r'` must be larger than any existing revision number. That is, if revision 3.0 exists, you cannot ``cvs commit -r 1.3'`. If you want to maintain several releases in parallel, you need to use a branch (see section Branching and merging).

## Tags--Symbolic revisions

The revision numbers live a life of their own. They need not have anything at all to do with the release numbers of your software product. Depending on how you use CVS the revision numbers might change several times between two releases. As an example, some of the source files that make up RCS 5.6 have the following revision numbers:

    ci.c            5.21
    co.c            5.9
    ident.c         5.3
    rcs.c           5.12
    rcsbase.h       5.11
    rcsdiff.c       5.10
    rcsedit.c       5.11
    rcsfcmp.c       5.9
    rcsgen.c        5.10
    rcslex.c        5.11
    rcsmap.c        5.2
    rcsutil.c       5.10

You can use the `tag` command to give a symbolic name to a certain revision of a file. You can use the ``-v'` flag to the `status` command to see all tags that a file has, and which revision numbers they represent. Tag names must start with an uppercase or lowercase letter and can contain uppercase and lowercase letters, digits, ``-'`, and ``_'`. The two tag names `BASE` and `HEAD` are reserved for use by CVS. It is expected that future names which are special to CVS will be specially named, for example by starting with ``.'`, rather than being named analogously to `BASE` and `HEAD`, to avoid conflicts with actual tag names.

You'll want to choose some convention for naming tags, based on information such as the name of the program and the version number of the release. For example, one might take the name of the program, immediately followed by the version number with ``.'` changed to ``-'`, so that CVS 1.9 would be tagged with the name `cvs1-9`. If you choose a consistent convention, then you won't constantly be guessing whether a tag is `cvs-1-9` or `cvs1_9` or what. You might even want to consider enforcing your convention in the taginfo file (see section User-defined logging).

The following example shows how you can add a tag to a file. The commands must be issued inside your working copy of the module. That is, you should issue the command in the directory where ``backend.c'` resides.

    $ cvs tag rel-0-4 backend.c
    T backend.c
    $ cvs status -v backend.c
    ===================================================================
    File: backend.c         Status: Up-to-date

        Version:            1.4     Tue Dec  1 14:39:01 1992
        RCS Version:        1.4     /u/cvsroot/yoyodyne/tc/backend.c,v
        Sticky Tag:         (none)
        Sticky Date:        (none)
        Sticky Options:     (none)

        Existing Tags:
            rel-0-4                     (revision: 1.4)

There is seldom reason to tag a file in isolation. A more common use is to tag all the files that constitute a module with the same tag at strategic points in the development life-cycle, such as when a release is made.

    $ cvs tag rel-1-0 .
    cvs tag: Tagging .
    T Makefile
    T backend.c
    T driver.c
    T frontend.c
    T parser.c

(When you give CVS a directory as argument, it generally applies the operation to all the files in that directory, and (recursively), to any subdirectories that it may contain. See section Recursive behavior.)

The `checkout` command has a flag, ``-r'`, that lets you check out a certain revision of a module. This flag makes it easy to retrieve the sources that make up release 1.0 of the module ``tc'` at any time in the future:

    $ cvs checkout -r rel-1-0 tc

This is useful, for instance, if someone claims that there is a bug in that release, but you cannot find the bug in the current working copy.

You can also check out a module as it was at any given date. See section checkout options.

When you tag more than one file with the same tag you can think about the tag as "a curve drawn through a matrix of filename vs. revision number." Say we have 5 files with the following revisions:

            file1   file2   file3   file4   file5

            1.1     1.1     1.1     1.1  /--1.1*      <-*-  TAG
            1.2*-   1.2     1.2    -1.2*-
            1.3  \- 1.3*-   1.3   / 1.3
            1.4          \  1.4  /  1.4
                          \-1.5*-   1.5
                            1.6

At some time in the past, the `*` versions were tagged. You can think of the tag as a handle attached to the curve drawn through the tagged revisions. When you pull on the handle, you get all the tagged revisions. Another way to look at it is that you "sight" through a set of revisions that is "flat" along the tagged revisions, like this:

            file1   file2   file3   file4   file5

                            1.1
                            1.2
                    1.1     1.3                       _
            1.1     1.2     1.4     1.1              /
            1.2*----1.3*----1.5*----1.2*----1.1     (--- <--- Look here
            1.3             1.6     1.3              \_
            1.4                     1.4
                                    1.5

## Sticky tags

Sometimes a working copy's revision has extra data associated with it, for example it might be on a branch (see section Branching and merging), or restricted to versions prior to a certain date by ``checkout -D'` or ``update -D'`. Because this data persists -- that is, it applies to subsequent commands in the working copy -- we refer to it as sticky.

Most of the time, stickiness is an obscure aspect of CVS that you don't need to think about. However, even if you don't want to use the feature, you may need to know something about sticky tags (for example, how to avoid them!).

You can use the `status` command to see if any sticky tags or dates are set:

    $ cvs status driver.c
    ===================================================================
    File: driver.c          Status: Up-to-date

        Version:            1.7.2.1 Sat Dec  5 19:35:03 1992
        RCS Version:        1.7.2.1 /u/cvsroot/yoyodyne/tc/driver.c,v
        Sticky Tag:         rel-1-0-patches (branch: 1.7.2)
        Sticky Date:        (none)
        Sticky Options:     (none)

The sticky tags will remain on your working files until you delete them with ``cvs update -A'`. The ``-A'` option retrieves the version of the file from the head of the trunk, and forgets any sticky tags, dates, or options.

The most common use of sticky tags is to identify which branch one is working on, as described in section Accessing branches. However, non-branch sticky tags have uses as well. For example, suppose that you want to avoid updating your working directory, to isolate yourself from possibly destabilizing changes other people are making. You can, of course, just refrain from running `cvs update`. But if you want to avoid updating only a portion of a larger tree, then sticky tags can help. If you check out a certain revision (such as 1.4) it will become sticky. Subsequent `cvs update` commands will not retrieve the latest revision until you reset the tag with `cvs update -A`. Likewise, use of the ``-D'` option to `update` or `checkout` sets a sticky date, which, similarly, causes that date to be used for future retrievals.

Many times you will want to retrieve an old version of a file without setting a sticky tag. The way to do that is with the ``-p'` option to `checkout` or `update`, which sends the contents of the file to standard output. For example, suppose you have a file named ``file1'` which existed as revision 1.1, and you then removed it (thus adding a dead revision 1.2). Now suppose you want to add it again, with the same contents it had previously. Here is how to do it:

    $ cvs update -p -r 1.1 file1 >file1
    ===================================================================
    Checking out file1
    RCS:  /tmp/cvs-sanity/cvsroot/first-dir/Attic/file1,v
    VERS: 1.1
    ***************
    $ cvs add file1
    cvs add: re-adding file file1 (in place of dead revision 1.2)
    cvs add: use 'cvs commit' to add this file permanently
    $ cvs commit -m test
    Checking in file1;
    /tmp/cvs-sanity/cvsroot/first-dir/file1,v  <--  file1
    new revision: 1.3; previous revision: 1.2
    done
    $

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