Changeset 340

Show
Ignore:
Timestamp:
04/29/2008 10:53:04 PM
Author:
toby
Message:

* Path for renames during restore and renames during share (thanks to Bryan Aldrich for the patch)
* Formatting cleanup and removal of commented code

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/script/Vss2Svn/ActionHandler.pm

    r319 r340  
    114114    if (!defined $version ) { 
    115115        $self->{errmsg} .= "Attempt to add entry '$row->{physname}' with " 
    116             . "unknown version number (probably destroyed)\n"; 
     116            . "unknown version number (probably destroyed) parent: $row->{parentphys} itemtype: $row->{itemtype}\n"; 
    117117         
    118118        $gOrphanedInfo {$row->{physname} } = 1; 
     
    264264    my $itempath = $parentpath . $row->{itemname}; 
    265265 
     266    # a SHARE *can* rename a file if the parent is no longer present. 
     267    $row->{info} = $row->{itemname}; 
     268    $self->_rename_handler(); 
     269 
    266270    # 'sourceinfo' contains the source path 
    267271    my $sourceinfo = $self->_get_valid_path ($physname, $row->{parentphys}, $version); 
     
    273277 
    274278        $self->{action} = 'ADD'; 
    275 #        $self->{version} = $version; 
    276 #        return $self->_add_handler(); 
    277     } 
    278  
    279     # if this is a share from orphan, and not a share+pin action either, we can treat it as a move 
    280     elsif (!defined $row->{version} &&        # share+pin? 
    281            defined $physinfo->{orphaned}      # orphaned? 
    282 #          scalar @{$physinfo->{order}} == 1  # only one parent? 
    283        ) { 
    284         $physinfo->{parents}->{'_' . $row->{physname}}->{deleted} = 1; 
    285         undef $physinfo->{orphaned}; 
    286         $self->{action} = 'MOVE'; 
    287     } 
    288      
     279    } 
     280 
    289281    # track the addition of the new parent 
    290282    $self->_add_parent ($physname, $row->{parentphys}); 
     
    330322    } 
    331323     
    332 #    # First delete this parentphys from the old shared object; see 
    333 #    # _delete_handler for details 
    334 #    if ($oldphysinfo->{parentphys} eq $row->{parentphys}) { 
    335 #        $oldphysinfo->{parentphys} = shift( @{ $oldphysinfo->{sharedphys} } ); 
    336 #    } else { 
    337 #        my $sharedphys = []; 
    338 # 
    339 #        foreach my $oldparent (@{ $oldphysinfo->{sharedphys} }) { 
    340 #            push @$sharedphys, $oldparent 
    341 #                unless $oldparent eq $row->{parentphys}; 
    342 #        } 
    343 # 
    344 #        $oldphysinfo->{sharedphys} = $sharedphys; 
    345 #    } 
    346  
    347324    my $version = defined $row->{version} ? $row->{version} 
    348325                    : $self->{version}; 
     
    389366    return $result; 
    390367 
    391  
    392 #    # Now create a new entry for this branched item 
    393 #    $gPhysInfo{$physname} = 
    394 #        { 
    395 #         type       => $row->{itemtype}, 
    396 #         name       => $row->{itemname}, 
    397 ##         parentphys => $row->{parentphys}, 
    398 ##         sharedphys => [], 
    399 #         parents    => {}, 
    400 #        }; 
    401  
    402 #    $self->_add_parent ($physname, $row->{parentphys}); 
    403 #    $self->{itempaths} = $self->_get_current_item_paths(1); 
    404  
    405 #    return 1; 
    406  
    407368}  #  End _branch_handler 
    408369 
     
    411372############################################################################### 
    412373sub _move_handler { 
    413     my($self) = @_; 
     374    my($self, $oldName) = @_; 
    414375    my $row = $self->{row}; 
    415376 
     
    440401    } 
    441402 
    442     # '$sourceinfo' is the path for the old location (the move source); 
    443     my $sourceparent = $self->_get_parent_path ($row->{info}); 
    444     my $sourceinfo = $sourceparent . $row->{itemname}; 
    445  
    446  
    447403    # check the target path 
    448404    if (!defined ($row->{parentphys})) { 
     
    453409    } 
    454410 
     411    # '$sourceinfo' is the path for the old location (the move source); 
     412    my $sourceparent = $self->_get_parent_path ($row->{info}); 
     413    my $sourceinfo; 
     414    if (defined $oldName) 
     415    { 
     416        $sourceinfo = $sourceparent . $oldName; 
     417    } 
     418    else 
     419    { 
     420        $sourceinfo = $sourceparent . $row->{itemname}; 
     421    } 
     422 
    455423    # '$itempath' contains the move target path 
    456424    my $parentpath = $self->_get_current_parent_path (); 
     
    495463    $self->{action} = 'MOVE'; 
    496464    $row->{actiontype} = 'MOVE'; 
    497     $row->{info} = $row->{parentphys}; 
    498     $row->{parentphys} = '_' . $row->{physname}; 
    499     return $self->_move_handler (); 
     465#    $row->{info} = $row->{parentphys}; 
     466#    $row->{parentphys} = '_' . $row->{physname}; 
     467     
     468    $gPhysInfo{ $row->{physname} } = 
     469        { 
     470         type       => $row->{itemtype}, 
     471         name       => $row->{itemname}, 
     472         parents    => {}, 
     473         first_version => 1, 
     474         last_version => 1, 
     475         orphaned   => 1, 
     476         was_binary => $row->{is_binary}, 
     477    }; 
     478     
     479    my $newName = $row->{info}; 
     480     
     481    undef $row->{info}; 
     482 
     483    return $self->_move_handler ($newName); 
    500484} 
    501485 
     
    524508    my $itempaths = [$parentpath . $physinfo->{name}]; 
    525509 
    526 #    if ($physinfo->{parentphys} eq $row->{parentphys}) { 
    527 #        # Deleting from the "main" parent; find a new one by shifting off the 
    528 #        # first shared path, if any; if none exists this will leave a null 
    529 #        # parent entry. We could probably just delete the whole node at this 
    530 #        # point. 
    531 # 
    532 #        $physinfo->{parentphys} = shift( @{ $physinfo->{sharedphys} } ); 
    533 # 
    534 #    } else { 
    535 #        my $sharedphys = []; 
    536 # 
    537 #        foreach my $parent (@{ $physinfo->{sharedphys} }) { 
    538 #            push @$sharedphys, $parent 
    539 #                unless $parent eq $row->{parentphys}; 
    540 #        } 
    541 # 
    542 #        $physinfo->{sharedphys} = $sharedphys; 
    543 #    } 
    544  
    545510    # protect for delete/purge cycles: if the parentphys isn't in the shares 
    546511    # anymore, the file was already deleted from the parent and is now purged 
     
    577542        return 0; 
    578543    } 
    579  
    580 #    if (defined $physinfo->{parentphys}) { 
    581 #        # Item still has other shares, so recover it by pushing this parent 
    582 #        # onto its shared list 
    583 # 
    584 #        push( @{ $physinfo->{sharedphys} }, $row->{parentphys} ); 
    585 # 
    586 #    } else { 
    587 #        # Recovering its only location; set the main parent back to this 
    588 #        $physinfo->{parentphys} = $row->{parentphys}; 
    589 #    } 
    590544 
    591545    # recover this item within the current parent 
     
    896850    $self->{physname_seen} .= "$physname, "; 
    897851 
    898 #    my @pathstoget = 
    899 #        ($physinfo->{parentphys}, @{ $physinfo->{sharedphys} } ); 
    900852    my @pathstoget = @parents; 
    901853     
    902854    my $paths; 
    903855    my $result; 
    904 #    if (defined $physinfo->{parents}->{$row->{parentphys}}->{deleted}) { 
    905 #        return 0; 
    906 #    } 
    907856 
    908857PARENT: 
     
    964913            $self->_track_item_path ($row->{physname}, $parent, $row->{version}, $result); 
    965914 
    966 #            my $versions = \@{$physinfo->{parents}->{$parent}->{versions}}; 
    967 #             
    968 #            # in the case of pinning and sharing with pinning, the version number 
    969 #            # denotes a version in the past. So if there is already an entry for 
    970 #            # this version number skip this parent. 
    971 #            if (exists $versions->[$row->{version}]) { 
    972 #                next PARENT; 
    973 #            } 
    974              
    975 #            # remember the last version, in which the file was modified 
    976 #            $physinfo->{last_version} = $row->{version}; 
    977              
    978 #            $result = $self->_get_parent_path ($parent) . $physinfo->{name}; 
    979      
    980 #            if(!defined($result)) { 
    981 #                next PARENT; 
    982 #            } 
    983      
    984 #            $versions->[$row->{version}] = $result; 
    985915        } 
    986916    } 
  • trunk/script/Vss2Svn/Dumpfile.pm

    r336 r340  
    206206        } 
    207207        else { 
    208             $self->add_error("Attempt to re-add directory '$itempath' at " 
    209                 . "revision $data->{revision_id}, skipping action: possibly " 
    210                 . "missing delete"); 
     208            #creating a new VSS database can cause a "ADD" for a "/" item which will fail. 
     209            if (!($itempath eq "/")) { 
     210                $self->add_error("Attempt to re-add directory '$itempath' at " 
     211                    . "revision $data->{revision_id}, skipping action: possibly " 
     212                    . "missing delete"); 
     213            } 
     214             
    211215            return 0; 
    212216        } 
     
    220224    } 
    221225    elsif ($success == 0) { 
    222         $self->add_error("Parent path missing while trying to add " 
    223             . "item '$itempath' at revision $data->{revision_id}: adding missing " 
    224             . "parents"); 
     226        if (!($itempath =~ m/^\/orphaned\/_.*/)) 
     227        { 
     228            $self->add_error("Parent path missing while trying to add " 
     229                . "item '$itempath' at revision $data->{revision_id}: adding missing " 
     230                . "parents"); 
     231        } 
    225232        $self->_create_svn_path ($nodes, $itempath); 
    226233    } 
  • trunk/script/vss2svn.pl

    r338 r340  
    6969                                next    => 'MERGEMOVEDATA'}, 
    7070 
    71             # Merge data from move actions  
     71            # Merge data from move actions 
    7272            MERGEMOVEDATA => {handler => \&MergeMoveData, 
    7373                                next    => 'REMOVETMPCHECKIN'}, 
     
    253253 
    254254    if (!defined $filesegment[0] || !defined $filesegment[1] 
    255        || !defined $filesegment[2]) { 
     255    || !defined $filesegment[2]) { 
    256256        # physical file doesn't exist; it must have been destroyed later 
    257257        &ThrowWarning("Can't retrieve info from physical file " 
     
    310310       $tphysname, $itemname, $itemtype, $parent, $user, $timestamp, $comment, 
    311311       $is_binary, $info, $priority, $sortkey, $label, $cachename); 
    312      
     312 
    313313    my $last_timestamp = 0; 
    314      
     314 
    315315VERSION: 
    316316    foreach $version (@{ $xml->{Version} }) { 
     
    342342        } 
    343343        $last_timestamp = $timestamp; 
    344          
     344 
    345345        $itemtype = $info->{type}; 
    346346        $actiontype = $info->{action}; 
     
    356356        $priority = 5; 
    357357        $label = undef; 
    358          
     358 
    359359        if ($version->{Comment} && !ref($version->{Comment})) { 
    360360            $comment = $version->{Comment} || undef; 
     
    380380                    $comment .= "\n"; 
    381381                } 
    382    
     382 
    383383                $comment .= $action->{LabelComment} || undef; 
    384384            } 
     
    439439        } elsif ($actiontype eq 'BRANCH') { 
    440440            $info = $action->{Parent}; 
    441         }  
     441        } 
    442442 
    443443        $vernum = ($parentdata)? undef : $version->{VersionNumber}; 
     
    474474            && $actiontype ne 'LABEL') { 
    475475            my ($labelComment); 
    476              
     476 
    477477            if ($version->{LabelComment} && !ref($version->{LabelComment})) { 
    478478                $labelComment = $version->{LabelComment}; 
     
    590590    # Get the row(s) corresponding to the parent(s) of this row, and work out 
    591591    # the maximum depth 
    592      
     592 
    593593    my $sql = <<"EOSQL"; 
    594594SELECT 
     
    657657    $parentdata = 0 unless defined $parentdata; 
    658658    $parentdata = 1 if $parentdata != 0; 
    659      
     659 
    660660    my $sql = <<"EOSQL"; 
    661661SELECT 
     
    723723 
    724724    my($sth, $rows, $row); 
     725 
    725726    $sth = $gCfg{dbh}->prepare('SELECT * FROM PhysicalAction ' 
    726727                               . 'WHERE actiontype = "MOVE_FROM"'); 
     
    739740        my $target = $row->{parentphys}; 
    740741 
    741         if (scalar @$childrecs > 1) { 
    742             &ThrowWarning("Multiple child recs for parent MOVE rec " 
    743                           . "'$row->{action_id}'"); 
    744         } 
    745  
    746         if (scalar @$childrecs >= 1) { 
    747             # only merge MOVE records that have the same timestamp 
    748             if ($row->{timestamp} == @$childrecs[0]->{timestamp}) { 
    749                 $source = @$childrecs[0]->{parentphys}; 
    750                 &DeleteChildRec(@$childrecs[0]->{action_id}); 
     742        my $chosenChildRecord; 
     743        my $childRecord; 
     744 
     745        foreach $childRecord (@$childrecs) { 
     746            if (!(defined $chosenChildRecord) 
     747                && $childRecord->{timestamp} == $row->{timestamp} 
     748                && !($childRecord->{parentphys} eq $row->{parentphys})) { 
     749 
     750                $chosenChildRecord = $childRecord; 
    751751            } 
    752752        } 
    753          
    754         my $sql = <<"EOSQL"; 
     753 
     754        if (defined $chosenChildRecord) { 
     755            $source = $chosenChildRecord->{parentphys}; 
     756            &DeleteChildRec($chosenChildRecord->{action_id}); 
     757 
     758            my $sql = <<"EOSQL"; 
    755759UPDATE 
    756760    PhysicalAction 
     
    762766    action_id = ? 
    763767EOSQL 
    764         my $update; 
    765         $update = $gCfg{dbh}->prepare($sql); 
    766          
    767         $update->execute( $target, $source, $row->{action_id}); 
     768            my $update; 
     769            $update = $gCfg{dbh}->prepare($sql); 
     770 
     771            $update->execute( $target, $source, $row->{action_id}); 
     772        } else { 
     773            #the record did not have a matching MOVE_TO. call it a RESTORE 
     774            print "Changing $row->{action_id} to a RESTORE\n"; 
     775 
     776            my $sql = <<"EOSQL"; 
     777UPDATE 
     778    PhysicalAction 
     779SET 
     780    actiontype = 'RESTORE' 
     781WHERE 
     782    action_id = ? 
     783EOSQL 
     784            my $update; 
     785            $update = $gCfg{dbh}->prepare($sql); 
     786 
     787            $update->execute( $row->{action_id}); 
     788        } 
    768789    } 
    769790 
     
    785806    } 
    786807 
     808    $sth = $gCfg{dbh}->prepare('SELECT * FROM PhysicalAction WHERE actiontype = "RESTORE"'); 
     809    $sth->execute(); 
     810    $rows = $sth->fetchall_arrayref( {} ); 
     811 
     812    foreach $row (@$rows) { 
     813        #calculate last name of this file. Store it in $info 
     814 
     815        my $sql = "SELECT * FROM PhysicalAction WHERE physname = ? AND timestamp < ? ORDER BY timestamp DESC"; 
     816 
     817        $sth = $gCfg{dbh}->prepare($sql); 
     818        $sth->execute( $row->{physname}, $row->{timestamp} ); 
     819 
     820        my $myOlderRecords = $sth->fetchall_arrayref( {} ); 
     821 
     822        if (scalar @$myOlderRecords > 0) { 
     823            my $update = $gCfg{dbh}->prepare('UPDATE PhysicalAction SET info = ? WHERE action_id = ?'); 
     824            $update->execute(@$myOlderRecords[0]->{itemname}, $row->{action_id}); 
     825        } 
     826    } 
    787827 
    788828    1; 
     
    807847    foreach $row (@$rows) { 
    808848        my $physname = $row->{physname}; 
    809          
     849 
    810850        my $sql = 'SELECT * FROM PhysicalAction WHERE physname = ?'; 
    811851        my $update = $gCfg{dbh}->prepare($sql); 
    812          
     852 
    813853        $update->execute( $physname ); 
    814854 
    815                    # need to pull in all recs at once, since we'll be updating/deleting data 
    816                    my $recs = $update->fetchall_arrayref( {} ); 
    817                  
    818                    foreach my $rec (@$recs) { 
    819           print "Remove action_id $rec->{action_id}, $rec->{physname}, $rec->{actiontype}, $rec->{itemname}\n"; 
    820           print "       $rec->{comment}\n" if defined ($rec->{comment}); 
    821           &DeleteChildRec($rec->{action_id}); 
    822         } 
    823                
     855        # need to pull in all recs at once, since we'll be updating/deleting data 
     856        my $recs = $update->fetchall_arrayref( {} ); 
     857 
     858        foreach my $rec (@$recs) { 
     859            print "Remove action_id $rec->{action_id}, $rec->{physname}, $rec->{actiontype}, $rec->{itemname}\n"; 
     860            print "       $rec->{comment}\n" if defined ($rec->{comment}); 
     861            &DeleteChildRec($rec->{action_id}); 
     862        } 
     863   
    824864 
    825865    1; 
     
    835875    $sth = $gCfg{dbh}->prepare($sql); 
    836876    $sth->execute(); 
    837   
     877 
    838878    # need to pull in all recs at once, since we'll be updating/deleting data 
    839879    $rows = $sth->fetchall_arrayref( {} ); 
    840   
     880 
    841881    return if ($rows == -1); 
    842882    return if (@$rows < 2); 
    843   
     883 
    844884    my @delchild = (); 
    845   
     885 
    846886    for $r (0 .. @$rows-2) { 
    847887        $row = $rows->[$r]; 
    848          
     888 
    849889        if ($row->{actiontype} eq 'PIN' && !defined $row->{version}) # UNPIN 
    850         {  
     890        { 
    851891            # Search for a matching pin action 
    852892            my $u; 
     
    854894                $next_row = $rows->[$u]; 
    855895 
    856                 if (   $next_row->{actiontype} eq 'PIN'  
     896                if (   $next_row->{actiontype} eq 'PIN' 
    857897                    && defined $next_row->{version}   # PIN 
    858898                    && $row->{physname} eq $next_row->{physname} 
     
    863903                        print "found UNPIN/PIN combination for $row->{parentphys}/$row->{physname}" 
    864904                            . "($row->{itemname}) @ ID $row->{action_id}\n"  if $gCfg{verbose}; 
    865                          
     905 
    866906                        # if we have a unpinFromVersion number copy this one to the PIN handler 
    867907                        if (defined $row->{info}) 
     
    871911                            $sth2->execute($row->{info}, $next_row->{action_id}); 
    872912                        } 
    873                          
     913 
    874914                        push (@delchild, $row->{action_id}); 
    875915                    } 
     
    880920        } 
    881921    } 
    882   
     922 
    883923    my $id; 
    884924    foreach $id (@delchild) { 
    885925        &DeleteChildRec($id); 
    886926    } 
    887   
     927 
    888928    1; 
    889   
     929 
    890930}  #  End MergeUnpinPinData 
    891931 
     
    898938    $sth = $gCfg{dbh}->prepare($sql); 
    899939    $sth->execute(); 
    900   
     940 
    901941    # need to pull in all recs at once, since we'll be updating/deleting data 
    902942    $rows = $sth->fetchall_arrayref( {} ); 
    903   
     943 
    904944    foreach $row (@$rows) { 
    905945 
     
    912952        # UNPIN/PIN with unknown UNPIN version: we are lost in this case and we 
    913953        #     can not distinguish this case from the PIN only case. 
    914          
     954 
    915955        my $sql2; 
    916956        my $prefix; 
     
    928968            $prefix = "reverted changes for: \n"; 
    929969        } 
    930          
     970 
    931971        # UNPIN only 
    932972        if (   !defined $row->{version}     # no PIN version number 
     
    941981        } 
    942982 
    943         # UNPIN/PIN  
     983        # UNPIN/PIN 
    944984        if (    defined $row->{version}     # PIN version number 
    945985            &&  defined $row->{info}) {     # UNPIN version number 
     
    951991                    . '      AND version<=' . $row->{version} 
    952992                    . ' ORDER BY version '; 
    953                      
     993 
    954994            if ($row->{info} > $row->{version}) { 
    955995                $sql2 .= "DESC"; 
     
    9631003 
    9641004        next if !defined $sql2; 
    965          
     1005 
    9661006        my $sth2 = $gCfg{dbh}->prepare($sql2); 
    9671007        $sth2->execute(); 
    9681008 
    9691009        my $comments = $sth2->fetchall_arrayref( {} ); 
    970         my $comment;      
     1010        my $comment; 
    9711011        print "merging comments for $row->{physname}" if $gCfg{verbose}; 
    9721012        print " from $row->{info}" if ($gCfg{verbose} && defined $row->{info}); 
    9731013        print " to $row->{version}" if ($gCfg{verbose} && defined $row->{version}); 
    9741014        print "\n" if $gCfg{verbose}; 
    975          
     1015 
    9761016        foreach my $c(@$comments) { 
    9771017            print " $c->{version}: $c->{comment}\n" if $gCfg{verbose}; 
     
    9801020            $comment =~ s/\n+$//; 
    9811021        } 
    982          
     1022 
    9831023        if (defined $comment && !defined $row->{comment}) { 
    9841024            $comment = $prefix . $comment if defined $prefix; 
     
    9901030    } 
    9911031    1; 
    992   
     1032 
    9931033}  #  End BuildComments 
    9941034 
     
    10951135        # prematurally call the next row. Otherwise, we get an empty revision. 
    10961136        $svnrevs->check($row); 
    1097          
     1137 
    10981138        # May contain add'l info for the action depending on type: 
    10991139        # RENAME: the new name (without path) 
    11001140        # SHARE: the source path which was shared 
    11011141        # MOVE: the old path 
    1102         # PIN: the path of the version that was pinned       
     1142        # PIN: the path of the version that was pinned 
    11031143        # LABEL: the name of the label 
    11041144        $row->{info} = $handler->{info}; 
     
    11081148            $row->{version} = $handler->{version}; 
    11091149        } 
    1110          
     1150 
    11111151        $allitempaths = join("\t", @$itempaths); 
    11121152        $row->{itempaths} = $allitempaths; 
     
    11151155                             itemtype is_binary info) }); 
    11161156        $joincache->add( $svnrevs->{revnum}, $vsscache->{pkey} ); 
    1117          
     1157 
    11181158        if (defined $row->{label}) { 
    11191159            $labelcache->add(@$row{ qw(physname version label itempaths) }); 
     
    11261166    $joincache->commit(); 
    11271167    $labelcache->commit(); 
    1128      
     1168 
    11291169}  #  End BuildVssActionHistory 
    11301170 
     
    11991239                        || $action->{action} eq 'COMMIT')) { 
    12001240                    &ThrowWarning("'$physname': no version specified for retrieval"); 
    1201              
     1241 
    12021242                    # fall through and try with version 1. 
    12031243                    $version = 1; 
    12041244                } 
    1205              
     1245 
    12061246                if ($itemtype == 2 && defined $version) { 
    12071247                    $exported{$physname} = &ExportVssPhysFile($physname, $version); 
     
    14951535    # Build numbers look like: 
    14961536    #  a.) ssphys 0.20.0, Build 123 
    1497     #  b.) ssphys 0.20.0, Build 123:150  
     1537    #  b.) ssphys 0.20.0, Build 123:150 
    14981538    #  c.) ssphys 0.20.0, Build 123:150 (locally modified) 
    1499     $out =~ m/^ssphys (.*?), Build (.*?)[ \n]/m;  
     1539    $out =~ m/^ssphys (.*?), Build (.*?)[ \n]/m; 
    15001540 
    15011541    # turn it into 
     
    17011741        RecoveredFile => {type => 2, action => 'RECOVER'}, 
    17021742        ArchiveVersionsofFile => {type => 2, action => 'ADD'}, 
    1703        ArchiveVersionsofProject => {type => 1, action => 'ADD'}, 
     1743    ArchiveVersionsofProject => {type => 1, action => 'ADD'}, 
    17041744        ArchiveFile => {type => 2, action => 'DELETE'}, 
    17051745        RestoredFile => {type => 2, action => 'RESTORE'}, 
     
    19341974sub Initialize { 
    19351975    $| = 1; 
    1936      
     1976 
    19371977    GetOptions(\%gCfg,'vssdir=s','tempdir=s','dumpfile=s','resume','verbose', 
    19381978               'debug','timing+','task=s','revtimerange=i','ssphys=s', 
     
    19882028 
    19892029    $gCfg{errortasks} = []; 
    1990      
     2030 
    19912031    { 
    19922032        no warnings 'once'; 
     
    20342074        XML::SAX->load_parsers($INC[1]); 
    20352075    } 
    2036      
     2076 
    20372077    $gCfg{xmlParser} = 'XML::SAX::Expat'; 
    20382078    $XML::SAX::ParserPackage = $gCfg{xmlParser}; 
     
    21072147    --task <task>     : specify the task to resume; task is one of the following 
    21082148                        INIT, LOADVSSNAMES, FINDDBFILES, GETPHYSHIST, 
    2109                         MERGEPARENTDATA, MERGEMOVEDATA, REMOVETMPCHECKIN,  
     2149                        MERGEPARENTDATA, MERGEMOVEDATA, REMOVETMPCHECKIN, 
    21102150                        MERGEUNPINPIN, BUILDACTIONHIST, IMPORTSVN 
    21112151 

PumaCode.org recommends CVSDude for fast, professional Subversion and Trac hosting:

CVSDude.com

These ads are automatically generated by Google. Revenue from these ads helps to pay for hosting this site; however, these ads do not constitute an endorsement by PumaCode.org.