src/BuildSystem/BuildSetup.pm

#
#
# Interface
# ---------
# new(ConfigArea) : A new BuildSetup
# BuildDir(directory,targets) : prepare the ground for a build and build
# getclass(directory) : return (Class, ClassDir, BuildFileobject) 
#                       associated with directory
# setup(dir)

package BuildSystem::BuildSetup;
require 5.004;
use Utilities::Verbose;
use Utilities::SCRAMUtils;
use BuildSystem::BuildFile;
use BuildSystem::BuildRecorder;
use BuildSystem::DateStampRecord;
use BuildSystem::Block;
use Utilities::AddDir;
@ISA=qw(Utilities::Verbose);

sub new {
        my $class=shift;
        my $self={};
        bless $self,$class;
        $self->{area}=shift;
        $self->{toolbox}=$self->{area}->toolbox();
        $self->{projconfigdir}=$self->{area}->configurationdir();
        $self->{localtop}=$self->{area}->location();
        $self->{releasearea}=$self->{area}->linkarea();
        if ( ! defined $self->{releasearea} ) {
           $self->{releasearea}=$self->{area};
        }
        $self->{releasetop}=$self->{releasearea}->location();
        $self->{buildfilename}="BuildFile";
        $self->verbosity(1);
        $self->_configurationsetup();
        # -- clean up from any previous builds
        $self->{BuildDBfile}=$self->{localtop}."/".
                                $self->{workdir}."/BuildReporterFile";
        if ( -f $self->{BuildDBfile} ) {
           unlink $self->{BuildDBfile};
        }
        return $self;
}

sub _generateexternals {
        my $self=shift;
        my $outfile=shift;

        # -- specify these files for dependency information
        my $depfile=$self->{projconfigdir}."/External_Dependencies";

        # -- get list of dependent files
        my $datadir=$self->{localtop}."/.SCRAM/".$ENV{SCRAM_ARCH};
        $fdir=FileHandle->new();
        opendir $fdir, $datadir; 
        my @depfiles=grep !/^\.\.?$/, readdir $fdir;
        undef $fdir;
        for (my $i=0; $i<=$#depfiles; $i++ ) {
           $depfiles[$i]=$datadir."/".$depfiles[$i];
        } 

        # -- do we need to rebuild?
        if ( SCRAMUtils::dated($outfile,@depfiles) ) {
          print "Configuring Local Area\n";
          # -- open output file
          my $fout=FileHandle->new();
          $fout->open(">".$outfile) or die "Unable to open $outfile for output".
                                        $!."\n";

          # -- print out tool/ version info
          my ($tool,$toolobj,$f,$val,$version);
          foreach $tool ( $self->{toolbox}->tools() ) {
            $version=$self->{toolbox}->defaultversion($tool);
            # default versions
            print $fout "ifdef $tool\n".$tool."_V_".$version."=true\nendif\n";
            # -- set up the different version  -- externals
            foreach $version ( $self->{toolbox}->versions($tool) ) {
             $toolobj=$self->{toolbox}->gettool($tool,$version);
             @deps=$toolobj->getfeature("_externals");
             foreach $d ( @deps ) {
              $d=~tr[A-Z][a-z];
              print $fout "ifdef ".$tool."_V_".$version."\n $d=true\nendif\n";
             }
             # -- tool info
             print $fout "ifdef ".$tool."_V_".$version."\n";
             foreach $f ( $toolobj->features() ) {
              foreach $val ( $toolobj->getfeature($f) ) {
                print $fout "\t".$f." += ".$val."\n";
              }
             }
             print $fout "endif\n";
            }
          }
          # -- some addittional processing of specific vars
          print $fout 'INCLUDEPATH+=$(addprefix -I,$(INCLUDE))'."\n";
          print $fout 'LDFLAGS+=$(addprefix -L,$(LIBDIR))'."\n";
          print $fout 'CPPFLAGS+=$(addprefix -D,$(CPPDEFINES))'."\n";
          print $fout 'lib+=$(extralib)'."\n";
          print $fout 'LDLIBS+=$(addprefix -l,$(lib))'."\n";
          print $fout 'LDLIBS+=$(addprefix -l,$(REQUIRES))'."\n";
          print $fout 'LD_LIBRARY_PATH:=$(subst $(space),:,$(LD_LIBRARY_PATH))'."\n";

          undef $fout;
          $self->verbose("End Externals Configuration Setup");
        }
}

sub classsetup {
        my $self=shift;
        my $THISDIR=shift;

        my $classmakefile;

        my ($Class, $ClassDir, $bf)=$self->getclass2($THISDIR);
        $self->verbose("Class = $Class : ClassDir = $ClassDir for directory ".
                        $THISDIR);

        # -- should we ignore?
        if ( $bf->ignore() ) {
           print "Nothing to be done - empty group\n";
           exit;
        }


        # -- Create a makefile from the class BuildFile
        my $classbuildfile=$self->{localtop}."/".
                $self->{projconfigdir}."/".$Class."_BuildFile";
        if ( -f $classbuildfile ) {
              $classmakefile=$self->{localtop}."/".$ENV{INTwork}.
                                        "/".$Class."_makefile.mk";
              if ( SCRAMUtils::dated($classmakefile, $classbuildfile) ) {
                # -- generate the new makefile if out of date
                $self->verbose("Generating $classmakefile from".
                                                " $classbuildfile");
                my $classbf=BuildSystem::BuildFile->new($self->{area},$self);
                undef $ENV{LatestBuildFile}; # gets set by BuildFile
                $classbf->GenerateMakefile($classbuildfile, $classmakefile);
                undef $ENV{LatestBuildFile}; # gets set by BuildFile
              }
        }
        else {
           # -- No BuildFile - maybe its old style makefile
              $classmakefile=$self->{localtop}."/".
              $self->{projconfigdir}."/".$Class."_makefile.mk";
              if ( ! -f $classmakefile ) {
                   $self->error("Unable to find matching ".$Class.
                                "_BuildFile or ".$Class."_makefile.mk");
              }
        }
        # -- set LatestBuildFile
        if ( $bf->buildfile() ne "" ) {
          $ENV{LatestBuildFile}=$bf->makefile();
        }
        else {
          $ENV{LatestBuildFile}=$self->{topbf}->makefile();
        }

        return ($Class,$ClassDir,$classmakefile);
}

sub _configurationsetup {
        my $self=shift;

        # -- set working directory
        $self->{workdir}=$ENV{INTwork};
        $self->{fullworkdir}=$self->{localtop}."/".$self->{workdir};

        # -- make working directory
        chdir $self->{localtop};
        AddDir::adddir($self->{workdir});

        # -- generate tool info
        $self->_generateexternals($self->{fullworkdir}."/clientmakefile");

        # -- process project BuildFile
        $self->_topbuildfile();
}

sub BuildDir {
        my $self=shift;
        my $THISDIR=shift;
        my @Targets=@_;
        my $DefaultBuildFile="";

        # -- Setup Class specifics
        ($Class,$ClassDir,$classmakefile)=$self->classsetup($THISDIR);
        $ENV{classmakefile}=$classmakefile;
        $ENV{Class}=$Class;
        $ENV{ClassDir}=$ClassDir;
        $DefaultBuildFile=$ENV{classmakefile};
        $ENV{DefaultBuildFile}=$DefaultBuildFile;

        # -- Create working directory
        my $workdir=$self->{workdir}."/".$ClassDir;
        chdir $self->{localtop};
        AddDir::adddir($workdir);
        $ENV{workdir}=$workdir;
        my $fullworkdir=$self->{localtop}."/".$ENV{workdir};
        chdir $fullworkdir || die "Unable to enter working directory $!";

        # -- Set up some other useful variables for the Build
        # set variables listing directories/files available
        my $fh=FileHandle->new();
        opendir $fh, "$self->{localtop}/$ClassDir";
        my @allfiles= grep !/^\.\.?$/, readdir $fh;
        undef $fh;
        foreach $file ( @allfiles ) {
         if ( -d "$self->{localtop}/$ClassDir/$file" ) {
           $ENV{SCRAM_AVAILDIRS}=$ENV{SCRAM_AVAILDIRS}." ".$file;
         }
         else {
           $ENV{SCRAM_AVAILFILES}=$ENV{SCRAM_AVAILFILES}." ".$file;
         }
        }
        my $targetnumber=$#Targets;
        $ENV{"MAKETARGETS"}="";
        foreach $word ( @Targets ) {
         if ( $word=~/.*=.*/ ) { # if we have an assignment it cant be a target
           $targetnumber--;
         }
         else {
          # set some variables for use in makefiles
          $ENV{"MAKETARGET_".$word}=$word;
          if ( $ENV{"MAKETARGETS"} ne "" ) {
            $ENV{"MAKETARGETS"}=$ENV{"MAKETARGETS"}." ".$word;
          }
          else {
            $ENV{"MAKETARGETS"}=$word;
          }
         }
        }

       # -- If target not specified default to the class name target
       if ( $targetnumber == -1 ) {
        push @Targets,$Class;
       }

    $ENV{DefaultMakefile}="$ENV{TOOL_HOME}/basics.mk";


    $SCRAM_GROUPSDIR=$self->{localtop}."/".$self->{projconfigdir}."/groups.mk";
    if ( -f $SCRAM_GROUPSDIR ) {
      $ENV{SCRAM_GROUPSDIR}=$SCRAM_GROUPSDIR;
    }


    #
    # Keep a track of what we have built this run
    #
    if ( ! defined $self->{BuildDB} ) {
         my $file=$self->{BuildDBfile};
         $self->{BuildDB}=BuildSystem::BuildRecorder->new($file);
    }   
    my $rv=0;
    if ( ! $self->{BuildDB}->checked($ClassDir) ) {
         $self->{BuildDB}->checked($ClassDir,1); # Mark it as taken care of

         # Do a datestamp check so that make will build files that have changed
         # rather than just those which are older than their dependencies
         $self->_checkdatestampindir($ClassDir);

         # -- The main build here
         $rv=system("gmake","--no-print-directory","-r","-k","-f",
                "$ENV{DefaultMakefile}","-I$ENV{TOOL_HOME}", @Targets);
    }
    return $rv/256; # return the exit status of gmake

}

# TODO - work in progress - replacement for BuildDir that can handle <Build> OK
sub BuildIt {
        my $self=shift;
        my $dir=shift;
        my @Targets=@_;


        # -- get the top building block
        my $topblock=$self->_gettopblock();
        $ENV{LatestBuildFile}=$self->_gettopbf()->makefile();

        # -- is there a class block associated with the directory?
        my ($Class,$ClassDir)=getclass($dir);
        $self->verbose("Using Class $Class");
        my $classblock=$self->_getclassblock($Class,$topblock);

        # -- If target not specified default to the class name target
        if ( $targetnumber == -1 ) {
          push @Targets,$Class;
        }

        # -- Create working directory
        my $workdir=$self->{workdir}."/".$ClassDir;
        chdir $self->{localtop};
        AddDir::adddir($workdir);
        $ENV{workdir}=$workdir;
        my $fullworkdir=$self->{localtop}."/".$ENV{workdir};
        chdir $fullworkdir || die "Unable to enter working directory $!";
        $self->verbose("Working area setup");

        # -- Search for Blocks up to tree root
        my @dirblocks=();
        my @dirs=split /\//, $dir;
        my $fulldir="";
        my $currentblock=$classblock;
        foreach $dire ( @dirs ) {
              ($fulldir eq "")?$fulldir=$dire
                              :$fulldir=$fulldir."/".$dire;
              $self->verbose("Searching $fulldir for Block");
              my $block=$self->_getdirblock($fulldir,$currentblock);
              if ( defined $block ) {
                 $currentblock=$block;
              }
              $ENV{LatestBuildFile}=$self->gettopbf()->makefile();
        }

        # -- Create a makefile to include both BuildFile and
        #    class makefile

        my $fh=FileHandle->new();
        my $mfile=$fullworkdir."/BuildFile.mk";
        $self->verbose("Building makefile $mfile");
        $fh->open(">".$mfile);
        $fh->autoflush(1);
        if ( -e $ENV{LatestBuildFile} ) {
          print $fh "include $ENV{LatestBuildFile}\n";
        }

        # -- Parse the local BuildFile
        my $dbf=$self->_getdirbf($dir);
        if ( defined $dbf ) {
          $dbf->Parsetofh($fh,$currentblock);
        }

        # -- Parse the class BuildFile
        my $cbf=$self->_getclassbf($Class);
        if ( defined $cbf ) {
          $cbf->Parsetofh($fh,$currentblock);
        }
        $fh->close();
        $ENV{DefaultMakefile}=$mfile;

        # -- Hack around make by checking datestamps in local working and
        #    in _class_ working directories
        $self->_checkdatestampindir($ClassDir);
        opendir $fh, $ClassDir;
        my @dfiles= grep { -d $_ } readdir $fh;
        undef $fh;
        foreach $dir ( @dfiles ) {
          if ( $dir=~/^_class_/ ) {
           $self->_checkdatestampindir($ClassDir."/".$dir);
          }
        }

        # -- Call gmake to do the actual build
        $rv=system("gmake","--no-print-directory","-r","-k","-f",
                "$mfile","-I$ENV{TOOL_HOME}", @Targets);
        return $rv/256; # return the exit status of gmake
}

#
# -- Block generation Routines
#

sub _getclassblock {
        my $self=shift;
        my $key=shift;

        if ( ! defined $self->{classblocks}{$key} ) {
            $self->verbose("Initialising Class Block $key");
            $self->{classblocks}{$key}=BuildSystem::Block->new();
            # -- get class buildfile
            my $bf=$self->_getclassbf($key);
            if ( @_ ) {
              $self->{classblocks}{$key}->parent(shift);
            }
            $bf->BlockParse($self->{classblocks}{$key});
            $self->verbose("Initialisation Complete for Class Block $key");
        }
        return $self->{classblocks}{$key};

}

sub _gettopblock {
        my $self=shift;

        if ( ! defined $self->{topblocks} ) {
            $self->verbose("Initialising Top Block");
            $self->{topblock}=BuildSystem::Block->new();
            # -- get class buildfile
            my $bf=$self->_gettopbf();
            if ( @_ ) {
              $self->{topblock}->parent(shift);
            }
            $bf->BlockParse($self->{topblock});
            $self->verbose("Initialisation Complete for Top Block");
        }
        return $self->{topblock};
}

sub _getdirblock {
        my $self=shift;
        my $dir=shift;
        my $block=shift;

        if ( defined $dir || $dir ne "" ) {
        if ( ! defined $self->{blocks}{$dir} ) {
          # -- get a buildfile and do a block parse
          $self->{blocks}{$dir}=BuildSystem::Block->new();
          my $bf=$self->_getbuildfile($dir);
          $self->{blocks}{$dir}->parent($block);
          $bf->blockparse($self->{blocks}{$dir});
        }
        return $self->{blocks}{$dir};
        }
        return undef;
}

#
# -- BuildFile generation routines
#

sub _getclassbf {
        my $self=shift;
        my $class=shift;

        if ( ! defined $self->{classbf}{$class} ) {
          $self->verbose("Initialising Class BuildFile $class");
          # -- determine BuildFile or makefile
          my $fname=$self->{localtop}."/".$self->{projconfigdir}.
                                                        "/".$class."_";
          if ( -f $fname.$self->{buildfilename} ) {
             $fname=$fname.$self->{buildfilename};
          }
          elsif ( -f $fname."makefile.mk" ) {
             $fname=$fname."makefile.mk";
          }
          else {
             $self->error("$fname".$self->{buildfilename}." does not exist in ".
                        $self->{projconfigdir});
          }

          # -- create a BuildFile object
          $self->{classbf}{$class}=BuildSystem::BuildFile->new($self->{area},$self);
          $self->{classbf}{$class}->buildfile($fname);
          $self->verbose("Finished Initialising Class BuildFile $class");
        }
        return $self->{classbf}{$class};
}

sub _gettopbf {
        my $self=shift;

        if ( ! defined $self->{topbf} ) {
          $self->{topbf}=BuildSystem::BuildFile->new($self->{area},$self);
          $self->{topbf}->buildfile($self->{localtop}."/".
                        $self->{projconfigdir}."/".$self->{buildfilename});
        }
        return $self->{topbf};
}
#
# Returns undef if BF does not exist at this dir level
#
sub _getdirbf {
        my $self=shift;
        my $dir=shift;

        if ( ! exists $self->{dirbf}{$dir} ) {
          $self->verbose("initialising dir BuildFile $dir");
          # -- determine if local or releasetop
          my $fname=$self->{path}."/".$self->{buildfilename};
          if ( -f $self->{localtop}."/".$fname ) {
            $fname=$self->{localtop}."/".$fname;
          }
          elsif ( -f $self->{releasetop}."/".$fname ) {
            $fname=$self->{releasetop}."/".$fname;
          }
          else {
            $self->{dirbf}{$dir}=undef;
            $self->verbose("initialisation complete for dir BuildFile $dir");
            return $self->{dirbf}{$dir};
          }

          # -- construct the bf object
          $self->{dirbf}{$dir}=BuildSystem::BuildFile->new($self->{area},$self);
          $self->{dirbf}{$dir}->buildfile($fname);

          $self->verbose("initialisation complete for dir BuildFile $dir");
        }
        return $self->{dirbf}{$dir};
}

sub getclass2 {
    my $self=shift;
    my $dirname = shift;
    my $Class="DEFAULT";
    my $ClassDir="";

    #return if $dirname eq "";
    my @DIRA=split /\//, $dirname;

    my $thispath=".";
    # -- construct all class buildfiles in the path
    for ( $i=0; $i<=$#DIRA; $i++ ) {
        #$thispath=(($thispath eq "")?$DIRA[$i]:$thispath."/".$DIRA[$i]);
        $thispath=$thispath."/".$DIRA[$i];
        if ( ! exists $self->{pathbf}{$thispath} ) {
          $self->verbose("Initialising BuildFile in $thispath");
          $self->{pathbf}{$thispath}=$self->_startbuildfile($thispath);
        }
        # -- check class overriden by BuildFile
        if ( defined $self->{pathbf}{$thispath}->classname() ) {
                $Class=$self->{pathbf}{$thispath}->classname();
                $ClassDir=$thispath;
        }
        else {
          # -- sort it out from classpath directives
          foreach $BlockClassA ( @{$self->{LoBCA}} ) {
           next if ( $#{$BlockClassA} < $i );
           $elem=${$BlockClassA}[$i];
            if ( $elem=~/^$DIRA[$i]\+/ ) {
                $elem=~s/^$DIRA[$i]//;
            }
            #print $elem." ".$DIRA[$i]."\n";
            if ( $elem=~/^\+/ ) {
                ($Class=$elem)=~s/^\+//;
                $ClassDir=$thispath;
            }
          #}
         }
        }
    }
    # -- default case
    if ( $ClassDir eq "" ) {
      if ( ! defined $self->{pathbf}{'.'}) {
          $self->{pathbf}{'.'}=$self->_startbuildfile(".");
          $self->verbose("DEFAULT class initialised : ".$self->{pathbf}{'.'});
      }
      $ClassDir=".";
    }

    # -- returns
    ($ClassDir_c=$ClassDir)=~s/^\.\///;
    return ( $Class, $ClassDir_c, $self->{pathbf}{$ClassDir});
}

sub getclass {
    my $self=shift;
    my $dirname = shift;

     my $Class="DEFAULT";
        my $ClassDir=".";

        # return if $dirname eq "";
        my @DIRA=split /\//, $dirname;

        my $thispath="";
        for ( $i=0; $i<=$#DIRA; $i++ ) {
          $thispath=(($thispath eq "")?$DIRA[$i]:$thispath."/".$DIRA[$i]);

          # -- sort it out from classpath directives
          foreach $BlockClassA ( @{$self->{LoBCA}} ) {
           next if ( $#{$BlockClassA} < $i );
           $elem=${$BlockClassA}[$i];
            if ( $elem=~/^$DIRA[$i]\+/ ) {
                $elem=~s/^$DIRA[$i]//;
            }
            #print $elem." ".$DIRA[$i]."\n";
            if ( $elem=~/^\+/ ) {
                ($Class=$elem)=~s/^\+//;
                $ClassDir=$thispath;
            }
          }
        }
        return ( $Class, $ClassDir );
}

#
# Check to see if the buildfile is local or in the release area and
# parse appropriately
#
sub _startbuildfile {
         my $self=shift;
         my $classdir=shift;

         my $bf=BuildSystem::BuildFile->new($self->{area},$self);
         my $thisfile="$classdir/$self->{buildfilename}";

         if ( -e $self->{localtop}."/".$thisfile ) {
            $bf->buildfile($self->{localtop}."/".$thisfile);
            $bf->ParseBuildFile($self->{localtop}, $classdir,
                                $self->{buildfilename});
         }
         elsif ( -e $self->{releasetop}."/".$thisfile ) {
            $bf->buildfile($self->{releasetop}."/".$thisfile);
            $bf->ParseBuildFile($self->{releasetop}, $classdir,
                                                $self->{buildfilename});
         }
         return $bf;
}

sub _topbuildfile {
    my $self=shift;

    $self->verbose("Generating Top Level BuildFile");
    # -- Analyse project buildfile if it exists

    my $topbf=$self->_gettopbf();

    # -- generate top level makefile
    undef $ENV{LatestBuildFile};
    $topbf->ParseBuildFile($self->{localtop},
                        $self->{projconfigdir},$self->{buildfilename});

    # -- Extract BuildStructure Information
    my @ClassPaths=split /:/, $self->{topbf}->BlockClassPath();
    foreach $BClassPath ( @ClassPaths ) {
      next if ( $BClassPath eq "");
      push @{$self->{LoBCA}}, [ split /\//, $BClassPath ];
    }
    $self->verbose("End top buildfile generation");
}

sub _checkdatestampindir {
        my $self=shift;
        my $dir=shift;

        # -- get all local .ds files
        my $fh=FileHandle->new();
        my $ldir=$self->{localtop}."/".$self->{workdir}."/".$dir;
        opendir $fh, $ldir;
        my @dsfiles= grep /^.*\.ds$/, readdir $fh;
        $fh->close();

        # -- copy across ds files from releasetop if not existing locally
        if ( $#dsfiles < 0 ) {
          # -- get all releasetop .ds files
          my $rdir=$self->{releasetop}."/".$self->{workdir}."/".$dir;
          opendir $fh, $rdir;
          my @releasedsfiles= grep /^.*\.ds$/, readdir $fh;
          foreach $file ( @releasedsfiles ) {
                use File::Copy;
                $self->verbose("Copying $file from $rdir to $ldir");
                copy($rdir."/".$file,$ldir."/".$file);
          }
          $fh->close();
          @dsfiles=@releasedsfiles;
        }

        # -- process ds files
        my $file;
        foreach $datafile ( @dsfiles ) {
          $self->verbose("Processing $ldir/$datafile\n");
          my $ds=BuildSystem::DateStampRecord->new($ldir."/".$datafile);
          $ds->verbosity($self->verbosity());
          my $date;
          my $needsupdate;
          my $productfile=$ds->product();
          my (%files,%moddate);

          # now get dates in our dependency list
          my @datedfiles=$ds->dated();
          if ( $#datedfiles >= 0 ) {

             $needsupdate=1;
             $date=$datedfiles[0][1]-1;
          }
          else {
           # -- extra checks for local replacement of files
           foreach $file ( $ds->contents() ) {
            # -- only check files
            if ( -f $file ) {
             $files{$file}=$ds->filedate($file);
             # -- check to see if we have a new local copy
             if ( ($file=~/\Q$self->{releasetop}\E/) &&
                                ($self->{releasetop} ne $self->{localtop}) ) {
              ($tempfile=$file)=~s/\Q$self->{releasetop}\E/$self->{localtop}/;
              if ( -f $tempfile ) {
                $files{$tempfile}=$files{$file};
                $file=$tempfile;
              }
             }
             $moddate{$file}=(stat($file))[9];
             if ( $moddate{$file} != $files{$file} ) {
              $self->verbose($file." changed");
              $date=$moddate{$file}-1;
              $needsupdate=1;
             }
            }
           }
          }
          # time stamp the product file to be older than the dependencies
          if ( $needsupdate == 1 ) { # touch file into the past
          my $newproductfile;
          if ( $productfile!~/\Q$self->{localtop}\E/ ) {
           if ( $productfile=~/\Q$self->{releasetop}\E/ ) {
             ($newproductfile=$productfile)=~
                        s/\Q$self->{releasetop}\E/$self->{localtop}/;
             $self->verbose("Copying $productfile to $newproductfile");
             copy($productfile,$newproductfile);
           }
           else { # assume no path to worry about
             $newproductfile=$self->{localtop}."/".$ENV{workdir}.
                                                      "/".$productfile;
              # -- make a local copy of the product file if not already here
              my $oldproductfile=$self->{releasetop}."/".$ENV{workdir}.
                                                        "/".$productfile;
             if ( ! -f $newproductfile ) {
              if ( -f $oldproductfile ) {
                $self->verbose("Copying $oldproductfile to $newproductfile");
                copy($oldproductfile,$newproductfile);
              }
             }
           }
          }
          else {
             $newproductfile=$productfile;
          }
          if ( -f $newproductfile ) {
            $self->verbose("Blasting $newproductfile to the past ($date)");
            # If the (local) productfile exists - make it older
            utime($date,$date,$newproductfile);
          }
          else {
            $self->verbose("SomeThing Wrong(?) with $newproductfile\n".
                "RELEASETOP=".$self->{releasetop}."\n".
                "LOCALTOP=".$self->{localtop}."\n".
                "workdir=".$ENV{workdir});
          }
        }
        else {
          $self->verbose("No need to touch $productfile");
        }
        }
        undef $fh;
}
Revision:	1.1.2.7.2.2.2.1.2.5
Committed:	Thu Nov 2 17:42:26 2000 UTC (24 years, 6 months ago) by williamc
Content type:	text/plain
Branch:	V0_16branch
Changes since 1.1.2.7.2.2.2.1.2.4:	+1 -1 lines
Log Message:	call correct checker