[ViewVC] Annotation of: cvsroot/COMP/SCRAM/src/scram

#!/usr/local/bin/perl5 
#
# User Interface
#
# Make sure were running the right version

versioncheck();

$inputcmd=shift;
$found='false';
$bold  = "\033[1m";
$rv=0;
$normal = "\033[0m";
$self={};

@allowed_commands=qw(project build install version list arch setup runtime db tool);
@dev_cmds=qw(devtest align);

if ( $inputcmd ne "" ) {
 foreach $command ( (@allowed_commands,@dev_cmds) ) {
         if ( $command=~/^$inputcmd/i) { 
                # Deal with a help request
                do{     helpheader($command);
                        &{"help_".$command}; exit; } if $ARGV[0]=~/help/i;
                $rv=&$command; $found='true'; 
                last;
         }
 }
}

if ( ! ( $found=~/true/ ) ) {
        helpheader('Recognised Commands');
        foreach $command ( @allowed_commands ) {
        print "      $bold scram ".$command.$normal."\n";       
        }
        print "\n";
        print "Help on individual commands available through\n\n";
        print "$bold       scram".$normal." command$bold help $normal\n\n";
}
exit $rv;

sub versioncheck {
        my $version;
        my $thisversion;

        $thisversion=getversion();

        if ( @_ ) {
           $version=shift;
        }
        else {
         if ( ! localtop_find() ) {
         LoadEnvFile();
         my $versionfile=$ENV{LOCALTOP}."/$ENV{projconfigdir}/scram_version";
          if ( -f $versionfile ) {
           open (VERSION, "<".$versionfile);
            $version=<VERSION>;
            chomp $version;
          }
         }
        }
        if ( defined $version ) {
            if ( $version ne $thisversion ) {
              # first try to use the correct version
              if ( -d $scram_top."/".$version ) {
                $ENV{SCRAM_HOME}=$scram_top."/".$version;
                my $rv=system("scram", @ARGV)/256;
                exit $rv;
              } 
              else { # if not then simply warn
                print "******* Warning : scram version inconsistent ********\n";
                print "This version: $thisversion; Required version: $version";
                print "*****************************************************\n";
                print "\n";
              }
            }
        }
}

sub _processcmds {
        my $optionhandler=shift;
        my $allowed_commands=shift;
        my $cmds=shift;
        my @subs=@_;

        my $found='false';
        # make a string from the subcommand levels
        my $substring="";
        if ( @subs ) {
           $substring= join '_', @subs;
           $substring=$substring."_";
        }

        # Process options
        if ( defined ${$cmds}[0] ) {
        while ( ${$cmds}[0]=~/^-/) {
           &{$optionhandler}( ${$cmds}[0],$cmds);
        }

        my $inputcmd=shift @{$cmds};
        if ( $inputcmd ne "" ) {
         foreach $command ( @{$allowed_commands} ) {
           if ( $command=~/^$inputcmd/i) {
                # Deal with a help request
                if ( ( defined $$cmds[0]) && $$cmds[0]=~/help/i ) {
                   &helpheader($command,@subs);
                   &{"help_".$substring.$command}; exit;
                }
                else {
        #print "calling $substring".$command."(@{$cmds})\n";
                   &{$substring.$command}(@{$cmds}); $found='true';
                   last;
                }
           }
         }
        }
        }
        return $found;
}


sub help_build {
        &build;
}

sub align {
        _localarea()->align();
}

sub build {
        # is this a based or free release?
        FullEnvInit();
        use BuildSystem::BuildSetup;
        $ENV{MAKETARGETS}=join ' ',@ARGV;
        my $bs=BuildSystem::BuildSetup->new(toolbox());
        $rv=$bs->BuildSetup($ENV{THISDIR},@ARGV);
        $rv;
}

sub project {
        my @args=@ARGV;
        # process options
        while ( $args[0]=~"^-" ) {
         if ( $args[0]=~/-n/ ) {
           shift @args;
           $ENV{devareaname}=shift @args;
         }
         elsif ( $args[0]=~/-d/ ) {  #installation area directory 
          shift @args;
          chdir $args[0];
          shift @args;
         }
         else {
          print "scram: unknown option $args[0] to project command\n";
          exit 1;
         }
        } 
        my $project=shift @args;
        my $version=shift @args;
        
        # quick scram version check (hack) - 
        environmentinit();
        my $pjurl="$project\?\?$version";
        require Utilities::urlhandler;
        my $bsfile=urlhandler::urlhandler($pjurl);
        my $local=0;
        my $config;
        if ( ($dir)=($bsfile=~/(.*)\/InstallFile$/) ) { # -- we have a dev area
          require Configuration::ConfigArea;
          $config=Configuration::ConfigArea->new(); 
          $local=1;
          $config->bootstrapfromlocation($dir); 
          unshift @ARGV, "project";
          versioncheck($config->scramversion());
        }
        use File::Copy;
        use Utilities::AddDir;
        
           use BootStrapProject;
           # get the bootstrap files downloaded
           BootStrapProject($pjurl);

           # Go setup the rest of the environement, now we can
           chdir $ENV{LOCALTOP};
           undef $ENV{LOCALTOP};
           &localtop;
           LoadEnvFile();

           #
           # Now create the directories specified in the interface
           #
           foreach $key ( keys %ENV ) {
                if ( $key=~/^INT/ ) {
                        AddDir::adddir($ENV{$key});
                }
           }
           if ( ! -e "$ENV{LOCALTOP}/$ENV{projconfigdir}" ) {
                AddDir::copydir("$ENV{RELEASETOP}/$ENV{projconfigdir}",
                                "$ENV{LOCALTOP}/$ENV{projconfigdir}");
           }

           require BuildSystem::Requirements;
           my $req=_requirements();
           
           $req->download(toolbox());
           if ( ! $local ) {
             _allprojectinitsearcher();
             toolbox()->searcher(_projsearcher());
             $req->setup(toolbox());
           }
           else {
              $config->copysetup($ENV{LOCALTOP});
           }
           use Cwd;
           print "\nInstallation Procedure Complete. \n".
                        "Installation Located at:\n".cwd()."\n";
}

# ------------ tool command --------------------------------------------
sub tool {
        @_=@ARGV;
        localtop();
        environmentinit();
        my @allowed_cmds=qw(info list);
        _processcmds("_tooloptions", \@allowed_cmds, \@_, ("tool"));    
}

sub tool_list {
        my $area=_localarea();
        print "Tool List for "; #.$area->name()." ".$area->version()."\n";
        print "Location : ".$area->location()."\n";
        print "+"x60;
        print "\n";
        foreach $t ( toolbox()->tools() ) {
          print $$t[0]." ".$$t[1]."\n";
        }
}

sub tool_info {
        my $project=shift;
        my $area=_localarea();
        print "Tool Info as configured in "; 
                        #.$area->name()." ".$area->version()."\n";
        print "Location : ".$area->location()."\n";
        print "+"x60;
        print "\n";

        my @tools=toolbox()->gettool($project,@_);
        foreach $t ( @tools ) {
          if ( defined $t ) {
           print "Name : ".$t->name();
           print "\n";
           print "Version : ".$t->version();
           print "\n";
           print "Docfile : ".$t->url();
           print "\n";
           print "+"x20;
           print "\n";
           @features=$t->features();
           foreach $ft ( @features ) {
             @vals=$t->getfeature($ft);
             foreach $v ( @vals ) {
               print $ft. "=$v\n";
             }
           }
          }
        }
}

sub _tooloptions {
        $scram->error("No Options defined for tool subcommand");
}

sub help_tool {
print <<ENDTEXT;
Manage the tools in the scram area that define the areas environment.
tool subcommands :
        list
        info

ENDTEXT
}

sub help_tool_info {
print <<ENDTEXT;
Description:
        Print out information on the specified tool in the current area
        configuration.
Usage :
        scram tool info tool_name [tool_version]

ENDTEXT
}

sub help_tool_list {
print <<ENDTEXT;
Description:
        List of currently configured tools available in ther current scram
        area
Usage :
        scram tool list

ENDTEXT
}


# ----------------------------------------------------------------------
sub _requirements {
        if ( ! defined $reqsobj ) {
          require BuildSystem::Requirements;
          $reqsobj=BuildSystem::Requirements->new($ENV{SCRAM_ProjReqsDoc});
        }
        return $reqsobj;
}

sub _allprojectinitsearcher {
        my $search=_projsearcher();
        foreach $proj ( _scramprojdb()->list() ) {
           $search->addproject($$proj[0],$$proj[1]);
        }
}

sub _projsearcher {
        if ( ! defined $self->{projsearcher} ) {
          require Scram::ProjectSearcher;
          $self->{projsearcher}=Scram::ProjectSearcher->new(_scramprojdb());
        }
        return $self->{projsearcher};
}

sub _scramprojdb {
        if ( ! defined $self->{scramprojectsdb} ) {
          environmentinit();
          require Scram::ScramProjectDB;
          $self->{scramprojectsdb}=Scram::ScramProjectDB->new(
                                                $ENV{SCRAM_LOOKUPDB});
        }
        return $self->{scramprojectsdb};        
}

sub runtime {
        my $shell;
        require Runtime;

        # process options
        while ( $ARGV[0]=~"^-" ) {
         if ( $ARGV[0]=~/-sh/ ) {
           shift @ARGV;
           $shell="sh";
           next;
         }
         if ( $ARGV[0]=~/-csh/ ) {  #installation area directory 
          shift @ARGV;
          $shell="csh";
          next;
         }
         print "Unknown Option $ARGV[0]\n";
         exit 1;
        } 

        FullEnvInit();
        if ( @ARGV ) {
           my $runtime=Runtime->new();
           my $arg=shift @ARGV;

           my $info=0;
           if ( $arg eq "info" ) {
              $arg=shift @ARGV;
              $info=1;
           }

           # --- determine filename
           my $filename;
           if ( -f $arg ) { # Is it a file?
              $filename=$arg;
           }
           else {
               # -- lets see if its a BuildFile location
               $filename=_testfile($ENV{LOCALTOP}."/src/".$arg,
                                $ENV{RELEASETOP}."/src/".$arg,
                                $ENV{LOCALTOP}."/src/".$arg."/BuildFile",
                                $ENV{RELEASETOP}."/src/".$arg."/BuildFile");
               if ( $filename eq "" ) {
                   print "Unable to find a file (or BuildFile) relating to ".
                        $arg."\n";
                   exit 1;
               }
           }
           $runtime->file($filename);
           if ( ! $info ) {
             $runtime->printenv($shell);
           }
           else {
             if ( @ARGV ) { #do we have a specific variable request?
                  _printvardoc($runtime,shift @ARGV);
             }
             else {
                foreach $var ( $runtime->list() ) {
                  _printvardoc($runtime,$var);
                } 
             }
           }
           undef $runtime;
        }
        else {
        FullEnvInit();
        # We have to clean up from the last runtime cmd - use env history
        foreach $variable ( %ENV ) {
          if ( $variable=~/^SCRAMRT_(.*)/ ) { #SCRAMRT are history retaining
            my $var=$1;
            $ENV{$var}=~s/\Q$ENV{$variable}\E//g;
            $ENV{$var}=~s/^:*//;  # Deal with any Path variables
            #print "$variable : $ENV{$variable} \n$var : $ENV{$var}\n";
            delete $ENV{$variable};
          }
        }

        # -- Set SCRAM release area paths
        addpath("LD_LIBRARY_PATH","$ENV{LOCALTOP}/lib/$ENV{SCRAM_ARCH}");
        addpath("LD_LIBRARY_PATH","$ENV{RELEASETOP}/lib/$ENV{SCRAM_ARCH}");

        # -- get the tool runtime environments
        my $toolbox=toolbox();
        foreach $toolpair ( $toolbox->tools() ) {
          # TODO - check for doubles
          $tool=$toolbox->gettool($$toolpair[0]); 
          
          if ( defined $tool ) {
           # -- get runtime paths
           foreach $f ( $tool->listtype("runtime_path")) {
            foreach $val ( $tool->getfeature($f) ) {
              addpath($f,$val);
            }
           }
           # -- get runtime vars
           foreach $f ( $tool->listtype("runtime")) {
            foreach $val ( $tool->getfeature($f) ) {
              $EnvRuntime{$f}=$val;
            }
           }
          }
        }

        addpath("PATH","$ENV{LOCALTOP}/bin/$ENV{SCRAM_ARCH}");
        addpath("PATH","$ENV{RELEASETOP}/bin/$ENV{SCRAM_ARCH}");

        # Now get the general project environment
        open ( SCRAMENV, "<$ENV{LOCALTOP}/$ENV{projconfigdir}/Runtime" );
        while ( <SCRAMENV> ) {
           chomp;
           next if /^#/;
           next if /^\s*$/;
           ($name, $value)=split /=/;
           addvar($name, (eval $value)," ");
        }
        close SCRAMENV; 

        # create new SCRAMRT history vars.
        foreach $variable ( keys %EnvRuntime ) {
          printoutenv($shell,"SCRAMRT_$variable",$EnvRuntime{$variable});
          #addvar("SCRAMRT_$variable", $EnvRuntime{$variable}, "");
        }
        # Now adapt as necessary - include base environment as well
        if ( exists $ENV{LD_LIBRARY_PATH} ) {
           addpath("LD_LIBRARY_PATH","$ENV{LD_LIBRARY_PATH}");
        }
        if ( exists $ENV{MANPATH} ) {
           addpath("MANPATH","$ENV{MANPATH}");
        }
        addpath("PATH","$ENV{PATH}");
        # Print out as reqd
        foreach $variable ( keys %EnvRuntime ) {
          printoutenv($shell,$variable,$EnvRuntime{$variable});
        }
        }
}

# Support rt for runtime

sub _testfile {
        my @files=@_;

        my $filename="";
        foreach $file ( @files ) {
          if ( -f $file ) {
                $filename=$file;
                last;
          }
        }
        return $filename;
}

sub _printvardoc {
        my $runtime=shift;
        my $var=shift;

        print $var." :\n";
        print $runtime->doc($var);
        print "\n";
}

sub printoutenv {
        my $shell=shift;
        my $variable=shift;
        my $value=shift;

        if ( $shell eq "csh" ) {
          print "setenv $variable \"$value\";\n";
        }
        elsif ( $shell eq "sh" ) {
          print "$variable=\"$value\";\n";
          print "export $variable;\n";
        }
}

sub addpath {
        my $name=shift;
        my $val=shift;

        my $n;
        my @env;
        @env=split /:/, $EnvRuntime{$name};
        foreach $n ( (split /:/, $val ) ){
         if (  ! grep /^\Q$n\E$/, @env ) {
          addvar($name,$n,":");
         }
        }
}

sub addvar {
        my $name=shift;
        my $val=shift;
        my $sep=shift;

        if ( $val ne "" ) {
        if ( defined $EnvRuntime{$name} ) {
         $EnvRuntime{$name}=$EnvRuntime{$name}.$sep.$val;
        }
        else {  
         $EnvRuntime{$name}=$val;
        }
        }
}

sub FullEnvInit {
    environmentinit();
    localtop();
    LoadEnvFile();
}

sub environmentinit {
        use Utilities::setarchitecture;
        my $name;
        my $value;

        $ENV{LatestBuildFile}=""; # stop recursive behaviour in make
        setarchitecture::setarch();
        $ENV{INTwork}="tmp/$ENV{SCRAM_ARCH}";
        $ENV{INTlib}="lib/$ENV{SCRAM_ARCH}";
        $ENV{INTsrc}="src";
        $ENV{INTbin}="bin/$ENV{SCRAM_ARCH}";
        $ENV{INTlog}="logs";

        ($ENV{SCRAM_BASEDIR}=$ENV{SCRAM_HOME})=~s/(.*)\/.*/$1/;
        if ( ! ( exists $ENV{SCRAM_CONFIG} ) ){
                $ENV{SCRAM_CONFIG}="$ENV{SCRAM_HOME}/configuration";
        }
        if ( ! ( exists $ENV{TOOL_HOME} ) ){
                $ENV{TOOL_HOME}="$ENV{SCRAM_HOME}/src";
        }
        if ( ! ( exists $ENV{SCRAM_LOOKUPDB} ) ){
                if ( -d "$ENV{SCRAM_BASEDIR}/scramdb/" ) {
                  $ENV{SCRAM_LOOKUPDB}="$ENV{SCRAM_BASEDIR}/scramdb/project.lookup";
                }
                else {
                  $ENV{SCRAM_LOOKUPDB}="$ENV{SCRAM_CONFIG}/project.lookup";
                }
        }
        $ENV{SCRAM_AVAILDIRS}="";
        $ENV{SCRAM_AVAILFILES}="";
}

sub _localarea {
        if ( ! defined $self->{localarea} ) {
          require Configuration::ConfigArea;
          $self->{localarea}=Configuration::ConfigArea->new();
          if ( ! defined $ENV{LOCALTOP} ) {
           if ( $self->{localarea}->bootstrapfromlocation() ) {
            # Were not in a local area 
            undef $self->{localarea};
           }
          }
          else {
            $self->{localarea}->location($ENV{LOCALTOP});
          }
        }
        return $self->{localarea};
}

sub localtop_find {
        my $rv=1;
        if ( defined _localarea()) {
          $rv=0;
          $ENV{LOCALTOP}=_localarea()->location();
        }
        return $rv;
}

sub localtop {
        localtop_find();
        if ( ! (defined $ENV{LOCALTOP}) ) {
         print "Unable to locate the top of local release. Exiting\n";
         exit 1;
        }
        ($ENV{THISDIR}=cwd)=~s/^\Q$ENV{LOCALTOP}\L//;
        $ENV{THISDIR}=~s/^\///;
}

sub LoadEnvFile {
        _localarea()->copyenv(\%ENV);
}

sub env {
   print "Sorry - Not yet\n";
}

sub devtest {
        require Utilities::TestClass;
        my $class=shift @ARGV;

        my $tester;
        my $path;

        #_initproject();
        if ( $class=~/::/ ) {
           ($path=$class)=~s/(.*)::.*/$1/;
        }
        $tester=Utilities::TestClass->new($class,
                "$ENV{SCRAM_HOME}/src/$path/test/testdata");
        $tester->dotest(@_);
}

#
# Create a lookup tag in the site database
#
sub install {
        my $tagname=shift @ARGV;
        my $version=shift @ARGV;

        # create database entry
        &FullEnvInit;
        if ( $version eq "" ) {
           $version=$ENV{SCRAM_PROJVERSION};
        }
        if ( $tagname eq "" ) {
           $tagname=$ENV{SCRAM_PROJECTNAME};
        }
        # -- use the scram db object
        _scramprojdb()->addarea($tagname,$version,_localarea());
        _localarea()->align();
}

sub help_install()  {

print <<ENDTEXT;
Associates a label with the current release in the SCRAM database.
This allows other users to refer to a centrally installed project by
this label rather than a remote url reference.

Usage:

        $bold   scram install $normal [project_tag [version_tag]]

porject_tag : override default label (the project name of the current release)
version_tag : the version tag of the current release. If version is not
          specified the base release version will be taken by default.

ENDTEXT
}

sub helpheader ($label) {
        my $label=shift;
print <<ENDTEXT;
*************************************************************************
                   SCRAM HELP --------- $label 
*************************************************************************
ENDTEXT
}

sub getversion {
        ($thisversion=$ENV{SCRAM_HOME})=~s/(.*)\///;
        $scram_top=$1;
        $scram_version=$thisversion;
        # deal with links
        my $version=readlink $ENV{SCRAM_HOME};
        if ( defined $version)  {
          $scram_version=$version;
        }
        return $scram_version;
}

sub version {
        my $version=shift @ARGV;
        my $thisversion;
        my $scram_top;
        my $cvsobject;

        ($thisversion=$ENV{SCRAM_HOME})=~s/(.*)\///;
        $scram_top=$1;
        if ( $version eq "" ) {
          print "$thisversion";
          # deal with links
          $version=readlink $ENV{SCRAM_HOME};
          if ( defined $version)  {
                print " ---> $version";
          }
          print "\n";
        }
        else {
          if ( -d $scram_top."/".$version ) {
                print "Version $version exists\n";
          }
          else {
              print "Version $version not available locally\n";
              print "Attempting download from the SCRAM repository\n";
              # set up and configure the cvs module for SCRAM
              use Utilities::cvsmodule;
              $cvsobject=cvsmodule->new();
              $cvsobject->set_base(
                "cmscvs.cern.ch:/cvs_server/repositories/SCRAM");
              $cvsobject->set_auth("pserver");
              $cvsobject->set_user("anonymous");
              $cvsobject->set_passkey("AA_:yZZ3e");
              # Now check it out in the right place
              chdir $scram_top or die "Unable to change to $scram_top $!\n";
              $cvsobject->invokecvs( ( split / /, 
                        "co -d $version -r $version SCRAM" ));
                
              # Get rid of cvs object now weve finished
              $cvsobject=undef;
              print "\n";
          }
        }
        0;
}

sub list {
        &environmentinit;
        my $filename="$ENV{SCRAM_LOOKUPDB}";
        if ( ! -f $ENV{SCRAM_LOOKUPDB} ) {
          print "No installation database available - perhaps no projects".
                " have been installed locally\n";
          exit 1;
        }
        print "Installed Projects\n";
        print "------------------\n";
        print "|Project Name  | Project Version |\n";
        print "----------------------------------\n";
        listdb($filename);
}

sub db {
        my $subcmd=shift @ARGV;
        &environmentinit;

        switch : {
        if ( $subcmd eq 'link' ) {
          dblink($ENV{SCRAM_LOOKUPDB},@ARGV);
          last switch;
        }
        if ( ! -f $ENV{SCRAM_LOOKUPDB} ) {
          print "No installation database available - perhaps no projects".
                "have been installed locally\n";
          exit 1;
        }
        if ( $subcmd eq 'unlink' ) {
          dbunlink($ENV{SCRAM_LOOKUPDB},@ARGV);
          last switch;
        }
        if ( $subcmd eq 'showlinks' ) {
          dblinklist($ENV{SCRAM_LOOKUPDB});
          last switch;
        }
        } # end switch
        
}

sub dblinklist {
        my $filename=shift;
        open (LOCALLOOKUPDB, "<$filename")  or
                die "Unable to open local database $!"; 
        while (<LOCALLOOKUPDB>) {
          if ( $_=~/\!DB (.*)/) {
            print $1,"\n";
          }
        }
        close LOCALLOOKUPDB;
}

sub dblink {
        my $filename=shift;
        my $newdbfilename=shift;
        my $exists=0;

        if ( -e $filename ) {
         if ( -e $newdbfilename ) {
         # Check if its already there
          open (LOCALLOOKUPDB, "<$filename")  or
                die "Unable to open local database $!"; 
           while (<LOCALLOOKUPDB>) {
            if ( $_=~/\!DB $newdbfilename/ ) {
                $exists=1;
                last;
            }
           }
          close LOCALLOOKUPDB;
          # Add it
          if ( ! $exists ) {
            open (LOCALLOOKUPDB, ">>$filename")  or 
                die "Unable to open local database $!";
            print LOCALLOOKUPDB "\!DB $newdbfilename\n";
            close LOCALLOOKUPDB;
          }
         }
         else {
          print "Unknown file $newdbfilename\n";
          exit 1;
         }
        }
        else {
          print "Unknown file $filename $!\n";
          exit 1;
        }
        
}

sub dbunlink {
        my $filename=shift;
        my $dbfilename=shift;
        if ( -e $filename ) {
         # Check if its already there
         open (LOCALLOOKUPDB, "<$filename")  or
                die "Unable to open local database $!"; 
         open (DBOUTFILE, ">$filename.tmp") or
                die "Unable to open working file $!";
         while (<LOCALLOOKUPDB>) {
            if ( $_!~/\!DB $dbfilename/ ) {
                print DBOUTFILE $_;
            }
           }
         close LOCALLOOKUPDB;
         close DBOUTFILE;
         use File::Copy;
         rename "$filename.tmp", $filename;
        }
}

sub listdb {
        my $filename=shift;
        my $map;

        use FileHandle;
        my $fh=FileHandle->new();
        open ( $fh, "<$filename" );
        while ( $map=<$fh> ) {
          if ( $map=~/^\!DB (.*)/ ) { # Check for other DB files
                my $db=$1;
                if ( -f $db ) {
                  listdb($db);
                }
                next;
          }
          ( $name, $version, $type, $url ) = split ":", $map; 
          printf "%1s",$name;
          printf "%25s\n",$version;
          printf "--> %25s\n",$type.":".$url;
        }
        close $fh;
        0;
}

sub arch {
        &environmentinit();
        print "$ENV{SCRAM_ARCH}\n";
}


#
# Setup a new tool
#

sub setup {
        my $interactive=0;

        # process options
        while ( $ARGV[0]=~"^-" ) {
         if ( $ARGV[0]=~/-i/ ) {
           shift @ARGV;
           $interactive=1;
         }
         else {
          print "scram: unknown option $ARGV[0] to project command\n";
          exit 1;
         }
        }

        &FullEnvInit;
        my $toolname=shift @ARGV;
        my $insert=0;
        toolbox()->interactive($interactive);

        if ( $ENV{SCRAM_BootStrapFiles}!~/\Q$ENV{LOCALTOP}\N\/\.SCRAM/ ) {
          $ENV{SCRAM_BootStrapFiles}="$ENV{LOCALTOP}/.SCRAM:".
                        $ENV{SCRAM_BootStrapFiles};
        }
        # If no toolname specified then its a full setup
        if ( $toolname eq "" ) {
           # -- add architecture specific directories
           use Utilities::AddDir;
           AddDir::adddir("$ENV{LOCALTOP}/lib/$ENV{SCRAM_ARCH}");
           AddDir::adddir("$ENV{LOCALTOP}/bin/$ENV{SCRAM_ARCH}");
        
           # -- check the releasetop area
           # if the releasetop has the files copy them
           my $releaseobj=_releasearea();
           if ( $releaseobj->copysetup($ENV{LOCALTOP}) ) {
             _allprojectinitsearcher();
             toolbox()->searcher(_projsearcher());
             my $reqs=_requirements();
             $reqs->setup(toolbox());
           }
        }
        else {
            _allprojectinitsearcher();
            toolbox()->searcher(_projsearcher());
            if ( my $rv=toolbox()->toolsetup($toolname,@ARGV) ) {
             if ( $rv eq 1 ) {
                print "Unknown tool $toolname @ARGV\n";
                exit 1;
             }
            }
        }
}

sub _releasearea {
        if ( !defined $self->{releasearea} ) {
           require Configuration::ConfigArea;
           $self->{releasearea}=Configuration::ConfigArea->new();
           $self->{releasearea}->bootstrapfromlocation($ENV{RELEASETOP});
        }
        return $self->{releasearea};
}

# get a toolbox object for the project
sub toolbox {
        if ( ! defined $toolbox ) {
           localtop();
           my $area=_localarea();
           require BuildSystem::ToolBox;
           $toolbox=BuildSystem::ToolBox->new($area);
           #$toolbox->verbosity(1);
        }
        return $toolbox;
}

sub help_db {
print <<ENDTEXT;
scram database administration command. 

Usage:

                 $bold scram db $normal subcommand

subcommands:
        link : 
                Make available an additional database for 
                project and list operations

                $bold scram db link $normal /a/directory/path/project.lookup

        unlink : 
                Remove a database from the link list. Note this does
                not remove the database, just the link to it in scram.

                $bold scram db unlink $normal /a/directory/path/project.lookup

        showlinks : 
                List the databases that are linked in

ENDTEXT
}

sub help_setup {

print <<ENDTEXT;
Allows installation/re-installation of a new tool/external package into an 
already existing development area. If not toolname is specified, 
the complete installation process is initiated.

Usage:

                 $bold scram setup [-i]$normal [toolname] [[version] [url]]

toolname : The name of the tool setup file required.
version  : where more than one version exists specify the version
url      : when setting up a completely new tool specify the url too

The -i option turns off the automatic search mechanism allowing for more
user interaction with the setup mechanism
ENDTEXT
}

sub help_list {
print <<ENDTEXT;
List the available projects and versions installed in the local SCRAM database
(see scram install help) 

Usage:

        $bold   scram list $normal

ENDTEXT
}

sub help_project {
print <<ENDTEXT;
Setup a new project development area. The new area will appear in the current 
working directory.
Usage:

        $bold scram project [-d install_area] [-n directory_name]$normal project_url [project_version]

Options:

project_url: The url of a scram bootstrap file.
             Currently supported types are:
                $bold Database label $normal
                        Labels can be assigned to bootstrap files for easy
                        access (See "scram install" command). If you
                        specify a label you must also specify a project_version.
                        e.g.

                           scram project SCRAM V1_0
                                
                           scram project ORCA ORCA_1_1_1

                        To see the list of installed projects use the
                        "scram list" command.

                $bold file: $normal A regular file on an accessable file system
                        e.g.

                           file:~/myprojects/projecta/config/BootStrapFile

project_version:
                 Only for use with a database label

-d install_area:
                 Indicate a project installation area into which the new
                 project area should appear. Default is the current working
                 directory.

-n directory_name:
                 Specify the name of the SCRAM development area you wish to 
                 create.
        
ENDTEXT
}

sub help_version {
print <<ENDTEXT;
With now $bold [version] $normal argument given, this command will simply
print to standard output the current version number.

Providing a version argument will cause that version to be downloaded and 
installed, if not already locally available. 


Usage:
                $bold scram version [version]$normal

ENDTEXT
}

sub help_arch {
print <<ENDTEXT;
Print out the architecture flag for the current machine.

Usage:
        $bold   scram arch $normal
ENDTEXT
}

sub help_runtime {
print <<ENDTEXT;
Echo to Standard Output the Runtime Environment for the current development area
Output available in csh or sh flavours

Usage:
        1) $bold   scram runtime [-csh|-sh] $normal
or
        2) $bold   scram runtime [-csh|-sh] filename $normal
or
        3) $bold   scram runtime info filename [variable]$normal

1) For the general configuration environment
2) For environment described in filename or 
                                areatop/src/directory/BuildFile 
3) Display information concerning the environment in the given file 
   (limited to variable if specified)

The file for cases 2) and 3) are searched as follows :
a) straightforward filename
b) filename relative to local_area/src
c) filename relative to release_area/src
d) BuildFile relative to local_area/src
e) BuildFile relative to release_area/src

Examples:

Setup the current environment to include the project Runtime Environment
in a csh environment

       $bold  eval `scram runtime -csh` $normal

Setup the current environment to include the project Runtime Environment in a
sh environment

       $bold  eval `scram runtime -sh` $normal


ENDTEXT
}
Revision:	1.23.2.89
Committed:	Tue Jun 20 16:40:56 2000 UTC (24 years, 10 months ago) by williamc
Branch:	V0_9branch
CVS Tags:	V0_12_12_4, V0_12_12_3, V0_12_12_2, V0_12_12_1, V0_12_12_0, PlayGround_0, V0_13_0, V0_12_12
Branch point for:	HPWbranch
Changes since 1.23.2.88:	+1 -1 lines
Log Message:	fix toolbox problem and return to releasedoc mechanism