This is ossdev.info, produced by makeinfo version 4.3 from
../book/ossdev/main.texi.

START-INFO-DIR-ENTRY
* CVS Book: (cvsbook).          A CVS tutorial and reference.
END-INFO-DIR-ENTRY

Copyright (C) 1999, 2000 Karl Fogel <kfogel@red-bean.com>

This document is free software; you can redistribute and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

This document is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

This manual describes how to use and administer CVS (Concurrent Versions
System).  It is part of a larger work entitled `Open Source Development
With CVS'; please see the introduction for details.

This is version 1.21 of this manual.


File: ossdev.info,  Node: The Future Of pcl-cvs,  Prev: Error Handling In pcl-cvs,  Up: pcl-cvs -- An Emacs Interface To CVS

The Future Of pcl-cvs
---------------------

Although I may be giving you the impression that pcl-cvs is barely
maintained and a risky investment, the instability appears to be
temporary.  Stefan Monnier is a responsive maintainer (I contacted him
several times during the writing of this chapter, and he always answered
right away; he is already making headway on some of the bugs in Version
2.9.6).  Very likely by the time this is published, you will be able to
download Version 2.9.7 or later with confidence.

In fact, I just now got an encouraging email on this topic from Greg
Woods, a former maintainer of pcl-cvs, reprinted here with his
permission:

     From: woods@most.weird.com (Greg A. Woods)
     Subject: Re: pcl-cvs maintenance status, stability of recent "release"s?
     To: kfogel@red-bean.com
     Date: Sun, 29 Aug 1999 18:59:19 -0400 (EDT)
     
     [...]
     I've been using Stefan's releases for some time now, and indeed I have
     abandoned my own branch of it.
     
     He's done a lot of really good work on PCL-CVS and except for a few odd
     quirks in the 2.9.6 version I'm using daily now it is quite usable (and
     is approximately infinitely more usable with modern CVS than the one
     that was in the CVS distribution! ;-).
     
     I've added a pcl-cvs.README file to my FTP site to point out that the
     files there are indeed quite old (at least in Internet time! ;-) and to
     give a pointer to Stefan's FTP site too.
     
     [...]

In a later email, Greg said that the FSF is considering including
pcl-cvs in their next release of Emacs (20.5), which would render most
of the preceding installation advice obsolete.  Sigh.  It's hard to keep
up with free software, sometimes.


File: ossdev.info,  Node: cvsutils -- General Utilities For Use With CVS,  Next: cvs2cl -- Generate GNU-Style ChangeLogs,  Prev: pcl-cvs -- An Emacs Interface To CVS,  Up: Third-Party Tools

cvsutils - General Utilities For Use With CVS
=============================================

Depends on: Perl

URLs:

   * `http://www.red-bean.com/cvsutils'

Authors: Tom Tromey (original author) and Pavel Roskin (current
maintainer)

The suite of small programs called `cvsutils' generally (although not
always) performs "offline" operations in the CVS working copy.  Offline
operations are those that can be done without contacting the
repository, while still leaving the working copy in a consistent state
for the next time the repository is contacted.  Offline behavior can be
extremely handy when your network connection to the repository is slow
or unreliable.

The cvsutils programs are listed below in approximate order of
usefulness (according to my opinion), with the more useful ones coming
first.  Coincidentally, this also arranges them by safety.  Safety is an
issue because some of these utilities can, in their normal course of
operation, cause you to lose local modifications or files from your
working copy.  Therefore, read the descriptions carefully before using
these utilities.

This documentation is accurate as of Version 0.1.4.  Be sure to read the
README file in any later versions for more up-to-date information.

* Menu:

* cvsu::
* cvsdo::
* cvschroot::
* cvsrmadm::
* cvspurge::
* cvsdiscard::
* cvsco::
* cvsdate::


File: ossdev.info,  Node: cvsu,  Next: cvsdo,  Up: cvsutils -- General Utilities For Use With CVS

cvsu
----

Danger level: None

Contacts repository: No

This does an offline cvs update by comparing the timestamps of files on
disk with their timestamps recorded in CVS/Entries.  You can thus tell
which files have been locally modified and which files are not known to
be under CVS control.  Unlike `cvs update', cvsu does not bring down
changes from the repository.

Although it can take various options, cvsu is most commonly invoked
without any options:

     floss$ cvsu
     ? ./bar
     ? ./chapter-10.html
     M ./chapter-10.sgml
     D ./out
     ? ./safe.sh
     D ./tools

The left-side codes are like the output of cvs update, except that `D'
means directory.  This example shows that chapter-10.sgml has been
modified locally.  What the example doesn't show is that cvsu ran
instantly, whereas a normal cvs update would have required half a minute
or so over my slow modem line.  Run

     floss$ cvsu --help

to see a list of options.


File: ossdev.info,  Node: cvsdo,  Next: cvschroot,  Prev: cvsu,  Up: cvsutils -- General Utilities For Use With CVS

cvsdo
-----

Danger level: Low to none

Contacts repository: No

This can simulate the working copy effects of cvs add and cvs remove,
but without contacting the repository.  Of course, you'd still have to
commit the changes to make them take effect in the repository, but at
least the add and remove commands themselves can be sped up this way.
Here's how to use it

     floss$ cvsdo add FILENAME

or

     floss$ cvsdo remove FILENAME

To see a list of further options, run:

     floss$ cvsdo --help


File: ossdev.info,  Node: cvschroot,  Next: cvsrmadm,  Prev: cvsdo,  Up: cvsutils -- General Utilities For Use With CVS

cvschroot
---------

Danger level: Low

Contacts repository: No

This deals with a repository move by tweaking the working copy to point
to the new repository.  This is useful when a repository is copied en
masse to a new location.  When that happens, none of the revisions are
affected, but the CVS/Root (and possibly the CVS/Repository) file of
every working copy must be updated to point to the new location.  Using
cvschroot is a lot faster than checking out a new copy.  Another
advantage is that it doesn't lose your local changes.

Usage:

     floss$ cvschroot NEW_REPOS

For example:

     floss$ cvschroot :pserver:newuser@newhost.wherever.com:/home/cvs/myproj


File: ossdev.info,  Node: cvsrmadm,  Next: cvspurge,  Prev: cvschroot,  Up: cvsutils -- General Utilities For Use With CVS

cvsrmadm
--------

Danger level: Low to medium

Contacts repository: No

This removes all of the CVS/ administrative subdirectories in your
working copy, leaving behind a tree similar to that created by cvs
export.

Although you won't lose any local changes by using cvsrmadm, your
working copy will no longer be a working copy.

Use with caution.


File: ossdev.info,  Node: cvspurge,  Next: cvsdiscard,  Prev: cvsrmadm,  Up: cvsutils -- General Utilities For Use With CVS

cvspurge
--------

Danger level: Medium

Contacts repository: No

This removes all non-CVS-controlled files in your working copy.  It does
not undo any local changes to CVS-controlled files.

Use with caution.


File: ossdev.info,  Node: cvsdiscard,  Next: cvsco,  Prev: cvspurge,  Up: cvsutils -- General Utilities For Use With CVS

cvsdiscard
----------

Danger level: Medium to high

Contacts repository: Maybe

This is the complement of cvspurge.  Instead of removing unknown files
but keeping your local changes, cvsdiscard undoes any local changes
(replacing those files with fresh copies from the repository), but keeps
unknown files.

Use with extreme caution.


File: ossdev.info,  Node: cvsco,  Next: cvsdate,  Prev: cvsdiscard,  Up: cvsutils -- General Utilities For Use With CVS

cvsco
-----

Danger level: High

Contacts repository: Maybe

This is the union of cvspurge and cvsdiscard.  It undoes any local
changes and removes unknown files from the working copy.

Use with truly paranoid caution.


File: ossdev.info,  Node: cvsdate,  Prev: cvsco,  Up: cvsutils -- General Utilities For Use With CVS

cvsdate
-------

This script is apparently incomplete and possibly may never be finished.
(See the README file for details.)


File: ossdev.info,  Node: cvs2cl -- Generate GNU-Style ChangeLogs,  Next: cvslock -- Lock Repositories For Atomicity,  Prev: cvsutils -- General Utilities For Use With CVS,  Up: Third-Party Tools

cvs2cl - Generate GNU-Style ChangeLogs
======================================

Depends on: Perl

URL: `http://www.red-bean.com/~kfogel/cvs2cl.shtml'

cvs2cl.pl condenses and reformats the output of cvs log to create a
GNU-style ChangeLog file for your project.  ChangeLogs are
chronologically organized documents showing the change history of a
project, with a format designed specifically for human-readability (see
the following examples).

The problem with the `cvs log' command is that it presents its output
on a per-file basis, with no acknowledgement that the same log message,
appearing at roughly the same time in different files, implies that
those revisions were all part of a single commit.  Thus, reading over
log output to get an overview of project development is a hopeless task
- you can really only see the history of one file at a time.

In the ChangeLog produced by cvs2cl.pl, identical log messages are
unified, so that a single commit involving a group of files shows up as
one entry.  For example:

     floss$ cvs2cl.pl -r
     cvs log: Logging .
     cvs log: Logging a-subdir
     cvs log: Logging a-subdir/subsubdir
     cvs log: Logging b-subdir
     floss$ cat ChangeLog
     ...
     1999-08-29 05:44  jrandom
     
        * README (1.6), hello.c (2.1), a-subdir/whatever.c (2.1),
        a-subdir/subsubdir/fish.c (2.1): Committing from pcl-cvs 2.9, just
        for kicks.
     
     1999-08-23 22:48  jrandom
     
        * README (1.5): [no log message]
     
     1999-08-22 19:34  jrandom
     
        * README (1.4): trivial change
     ...
     floss$

The first entry shows that four files were committed at once, with the
log message, "Committing from pcl-cvs 2.9, just for kicks.".  (The -r
option was used to show the revision number of each file associated with
that log message.)

Like CVS itself, cvs2cl.pl takes the current directory as an implied
argument but acts on individual files if given file name arguments.
Following are a few of the most commonly used options.

   *  `h', `--help'

     Show usage (including a complete list of options).

   *  `-r', `--revisions'

     Show revision numbers in output.  If used in conjunction with -b,
     branches are shown as BRANCHNAME.N, where N is the revision on the
     branch.

   *  `-t', `--tags'

     Show tags (symbolic names) for revisions that have them.

   *  `-b', `--branches'

     Show the branch name for revisions on that branch.  (See also -r.)

   *  `-g OPTS', `--global-opts OPTS'

     Pass OPTS as global arguments to cvs.  Internally, cvs2cl.pl
     invokes cvs to get the raw log data; thus, OPTS are passed right
     after the cvs in that invocation.  For example, to achieve quiet
     behavior and compression, you can do this:

          floss$ cvs2cl.pl -g "-Q -z3"

   *  `-l OPTS', `--log-opts OPTS'

     Similar to -g, except that OPTS are passed as command options
     instead of global options.  To generate a ChangeLog showing only
     commits that happened between July 26 and August 15, you can do
     this:

          floss$ cvs2cl.pl -l "'-d1999-07-26<1999-08-15'"

     Notice the double-layered quoting - this is necessary in Unix
     because the shell that invokes cvs log (inside cvs2cl.pl)
     interprets the `<' as a shell redirection symbol.  Therefore, the
     quotes have to be passed as part of the argument, making it
     necessary to surround the whole thing with an additional set of
     quotes.

   *  `-d', `--distributed'

     Put an individual ChangeLog in each subdirectory, covering only
     commits in that subdirectory (as opposed to building one ChangeLog
     that covers the directory where cvs2cl.pl was invoked and all
     subdirectories underneath it).



File: ossdev.info,  Node: cvsq -- Queue CVS Commands For Later Connection,  Next: Other Packages,  Prev: cvslock -- Lock Repositories For Atomicity,  Up: Third-Party Tools

cvsq - Queue CVS Commands For Later Connection
==============================================

Depends on: Bash

URL: `http://www.volny.cz/v.slavik/lt/cvsq.html'

Vaclav Slavik <v.slavik@volny.cz>, the author of cvsq, has this to say
about it:

cvsq stands for "cvs queued" and it is a small bash script that wraps
around Cyclic's CVS.  It makes working with CVS repository a bit easier
for people connected via dial-up, because it can queue CVS commands and
pass them to "real cvs" later.

For example, you can commit files immediately after editing them, when
being offline, so you don't forget about them:

         cvsq commit -m "change 1" file1.c
         cvsq commit -m "change 2" file2.c
         cvsq commit -m "change 3" file3.c

And then, when you go online, you simply type

         cvsq upload

and all changes will be commited into the repository.  If uploading of a
particular file fails, it won't be lost - instead, you'll see error
message and the file will stay in cvsq queue.

You can use cvsq even for commands that make no sense when offline - in
that case, the command is immediately passed to cvs and not queued.  For
example, you can call cvsq update and it won't be put into the queue but
executed immediately.  In fact, you can start using cvsq as a
replacement for cvs.

cvsq is in public domain.


File: ossdev.info,  Node: cvslock -- Lock Repositories For Atomicity,  Next: cvsq -- Queue CVS Commands For Later Connection,  Prev: cvs2cl -- Generate GNU-Style ChangeLogs,  Up: Third-Party Tools

cvslock - Lock Repositories For Atomicity
=========================================

Depends on: C compiler for installation; nothing for runtime

URL: `ftp://riemann.iam.uni-bonn.de/pub/users/roessler/cvslock/'

This program locks a CVS repository (either for reading or writing) in
the same way that CVS does, so that CVS will honor the locks.  This can
be useful when, for example, you need to make a copy of the whole
repository and want to avoid catching parts of commits or other people's
lockfiles.

The cvslock distribution is packaged extremely well and can be installed
according to the usual GNU procedures.  Here's a transcript of an
install session:

     floss$ zcat cvslock-0.1.tar.gz | tar xvf -
     cvslock-0.1/
     cvslock-0.1/Makefile.in
     cvslock-0.1/README
     cvslock-0.1/COPYING
     cvslock-0.1/Makefile.am
     cvslock-0.1/acconfig.h
     cvslock-0.1/aclocal.m4
     cvslock-0.1/config.h.in
     cvslock-0.1/configure
     cvslock-0.1/configure.in
     cvslock-0.1/install-sh
     cvslock-0.1/missing
     cvslock-0.1/mkinstalldirs
     cvslock-0.1/stamp-h.in
     cvslock-0.1/cvslock.c
     cvslock-0.1/cvslock.1
     cvslock-0.1/snprintf.c
     cvslock-0.1/cvslssh
     cvslock-0.1/VERSION
     floss$ cd cvslock-0.1
     floss$ ./configure
      ...
     floss$ make
     gcc -DHAVE_CONFIG_H -I. -I. -I.   -g -O2 -c cvslock.c
     gcc -g -O2  -o cvslock  cvslock.o
     floss$ make install
      ...
     floss$

(Note that you may have to do the make install step as root).

Now, cvslock is installed as /usr/local/bin/cvslock.  When you invoke
it, you can specify the repository with -d or via the $CVSROOT
environment variable, just as with CVS itself (the following examples
use -d).  Its only required argument is the name of the directory to
lock, relative to the top of the repository.  That directory and all of
its subdirectories will be locked.  In this example, there are no
subdirectories, so only one lockfile is created:

     floss$ ls /usr/local/newrepos/myproj/b-subdir/
     random.c,v
     floss$ cvslock -d /usr/local/newrepos  myproj/b-subdir
     floss$ ls /usr/local/newrepos/myproj/b-subdir/
     #cvs.rfl.cvslock.floss.27378  random.c,v
     floss$ cvslock -u -p 27378 -d /usr/local/newrepos  myproj/b-subdir
     floss$ ls /usr/local/newrepos/myproj/b-subdir/
     random.c,v
     floss$

Notice that when I cleared the lock (-u for `unlock'), I had to specify
`-p 27378'.  That's because cvslock uses Unix process IDs when creating
lockfile names to ensure that its locks are unique.  When you unlock,
you have to tell cvslock which lock instance to remove, even if there's
only one instance present.  Thus, the -p flag tells cvslock which
previous instance of itself it's cleaning up after (you can use -p with
or without -u, though).

If you're going to be working in the repository for a while, doing
various operations directly in the file system, you can use the -s
option to have cvslock start up a new shell for you.  It then consults
the `$SHELL' environment variable in your current shell to determine
which shell to use:

     floss$ cvslock -s -d /usr/local/newrepos myproj

The locks remain present until you exit the shell, at which time they
are automatically removed.  You can also use the -c option to execute a
command while the repository is locked.  Just as with -s, the locks are
put in place before the command starts and removed when it's finished.
In the following example, we lock the repository just long enough to
display a listing of all of the lockfiles:

     floss$ cvslock -c 'find . -name "*cvslock*" ' -d /usr/local/newrepos myproj
     cvslock: '/usr/local/newrepos/myproj' locked successfully.
     cvslock: Starting 'find . -name "*cvslock*" -print'...
     ./a-subdir/subsubdir/#cvs.rfl.cvslock.floss.27452
     ./a-subdir/#cvs.rfl.cvslock.floss.27452
     ./b-subdir/#cvs.rfl.cvslock.floss.27452
     ./#cvs.rfl.cvslock.floss.27452
     floss$ find /usr/local/newrepos/myproj -name "*cvslock*" -print
     floss$

The command (the argument to the -c option) is run with the specified
repository directory as its working directory.

By default, cvslock creates read-locks.  You can tell it to use
write-locks instead by passing the -W option.  (You can pass -R to
specify read-locks, but that's the default anyway.)  Always remove any
locks when you're finished, so that other users' CVS processes don't
wait needlessly.

Note that cvslock must be run on the machine where the repository
resides - you cannot specify a remote repository.  (For more
information, run `man cvslock', which is a manual page installed when
you ran `make install'.)


File: ossdev.info,  Node: Other Packages,  Next: Writing Your Own Tools,  Prev: cvsq -- Queue CVS Commands For Later Connection,  Up: Third-Party Tools

Other Packages
==============

Many other third-party packages are available for CVS.  Following are
pointers to some of these.

CVSUp (Part Of The FreeBSD Project)
===================================

CVSUp is an efficient generic mirroring tool with special built-in
support for mirroring CVS repositories.  The FreeBSD operating system
uses it to distribute changes from their master repository, so users can
keep up to date conveniently.

For more information on CVSUp in general, check out
`http://www.polstra.com/projects/freeware/CVSup/'.

For its use in FreeBSD in particular, see
`http://www.freebsd.org/handbook/synching.html#CVSUP'.

CVSWeb: A Web Interface To CVS Repositories
===========================================

CVSWeb provides a Web interface to browsing CVS repositories.  A more
accurate name might be "RCSWeb", because what it actually does is allow
you to browse revisions directly in a repository, viewing log messages
and diffs.  Although I've never found it to be a particularly compelling
interface myself, I have to admit that it is intuitive enough and a lot
of sites use it.

Although the software was originally written by Bill Fenner, the version
most actively under development right now seems to be Henner Zeller's,
at `http://linux.fh-heilbronn.de/~zeller/cgi/cvsweb.cgi/'.

You may also want to visit Fenner's original site at
`http://www.freebsd.org/~fenner/cvsweb/' and possibly Cyclic Software's
summary of the CVSWeb scene at
`http://www.cyclic.com/cyclic-pages/web-cvsweb.html'.

Finally, if you'd like to see CVSWeb in action, a good example can be
browsed at `http://sourceware.cygnus.com/cgi-bin/cvsweb.cgi/'.

The CVS contrib/ Directory
==========================

As mentioned in *Note Repository Administration::, a number of
third-party tools are shipped with CVS and are collected in the
contrib/ directory.  Although I'm not aware of any formal rule for
determining which tools are distributed with CVS, an effort may be in
process to gather most of the widely used third-party tools and put
them in contrib/ so people know where to find them.  Until that
happens, the best way to find such tools is to look in contrib/, look
at various CVS Web sites, and ask on the mailing list.


File: ossdev.info,  Node: Writing Your Own Tools,  Prev: Other Packages,  Up: Third-Party Tools

Writing Your Own Tools
======================

CVS can at times seem like a bewildering collection of improvised
standards.  There's RCS format, various output formats (history,
annotate, log, update, and so on), several repository administrative
file formats, working copy administrative file formats, the
client/server protocol, the lockfile protocol....  (Are you numb yet? I
could keep going, you know.)

Fortunately, these standards remain fairly consistent from release to
release - so if you're trying to write a tool to work with CVS, you at
least don't have to worry about hitting a moving target.  For every
internal standard, there are usually a few people on the
<info-cvs@gnu.org> mailing list who know it extremely well (several of
them helped me out during the writing of this book).  There is also the
documentation that comes with the CVS distribution (especially
doc/cvs.texinfo, doc/cvsclient.texi, and doc/RCSFILES).  Finally, there
is the CVS source code itself, the last word on any question of
implementation or behavior.

With all of this at your disposal, there's no reason to hesitate.  If
you can think of some utility that would make your life with CVS easier,
go ahead and write it - chances are other people have been wanting it,
too.  Unlike a change to CVS itself, a small, standalone external
utility can get wide distribution very quickly, resulting in quicker
feedback for its author and faster bug fixes for all of the users.


File: ossdev.info,  Node: Index,  Next: GNU General Public License,  Prev: Third-Party Tools,  Up: Top

Index
*****

Sorry, the index is still in progress.

Since the online format is searchable anyway, I decided the
incompleteness of the index need not delay the release of the chapters.
I hope to have the index finished reasonably soon.  Volunteer indexers
are certainly welcome, too - please email <bug-cvsbook@red-bean.com> if
you're interested.


File: ossdev.info,  Node: GNU General Public License,  Next: GNU Free Documentation License,  Prev: Index,  Up: Top

GNU General Public License
**************************

     GNU General Public License
     
     Version 2, June 1991
     
     Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
     
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.
     
     Preamble
     
     The licenses for most software are designed to take away your freedom to
     share and change it. By contrast, the GNU General Public License is intended
     to guarantee your freedom to share and change free software--to make sure
     the software is free for all its users. This General Public License applies
     to most of the Free Software Foundation's software and to any other program
     whose authors commit to using it. (Some other Free Software Foundation
     software is covered by the GNU Library General Public License instead.) You
     can apply it to your programs, too.
     
     When we speak of free software, we are referring to freedom, not price. Our
     General Public Licenses are designed to make sure that you have the freedom
     to distribute copies of free software (and charge for this service if you
     wish), that you receive source code or can get it if you want it, that you
     can change the software or use pieces of it in new free programs; and that
     you know you can do these things.
     
     To protect your rights, we need to make restrictions that forbid anyone to
     deny you these rights or to ask you to surrender the rights. These
     restrictions translate to certain responsibilities for you if you distribute
     copies of the software, or if you modify it.
     
     For example, if you distribute copies of such a program, whether gratis or
     for a fee, you must give the recipients all the rights that you have. You
     must make sure that they, too, receive or can get the source code. And you
     must show them these terms so they know their rights.
     
     We protect your rights with two steps: (1) copyright the software, and (2)
     offer you this license which gives you legal permission to copy, distribute
     and/or modify the software.
     
     Also, for each author's protection and ours, we want to make certain that
     everyone understands that there is no warranty for this free software. If
     the software is modified by someone else and passed on, we want its
     recipients to know that what they have is not the original, so that any
     problems introduced by others will not reflect on the original authors'
     reputations.
     
     Finally, any free program is threatened constantly by software patents. We
     wish to avoid the danger that redistributors of a free program will
     individually obtain patent licenses, in effect making the program
     proprietary. To prevent this, we have made it clear that any patent must be
     licensed for everyone's free use or not licensed at all.
     
     The precise terms and conditions for copying, distribution and modification
     follow.
     
     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
     
     0. This License applies to any program or other work which contains a notice
     placed by the copyright holder saying it may be distributed under the terms
     of this General Public License. The "Program", below, refers to any such
     program or work, and a "work based on the Program" means either the Program
     or any derivative work under copyright law: that is to say, a work
     containing the Program or a portion of it, either verbatim or with
     modifications and/or translated into another language. (Hereinafter,
     translation is included without limitation in the term "modification".) Each
     licensee is addressed as "you".
     
     Activities other than copying, distribution and modification are not covered
     by this License; they are outside its scope. The act of running the Program
     is not restricted, and the output from the Program is covered only if its
     contents constitute a work based on the Program (independent of having been
     made by running the Program). Whether that is true depends on what the
     Program does.
     
     1. You may copy and distribute verbatim copies of the Program's source code
     as you receive it, in any medium, provided that you conspicuously and
     appropriately publish on each copy an appropriate copyright notice and
     disclaimer of warranty; keep intact all the notices that refer to this
     License and to the absence of any warranty; and give any other recipients of
     the Program a copy of this License along with the Program.
     
     You may charge a fee for the physical act of transferring a copy, and you
     may at your option offer warranty protection in exchange for a fee.
     
     2. You may modify your copy or copies of the Program or any portion of it,
     thus forming a work based on the Program, and copy and distribute such
     modifications or work under the terms of Section 1 above, provided that you
     also meet all of these conditions:
     
        * a) You must cause the modified files to carry prominent notices stating
          that you changed the files and the date of any change.
     
        * b) You must cause any work that you distribute or publish, that in
          whole or in part contains or is derived from the Program or any part
          thereof, to be licensed as a whole at no charge to all third parties
          under the terms of this License.
     
        * c) If the modified program normally reads commands interactively when
          run, you must cause it, when started running for such interactive use
          in the most ordinary way, to print or display an announcement including
          an appropriate copyright notice and a notice that there is no warranty
          (or else, saying that you provide a warranty) and that users may
          redistribute the program under these conditions, and telling the user
          how to view a copy of this License. (Exception: if the Program itself
          is interactive but does not normally print such an announcement, your
          work based on the Program is not required to print an announcement.)
     
     These requirements apply to the modified work as a whole. If identifiable
     sections of that work are not derived from the Program, and can be
     reasonably considered independent and separate works in themselves, then
     this License, and its terms, do not apply to those sections when you
     distribute them as separate works. But when you distribute the same sections
     as part of a whole which is a work based on the Program, the distribution of
     the whole must be on the terms of this License, whose permissions for other
     licensees extend to the entire whole, and thus to each and every part
     regardless of who wrote it.
     
     Thus, it is not the intent of this section to claim rights or contest your
     rights to work written entirely by you; rather, the intent is to exercise
     the right to control the distribution of derivative or collective works
     based on the Program.
     
     In addition, mere aggregation of another work not based on the Program with
     the Program (or with a work based on the Program) on a volume of a storage
     or distribution medium does not bring the other work under the scope of this
     License.
     
     3. You may copy and distribute the Program (or a work based on it, under
     Section 2) in object code or executable form under the terms of Sections 1
     and 2 above provided that you also do one of the following:
     
        * a) Accompany it with the complete corresponding machine-readable source
          code, which must be distributed under the terms of Sections 1 and 2
          above on a medium customarily used for software interchange; or,
     
        * b) Accompany it with a written offer, valid for at least three years,
          to give any third party, for a charge no more than your cost of
          physically performing source distribution, a complete machine-readable
          copy of the corresponding source code, to be distributed under the
          terms of Sections 1 and 2 above on a medium customarily used for
          software interchange; or,
     
        * c) Accompany it with the information you received as to the offer to
          distribute corresponding source code. (This alternative is allowed only
          for noncommercial distribution and only if you received the program in
          object code or executable form with such an offer, in accord with
          Subsection b above.)
     
     The source code for a work means the preferred form of the work for making
     modifications to it. For an executable work, complete source code means all
     the source code for all modules it contains, plus any associated interface
     definition files, plus the scripts used to control compilation and
     installation of the executable. However, as a special exception, the source
     code distributed need not include anything that is normally distributed (in
     either source or binary form) with the major components (compiler, kernel,
     and so on) of the operating system on which the executable runs, unless that
     component itself accompanies the executable.
     
     If distribution of executable or object code is made by offering access to
     copy from a designated place, then offering equivalent access to copy the
     source code from the same place counts as distribution of the source code,
     even though third parties are not compelled to copy the source along with
     the object code.
     
     4. You may not copy, modify, sublicense, or distribute the Program except as
     expressly provided under this License. Any attempt otherwise to copy,
     modify, sublicense or distribute the Program is void, and will automatically
     terminate your rights under this License. However, parties who have received
     copies, or rights, from you under this License will not have their licenses
     terminated so long as such parties remain in full compliance.
     
     5. You are not required to accept this License, since you have not signed
     it. However, nothing else grants you permission to modify or distribute the
     Program or its derivative works. These actions are prohibited by law if you
     do not accept this License. Therefore, by modifying or distributing the
     Program (or any work based on the Program), you indicate your acceptance of
     this License to do so, and all its terms and conditions for copying,
     distributing or modifying the Program or works based on it.
     
     6. Each time you redistribute the Program (or any work based on the
     Program), the recipient automatically receives a license from the original
     licensor to copy, distribute or modify the Program subject to these terms
     and conditions. You may not impose any further restrictions on the
     recipients' exercise of the rights granted herein. You are not responsible
     for enforcing compliance by third parties to this License.
     
     7. If, as a consequence of a court judgment or allegation of patent
     infringement or for any other reason (not limited to patent issues),
     conditions are imposed on you (whether by court order, agreement or
     otherwise) that contradict the conditions of this License, they do not
     excuse you from the conditions of this License. If you cannot distribute so
     as to satisfy simultaneously your obligations under this License and any
     other pertinent obligations, then as a consequence you may not distribute
     the Program at all. For example, if a patent license would not permit
     royalty-free redistribution of the Program by all those who receive copies
     directly or indirectly through you, then the only way you could satisfy both
     it and this License would be to refrain entirely from distribution of the
     Program.
     
     If any portion of this section is held invalid or unenforceable under any
     particular circumstance, the balance of the section is intended to apply and
     the section as a whole is intended to apply in other circumstances.
     
     It is not the purpose of this section to induce you to infringe any patents
     or other property right claims or to contest validity of any such claims;
     this section has the sole purpose of protecting the integrity of the free
     software distribution system, which is implemented by public license
     practices. Many people have made generous contributions to the wide range of
     software distributed through that system in reliance on consistent
     application of that system; it is up to the author/donor to decide if he or
     she is willing to distribute software through any other system and a
     licensee cannot impose that choice.
     
     This section is intended to make thoroughly clear what is believed to be a
     consequence of the rest of this License.
     
     8. If the distribution and/or use of the Program is restricted in certain
     countries either by patents or by copyrighted interfaces, the original
     copyright holder who places the Program under this License may add an
     explicit geographical distribution limitation excluding those countries, so
     that distribution is permitted only in or among countries not thus excluded.
     In such case, this License incorporates the limitation as if written in the
     body of this License.
     
     9. The Free Software Foundation may publish revised and/or new versions of
     the General Public License from time to time. Such new versions will be
     similar in spirit to the present version, but may differ in detail to
     address new problems or concerns.
     
     Each version is given a distinguishing version number. If the Program
     specifies a version number of this License which applies to it and "any
     later version", you have the option of following the terms and conditions
     either of that version or of any later version published by the Free
     Software Foundation. If the Program does not specify a version number of
     this License, you may choose any version ever published by the Free Software
     Foundation.
     
     10. If you wish to incorporate parts of the Program into other free programs
     whose distribution conditions are different, write to the author to ask for
     permission. For software which is copyrighted by the Free Software
     Foundation, write to the Free Software Foundation; we sometimes make
     exceptions for this. Our decision will be guided by the two goals of
     preserving the free status of all derivatives of our free software and of
     promoting the sharing and reuse of software generally.
     
     NO WARRANTY
     
     11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
     THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
     OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
     PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
     OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO
     THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM
     PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
     CORRECTION.
     
     12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
     WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
     REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
     INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
     OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO
     LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR
     THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
     PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
     POSSIBILITY OF SUCH DAMAGES.
     
     END OF TERMS AND CONDITIONS
     
     How to Apply These Terms to Your New Programs
     
     If you develop a new program, and you want it to be of the greatest possible
     use to the public, the best way to achieve this is to make it free software
     which everyone can redistribute and change under these terms.
     
     To do so, attach the following notices to the program. It is safest to
     attach them to the start of each source file to most effectively convey the
     exclusion of warranty; and each file should have at least the "copyright"
     line and a pointer to where the full notice is found.
     
     one line to give the program's name and an idea of what it does.
     Copyright (C) yyyy  name of author
     
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version 2
     of the License, or (at your option) any later version.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
     
     Also add information on how to contact you by electronic and paper mail.
     
     If the program is interactive, make it output a short notice like this when
     it starts in an interactive mode:
     
     Gnomovision version 69, Copyright (C) yyyy name of author
     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
     type `show w'.  This is free software, and you are welcome
     to redistribute it under certain conditions; type `show c'
     for details.
     
     The hypothetical commands `show w' and `show c' should show the appropriate
     parts of the General Public License. Of course, the commands you use may be
     called something other than `show w' and `show c'; they could even be
     mouse-clicks or menu items--whatever suits your program.
     
     You should also get your employer (if you work as a programmer) or your
     school, if any, to sign a "copyright disclaimer" for the program, if
     necessary. Here is a sample; alter the names:
     
     Yoyodyne, Inc., hereby disclaims all copyright
     interest in the program `Gnomovision'
     (which makes passes at compilers) written
     by James Hacker.
     
     signature of Ty Coon, 1 April 1989
     Ty Coon, President of Vice
     
     This General Public License does not permit incorporating your program into
     proprietary programs. If your program is a subroutine library, you may
     consider it more useful to permit linking proprietary applications with the
     library. If this is what you want to do, use the GNU Library General Public
     License instead of this License.

