eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' & eval 'exec perl -S $0 $argv:q' if 0; # THE PRECEEDING STUFF EXECS perl via $PATH # -*-Fundamental-*- require 5.000; #use bytes; my $s = "\001"; # Schema stuff # my $Act_add = 0; my $Act_edit = 1; my $Act_delete = 2; my $Act_branch = 3; my $Act_integ = 4; my $Act_import = 5; # $Id: //guest/richard_geiger/utils/cvs2p4/bin/dochanges#57 $ # # Richard Geiger # sub dirname { local($dir) = @_; $dir =~ s%^$%.%; $dir = "$dir/"; if ($dir =~ m%^/[^/]*//*$%) { return "/"; } if ($dir =~ m%^.*[^/]//*[^/][^/]*//*$%) { $dir =~ s%^(.*[^/])//*[^/][^/]*//*$%$1%; { return $dir; } } return "."; } use Carp; # ...or flounder. (This will fail unless 'perl' is a perl5!) $| = 1; ($Myname = $0) =~ s%^.*/%%; $Mydir = &dirname($0); $Here = `/bin/pwd`; chop $Here; if ($Mydir ne ".") { chdir "$Mydir" || die "$Myname: can't chdir \"$Mydir\": $!"; } chdir ".." || die "$Myname: can't chdir \"..\": $!"; $Mydir = `/bin/pwd`; chop $Mydir; chdir $Here || die "$Myname: can't chdir \"$Here\": $!"; #obs#use IPC::Open2; require "$Mydir/lib/util.pl"; $Usage = <] [-s ] [-c] LIT sub usage { print STDERR $Usage; exit 1; } sub help { print STDERR < set verbosity level [0] -s start numbering generated changes at -c copy (rather than link) the file archive $Myname uses the outputs of the genmetadata and genchanges stages of cvs2p4 and creates a Perforce metadatabase describing the converted changes. It also links (or, optionally, copies) the RCS archives being converted into the file archive tree under $P4ROOT. LIT exit 1; } sub path { my($prefix, $file_dir, $file_name) = @_; my($path); $path = "$prefix"; if ($file_dir) { $path .= "$file_dir/"; } $path .= "$file_name"; return $path; } sub is_binary_ext { my ($path) = @_; my ($chkpath) = ($path =~ /^$CVS_MODULE\/(.*)$/); my ($filename) = $path; $filename =~ s/^.*\///; my $fileext; $filename =~ m/\.([^\.]+)$/; $fileext = $1; $fileext =~ tr/A-Z/a-z/; if (defined($EXT{$fileext})) { return 1; } return 0; } # Determine whether the depot already has this file on this code line. # (Used to determine when we need to branch). # sub depot_has { my($file) = @_; if (defined($DEPOTMAP{$file})) { my ($have, $rev) = split(/$S/, $DEPOTMAP{$file}); return $have; } return 0; } sub depot_newrev { my($file, $action) = @_; my ($have, $rev); if ($action =~ /^(add|branch)$/) { if (defined($DEPOTMAP{$file})) { ($have, $rev) = split(/$S/, $DEPOTMAP{$file}); if ($have) { die "already have $file on add"; } $have = 1; $rev++; } else { $have = 1; $rev = 1; } } else { if (! defined($DEPOTMAP{$file})) { print "$Myname: unmapped \"$file\" on edit/delete.\n"; exit 1; } ($have, $rev) = split(/$S/, $DEPOTMAP{$file}); if (! $have) { print "$Myname: don't already have \"$file\" on edit/delete.\n"; exit 1; } if ($action eq "delete") { $have = 0; } $rev++; } $DEPOTMAP{$file} = "$have$S$rev"; return $rev; } sub genrev { my ($depotfile, $p4rev, $type, $action, $modtime, $lbrfile, $lbrrev, $lbrtype) = @_; return "$depotfile$s$p4rev$s$type$s$action$s$modtime$s//$lbrfile$s$lbrrev$s$lbrtype"; } sub mkdepot { my ($depot, $spec) = @_; my $depot_type; my $depot_extra; if ($spec) { $depot_type = "2"; $depot_extra = ".p4s"; } else { $depot_type = "0"; $depot_extra = "subdir"; } print DBMETA "\@pv\@ 0 \@db.depot\@ \@$depot\@ $depot_type \@$depot_extra\@ \@$depot/...\@\n"; $now = time; print DBMETA "\@pv\@ 2 \@db.domain\@ \@$depot\@ 100 \@\@ \@\@ \@$CONVUSER\@ $now $now". " 0 0 \@Created by cvs2p4\n@\n"; print DEPOTS "$depot\n"; $Made_depot{$depot} = 1; } # This is a hash, keyed by branch name. Each element is a list. # The first list element is the db.domain record to create a branch. # The second list element is an anonymous hash, keyed by depot name, # with the values being the db.view records needed to reflect the # branch within the given depot. # my %Branches; sub mkbranch { my ($from, $to, $from_depot, $to_depot, $from_user, $to_user) = @_; # There's no branch spec for "main" # if ($to eq "main") { $Branched{"main"} = 1; return; } if (! $from) { $from = "main"; } if (! $to) { $to = "main"; } my $qto; if ($to_user) { $qto = &atq("$to_user-$to"); } else { $qto = &atq("$to"); } my $time = time; if (! defined($Branches{$to})) { $Branches{$qto} = []; ${$Branches{$qto}}[0] = "\@pv\@ 2 \@db.domain\@ $qto 98 \@\@ \@\@ \@$CONVUSER\@ $time $time 0 0 \@Created by cvs2p4.\@\n"; ${$Branches{$qto}}[1] = {} } my $depotrefs = ${$Branches{$qto}}[1]; # copy the reference for convenience... my $k = "$from_user=$from_depot=$to_user=$to_depot"; if (! defined(${$depotrefs}{$k})) { my $qlhs; if ($to_user) { $qlhs = &atq("//$to_depot/$to_user/$to/..."); } else { $qlhs = &atq("//$to_depot/$to/..."); } my $qrhs; if ($from_user) { $qrhs = &atq("//$from_depot/$from_user/$from/..."); } else { $qrhs = &atq("//$from_depot/$from/..."); } ${$depotrefs}{"$k"} = "\@pv\@ 1 \@db.view\@ $qto 0 0 $qlhs $qrhs\n"; } } sub genchange { my ($revs, $ch_time, $msg, $who, $integs) = @_; if ($LOGNOTE) { my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime(time); my($ts) = sprintf("%04d/%02d/%02d %02d:%02d:%02d", $year+1900, $mon+1, $mday, $hour, $min, $sec); $msg .= "\n[imported from CVS by cvs2p4 at $ts]\n"; } my $smsg = $msg; $smsg = substr($smsg, 0, 31); $smsg = &atq($smsg); print DBMETA "\@pv\@ 0 \@db.change\@ $Change $Change cvs2p4 $who $ch_time 1 $smsg\n"; foreach my $rev (@{$revs}) { my ($depotfile, $p4rev, $type, $action, $modtime, $lbrfile, $lbrrev, $lbrtype) = split(/$s/, $rev); $depotfile = &atq($depotfile); $lbrfile = &atq($lbrfile); $lbrrev = &atq($lbrrev); $zdig = "00000000000000000000000000000000"; $depotfile =~ s/\/Attic(\/[^\/]+)$/$1/; if ($Pathhacks) { $depotfile = &Pathhacks($depotfile); } my ($depot) = ($depotfile =~ /^@\/\/([^\/]+)\//); if (! defined($Made_depot{$depot})) { &mkdepot($depot); } my $p4depotfile = &p4_esc($depotfile); print DBMETA "\@pv\@ 3 \@db.rev\@ $p4depotfile $p4rev $type $action ". "$Change $ch_time $time $zdig $lbrfile $lbrrev $lbrtype\n"; print DBMETA "\@pv\@ 0 \@db.revcx\@ $Change $p4depotfile $p4rev $action\n"; if ($REVRECS) { $msg .= "$depotfile $p4rev $type $action $modtime $lbrfile $lbrrev $lbrtype\n"; } } $msg = &atq($msg); print DBMETA "\@pv\@ 0 \@db.desc\@ $Change $msg\n"; foreach my $integ (@{$integs}) { my($tofile, $fromfile, $fromrev) = split(/$s/, $integ); my $to_user; my ($to_depot, $to_branch, $to_module, $to_path) = ($tofile =~ /^\/\/([^\/]+)\/([^\/]+)\/([^\/]+)(\/.*)?$/); # Methinks the case below is handled when the files are first seen when the revs are # processed; thus no path adjustments are needed here. Wonder how long this # has been dead code?! # dead!? # # if ("//$to_depot" ne $USE_IMPORT_DEPOT && defined($Depotmap{$to_module})) # { # $tofile = $Depotmap{$to_module}; # if ($to_branch ne "main") # { # if ($INTOUCH) # { $tofile =~ s/\/main\//\/task\/$to_branch\//; } # for inTouch's convention # else # { $tofile =~ s/\/main\//\/$to_branch\//; } # for general use # } ## $tofile .= "/$to_module$to_path"; # $tofile .= "/$to_module$to_path"; #print STDERR "TOFILE mod $to_module <$tofile>\m"; #die "to_module"; # } if ($Pathhacks && $to_depot eq "user") { # The things I will not do for my users! ($to_depot, $to_branch, $to_user, $to_module, $to_path) = ($tofile =~ /^\/\/([^\/]+)\/([^\/]+)\/([^\/]+)\/([^\/]+)(\/.*)?$/); } my $from_user; my ($from_depot, $from_branch, $from_module, $from_path) = ($fromfile =~ /^\/\/([^\/]+)\/([^\/]+)\/([^\/]+)(\/.*)?$/); if ($Pathhacks && $from_depot eq "user") { # The things I will not do for my users! ($from_depot, $from_branch, $from_user, $from_module, $from_path) = ($fromfile =~ /^\/\/([^\/]+)\/([^\/]+)\/([^\/]+)\/([^\/]+)(\/.*)?$/); } # (We don't make branch specs in //import depots) # if ("//$to_depot" ne $USE_IMPORT_DEPOT && "//$from_depot" ne $USE_IMPORT_DEPOT) { &mkbranch($from_branch, $to_branch, $from_depot, $to_depot, $from_user, $to_user); } # dead!? # # if (defined($Depotmap{$from_module})) # { # $fromfile = $Depotmap{$from_module}; # if ($from_branch ne "main") # { # if ($INTOUCH) # { $fromfile =~ s/\/main\//\/task\/$from_branch\//; } # for inTouch # else # { $fromfile =~ s/\/main\//\/$from_branch\//; } # for general use # } # $fromfile .= "/$from_module$from_path"; #print STDERR "FROM mod $from_module <$fromfile>\n"; #die "from_module"; # } $tofile = &atq($tofile); $fromfile = &atq($fromfile); if ($Pathhacks) { $tofile = &Pathhacks($tofile); $fromfile = &Pathhacks($fromfile); } $tofile =~ s/\/Attic(\/[^\/]+)$/$1/; $fromfile =~ s/\/Attic(\/[^\/]+)$/$1/; my $p4tofile = &p4_esc($tofile); my $p4fromfile = &p4_esc($fromfile); print DBMETA "\@pv\@ 0 \@db.integed\@ $tofile $fromfile 0 $fromrev 0 1 2 $Change\n"; print DBMETA "\@pv\@ 0 \@db.integed\@ $fromfile $tofile 0 1 0 $fromrev 3 $Change\n"; } $Change++; } # # ***** NOTE *****: We are writing the metadata format for a 2002.1 # p4d, which has db.rev version 3; the definitions for the FileType # field have changed in later versions of Perforce. Perforce will # upgrade this format to all subsequent releases (at the time of this # writing), but be aware that, if you tweak any filetype bits below, # you should be using the 2002.1 definitions; see for reference # # http://www.perforce.com/perforce/doc.021/schema/index.html#DmtFileType # # Perforce filetype bit constants # # 0x0020 to "ktext" # 0x0000 to "text" # my $TEXTTYPE_K = 0x0020; my $TEXTTYPE = 0x0000; sub type_of { my ($rcsfile, $rev, $options) = @_; my $lockedit = 0; if ($options =~ /bx/) { $lockedit = 1; } # CVSNT uses x for exclusive open my $binary = 0; if ($options =~ /[ob]/ || &is_binary_ext($rcsfile)) { $binary = 1; } elsif ($CHECKBIN) { if (&s("$CO -q -p$rev '$file' >'$Convdir/rev.tmp'")) { print "$Myname: \"$CO -p$rev '$file' >'$Convdir/rev.tmp'\" failed.\n"; exit 1; } if (-B "$Convdir/rev.tmp") { $binary = 1; } unlink "$Convdir/rev.tmp"; } my $type = 0; # NOTE: CVS/RCS just doesn't have the notion of Perforce's "text" # vs "ktext" types; in RCS, a file is either "text" (in which # keywords get expanded in one way or another), or "binary", in # which they are left untouched (RCS's concept of "binary"). How's # a poor conversion program to cope?! For now, we treat all text # files as "ktext", with an exclusion list for files which must be # plain text. # if ($binary) { $type |= 0x0100; } else { my $chkpath = $rcsfile; $chkpath =~ s/^$CVS_ROOT\///; if (defined($NOKEYEXP_PATHNAME{$chkpath})) { $type |= $TEXTTYPE; } else { $type |= $TEXTTYPE_K; } } if ($lockedit) { $type |= 0x0040; } if ($options =~ /\*/) { $type |= 0x0200; } return $type; } sub set_depot_paths { my ($file_dir, $file_name, $line, $import_branch) = @_; my ($Depotfile, $Importfile); my ($module, $remainder) = ($file_dir =~ /^([^\/]+)\/?(.*)?$/); # If we are doing $USE_IMPORT_DEPOT, and $line names the branch for # 1.1.1, use "$USE_IMPORT_DEPOT" as the depot; otherwise, use that # selected by $Depotmap{}; otherwise, the default $P4_DEPOT. # if ($USE_IMPORT_DEPOT && $line eq $import_branch) { $Depotfile = &path("$USE_IMPORT_DEPOT/$line/", $remainder, $file_name); $Importfile = &path("$IMPORT/", $file_dir, $file_name); } elsif (defined($Depotmap{$module})) { $mapent = $Depotmap{$module}; if ($line ne "main") { if ($INTOUCH) { $mapent =~ s/\/main\//\/task\/$line\//; } # for inTouch else { $mapent =~ s/\/main\//\/$line\//; } # for general use } $Depotfile = &path("$mapent/", $remainder, $file_name); $Importfile = &path("$IMPORT/", $file_dir, $file_name); } else { $Depotfile = &path("$P4_DEPOT/$line/", $file_dir, $file_name); $Importfile = &path("$IMPORT/", $file_dir, $file_name); } return ($Depotfile, $Importfile); } sub rmap { my ($depotrev, $cvsrev, $revinfo) = @_; $depotrev =~ s/\/Attic(\/[^\/]+)$/$1/; $REVMAP{$depotrev} = $revinfo; if ($RREVMAP{$cvsrev}) { $RREVMAP{$cvsrev} .= "\001"; } $RREVMAP{$cvsrev} .= "$depotrev"; } my %map; # Process one "change" from CVS. # Called with the set of CVS files/revs to process in @change # sub dochange { print "========== change group $do_change_num\n"; if ($V > 0) { print "NCHGS = <$#change>\n"; foreach $c (@change) { ($filerev, $time, $who, $state, $line, $import_branch, $branches, $prevrev, $options) = split(/$S/, $c); @filerev = split(/\//, $filerev); $rev = pop(@filerev); $file = join("/", @filerev); print "DUMP $who $time $filerev $state $line $import_branch $branches\n"; } } # Do the revisions... # # print "=== deletes\n"; undef @revs; my $ch_time = 0; foreach $c (@change) { chomp $c; ($filerev, $time, $who, $state, $line, $import_branch, $branches, $prevrev, $options) = split(/$S/, $c); if ($line eq $TRUNKLINE) { $line = $MAINNAME; } @filerev = split(/\//, $filerev); $rev = pop(@filerev); $file = join("/", @filerev); ($file_dir = &dirname($file)) =~ s/^$CVS_MODULE//; $file_dir =~ s/^\///; ($file_name = $file) =~ s%^.*/%%; ($Depotfile, $Importfile) = &set_depot_paths($file_dir, $file_name, $line, $import_branch); if ($state eq $DEADSTATE) { $Exists_in_depot = &depot_has($Depotfile); if ($Exists_in_depot) { $type = &type_of($file, $rev, $options); if ($time > $ch_time) { $ch_time = $time; } my $grev = &depot_newrev($Depotfile, "delete"); &rmap("$Depotfile#$grev", $filerev, $c); push(@revs, (&genrev($Depotfile, $grev, $type, $Act_delete, $time, $Importfile, $rev, $type))); } } } if ($#revs >= 0) { &genchange(\@revs, $ch_time, $MSGS{$filerev}, $who); } # print "===adds/edits===\n"; undef @revs; $ch_time = 0; foreach $c (@change) { chomp $c; ($filerev, $time, $who, $state, $line, $import_branch, $branches, $prevrev, $options) = split(/$S/, $c); if ($line eq "$TRUNKLINE") { $line = $MAINNAME; } @filerev = split(/\//, $filerev); $rev = pop(@filerev); $file = join("/", @filerev); # The was already done by the main/import handling when the 1.1 # revision was processed (Since 1.1.1.1 is, logically, on a # sub-branch of 1.1). Or so I claim. Note that we still *do* # note the creation of new sub-branches of 1.1.1.1 implied by a # non-empty $branches. # if ($rev eq "1.1.1.1" && $line eq $import_branch) { next; } ($file_dir = &dirname($file)) =~ s/^$CVS_MODULE//; $file_dir =~ s/^\///; ($file_name = $file) =~ s%^.*/%%; ($Depotfile, $Importfile) = &set_depot_paths($file_dir, $file_name, $line, $import_branch); # Note: we assume binary files never become text files or vice versa # if ($state ne $DEADSTATE) { $Exists_in_depot = &depot_has($Depotfile); if ($Exists_in_depot) { $type = &type_of($file, $rev, $options); if ($time > $ch_time) { $ch_time = $time; } my $grev = &depot_newrev($Depotfile, "edit"); &rmap("$Depotfile#$grev", $filerev, $c); push(@revs, (&genrev($Depotfile, $grev, $type, $Act_edit, $time, $Importfile, $rev, $type))); $map{"$Depotfile$s$rev"} = $grev; } else { $type = &type_of($file, $rev, $options); if ($time > $ch_time) { $ch_time = $time; } my $grev = &depot_newrev($Depotfile, "add"); &rmap("$Depotfile#$grev", $filerev, $c); push(@revs, (&genrev($Depotfile, $grev, $type, $Act_add, $time, $Importfile, $rev, $type))); $map{"$Depotfile$s$rev"} = $grev; } } } if ($#revs >= 0) { &genchange(\@revs, $ch_time, $MSGS{$filerev}, $who); } # print "===branches===\n"; undef @revs; undef @integs; $ch_time = 0; foreach $c (@change) { chomp $c; ($filerev, $time, $who, $state, $line, $import_branch, $branches, $prevrev, $options) = split(/$S/, $c); if ($line eq "$TRUNKLINE") { $line = $MAINNAME; } if ($state ne $DEADSTATE && $branches ne "-") { @filerev = split(/\//, $filerev); $rev = pop(@filerev); $file = join("/", @filerev); ($file_dir = &dirname($file)) =~ s/^$CVS_MODULE//; $file_dir =~ s/^\///; ($file_name = $file) =~ s%^.*/%%; ($Depotfile, $Importfile) = &set_depot_paths($file_dir, $file_name, $line, $import_branch); foreach $branch (split(/:/, $branches)) { $type = &type_of($file, $rev, $options); my ($Depot_branchfile) = &set_depot_paths($file_dir, $file_name, $branch, $import_branch); if ($time > $ch_time) { $ch_time = $time; } my $grev = &depot_newrev($Depot_branchfile, "add"); # if we are adding the initial import_branch revision as 1.1, # make it 1.1.1.1 # if ($branch eq $import_branch && $grev eq "1") { my ($f, $r) = ($filerev =~ m/^(.*)\/([^\/]+)$/); if ($r !~ /^1\.1(\.1\.1)?$/) { die "import_branch $import_branch assert rev '$r' !~ /^1\.1(\.1\.1)?\$/"; } $filerev = "$f/1.1.1.1"; } &rmap("$Depot_branchfile#$grev", $filerev, $c); push(@revs, (&genrev($Depot_branchfile, $grev, $type, $Act_branch, $time, $Importfile, $rev, $type))); $map{"$Depot_branchfile$s$rev"} = $grev; my $bprev; if (! ($bprev = $map{"$Depotfile$s$rev"})) { if ($rev eq "1.1.1.1") { if (! ($bprev = $map{"$Depotfile${s}1.1"})) { die "unmapped rev <$Depotfile> <1.1[.1.1]>"; } } else { die "unmapped rev <$Depotfile> <$rev>"; } } push(@integs, "$Depot_branchfile$s$Depotfile$s$bprev"); } } } if ($#revs >= 0) { &genchange(\@revs, $ch_time, "Branching\n", $who, \@integs); } } ###### main starts here # # option switch variables get defaults here... $Metadata = "metadata"; # option switch variables get defaults here... $V = 0; $Change = 1; $Copy = 0; while ($#ARGV >= 0) { if ($ARGV[0] eq "-c") { $Copy = 1; shift; next; } elsif ($ARGV[0] eq "-v") { shift; if ($ARGV[0] < 0) { &usage; } $V = $ARGV[0]; shift; next; } elsif ($ARGV[0] eq "-s") { shift; if ($ARGV[0] < 0) { &usage; } $Change = $ARGV[0]; shift; next; } elsif ($ARGV[0] eq "-help") { &help; } elsif ($ARGV[0] =~ /^-/) { &usage; } push(@Args, $ARGV[0]); shift; } if ($#Args ne 0) { &usage; } $Convdir = $Args[0]; #chdir $Convdir || die "$Myname: can't chdir \"$Convdir\": $!"; #$Convdir = `/bin/pwd`; chop $Convdir; #chdir $Here || die "$Myname: can't chdir \"$Here\": $!"; require "$Convdir/config"; if ($PureRCS) { $MAINNAME = "1"; } my ($p4d_y, $p4d_r) = &p4d_vers($P4D); if ($p4d_y < 2002) { print "$Myname: this version requires p4d 2002.1 or later <$p4d>.\n"; exit 1; } if ($CHECKBIN) { # Path the the RCS co command # if (! defined($CO)) { $CO = "/usr/local/bin/co"; } if (! -x ($CO)) { print "$Myname: No executable \"co\" command at \"$CO\".\n"; exit 1; } } $Metadata = "$Convdir/metadata"; $Logmsgs = "$Convdir/logmsgs"; $Changes = "$Convdir/changes"; $Revmap = "$Convdir/revmap"; $Rrevmap = "$Convdir/rrevmap"; $Depotmap = "$Convdir/depotmap"; $Depotlist = "$Convdir/depots"; $Client = "$Convdir/p4"; $DBmeta = "$P4ROOT/dbmeta"; $Checkpoint = "checkpoint"; $LOGNOTE = 1; if (! defined($P4PORT)) { print "$Myname: no P4PORT in \"$Convdir/config\".\n"; exit 1; } ($P4HOST = $P4PORT) =~ s/:.*//; ($P4PORTNUM = $P4PORT) =~ s/^.*://; $P4ADMINUSER = "p4"; # These defaults can be overriden in the config file # if ($Change == 1) { # Remove any revmap, rrevmap files... # if (&s("/bin/rm -f $Revmap $Revmap.db $Revmap.dir $Revmap.pag")) { die "/bin/rm -f $Revmap.db ..."; } if (&s("/bin/rm -f $Rrevmap $Rrevmap.db $Rrevmap.dir $Rrevmap.pag")) { die "/bin/rm -f $Rrevmap.db ..."; } if (&s("/bin/rm -f $Depotmap $Depotmap.db $Depotmap.dir $Depotmap.pag")) { die "/bin/rm -f $Depotmap.db ..."; } if (&s("/bin/rm -rf $P4ROOT && mkdir -p $P4ROOT")) { die "/bin/rm -rf $P4ROOT && mkdir -p $P4ROOT"; } } $CVS_MODPATH = $CVS_MODULE; chdir $CVS_MODPATH || die "$Myname: can't chdir \"$CVS_MODPATH\": $!"; $CVS_MODPATH = `/bin/pwd`; chop $CVS_MODPATH; chdir $Here || die "$Myname: can't chdir \"$Here\": $!"; $CVS_MODULE_NAME = $CVS_MODULE; $CVS_MODULE_NAME =~ s@/.*/@@g; $IMPORT = "$DEPOT/$CVS_MODULE_NAME"; $ndIMPORT = $IMPORT; $ndIMPORT =~ s@^[^/]+/@@; chdir $P4ROOT || die "$Myname: can't chdir \"$P4ROOT\": $!"; $P4ROOT = `/bin/pwd`; chop $P4ROOT; if (&s("/bin/mkdir -p $P4ROOT/$DEPOT")) { die "/bin/mkdir -p $P4ROOT/$DEPOT"; } if ($Change == 1) { my $destdir = dirname("$P4ROOT/$IMPORT"); if (&s("/bin/mkdir -p $destdir")) { die "/bin/mkdir -p $destdir"; } if ($Copy || $COPYIMPORT) { my $cmd = "/bin/cp -rp \"$CVS_MODPATH\" \"$P4ROOT/$IMPORT\""; if (&s($cmd)) { print "$Myname <$cmd> failed.\n"; exit 1; } $cmd = "/usr/bin/find \"$P4ROOT/$IMPORT\" -type f -print0 | /usr/bin/xargs -0 /bin/chmod a-w"; if (&s($cmd)) { print "$Myname <$cmd> failed.\n"; exit 1; } } else { my $cmd = "/bin/ln -s \"$CVS_MODPATH\" \"$P4ROOT/$IMPORT\""; if (&s($cmd)) { print "$Myname <$cmd> failed.\n"; exit 1; } } } chdir $Here || die "$Myname: can't chdir \"$Here\": $!"; # Open the changes file (this is the genchanges output file) # if (! open(CHGS, "<$Changes")) { print "$Myname: can't open \"$Changes\": $!\n"; exit 1; } # Open the db metadata (journal format) file we will write # if (! open(DBMETA, ">$DBmeta")) { print "$Myname: can't open \"$DBmeta\": $!\n"; exit 1; } use DB_File; $DBMCLASS="DB_File"; #$myhashinfo = new DB_File::HASHINFO; #$myhashinfo->{bsize}=4096; $myhashinfo = new DB_File::BTREEINFO; # Open the REVMAP database... # if (! tie(%REVMAP, $DBMCLASS, $Revmap, O_CREAT|O_RDWR, 0666, $myhashinfo)) { print "$Myname: can't tie \"$Revmap\": $!\n"; exit 1; } # Open the RREVMAP database... # if (! tie(%RREVMAP, $DBMCLASS, $Rrevmap, O_CREAT|O_RDWR, 0666, $myhashinfo)) { print "$Myname: can't tie \"$Rrevmap\": $!\n"; exit 1; } # Open the DEPOTMAP database... # if (! tie(%DEPOTMAP, $DBMCLASS, $Depotmap, O_CREAT|O_RDWR, 0666, $myhashinfo)) { print "$Myname: can't tie \"$Depotmap\": $!\n"; exit 1; } # Open the log messages database # if (! tie(%MSGS, $DBMCLASS, $Logmsgs, O_RDONLY, 0444, $myhashinfo)) { print "$Myname: can't tie \"$Logmsgs\": $!\n"; exit 1; } # Open the depot list, needed for making label maps in dolabels # if (! open(DEPOTS, ">$Depotlist")) { print "$Myname: can't open \"$Depotlist\": $!\n"; exit 1; } # # ($depotname) = ($P4_DEPOT =~ m/^\/\/([^\/]+)\/?/); my %Made_depot; my $import_depot = $DEPOT; $import_depot =~ s/\/.*$//; &mkdepot($import_depot); if ($USE_IMPORT_DEPOT) { my $ndUSE_IMPORT_DEPOT = $USE_IMPORT_DEPOT; $ndUSE_IMPORT_DEPOT =~ s/^\/\///; &mkdepot($ndUSE_IMPORT_DEPOT); } $gather_change_num = $do_change_num = 0; while () { if (/^# ([0-9]+)$/) { $gather_change_num = $1; if ($do_change_num) { &dochange(@change); $do_change_num = 0; } # Clear the change # undef @change; } elsif ($gather_change_num) { push(@change, $_); $do_change_num = $gather_change_num; } } if ($do_change_num) { &dochange(@change); } # Now output the branch metadata we have accumulated in $Branches... # foreach my $brname (sort(keys(%Branches))) { print DBMETA ${$Branches{$brname}}[0]; my $r = ${$Branches{$brname}}[1]; foreach my $k (keys(%{$r})) { print DBMETA ${$r}{$k}; } } if ($SPEC_DEPOT) { &mkdepot($SPEC_DEPOT, 1); } $Change--; print DBMETA "\@pv\@ 0 \@db.counters\@ \@change\@ $Change\n"; # We've written an upgrade-level 3 compliant database. # print DBMETA "\@pv\@ 0 \@db.counters\@ \@upgrade\@ 3\n"; close DBMETA; untie %MSGS; close CHGS; untie %REVMAP; untie %RREVMAP; untie %DEPOTMAP; close DEPOTS; $DBmeta =~ s%^.*/%%; $P4D = "$P4D -r ."; if (&s("cd $P4ROOT && $P4D -jr $DBmeta")) { print "$Myname: \"$P4D -jr $DBmeta\" failed.\n"; exit 1; } if ($p4d_y > 2002 || $p4d_r > 1) { # Then we could need a database upgrade. Let's go for it... # if (&s("cd $P4ROOT && $P4D -xu")) { print "$Myname: \"$P4D -xu\" failed.\n"; exit 1; } } if (&s("cd $P4ROOT && rm -f $Checkpoint && $P4D -jd $Checkpoint")) { print "$Myname: \"$P4D -jd $Checkpoint\" failed.\n"; exit 1; } exit 0;