cvs.pm #23

  • //
  • guest/
  • perforce_software/
  • revml/
  • lib/
  • VCP/
  • Source/
  • cvs.pm
  • View
  • Commits
  • Open Download .zip Download (28 KB)
package VCP::Source::cvs ;

=head1 NAME

VCP::Source::cvs - A CVS repository source

=head1 SYNOPSIS

   vcp cvs:module/... -d ">=2000-11-18 5:26:30" <dest>
                                  # All file revs newer than a date/time

   vcp cvs:module/... -r foo      # all files in module and below labelled foo
   vcp cvs:module/... -r foo:     # All revs of files labelled foo and newer,
                                  # including files not tagged with foo.
   vcp cvs:module/... -r 1.1:1.10 # revs 1.1..1.10
   vcp cvs:module/... -r 1.1:     # revs 1.1 and up on main trunk

   ## NOTE: Unlike cvs, vcp requires spaces after option letters.

=head1 DESCRIPTION

Source driver enabling L<C<vcp>|vcp> to extract versions form a cvs
repository.

This doesn't deal with branches yet (at least not intentionally).  That
will require a bit of Deep Thought.

The source specification for CVS looks like:

    cvs:cvsroot/filespec [<options>]

where the C<cvsroot> is passed to C<cvs> with the C<-d> option if
provided (C<cvsroot> is optional if the environment variable C<CVSROOT>
is set) and the filespec and E<lt>optionsE<gt> determine what revisions
to extract.

C<filespec> may contain trailing wildcards, like C</a/b/...> to extract
an entire directory tree.

=head1 OPTIONS

=over

=item -b, --bootstrap

   -b ...
   --bootstrap=...
   -b file1[,file2[, etc.]]
   --bootstrap=file1[,file2[, etc. ]]

(the C<...> there is three periods, a
L<Regexp::Shellish|Regexp::Shellish> wildcard borrowed from C<p4>
path syntax).

Forces bootstrap mode for an entire export (C<-b ...>) or for certain
files.  Filenames may contain wildcards, see L<Regexp::Shellish> for
details on what wildcards are accepted.

Controls how the first revision of a file is exported.  A bootstrap
export contains the entire contents of the first revision in the
revision range.  This should only be necessary when exporting for the
first time.

An incremental export contains a digest of the revision preceding the
first revision in the revision range, followed by a delta record between
that revision and the first revision in the range.  This allows the
destination import function to make sure that the incremental export
begins where the last export left off.

The default is decided on a per-file basis: if the first revision in the
range is revision #.1, the full contents are exported.  Otherwise an
incremental export is done for that file.

This option is necessary when exporting only more recent revisions from
a repository.

=item --cd

Used to set the CVS working directory.  VCP::Source::cvs will cd to this
directory before calling cvs, and won't initialize a CVS workspace of
it's own (normally, VCP::Source::cvs does a "cvs checkout" in a
temporary directory).

This is an advanced option that allows you to use a CVS workspace you
establish instead of letting vcp create one in a temporary directory
somewhere.  This is useful if you want to read from a CVS branch or if
you want to delete some files or subdirectories in the workspace.

If this option is a relative directory, then it is treated as relative
to the current directory.

=item -kb, -k b

Pass the -kb option to cvs, forces a binary checkout.  This is
useful when you want a text file to be checked out with Unix linends,
or if you know that some files in the repository are not flagged as
binary files and should be.

=item --rev-root

B<Experimental>.

Falsifies the root of the source tree being extracted; files will
appear to have been extracted from some place else in the hierarchy.
This can be useful when exporting RevML, the RevML file can be made
to insert the files in to a different place in the eventual destination
repository than they existed in the source repository.

The default C<rev-root> is the file spec up to the first path segment
(directory name) containing a wildcard, so

   cvs:/a/b/c...

would have a rev-root of C</a/b>.

In direct repository-to-repository transfers, this option should not be
necessary, the destination filespec overrides it.

=item -r

   -r v_0_001:v_0_002
   -r v_0_002:

Passed to C<cvs log> as a C<-r> revision specification. This corresponds
to the C<-r> option for the rlog command, not either of the C<-r>
options for the cvs command. Yes, it's confusing, but 'cvs log' calls
'rlog' and passes the options through.

IMPORTANT: When using tags to specify CVS file revisions, it would ordinarily
be the case that a number of unwanted revisions would be selected.  This is
because the behavior of the cvs log command dumps the entire log history for
any files that do not contain the tag. VCP captures the histories of such files
and ignores all revisions that are older or newer than any files that match the
tags.

Be cautious using HEAD as the end of a revision range, this seems to cause the
delete actions for files deleted in the last revision to not be noticed. Not
sure why.

=item C<-d>

   -d "2000-11-18 5:26:30<="

Passed to 'cvs log' as a C<-d> date specification. 

WARNING: if this string doesn't contain a '>' or '<', you're probably doing
something wrong, since you're not specifying a range.  vcp may warn about this
in the future.

=back

=head2 Files that aren't tagged

CVS has one peculiarity that this driver works around.

If a file does not contain the tag(s) used to select the source files,
C<cvs log> outputs the entire life history of that file.  We don't want
to capture the entire history of such files, so L<VCP::Source::cvs> goes
ignores any revisions before and after the oldest and newest tagged file
in the range.

=head1 LIMITATIONS

   "What we have here is a failure to communicate!"
       - The warden in Cool Hand Luke

CVS does not try to protect itself from people checking in things that
look like snippets of CVS log file: they come out exactly like they
went in, confusing the log file parser.

So, if a repository contains messages in the log file that look like the 
output from some other "cvs log" command, things will likely go awry.

At least one cvs repository out there has multiple revisions of a single file
with the same rev number.  The second and later revisions with the same rev
number are ignored with a warning like "Can't add same revision twice:...".

=cut

$VERSION = 1.2 ;

# Removed docs for -f, since I now think it's overcomplicating things...
#Without a -f This will normally only replicate files which are tagged.  This
#means that files that have been added since, or which are missing the tag for
#some reason, are ignored.
#
#Use the L</-f> option to force files that don't contain the tag to be
#=item -f
#
#This option causes vcp to attempt to export files that don't contain a
#particular tag but which occur in the date range spanned by the revisions
#specified with -r. The typical use is to get all files from a certain
#tag to now.
#
#It does this by exporting all revisions of files between the oldest and
#newest files that the -r specified.  Without C<-f>, these would
#be ignored.
#
#It is an error to specify C<-f> without C<-r>.
#
#exported.

use strict ;

use Carp ;
use Getopt::Long ;
use Regexp::Shellish qw( :all ) ;
use VCP::Branches;
use VCP::Branch;
use VCP::Debug ':debug' ;
use VCP::Rev ;
use VCP::Source ;
use VCP::Utils::cvs ;

use base qw( VCP::Source VCP::Utils::cvs ) ;
use fields (
   'CVS_CUR',            ## The current change number being processed
   'CVS_BOOTSTRAP',      ## Forces bootstrap mode
   'CVS_IS_INCREMENTAL', ## Hash of filenames, 0->bootstrap, 1->incremental
   'CVS_INFO',           ## Results of the 'cvs --version' command and CVSROOT
   'CVS_LABEL_CACHE',    ## ->{$name}->{$rev} is a list of labels for that rev
   'CVS_LABELS',         ## Array of labels from 'p4 labels'
   'CVS_MAX',            ## The last change number needed
   'CVS_MIN',            ## The first change number needed
   'CVS_REV_SPEC',       ## The revision spec to pass to `cvs log`
   'CVS_DATE_SPEC',      ## The date spec to pass to `cvs log`
   'CVS_FORCE_MISSING',  ## Set if -r was specified.

   'CVS_K_OPTION',       ## Which of the CVS/RCS "-k" options to use, if any

   'CVS_LOG_CARRYOVER',  ## The unparsed bit of the log file
   'CVS_LOG_FILE_DATA',  ## Data about all revs of a file from the log file
   'CVS_LOG_STATE',      ## Parser state machine state
   'CVS_LOG_REV',        ## The revision being parsed (a hash)

   'CVS_NAME_REP_NAME',  ## A mapping of repository names to names, used to
                         ## figure out what files to ignore when a cvs log
			 ## goes ahead and logs a file which doesn't match
			 ## the revisions we asked for.

   'CVS_NEEDS_BASE_REV', ## What base revisions are needed.  Base revs are
                         ## needed for incremental (ie non-bootstrap) updates,
			 ## which is decided on a per-file basis by looking
			 ## at VCP::Source::is_bootstrap_mode( $file ) and
			 ## the file's rev number (ie does it end in .1).
   'CVS_SAW_EQUALS',     ## Set when we see the ==== lines in log file [1]
) ;


sub new {
   my $class = shift ;
   $class = ref $class || $class ;

   my VCP::Source::cvs $self = $class->SUPER::new( @_ ) ;

   ## Parse the options
   my ( $spec, $options ) = @_ ;

   $self->parse_cvs_repo_spec( $spec ) ;

   my $work_dir ;
   my $rev_root ;
   my $rev_spec ;
   my $date_spec ;
   #   my $force_missing ;

   GetOptions(
      "b|bootstrap:s"   => sub {
	 my ( $name, $val ) = @_ ;
	 $self->{CVS_BOOTSTRAP} = $val eq ""
	    ? [ compile_shellish( "..." ) ]
	    : [ map compile_shellish( $_ ), split /,+/, $val ] ;
      },
      "cd=s"          => \$work_dir,
      "rev-root=s"    => \$rev_root,
      "r=s"           => \$rev_spec,
      "d=s"           => \$date_spec,
      "k=s"           => sub { warn $self->{CVS_K_OPTION} = $_[1] } ,
      "kb"            => sub { warn $self->{CVS_K_OPTION} = "b" } ,
#      "f+"            => \$force_missing,
   ) or $self->usage_and_exit ;

#   unless ( defined $rev_spec || defined $date_spec ) {
#      print STDERR "Revision (-r) or date (-d) specification missing\n" ;
#      $self->usage_and_exit ;
#   }

#   if ( $force_missing && ! defined $rev_spec ) {
#      print STDERR
#         "Force missing (-f) may not be used without a revision spec (-r)\n" ;
#      $self->usage_and_exit ;
#   }
#
   my $files = $self->repo_filespec ;
   unless ( defined $rev_root ) {
      $self->deduce_rev_root( $files ) ;
   }

   ## Don't normalize the filespec.
   my $recurse = $files =~ s{/\.\.\.$}{} ;
   $self->repo_filespec( $files ) ;

   $self->rev_spec( $rev_spec ) ;
   $self->date_spec( $date_spec ) ;
   $self->force_missing( defined $rev_spec ) ;
#   $self->force_missing( $force_missing ) ;

   ## Make sure the cvs command is available
   $self->command_stderr_filter(
      qr{^
         (?:cvs\s
             (?:
                (?:server|add|remove):\suse\s'cvs\scommit'\sto.*
                |tag.*(?:waiting for.*lock|obtained_lock).*
             )
        )\n
      }x
   ) ;

   ## Doing a CVS command or two here also forces cvs to be found in new(),
   ## or an exception will be thrown.
   $self->cvs( ['--version' ], \$self->{CVS_INFO} ) ;

   ## This does a checkout, so we'll blow up quickly if there's a problem.
   unless ( defined $work_dir ) {
      $self->create_cvs_workspace ;
   }
   else {
      $self->work_root( File::Spec->rel2abs( $work_dir ) ) ; 
      $self->command_chdir( $self->work_path ) ;
   }

   return $self ;
}


sub is_incremental {
   my VCP::Source::cvs $self= shift ;
   my ( $file, $first_rev ) = @_ ;

   my $bootstrap_mode = substr( $first_rev, -2 ) eq ".1"
      || ( $self->{CVS_BOOTSTRAP}
         && grep $file =~ $_, @{$self->{CVS_BOOTSTRAP}}
      ) ;

   return $bootstrap_mode ? 0 : "incremental" ;
}


sub rev_spec {
   my VCP::Source::cvs $self = shift ;
   $self->{CVS_REV_SPEC} = shift if @_ ;
   return $self->{CVS_REV_SPEC} ;
}


sub rev_spec_cvs_option {
   my VCP::Source::cvs $self = shift ;
   return defined $self->rev_spec? "-r" . $self->rev_spec : (),
}


sub date_spec {
   my VCP::Source::cvs $self = shift ;
   $self->{CVS_DATE_SPEC} = shift if @_ ;
   return $self->{CVS_DATE_SPEC} ;
}


sub date_spec_cvs_option {
   my VCP::Source::cvs $self = shift ;
   return defined $self->date_spec ? "-d" . $self->date_spec : (),
}


sub force_missing {
   my VCP::Source::cvs $self = shift ;
   $self->{CVS_FORCE_MISSING} = shift if @_ ;
   return $self->{CVS_FORCE_MISSING} ;
}


sub denormalize_name {
   my VCP::Source::cvs $self = shift ;
   return '/' . $self->SUPER::denormalize_name( @_ ) ;
}


sub handle_header {
   my VCP::Source::cvs $self = shift ;
   my ( $header ) = @_ ;

   $header->{rep_type} = 'cvs' ;
   $header->{rep_desc} = $self->{CVS_INFO} ;
   $header->{rev_root} = $self->rev_root ;
   $header->{branches} = $self->branches;

   $self->dest->handle_header( $header ) ;
   return ;
}


sub get_rev {
   my VCP::Source::cvs $self = shift ;

   my VCP::Rev $r ;
   ( $r ) = @_ ;

   my $wp = $self->work_path( "revs", $r->name, $r->rev_id ) ;
   $r->work_path( $wp ) ;
   $self->mkpdir( $wp ) ;

   $self->cvs( [
	 "checkout",
	 "-r" . $r->rev_id,
	 "-p",
	 $r->source_name,
      ],
      '>', $wp,
   ) ;
}


sub copy_revs {
   my VCP::Source::cvs $self = shift ;

   $self->{CVS_LOG_STATE} = '' ;
   $self->{CVS_LOG_CARRYOVER} = '' ;
   $self->revs( VCP::Revs->new ) ;

   ## We need to watch STDERR for messages like
   ## cvs log: warning: no revision `ch_3' in `/home/barries/src/revengine/tmp/cvsroot/foo/add/f4,v'
   ## Files that cause this warning need to have some revisions ignored because
   ## cvs log will emit the entire log for these files in addition to 
   ## the warning, including revisions checked in before the first tag and
   ## after the last tag.
   my $tmp_f = $self->command_stderr_filter ;
   my %ignore_files ;
   my $ignore_file = sub {
      exists $ignore_files{$self->{CVS_NAME_REP_NAME}->{$_[0]}} ;
   } ;

   ## This regexp needs to gobble newlines.
   $self->command_stderr_filter( sub {
      my ( $err_text_ref ) = @_ ;
      $$err_text_ref =~ s@
         ^cvs(?:\.exe)?\slog:\swarning:\sno\srevision\s.*?\sin\s[`"'](.*)[`"']\r?\n\r?
      @
         $ignore_files{$1} = undef ;
	 '' ;
      @gxmei ;
   } ) ; ## `

   $self->{CVS_LOG_FILE_DATA} = {} ;
   $self->{CVS_LOG_REV} = {} ;
   $self->{CVS_SAW_EQUALS} = 0 ;
   # The log command must be run in the directory above the work root,
   # since we pass in the name of the workroot dir as the first dir in
   # the filespec.
   my $tmp_command_chdir = $self->command_chdir ;
   $self->command_chdir( $self->tmp_dir( "co" ) ) ;
   $self->cvs( [
         "log",
	 $self->rev_spec_cvs_option,
	 $self->date_spec_cvs_option,
	 length $self->repo_filespec ? $self->repo_filespec : (),
      ],
      '>', sub { $self->parse_log_file( @_ ) },
   ) ;

#open L, "tmp/gnome/ChangeLog.log" or die $!;
#$self->parse_log_file( join "", <L> );
#close L;

   $self->command_chdir( $tmp_command_chdir ) ;
   $self->command_stderr_filter( $tmp_f ) ;

   my $revs = $self->revs ;

   ## Figure out the time stamp range for force_missing calcs.
   my ( $min_rev_spec_time, $max_rev_spec_time ) ;
   if ( $self->force_missing ) {
      ## If the rev_spec is /:$/ || /^:/, we tweak the range ends.
      my $max_time = 0 ;
      $max_rev_spec_time = 0 ;
      $min_rev_spec_time = 0 if substr( $self->rev_spec, 0, 1 ) eq ':' ;
      for my $r ( @{$revs->as_array_ref} ) {
         next if $r->is_base_rev ;
         my $t = $r->time ;
         $max_time = $t if $t >= $max_rev_spec_time ;
	 next if $ignore_file->( $r->source_name ) ;
         $min_rev_spec_time = $t if $t <= ( $min_rev_spec_time || $t ) ;
         $max_rev_spec_time = $t if $t >= $max_rev_spec_time ;
      }
#      $max_rev_spec_time = $max_time if substr( $self->rev_spec, -1 ) eq ':' ;
      $max_rev_spec_time = undef if substr( $self->rev_spec, -1 ) eq ':' ;

      debug(
	 "vcp: including files in ['",
	 localtime( $min_rev_spec_time ),
	 "'..'",
	 defined $max_rev_spec_time
	    ? localtime( $max_rev_spec_time )
	    : "<end_of_time>",
	 "']"
      ) if debugging $self ;
   }

   ## Remove extra revs from queue by copying from $revs to $self->revs().
   ## TODO: Debug simultaneous use of -r and -d, since we probably are
   ## blowing away revs that -d included that -r didn't.  I haven't
   ## checked to see if we do or don't blow said revs away.
   my %oldest_revs ;
   $self->revs( VCP::Revs->new ) ;
   for my $r ( @{$revs->as_array_ref} ) {
      if ( $ignore_file->( $r->source_name ) ) {
	 if (
	       (!defined $min_rev_spec_time || $r->time >= $min_rev_spec_time)
	    && (!defined $max_rev_spec_time || $r->time <= $max_rev_spec_time)
	 ) {
	    debug(
	       "vcp: including file ", $r->as_string
	    ) if debugging $self ;
	 }
	 else {
	    debug(
	       "vcp: ignoring file ", $r->as_string,
	       ": no revisions match -r"
	    ) if debugging $self ;
	    next ;
	 }
      }
      ## Because of the order of the log file, the last rev set is always
      ## the first rev in the range.
      $oldest_revs{$r->source_name} = $r ;
      $self->revs->add( $r ) ;
   }
   $revs = $self->revs ;

   ## Add in base revs
   for my $fn ( keys %oldest_revs ) {
      my $r = $oldest_revs{$fn} ;
      my $rev_id = $r->rev_id ;
      if ( $self->is_incremental( $fn, $rev_id ) ) {
	 $rev_id =~ s{(\d+)$}{$1-1}e ;
         $revs->add(
	    VCP::Rev->new(
	       source_name => $r->source_name,
	       name        => $r->name,
	       rev_id      => $rev_id,
	       type        => $r->type,
	    )
	 )
      }
   }

   $self->dest->sort_revs( $self->revs ) ;

   my $metadata_only = $self->dest->metadata_only;

   my VCP::Rev $r ;
   while ( $r = $self->revs->shift ) {
      $self->get_rev( $r ) unless $metadata_only;
      $self->dest->handle_rev( $r ) ;
   }
}


# Here's a typical file log entry.
#
###############################################################################
#
#RCS file: /var/cvs/cvsroot/src/Eesh/Changes,v
#Working file: src/Eesh/Changes
#head: 1.3
#branch:
#locks: strict
#access list:
#symbolic names:
#        Eesh_003_000: 1.3
#        Eesh_002_000: 1.2
#        Eesh_000_002: 1.1
#keyword substitution: kv
#total revisions: 3;     selected revisions: 3
#description:
#----------------------------
#revision 1.3
#date: 2000/04/22 05:35:27;  author: barries;  state: Exp;  lines: +5 -0
#*** empty log message ***
#----------------------------
#revision 1.2
#date: 2000/04/21 17:32:14;  author: barries;  state: Exp;  lines: +22 -0
#Moved a bunch of code from eesh, then deleted most of it.
#----------------------------
#revision 1.1
#date: 2000/03/24 14:54:10;  author: barries;  state: Exp;
#*** empty log message ***
#=============================================================================
###############################################################################

sub parse_log_file {
   my ( $self, $input ) = @_ ;

   if ( defined $input ) {
      $self->{CVS_LOG_CARRYOVER} .= $input ;
   }
   else {
      ## There can only be leftovers if they don't end in a "\n".  I've never
      ## seen that happen, but given large comments, I could be surprised...
      $self->{CVS_LOG_CARRYOVER} .= "\n" if length $self->{CVS_LOG_CARRYOVER} ;
   }

   my $store_rev = sub {
      return unless keys %{$self->{CVS_LOG_REV}} ;

      $self->{CVS_LOG_REV}->{MESSAGE} = ''
         if $self->{CVS_LOG_REV}->{MESSAGE} eq '*** empty log message ***' ;

      $self->{CVS_LOG_REV}->{MESSAGE} =~ s/\r\n|\n\r/\n/g ;

#debug map "$_ => $self->{CVS_LOG_FILE_DATA}->{$_},", sort keys %{$self->{CVS_LOG_FILE_DATA}} ;
      $self->_add_rev( $self->{CVS_LOG_FILE_DATA}, $self->{CVS_LOG_REV} ) ;

#      if ( $is_oldest ) {
#         if ( 
#	    $self->is_incremental(
#	       $self->{CVS_LOG_FILE_DATA}->{WORKING},
#	       $self->{CVS_LOG_REV}->{REV}
#	    )
#	 ) {
#	    $self->{CVS_LOG_REV}->{REV} =~ s{(\d+)$}{$1-1}e ;
#
#	    $self->_add_rev(
#	       $self->{CVS_LOG_FILE_DATA},
#	       $self->{CVS_LOG_REV},
#	       "is base rev"
#	    );
#	 }
#      }
      $self->{CVS_LOG_REV} = {} ;
   } ;

   local $_ ;

   ## DOS, Unix, Mac lineends spoken here.
   while ( $self->{CVS_LOG_CARRYOVER} =~ s/^(.*(?:\r\n|\n\r|\n))// ) {
      $_ = $1 ;

      ## [1] See bottom of file for a footnote explaining this delaying of 
      ## clearing CVS_LOG_FILE_DATA and CVS_LOG_STATE until we see
      ## a ========= line followed by something other than a -----------
      ## line.
      ## TODO: Move to a state machine design, hoping that all versions
      ## of CVS emit similar enough output to not trip it up.

      ## TODO: BUG: Turns out that some CVS-philes like to put text
      ## snippets in their revision messages that mimic the equals lines
      ## and dash lines that CVS uses for delimiters!!

   PLEASE_TRY_AGAIN:
      if ( /^===========================================================*$/ ) {
         $store_rev->() ;# "is oldest" ) ;
	 $self->{CVS_SAW_EQUALS} = 1 ;
	 next ;
      }

      if ( /^----------------------------*$/ ) {
         $store_rev->() unless $self->{CVS_SAW_EQUALS} ;
	 $self->{CVS_SAW_EQUALS} = 0 ;
	 $self->{CVS_LOG_STATE} = 'rev' ;
	 next ;
      }

      if ( $self->{CVS_SAW_EQUALS} ) {
	 $self->{CVS_LOG_FILE_DATA} = {} ;
	 $self->{CVS_LOG_STATE} = '' ;
	 $self->{CVS_SAW_EQUALS} = 0 ;
      }

      unless ( $self->{CVS_LOG_STATE} ) {
	 if (
	    /^(RCS file|Working file|head|branch|locks|access list|keyword substitution):\s*(.*)/i
	 ) {
#warn uc( (split /\s+/, $1 )[0] ), "/", $1, ": ", $2, "\n" ;
	    $self->{CVS_LOG_FILE_DATA}->{uc( (split /\s+/, $1 )[0] )} = $2 ;
#$DB::single = 1 if /keyword/ && $self->{CVS_LOG_FILE_DATA}->{WORKING} =~ /Makefile/ ;
	 }
	 elsif ( /^total revisions:\s*([^;]*)/i ) {
	    $self->{CVS_LOG_FILE_DATA}->{TOTAL} = $1 ;
	    if ( /selected revisions:\s*(.*)/i ) {
	       $self->{CVS_LOG_FILE_DATA}->{SELECTED} = $1 ;
	    }
	 }
	 elsif ( /^symbolic names:/i ) {
	    $self->{CVS_LOG_STATE} = 'tags' ;
	    next ;
	 }
	 elsif ( /^description:/i ) {
	    $self->{CVS_LOG_STATE} = 'desc' ;
	    next ;
	 }
	 else {
	    carp "Unhandled CVS log line '$_'" if /\S/ ;
	 }
      }
      elsif ( $self->{CVS_LOG_STATE} eq 'tags' ) {
	 if ( /^\S/ ) {
	    $self->{CVS_LOG_STATE} = '' ;
	    goto PLEASE_TRY_AGAIN ;
	 }
	 my ( $tag, $rev ) = m{(\S+):\s+(\S+)} ;
	 unless ( defined $tag ) {
	    carp "Can't parse tag from CVS log line '$_'" ;
	    $self->{CVS_LOG_STATE} = '' ;
	    next ;
	 }
# not actually needed
#	 $self->{CVS_LOG_FILE_DATA}->{TAGS}->{$tag} = $rev ; 
	 push( @{$self->{CVS_LOG_FILE_DATA}->{RTAGS}->{$rev}}, $tag ) ; 
         $self->{CVS_LOG_FILE_DATA}->{BRANCH_TAGS}->{$tag} = 1
            if $rev =~ /\.0\.\d+\z/;
      }
      elsif ( $self->{CVS_LOG_STATE} eq 'rev' ) {
	 ( $self->{CVS_LOG_REV}->{REV} ) = m/([\d.]+)/ ;
	 $self->{CVS_LOG_STATE} = 'rev_meta' ;
	 next ;
      }
      elsif ( $self->{CVS_LOG_STATE} eq 'rev_meta' ) {
	 for ( split /;\s*/ ) {
	    my ( $key, $value ) = m/(\S+):\s+(.*?)\s*$/ ;
	    $self->{CVS_LOG_REV}->{uc($key)} = $value ;
	 }
	 $self->{CVS_LOG_STATE} = 'rev_message' ;
	 next ;
      }
      elsif ( $self->{CVS_LOG_STATE} eq 'rev_message' ) {
	 $self->{CVS_LOG_REV}->{MESSAGE} .= $_ ;
      }
   }

   ## Never, ever forget the last rev.  "Wait for me! Wait for me!"
   ## Most of the time, this should not be a problem: cvs log puts a
   ## line of "=" at the end.  But just in case I don't know of a
   ## funcky condition where that might not happen...
   unless ( defined $input ) {
      $store_rev->() ;
      $self->{CVS_LOG_REV} = undef ;
      $self->{CVS_LOG_FILE_DATA} = undef ;
   }
}


# Here's a (probably out-of-date by the time you read this) dump of the args
# for _add_rev:
#
###############################################################################
#$file = {
#  'WORKING' => 'src/Eesh/eg/synopsis',
#  'SELECTED' => '2',
#  'LOCKS' => 'strict',
#  'TOTAL' => '2',
#  'ACCESS' => '',
#  'RCS' => '/var/cvs/cvsroot/src/Eesh/eg/synopsis,v',
#  'KEYWORD' => 'kv',
#  'RTAGS' => {
#    '1.1' => [
#      'Eesh_003_000',
#      'Eesh_002_000'
#    ]
#  },
#  'HEAD' => '1.2',
###  'TAGS' => {   <== not used, so commented out.
###    'Eesh_002_000' => '1.1',
###    'Eesh_003_000' => '1.1'
###  },
#  'BRANCH' => ''
#};
#$rev = {
#  'DATE' => '2000/04/21 17:32:16',
#  'MESSAGE' => 'Moved a bunch of code from eesh, then deleted most of it.
#',
#  'STATE' => 'Exp',
#  'AUTHOR' => 'barries',
#  'REV' => '1.1'
#};
###############################################################################

sub _add_rev {
   my VCP::Source::cvs $self = shift ;
   my ( $file_data, $rev_data, $is_base_rev ) = @_ ;

   my $norm_name = $self->normalize_name( $file_data->{WORKING} ) ;

   my $action = $rev_data->{STATE} eq "dead" ? "delete" : "edit" ;

   my $type = $file_data->{KEYWORD} =~ /[o|b]/ ? "binary" : "text" ;

#debug map "$_ => $rev_data->{$_}, ", sort keys %{$rev_data} ;

   my $rev_id = $rev_data->{REV};

   my $branch_id;
   my $base_rev_id;

   if ( $rev_id =~ /\A(\d+(?:\.\d+)+)\.(\d+)\.(\d+)\z/ ) {
      $base_rev_id = $1 if $3 eq "1";
      my $magic_branch_number = "$1.0.$2";
      $branch_id = $file_data->{RTAGS}->{$magic_branch_number};

      die "Could not locate branch_id for $rev_id ($magic_branch_number)\n"
         unless defined $branch_id;

      $branch_id = $branch_id->[0];
   }

   elsif ( ( $rev_id =~ tr/.// ) > 1 ) {
      die "Did not parse $rev_id's branch number";
   }

   my VCP::Rev $r = VCP::Rev->new(
      source_name => $file_data->{WORKING},
      name        => $norm_name,
      rev_id      => $rev_id,
      type        => $type,
#      ! $is_base_rev
#	 ? (
	    action      => $action,
	    time        => $self->parse_time( $rev_data->{DATE} ),
	    user_id     => $rev_data->{AUTHOR},
	    comment     => $rev_data->{MESSAGE},
	    state       => $rev_data->{STATE},
	    labels      => $file_data->{RTAGS}->{$rev_id},
#	 )
#	 : (),
      branch_id => $branch_id,
      base_rev_id => $base_rev_id,
   ) ;

   $self->{CVS_NAME_REP_NAME}->{$file_data->{WORKING}} = $file_data->{RCS} ;

   my $ok = eval {
      $self->revs->add( $r ) ;
      1 ;
   } ;
   unless ( $ok ) {
      if ( $@ =~ /Can't add same revision twice/ ) {
         warn $@ ;
      }
      else {
         die $@ ;
      }
   }

   $self->branches->add( VCP::Branch->new( branch_id => $_ ) )
      for sort keys %{$file_data->{BRANCH_TAGS}};
}

## FOOTNOTES:
# [1] :pserver:guest@cvs.tigris.org:/cvs hass some goofiness like:
#----------------------------
#revision 1.12
#date: 2000/09/05 22:37:42;  author: thom;  state: Exp;  lines: +8 -4
#
#merge revision history for cvspatches/root/log_accum.in
#----------------------------
#revision 1.11
#date: 2000/08/30 01:29:38;  author: kfogel;  state: Exp;  lines: +8 -4
#(derive_subject_from_changes_file): use \t to represent tab
#characters, not the incorrect \i.
#=============================================================================
#----------------------------
#revision 1.11
#date: 2000/09/05 22:37:32;  author: thom;  state: Exp;  lines: +3 -3
#
#merge revision history for cvspatches/root/log_accum.in
#----------------------------
#revision 1.10
#date: 2000/07/29 01:44:06;  author: kfogel;  state: Exp;  lines: +3 -3
#Change all "Tigris" ==> "Helm" and "tigris" ==> helm", as per Daniel
#Rall's email about how the tigris path is probably obsolete.
#=============================================================================
#----------------------------
#revision 1.10
#date: 2000/09/05 22:37:23;  author: thom;  state: Exp;  lines: +22 -19
#
#merge revision history for cvspatches/root/log_accum.in
#----------------------------
#revision 1.9
#date: 2000/07/29 01:12:26;  author: kfogel;  state: Exp;  lines: +22 -19
#tweak derive_subject_from_changes_file()
#=============================================================================
#----------------------------
#revision 1.9
#date: 2000/09/05 22:37:13;  author: thom;  state: Exp;  lines: +33 -3
#
#merge revision history for cvspatches/root/log_accum.in
#

=head1 SEE ALSO

L<VCP::Dest::cvs>, L<vcp>, L<VCP::Process>.

=head1 AUTHOR

Barrie Slaymaker <barries@slaysys.com>

=head1 COPYRIGHT

Copyright (c) 2000, 2001, 2002 Perforce Software, Inc.
All rights reserved.

See L<VCP::License|VCP::License> (C<vcp help license>) for the terms of use.

=cut

1
# Change User Description Committed
#131 5403 Barrie Slaymaker - Misc logging, maintainability & debugging improvements
#130 4517 Barrie Slaymaker - VCP::Source::cvs uses earlier_ids to prevent deletes from
  occuring before clones or branches
#129 4507 Barrie Slaymaker - RevML:
    - added <action>, removed <delete>, <placeholder> and <move>
    - added <from_id> for clones (and eventually merge actions)
    - Simplified DTD (can't branch DTD based on which action
      any more)
- VCP::Source::cvs, VCP::Filter::changesets and VCP::Dest::p4
  support from_id in <action>clone</action> records
- VCP::Dest::perl_data added
- VCP::Rev::action() "branch" added, no more undefined action
  strings
- "placeholder" action removed
#128 4487 Barrie Slaymaker - dead code removal (thanks to clkao's coverage report)
#127 4476 Barrie Slaymaker - misc bugfixes
#126 4220 Barrie Slaymaker - VCP::Source::cvs no longer passes a leading '/' on module name for checkout
#125 4039 Barrie Slaymaker - VCP::Source::scan_metadata() API now in place,
- VCP::Source::copy_revs() is fully deprecated.
#124 4035 Barrie Slaymaker - VCP::Source::cvs no longer specifies a user_id or time for
  concocted delete revs
#123 4034 Barrie Slaymaker - VCP::Source::cvs does not set the user_id on branch revs
#122 4032 Barrie Slaymaker - VCP::Dest::p4 now estimates missing metadata
#121 4021 Barrie Slaymaker - Remove all phashes and all base & fields pragmas
- Work around SWASHGET error
#120 4012 Barrie Slaymaker - Remove dependance on pseudohashes (deprecated Perl feature)
#119 4005 Barrie Slaymaker - VCP::Source::cvs: minor, abandoned code removed
#118 3999 Barrie Slaymaker - VCP::Source::cvs parses branch numbers more correcly
#117 3995 Barrie Slaymaker - VCP::Source::cvs parses large RCS text sections with lots of
  "@@" escapes.
#116 3994 Barrie Slaymaker - VCP::Source::cvs splits dead revs in to edit followed by a
         delete rev if need be (not always, but only when needed).
#115 3993 Barrie Slaymaker - Fold in changes from clkao's SVN work
#114 3982 Barrie Slaymaker - VCP::Source no longer leaks memory by delete()ing from a phash
- VCP::Source::cvs now flushes to disk more often to conserve RAM
#113 3979 Barrie Slaymaker - VCP::Source::cvs branch number regex fixed
- VCP::Dest::null --dont-get-revs option added
#112 3970 Barrie Slaymaker - VCP::Source handles rev queing, uses disk to reduce RAM
- Lots of other fixes
#111 3930 Barrie Slaymaker - VCP::Source::cvs and VCP::Dest::p4 handle cloning deletes
- "placeholder" actions and is_placeholder_rev() deprecated in
  favor of is_branch_rev() and is_clone_rev().
- Misc cleanups and minor bugfixes
#110 3923 Barrie Slaymaker - VCP::Source::cvs now uses source_...() where possible to
  avoid using modified fields (for instance fields touched by Map:)
#109 3916 Barrie Slaymaker - Reduce memory consumption
#108 3907 Barrie Slaymaker - Debugging cleanups
#107 3904 Barrie Slaymaker - VCP::Source::cvs copes with consecutive dead revisions by
  concocting edit revisions with the same rev_id but different
  ids.  This is experimental.
#106 3894 Barrie Slaymaker - VCP::Source::cvs RCS scan RE no longer explodes
#105 3855 Barrie Slaymaker - vcp scan, filter, transfer basically functional
    - Need more work in re: storage format, etc, but functional
#104 3850 Barrie Slaymaker - No longer stores all revs in memory
#103 3836 Barrie Slaymaker - Sources no longer cache all revs in RAM before sending
#102 3819 Barrie Slaymaker - Factor send & queueing of revs up in to VCP::Source
#101 3818 Barrie Slaymaker - VCP::Source::{cvs,p4,vsS} use less memory
#100 3813 Barrie Slaymaker - VCP::Rev::previous() is no more
#99 3811 Barrie Slaymaker - fetch_*() and get_rev() renamed get_source_file()
#98 3804 Barrie Slaymaker - Refactored to prepare way for reducing memory footprint
#97 3800 Barrie Slaymaker - <branches> removed from all code
#96 3763 Barrie Slaymaker - VCP::Source::cvs now explains what was ignored and what was
  scanned when it finds both foo,v and Attic/foo,v.
#95 3747 Barrie Slaymaker - VCP::Source::cvs branches vendor tags properly
#94 3746 Barrie Slaymaker - VCP::Source::cvs parses vendor tags when no revisions are present
  on the vendor branch (as per Marc Tooley's patch)
    - add test for said parsing
#93 3744 Barrie Slaymaker - VCP::Source::cvs understands a source filespec of "..." for local
  respositories (unless --use-cvs)
#92 3681 Barrie Slaymaker - VCP now scans much more of real_vss_1 and converts it to revml
#91 3677 Barrie Slaymaker - rev_root sanity check is now case insensitive on Win32
- Parens in source filespecs are now treated as regular
  characters, not capture groups
- ** is not treated as '...'
#90 3568 Barrie Slaymaker - Use xchdir() instead of chdir()
#89 3532 John Fetkovich changed File::Spec->rel2abs( blah, start_dir )
to      start_dir_rel2abs blah
everywhere.

which
   does the same thing
   and is defined in VCP::Utils
#88 3523 John Fetkovich more ui defaults and checks added
#87 3489 Barrie Slaymaker - Document options emitted to .vcp files.
#86 3477 Barrie Slaymaker - Make --rev-root only available in VCP::Source::p4
#85 3462 Barrie Slaymaker - Make sure bootstrap regexps get compiled
#84 3460 Barrie Slaymaker - Revamp Plugin/Source/Dest hierarchy to allow for
  reguritating options in to .vcp files
#83 3418 Barrie Slaymaker - Better progress reporting.
- VCP::Source::cvs now actually passes the -k option through to cvs
#82 3384 John Fetkovich moved setting of default repo_id
#81 3285 John Fetkovich In 'sub new' constructor, Only call parse_cvs_repo_spec if a $spec is
       provided.  parse_cvs_repo_spec also now sets repo_id.
#80 3274 John Fetkovich split part of 'sub new' into 'sub init'
#79 3206 John Fetkovich documentation changes
#78 3205 John Fetkovich pod improvements
#77 3199 John Fetkovich Improved documentation of --bootstrap switch.
#76 3167 Barrie Slaymaker Add profiling report that details various chunks of time
       taken.
#75 3166 Barrie Slaymaker Remove stale code, update to _run3 calling conventions
#74 3155 Barrie Slaymaker Convert to logging using VCP::Logger to reduce stdout/err spew.
       Simplify & speed up debugging quite a bit.
       Provide more verbose information in logs.
       Print to STDERR progress reports to keep users from wondering
       what's going on.
       Breaks test; halfway through upgrading run3() to an inline
       function for speed and for VCP specific features.
#73 3133 Barrie Slaymaker Make destinations call back to sources to check out files to
       simplify the architecture (is_metadata_only() no longer needed)
       and make it more optimizable (checkouts can be batched).
#72 3131 Barrie Slaymaker Double the speed of the RCS file parser.
       Deprecate VCP::Revs::shift() in favor of remove_all().
#71 3129 Barrie Slaymaker Stop calling the slow Cwd::cwd so much, use start_dir
       instead.
#70 3120 Barrie Slaymaker Move changeset aggregation in to its own filter.
#69 3106 Barrie Slaymaker Remove an unused field (state) from VCP::Rev
       optimize and bugfix labelmap
#68 3096 Barrie Slaymaker Tuning
#67 3086 Barrie Slaymaker Optimize change aggregation from something like O(N^2)
       down to something more reasonable.  Noticable only
       on large transfers.
#66 3081 Barrie Slaymaker Get cvs->p4 propogation branches with multiple tags working
       to spec.
#65 3075 Barrie Slaymaker Make all empty branches be timestamped at $last_rev_time_in_cvsroot + 1
       second.
#64 3068 Barrie Slaymaker Note a cleanup to be done someday
#63 3067 Barrie Slaymaker Improve revision linking logic for direct-read case
#62 3061 Barrie Slaymaker Make VCP use the first label for a branch instead of the last
#61 3038 Barrie Slaymaker Get proper identification of founding revisions implemented.
#60 3035 Barrie Slaymaker code format tweak.
#59 3032 Barrie Slaymaker Fix rev_id parsing RE
#58 3013 Barrie Slaymaker Clean up minor undefined var warning discovered in testing
#57 3010 Barrie Slaymaker Log the number of tag applications (the xzfree86 repo has a
       lot of tags applied to each file rev, I need numbers).
#56 3007 Barrie Slaymaker Read CVS vendor branche tags
#55 2982 Barrie Slaymaker Treat 1.0, 2.0, 3.0 as first revs
#54 2979 Barrie Slaymaker Put all 1.x, 2.x, 3.x, etc. on the main dev trunk
       (1.1.1.x, 1.1.2.x, etc. are still separate branches)
#53 2973 Barrie Slaymaker Fix handling of branched but unchanged files
#52 2972 Barrie Slaymaker Interim checkin
#51 2938 John Fetkovich added empty() calls
#50 2925 Barrie Slaymaker Source cleanup; no significant changes
#49 2900 Barrie Slaymaker Handle case where the first rev in a branch is deleted.
#48 2824 John Fetkovich removed CVS_CONTINUE field from Source/cvs.pm, and added
       CONTINUE field and continue accessor to Source.pm.  Moved parsing
       of the --continue option also.
#47 2809 Barrie Slaymaker Implement --repo-id in Plugin.pm, refactor source & dest
       options parsing starting in VCP::Source::cvs (need to
       roll out to other sources and dests), get t/91cvs2revml.t
       passing again (first time in months! branching and
       --continue support works in cvs->foo!).
#46 2802 John Fetkovich Added a source_repo_id to each revision, and repo_id to each
Source and Dest.  The repo_ids include repository type
(cvs,p4,revml,vss,...) and the repo_server fields.  Changed the
$self->...->set() and $self->...->get() lines in VCP::Dest::* to
pass in a conglomerated key value, by passing in the key as an
ARRAY ref.  Also various restructuring in VCP::DB.pm,
VCP::DB_file.pm and VCP::DB_file::sdbm.pm related to this
change.
#45 2800 Barrie Slaymaker Get --continue working in cvs->foo transfers.
#44 2743 John Fetkovich Add fields to vcp:
         source_name,
         source_filebranch_id,
         source_branch_id,
         source_rev_id,
         source_change_id

        1. Alter revml.dtd to include the fields
        2. Alter bin/gentrevml to emit legal RevML
        3. Extend VCP::Rev to have the fields
        4. Extend VCP::{Source,Dest}::revml to read/write the fields
           (VCP::Dest::revml should die() if VCP tries to emit illegal
           RevML)
        5. Extend VCP::{Source,Dest}::{cvs,p4} to read the fields
        7. Get all tests through t/91*.t to pass
           except those that rely on ch_4 labels
#43 2667 Barrie Slaymaker Convert more to IPC::Run3
#42 2389 John Fetkovich removed calls to methods:
         command_stderr_filter
         command_ok_result_codes
         command_chdir
       and replaced with named Plugin::run_safely method parameters
         stderr_filter
         ok_result_codes
         in_dir
       respectively, where possible.
#41 2337 Barrie Slaymaker Correct the parser, reduce memory usage
#40 2331 Barrie Slaymaker tune memory usage of VCP::Source::cvs
#39 2322 Barrie Slaymaker Fix jack-in-the-bug options parsing exposed by .vcp files
#38 2321 Barrie Slaymaker Fix a jack-in-the-bug triggered by changing gentrevml's time outputs.
#37 2293 Barrie Slaymaker Update CHANGES, TODO, improve .vcp files, add --init-cvs
#36 2267 Barrie Slaymaker factor out cvs2revml, test both --use-cvs and direct modes, with times
#35 2266 Barrie Slaymaker clean up --use-cvs doc
#34 2245 Barrie Slaymaker cvs -r (re)implemented for direct reads, passes all cvs-only tests
#33 2241 Barrie Slaymaker RCS file scanning improvements, implement some of -r
#32 2240 Barrie Slaymaker Start on cvs -r option support.
#31 2236 Barrie Slaymaker Debug, speed up cvs file parsing
#30 2235 Barrie Slaymaker Debugging cvs speed reader.
#29 2228 Barrie Slaymaker working checkin
#28 2199 Barrie Slaymaker um, comment out the cache I was using to debug.
#27 2153 Barrie Slaymaker checkin
#26 2151 Barrie Slaymaker checkin
#25 2042 Barrie Slaymaker Basic source::p4 branching support
#24 2026 Barrie Slaymaker VCP::8::cvs now supoprt branching
#23 2009 Barrie Slaymaker lots of fixes, improve core support for branches and VCP::Source::cvs
       now supports branches.
#22 2006 Barrie Slaymaker more preparations for branching support,
       handling of cvs :foo:... CVSROOT specs,
       misc fixes, improvements
#21 1998 Barrie Slaymaker Initial, revml and core VCP support for branches
#20 1855 Barrie Slaymaker Major VSS checkin.
 Works on Win32
#19 1728 Barrie Slaymaker CVS on win32, minor bugfixes
#18 1367 Barrie Slaymaker lots of docco updates
#17 1358 Barrie Slaymaker Win32 changes
#16 1330 Barrie Slaymaker Ignore cvs lock mgmt warnings in VCP::Source::cvs.
#15 723 Barrie Slaymaker VCP::Dest::cvs tuning and cvs and p4 bugfixes
#14 705 Barrie Slaymaker Release 0.22.
#13 692 Barrie Slaymaker Add VCP::Utils::p4 and use it to get VCP::Dest::p4 to create it's
own client view as needed.
#12 689 Barrie Slaymaker reinstate -f behavior as the default for VCP::Source::cvs, clean
up -D --> -d doco.
#11 687 Barrie Slaymaker remove -f, tweak deduce_rev_root
#10 630 Barrie Slaymaker Fix bug in CVS log file parsing that made it think it was always
seeing the same file, different revisions over and over again.
Reported by Matthew Attaway.
#9 628 Barrie Slaymaker Cleaned up POD in bin/vcp, added BSD-style license.
#8 627 Barrie Slaymaker Beef up CVS log file parsing.
#7 626 Barrie Slaymaker Removed POD that was older than the current feature set.
#6 625 Barrie Slaymaker Add NOTE about required " " in cvs options.
#5 624 Barrie Slaymaker Add a space to bin/vcp SYNOPSIS after the cvs -r option.
#4 480 Barrie Slaymaker 0.06 Wed Dec 20 23:19:15 EST 2000
   - bin/vcp: Added --versions, which loads all modules and checks them
     for a $VERSION and print the results out.  This should help with
     diagnosing out-of-sync modules.
   - Added $VERSION vars to a few modules :-).  Forgot to increment any
     $VERSION strings.
   - VCP::Dest::cvs: The directory "deeply" was not being `cvs add`ed on
     paths like "a/deeply/nested/file", assuming "deeply" had no files
     in it.
   - VCP::Dest::revml: fixed a bug that was causing files with a lot of
     linefeeds to be emitted in base64 instead of deltaed.  This means
     most text files.
   - Various minor cleanups of diagnostics and error messages, including
     exposing "Can't locate Foo.pm" when a VCP::Source or VCP::Dest
     module depends on a module that's not installed, as reported by
     Jeff Anton.
#3 478 Barrie Slaymaker 0.05 Mon Dec 18 07:27:53 EST 2000
   - Use `p4 labels //...@label` command as per Rober Cowham's suggestion, with
     the '-s' flag recommended by Christopher Siewald and
     Amaury.FORGEOTDARC@atsm.fr.  Though it's actually something like

       vcp: running /usr/bin/p4 -u safari -c safari -p localhost:5666 -s files
       //.../NtLkly //...@compiler_a3 //.../NtLkly //...@compiler_may3

     and so //on //for 50 parameters to get the speed up.  I use the
     //.../NtLkly "file" as //a separator between the lists of files in various
     //revisions.  Hope nobody has any files named that :-).  What I should do
     is choose a random label that doesn't occur in the labels list, I guess.
   - VCP::Source::revml and VCP::Dest::revml are now binary, control code, and
     "hibit ASCII" (I know, that's an oxymoron) clean.  The <comment>, <delta>,
     and <content> elements now escape anything other than tab, line feed,
     space, or printable chars (32 <= c <= ASCII 126) using a tag like '<char
     code="0x09">'.  The test suite tests all this.  Filenames should also
     be escaped this way, but I didn't get to that.
   - The decision whether to do deltas or encode the content in base64 is now
     based on how many characters would need to be escaped.
   - We now depend on the users' diff program to have a "-a" option to force it
     to diff even if the files look binary to it.  I need to use Diff.pm and
     adapt it for use on binary data.
   - VCP::Dest::cvs now makes sure that no two consecutive revisions of the
     same file have the same mod_time.  VCP::Source::p4 got so fast at pulling
     revisions from the repositories the test suite sets up that CVS was not
     noticing that files had changed.
   - VCP::Plugin now allows you to set a list of acceptable result codes, since
     we now use p4 in ways that make it return non-zero result codes.
   - VCP::Revs now croaks if you try to add two entries of the same VCP::Rev
     (ie matching filename and rev_id).
   - The <type> tag is now limited to "text" or "binary", and is meant to
     pass that level of info between foreign repositories.
   - The <p4_info> on each file now carries the one line p4 description of
     the file so that p4->p4 transferes can pick out the more detailed
     info.  VCP::Source::p4, VCP::Dest::p4 do this.
   - VCP::{Source,Dest}::{p4,cvs} now set binaryness on added files properly,
     I think.  For p4->p4, the native p4 type is preserved.  For CVS sources,
     seeing the keyword substitution flag 'o' or 'b' implies binaryness, for
     p4, seeing a filetype like qr/u?x?binary/ or qr/x?tempobj/ or "resource"
     implies binaryness (to non-p4 destinations).  NOTE: Seeing a 'o' or 'b'
     in a CVS source only ends up setting the 'b' option on the destination.
     That should be ok for most uses, but we can make it smarter for cvs->cvs
     transfers if need be.
#2 468 Barrie Slaymaker - VCP::Dest::p4 now does change number aggregation based on the
  comment field changing or whenever a new revision of a file with
  unsubmitted changes shows up on the input stream.  Since revisions of
  files are normally sorted in time order, this should work in a number
  of cases.  I'm sure we'll need to generalize it, perhaps with a time
  thresholding function.
- t/90cvs.t now tests cvs->p4 replication.
- VCP::Dest::p4 now doesn't try to `p4 submit` when no changes are
  pending.
- VCP::Rev now prevents the same label from being applied twice to
  a revision.  This was occuring because the "r_1"-style label that
  gets added to a target revision by VCP::Dest::p4 could duplicate
  a label "r_1" that happened to already be on a revision.
- Added t/00rev.t, the beginnings of a test suite for VCP::Rev.
- Tweaked bin/gentrevml to comment revisions with their change number
  instead of using a unique comment for every revision for non-p4
  t/test-*-in-0.revml files.  This was necessary to test cvs->p4
  functionality.
#1 467 Barrie Slaymaker Version 0.01, initial checkin in perforce public depot.