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

# -*-perl-*-
#===========================================================================#
# NAME: scramcli                                                            #
#===========================================================================#
# DATE: Mon May 28 11:36:18 2001                                            #
# AUTHOR:      C. Williams                                                  #
# MAINTAINER:  Shaun Ashby                                                  #
#===========================================================================#
# DESCRIPTION: The main scram program (NOTE: this is wrapped at runtime to  #
#              set up the path to the SCRAM Perl modules).                  #
#                                                                           #
#===========================================================================#
# V1.36:       V0_19_3 release ready  Wed Feb 20 13:41:56 2002              #
# V1.39:       NR fixes included (no references to "which" anywhere)        #
# V1.44:       Added -f options to set/project. Added simple parser to      #
#              remove duplicate lib entries.                                #
# V1.46:       V0_19_4 release ready  Tue May 21 12:35:14 2002              #
# V1.52:       V0_19_6p1 prerelease   Tue May 21 13:53:14 2002              #
# V1.53:       V0_19_6 release        Mon Aug 19 15:51:43 2002              #
# V1.65:       V0_19_7 release        Mon Nov 18 15:23:36 2002              #
#===========================================================================#


# Verbose mode:
&local_verbose("MAIN");

$main::bold = "";
$main::normal = "";
$main::line = "-"x80;
$main::lookupobject = "";

# Test whether the output from SCRAM is being redirected, or
# not (prevents escape signals from being printed to STDOUT if
# STDOUT is redirected to a file or piped):
if ( -t STDIN && -t STDOUT )
   {
   $bold = "\033[1m";
   $normal = "\033[0m";
   }

# Allowed main and dev commands:
@allowed_commands=qw(project build install version list listcompact remove arch setup runtime setroot db tool url switch);
@dev_cmds=qw(devtest devint align);

# Check for prerequisites:
prerequisitecheck();
# Check for version consistency:
versioncheck();


# Parse arguments (look for "-verbose","-debug" or "-arch" then shift): 
while ( $ARGV[0] =~ /^-/)
   {
   if ( $ARGV[0] eq "-verbose" )
      {
      # Enable verbose for main as well, by default when -verbose mode selected:
      $ENV{'SCRAMDEBUG'} = 1;
      shift @ARGV;
      # If no argument (i.e. class to activate "verbose" for) do nothing:
      if (defined ($ARGV[0]))
         {
         print "Verbose mode for $ARGV[0] switched ".$bold."ON".$normal."\n" ;
         scrambasics()->classverbose($ARGV[0],1);
         }
      }
   # If called with -debug flag, turn on verbose mode for all packages:
   elsif ( $ARGV[0] eq "-debug" )
      {
      fullverbosity();
      }
   elsif ( $ARGV[0] eq "-arch" )
      {
      shift @ARGV;
      $ENV{SCRAM_ARCH}=$ARGV[0];
      scrambasics()->arch($ARGV[0]);
      }
   else
      {
      ReportError("Unknown option $ARGV[0]");
      }
   shift @ARGV;
   }

# Shift args to get input command:
$inputcmd=shift;
$found='false';
$rv=0;
$self={};

# Check that input command is defined, and then
# run a scram subroutine for the command or show
# some help:
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";
   
   print "\nOptions:\n";
   print "--------\n";
   printf("%-28s : %-55s\n",$bold."-verbose ".$normal."<class> ","Activate the verbose ".
      "function on the specified class.");
   printf("%-28s : %-55s\n",$bold."-debug ".$normal,"Activates the verbose function on all SCRAM classes.");
   print "\n";
   printf("%-28s : %-55s\n",$bold."-arch ".$normal."<architecture>","Set the architecture ID ".
      "to that specified.");
   print "\n";
   }

# Exit with exit status of subroutine
# that was executed in line 80:
exit $rv;


######################################################################################
## Subroutine definitions                                                           ##
######################################################################################

sub switch
   {   
   ###############################################################
   # switch                                                      #
   ###############################################################
   # modified : Fri Aug 23 14:01:41 2002 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Set some user flags, mostly for BuildSystem.     #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("switch");
   
   # Store this in working dir::
   my $mk = $ENV{LOCALTOP}."/".$ENV{INTwork}."/switch.mk";

   open(SWITCHMK,">$mk") || die "$mk: $!","\n";
   foreach my $sw (@ARGV)
      {
      print SWITCHMK $sw,"\n";
      }
   close(SWITCHMK);
   }

sub help_switch
   {
   ###############################################################
   # help_switch()                                               #
   ###############################################################
   # modified : Fri Aug 23 14:07:23 2002                         #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for the scram switch command.          #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_switch");

   print <<ENDTEXT;
Pass statements/switches directly to the build system. Mainly
useful for changing to a different default compiler, e.g.

        $bold scram switch gcc=true $normal

to use gcc. This change is permanent until a subsequent "scram b very_clean"
is performed in the project area. Only valid makefile statements can be used.
Statements must be separated by spaces and occur on the same line.

ENDTEXT
   return (0);
   }


sub ReportError
   {
   ###############################################################
   # ReportError(string)                                         #
   ###############################################################
   # modified : Mon May 28 11:26:47 2001 / SFA                   #
   # params   : Error messsage string                            #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Exit with an error string. Print string to       #
   #          : STDERR if using pipes.                           #
   #          :                                                  #
   ###############################################################
   my $string=shift;
   &local_verbose("ReportError");

   if ( -t STDERR ) # Make sure that errors go to STDERR
      {             # when using pipes
      print STDERR "\n","SCRAM error: ".$string."\n";
      }
   else
      {
      print "\n","SCRAM error: ".$string."\n";
      }
   exit (1);
   }

sub prerequisitecheck
   {
   ###############################################################
   # prerequisitecheck()                                         #
   ###############################################################
   # modified : Mon May 28 11:26:52 2001 / SFA                   #
   # params   : None.                                            #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Check for prerequisite programs.                 #
   #          : Don't bother checking for shell: too much hassle.#
   #          : (and doesn't work outside of HEPiX scheme)       #
   ###############################################################
   my $reqdmake="gmake";
   &local_verbose("prerequisitecheck");
   
   # We must have gmake. Check this or exit if no gmake:
   my $gmake_version_info=`$reqdmake -v`;
   if ( $? == 0 )
      {
      return (0);
      }
   else
      {
      print "It appears that you do not have all prerequisite","\n";
      print "programs. To run SCRAM, you must have:","\n";
      print "\n";
      print "        - GNU make (gmake)","\n";
      print "\n";
      print "Please make sure that this program is present.","\n\n";
      exit (1);
      }
   }

sub versioncheck
   {
   ###############################################################
   # versioncheck(version)                                       #
   ###############################################################
   # modified : Mon May 28 11:27:06 2001 / SFA                   #
   # params   : version (optional)                               #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Check for scram version info.                    #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   my $version;
   &local_verbose("versioncheck");

   if ( @_ )
      {
      $version=shift;
      }
   else
      {
      # -- get version from local area
      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 )
      {
      scrambasics()->spawnversion($version,@ARGV);
      }
   }

sub fullverbosity
   {
   ###############################################################
   # fullverbosity()                                             #
   ###############################################################
   # modified : Fri Oct 11 15:56:29 2002 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Turn on verbose mode for all packages.           #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("fullverbosity");
   print "In verbosity routine...","\n";
   
   require "PackageList.pm";

   foreach $packge (@PackageList)
      {
      print "Verbose mode for ",$packge," switched ".$bold."ON".$normal."\n" ;
      scrambasics()->classverbose($packge,1);
      }
   return;
   }

sub _processcmds
   {
   ###############################################################
   # _processcmds(handlercoderef,refarrayofallowedcommands,      #
   #              refarrayofactualcommands,                      #
   #              arrayofsubroutinestringstocall)                #
   #                                                             #
   ###############################################################
   # modified : Mon May 28 11:27:12 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_processcmds");

   my $optionhandler=shift;
   my $allowed_commands=shift;
   my $cmds=shift;
   my @subs=@_;
   my $found=0;
   my $rv = 0;
   
   # 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
               {
               $rv=&{$substring.$command}(@{$cmds});
               $found=1;
               last;
               }
            }
         }
      }
      }
           
        if ( ! $found )
           {
           &{$substring."error"}(@subs);
           return (1);
           }
   # Return the status of the command subrtn executed:
   return $rv;
   }


sub help_build
   {
   ###############################################################
   # help_build()                                                #
   ###############################################################
   # modified : Mon May 28 11:27:23 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for the scram build command            #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_build");

   print <<ENDTEXT;
Information for building binaries and libraries.      

Subcommands:
   
        scram (b)uild lib/bin

Command is run from the src directory.
   
ENDTEXT
   # Also run "build" dir because this will run "gmake help":
   &build();
   return (0);
   }
  

sub align
   {
   ###############################################################
   # align()                                                     #
   ###############################################################
   # modified : Mon May 28 11:27:27 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("align");
   _localarea()->align();
   }

sub build
   {
   ###############################################################
   # build()                                                     #
   ###############################################################
   # modified : Mon May 28 11:27:34 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Compile project.                                 #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("build");
   
   # is this a based or free release?
   FullEnvInit();
   use BuildSystem::BuildSetup;
   $ENV{MAKETARGETS}=join ' ',@ARGV;
   
   # -- set the runtime environment
   my $toolrt=scrambasics()->toolruntime(_localarea());
   $toolrt->sethash(\%Env);
   
   # -- set up the builder
   my $bs=BuildSystem::BuildSetup->new(toolbox());
   $rv=$bs->BuildSetup($ENV{THISDIR},@ARGV);
   return $rv;
   }

sub buildn
   {
   ###############################################################
   # build()                                                     #
   ###############################################################
   # modified : Mon May 28 11:27:34 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Compile project.                                 #
   #          :                                                  #
   #          : Currently NOT working properly....!              #
   ###############################################################
   &local_verbose("build");   
   use BuildSystem::Build;
   use BuildSystem::BuildSetup;

   # Init the environment:
   FullEnvInit();
   $ENV{MAKETARGETS}=join ' ',@ARGV;
   
   # Set the runtime environment:
   my $toolrt=scrambasics()->toolruntime(_localarea());
   $toolrt->sethash(\%Env);
   
   # Set up the builder:
   my $build = BuildSystem::Build->new(_localarea(),toolbox());
   
   # Invoke a build:
   my $buildreport = $build->build($ENV{THISDIR}, @ARGV);
   
   # Print the info from the build:
   $buildreport->reportBuildStatus();
   }

sub project
   {
   ###############################################################
   # project()                                                   #
   ###############################################################
   # modified : Mon May 28 11:27:38 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Set up a project area.                           #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("project");
   
   my $template;
   my @args=@ARGV;
   my $devareaname="";
   use Cwd;
   my $installarea=cwd();
   my $configdir;
   
   # Check for a template command:
   if ($args[0] =~ /template$/)
      {
      my $templatedir=$ENV{SCRAM_HOME}."/Templates/config";
      print "Copying templates of project configuration files to ","\n";

      # Check if there is a config dir already and set $configdir accordingly:
      if ( -d "$installarea/config")
         {
         $configdir=$installarea."/configTemplates";
         }
      else
         {
         $configdir=$installarea."/config";
         }
      
      # Location:
      print $configdir,"\n";
      # Do the copy:
      system("cp","-r","$templatedir","$configdir");
      # Clean up CVS dirs:
      my @CVSdirs=`find $configdir -name CVS`;
      # 
      foreach my $cvsdir (@CVSdirs)
         {
         chomp($cvsdir);
         system("rm","-rf","$cvsdir");
         }
      print "Done!","\n";
      return;
      }
   
   # process options
   while ( $args[0] =~ "^-" )
      {
      if ( $args[0] =~ /-n/ )
         {
         shift @args;
         $devareaname=shift @args;
         }
      elsif ( $args[0] =~ /-d/ ) #installation area directory 
         {
         shift @args;
         $installarea=$args[0];
         if ( ! -d $installarea )
            {
            ReportError("$installarea does not exist");
            }
         shift @args;
         }
      else
         {
         ReportError("Unknown option $args[0] to project command");
         }
      } 
   
   # -- check what arguments have been passed
   if ( $#args <0 || $#args>3 )
      {
      ReportError("\"scram project help\" for usage info.");
      }
   
   my $area; #somewhere to store the area object when we have it

   if ( $args[0] =~ /:/ )
      {
      # Get the bootstrapfile:
      my $bootstrapfile=shift @args;
      # -- must be a url to bootstrap from
      print "Bootstrapping using ",$bootstrapfile,"\n";
      $area=scrambasics()->project($bootstrapfile, $installarea,
                                   $devareaname);
     
      # Need to set the sitename for the setup process:
      if (defined ($area))
         {
         # Check for a config file argument:
         my $flag=shift @args;
         my $file=shift @args;
         
         # Make sure the extra flag is -f, followed by a valid filename:
         if ( $flag =~ /-f/ )
            {
            # OK, flag is valid. Is there a filename arg given?:
            if ( $file =~ /.*conf$/)
               {
               $ENV{LOCCMSTOOLS}=$file;
               }
            else
               {
               # The file doesn't look like a conf file:
               ReportError("Invalid file given as arg to project command.");
               }
            }

         # We have an area so we can invoke method. First,
         # establish our site name. See if there is an environment
         # setting:
         if ( ! $ENV{'SITENAME'})
            {
            $ENV{'SITENAME'} = $area->sitename();
            }
         $ENV{'PROJECTDIR'} = $area->location();
         }
      else
         {
         ReportError("No project area defined. Cannot continue.");
         }
      
      # Initialize the lookup table:
      use Scram::AutoToolSetup;
      $lookupobject = Scram::AutoToolSetup->new();

      print "Setting up tools in project area","\n";
      
      # Now run the full setup for the area:
      scrambasics()->setuptoolsinarea($area);
      }
   elsif ( $#args >0 )
      { 
      # -- get the release area
      print "Getting release area....","\n";
      my $relarea=scrambasics()->scramprojectdb()->getarea(@args);
      if ( ! defined $relarea )
         {
         ReportError("Unknown project @args");
         }

      # -- we need to spawn the correct scram version to handle it:
      unshift @ARGV, "project";
      print "Checking SCRAM version....","\n";
      versioncheck($relarea->scramversion());
          
      # -- need to create a satellite area:
      print "Creating satellite area....","\n";
      $area=scrambasics()->satellite(@args,$installarea, $devareaname);
      }
   else
      {
      ReportError("\"scram project help\" for usage info.");
      }
   #
   # Now create the directories specified in the interface
   # There should be some better mechanism - TODO
   #
   print "Creating directories....","\n";
   chdir $area->location();
   foreach $key ( keys %ENV )
      {
      if ( $key =~ /^INT/ )
         {
         AddDir::adddir($ENV{$key});
         }
      }
   # Final message 
   print "\n\nInstallation procedure complete.\n";
   print "Installation Located at:\n\n\t\t".$bold.$area->location().$normal."\n\n";
   return(0);
   }


sub scrambasics
   {
   ###############################################################
   # scrambasics()                                               #
   ###############################################################
   # modified : Mon May 28 11:27:44 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("scrambasics");

   require Scram::ScramFunctions;
   if ( ! defined $scramobj )
      {
      environmentinit();
      $scramobj=Scram::ScramFunctions->new();
      $scramobj->arch($ENV{SCRAM_ARCH});
      }
   return $scramobj;
   }

sub url
   {
   ###############################################################
   # url()                                                       #
   ###############################################################
   # modified : Mon May 28 11:27:48 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("url");

   @_=@ARGV;
   localtop();
   environmentinit();
   my @allowed_cmds=qw(get);
   my $rv=_processcmds("_tooloptions", \@allowed_cmds, \@_, ("url"));
   return $rv;
   }

sub url_get
   {
   ###############################################################
   # url_get()                                                   #
   ###############################################################
   # modified : Mon May 28 11:27:52 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("url_get");

   my $url=shift;
   my $area=_localarea();
   
   ($uurl,$file)=scrambasics()->webget($area,$url);
   print "$file\n";
   return (0);
   }

sub help_url
   {
   ###############################################################
   # help_url()                                                  #
   ###############################################################
   # modified : Mon May 28 11:28:06 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for the scram url command.             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_url");

   print <<ENDTEXT;
URL information.
      
Subcommands:
   
        scram url get

ENDTEXT
   return (0);
   }

sub help_url_get
   {
   ###############################################################
   # help_url_get()                                              #
   ###############################################################
   # modified : Mon May 28 11:28:11 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for the scram url get command.         #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_url_get");

   print <<ENDTEXT;
Description:
        Return the location of the local copy of the specified url
Usage :
        scram url get url

ENDTEXT
   return (0);
   }

# ------------ tool command --------------------------------------------
sub tool
   {
   ###############################################################
   # tool()                                                      #
   ###############################################################
   # modified : Mon May 28 11:28:16 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool");

   @_=@ARGV;
   localtop();
   environmentinit();
   my @allowed_cmds=qw(info list default setup tag remove template);
   my $rv=_processcmds("_tooloptions", \@allowed_cmds, \@_, ("tool"));  
   return $rv;
   }

sub tool_error
   {
   ###############################################################
   # tool_error(error_string)                                    #
   ###############################################################
   # modified : Mon May 28 11:28:20 2001 / SFA                   #
   # params   : Error message string.                            #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show an error message for tool command.          #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_error");

   ReportError("Unknown tool subcommand : @_");
   }

sub tool_default
   {
   ###############################################################
   # tool_default()                                              #
   ###############################################################
   # modified : Mon May 28 11:28:24 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_default");

   if ( $#_ != 1 )
      {
      ReportError("\"scram tool default help\" for usage information");
      }
   my $tool=shift; 
   my $version=shift;
   print "Setting default version of $tool to $version\n";
   # -- adjust the toolbox
   toolbox()->setdefault($tool,$version);
   return (0);
   }

sub tool_list
   {
   ###############################################################
   # tool_list()                                                 #
   ###############################################################
   # modified : Mon May 28 11:28:27 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : List the tools defined in toolbox.               #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_list");

   my $area=_localarea();
   my $locationstring="Tool list for location ".$area->location();
   my $length=length($locationstring);

   print "\n",$locationstring,"\n";
   print "+"x $length;
   print "\n";
   print "\n";
   
   foreach $t ( toolbox()->tools() )
      {
      my $vers=join / /, toolbox()->versions($t);
      # How many versions of this tool available?
      # If greater than 1, be verbose:
      my @nversions=toolbox()->versions($t);
      if ($#nversions > 0)
         {
         # Since we choose a particluar compiler, default
         # setting is always the version we've chosen
         printf " %-20s %-10s ",$t,toolbox()->defaultversion($t);
         print "[Versions:";
         foreach my $vr (@nversions)
            {
            print " ",$vr;
            }
         print "]","\n";
         }
      else
         {
         # Only one version:
         printf " %-20s %-10s (default=%s)\n",$t,$vers,toolbox()->defaultversion($t);
         }
      }
   print "\n";
   return (0);
   }

sub tool_info
   {
   ###############################################################
   # tool_info()                                                 #
   ###############################################################
   # modified : Mon May 28 11:28:30 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show info for available tools.                   #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_info");

   my $project=shift;
   my $area=_localarea();
   my $locationstring="Tool info as configured in location ".$area->location();
   my $length=length($locationstring);
   my $rv=0;
   
   print $locationstring,"\n";
   print "+"x $length;
   print "\n";
   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";
               }
            }
         }
      else
         {
         print "Tool $t is not defined for this project area.","\n";
         $rv=1;
         }
      }
   return $rv;
   }

sub tool_tag
   {
   ###############################################################
   # tool_tag()                                                  #
   ###############################################################
   # modified : Mon May 28 11:28:30 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show value of tool tag <tagname>.                #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_tag");

   my $toolname=shift;
   chomp (my $tagname=shift);
   my $area=_localarea();
   my @tools=toolbox()->gettool($toolname,@_);

   foreach $t ( @tools )
      {
      # If we have a hash for this tool, proceed:
      if ( defined $t )
         {
         # Get the features:
         @features=$t->features();
         # If a tag name was supplied then try to get the value,
         # otherwise just display all tag+value pairs defined:
         if ( defined $tagname )
            {
            foreach $feature (@features)
               {
               print $t->getfeature($feature),"\n" if ($feature eq $tagname);
               }
            }
         else
            {
            # Loop over features:
            foreach $ft ( @features )
               {
               @vals=$t->getfeature($ft);
               foreach $v ( @vals )
                  {
                  print $ft,"\n";
                  }
               }
            }
         }
      else
         {
         return (1);
         }
      }
   }

sub tool_setup
   {
   ###############################################################
   # tool_setup()                                                #
   ###############################################################
   # modified : Mon May 28 11:28:35 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_setup");
   print "Please use scram setup command\n";
   return (1);
   }

sub tool_template
   {
   ###############################################################
   # tool_template                                               #
   ###############################################################
   # modified : Fri Oct 11 16:36:59 2002 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Output a simple template for a tool file.        #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_template");
   # The user can specify a template type (a compiler or regular tool):
   my $templatetype=shift;
   my $templatedir=$ENV{SCRAM_HOME}."/Templates/toolbox";
   # Check for a "compiler" or "basic" tag:
   if ($templatetype =~ /compiler/)
      {
      my $tdir=$templatedir."/CompilerTools/CXX";
      # Copy the template from the SCRAM template dir:
      print "Installing compiler templates in current directory-\n";
      print "destination directory will be CompilerTemplates: ","\n";
      system("cp","-r",$tdir,"CompilerTemplates");
      # Clean up the directory (remove CVS directory):
      system("rm","-rf","CompilerTemplates/CVS");
      print "Done!","\n";
      }
   elsif ($templatetype =~ /basic/)
      {
      print "Installing basic tool template in current directory: ","\n";
      system("cp",$templatedir."/basic_template",".");
      print "Done!","\n";
      }
   else
      {
      ReportError("Invalid template type. Please choose \"compiler\" or \"basic\"");
      print "\n";
      }
   return;
   }

sub tool_remove
   {
   ###############################################################
   # tool_remove()                                               #
   ###############################################################
   # modified : Fri Apr 26 11:18:35 2002 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Remove the tool from the project area.           #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("tool_remove");
   my $tool_name = shift;
   # Translate to lower case:
   $tool_name =~ tr[A-Z][a-z];

   my $here=_localarea()->location();
   my @tools_hash=toolbox()->gettool($tool_name,@_);
   my $adminfile=$here."/.SCRAM/".$ENV{SCRAM_ARCH}."/admin";
   my $newadminfile=$here."/.SCRAM/".$ENV{SCRAM_ARCH}."/admin.new";
   my $foundtool=0;

   $lncount=0;
   
   if (defined $tools_hash[0]) # Check that the tool is defined in this area
      {
      my $tool_version=$tools_hash[0]->version();
      print "\n";
      my $toolstring=$tool_name."_".$tool_version;
      print "Tool exists in project area ",$here,
      "\n...removing ",$toolstring," from admin file:\n\n";
      open (ADMIN, "<".$adminfile);
      open (NEWADMIN, ">".$newadminfile);

      while (<ADMIN>)
         {
         # First we look for a line matching the tool name:
         if ($_ =~ /$tool_name/)
            {
            $foundtool=1;
            }
         # Once we have found the tool, check the next two lines for
         # matching version. End after the two version lines have been read:
         elsif (($foundtool == 1) && ($_ =~ /$tool_version/) && ($lncount < 2))
            {
            $lncount++;
            next;
            }
         else
            {
            # We write this to our new admin file:
            print NEWADMIN $_;
            }
         }
      close(ADMIN);
      close(NEWADMIN);
      
      # Rename the new admin file:
      rename($newadminfile, $adminfile) || ReportError("Unable to rename admin file.");
      # Create variables pointing to the files we're going to remove:
      my $tooldesc=$here."/.SCRAM/ToolFiles/".$toolstring;
      my $tooldat=$here."/.SCRAM/".$ENV{SCRAM_ARCH}."/".$toolstring.".dat";
      
      print "Removing ".$tooldesc."\n";
      # Remove the tool description:
      unlink($tooldesc) || ReportError("Unable to remove tool description file.");      
      print "Removing ".$tooldat."\n";
      # Remove the dat file:
      unlink($tooldat) || ReportError("Unable to remove ".$toolstring.".dat file");      
      print "..done.","\n";
      }
   else
      {
      ReportError("Tool \"".$tool_name."\" is not defined in this project area!\n");      
      }
   return (0);
   }

sub _tooloptions
   {
   ###############################################################
   # _tooloptions(error_string)                                  #
   ###############################################################
   # modified : Mon May 28 11:28:38 2001 / SFA                   #
   # params   : Error message string.                            #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_tooloptions");
   ReportError("No Options defined for tool subcommand");
   }

sub help_tool
   {
   ###############################################################
   # help_tool()                                                 #
   ###############################################################
   # modified : Mon May 28 11:28:41 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for tool command.                      #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_tool");

   print <<ENDTEXT;
Manage the tools in the scram area that define the areas environment.
Tool subcommands:

        list
        info <tool_name>
        default <tool_name> <tool_version>
        tag <tool_name> <tag_name>
        remove <tool_name>
        template <compiler> (or <basic>)

ENDTEXT
   return (0);
   }

sub help_tool_info
   {
   ###############################################################
   # help_tool_info()                                            #
   ###############################################################
   # modified : Mon May 28 11:28:45 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for tool info command.                 #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
   return (0);
   }

sub help_tool_list
   {
   ###############################################################
   # help_tool_list()                                            #
   ###############################################################
   # modified : Mon May 28 11:28:50 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for tool info command.                 #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_tool_list");

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

ENDTEXT
   return (0);
   }

sub help_tool_default
   {
   ###############################################################
   # help_tool_default()                                         #
   ###############################################################
   # modified : Mon May 28 11:28:54 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_tool_default");

   print <<ENDTEXT;
Description:
        Change the default version of a tool to be used in the area
Usage :
        scram tool default tool_name tool_version

ENDTEXT
   return (0);
   }


sub help_tool_tag
   {
   ###############################################################
   # help_tool_tag()                                             #
   ###############################################################
   # modified : Mon May 28 11:28:45 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for tool tag command.                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_tool_tag");

   print <<ENDTEXT;
Description:
        Print out the value of a variable (tag) for the specified tool in the
        current area configuration. If no tag name is given, then all known tag
        names are printed to STDOUT.
Usage :
        scram tool tag tool_name [tag_name]

ENDTEXT
   return (0);
   }

sub help_tool_remove
   {
   ###############################################################
   # help_tool_remove()                                          #
   ###############################################################
   # modified :                                                  #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for tool remove command.               #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_tool_remove");

   print <<ENDTEXT;
Description:
        Remove the specified tool from the current project area
Usage :
        scram tool remove tool_name
           
ENDTEXT
   return (0);
   }

sub help_tool_template
   {
   ###############################################################
   # help_tool_template()                                        #
   ###############################################################
   # modified :                                                  #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for tool template command.             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_tool_template");

   print <<ENDTEXT;
Description:
        Create a template tool description file.
        The template will be created in the current directory.
Usage :
        scram tool template <type>

        where <type> can be either "compiler" or "basic" depending on whether the
        template is for a compiler or for a basic tool.
           
ENDTEXT
   return (0);
   }


# ----------------------------------------------------------------------
sub _requirements
   {
   ###############################################################
   # _requirements()                                             #
   ###############################################################
   # modified : Mon May 28 11:28:59 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_requirements");

   if ( ! defined $reqsobj )
      {
      localtop();
      my $area=_localarea();
      scrambasics()->arearequirements($area);
      }
   return $reqsobj;
   }

sub _allprojectinitsearcher
   {
   ###############################################################
   # _allprojectinitsearcher()                                   #
   ###############################################################
   # modified : Mon May 28 11:29:03 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_allprojectinitsearcher");

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

sub _projsearcher
   {
   ###############################################################
   # _projsearcher()                                             #
   ###############################################################
   # modified : Mon May 28 11:29:05 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_projsearcher");

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

sub _scramprojdb
   {
   ###############################################################
   # _scramprodb()                                               #
   ###############################################################
   # modified : Mon May 28 11:29:10 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_scramprojdb");

   return scrambasics()->scramprojectdb();      
   }

sub runtime
   {
   ###############################################################
   # runtime()                                                   #
   ###############################################################
   # modified : Mon May 28 11:29:13 2001 / SFA                   #
   # params   : shell type (-sh for Bourne, -csh for C/tcsh)     #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Get/set runtime environment.                     #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("runtime");

   my $shell;
   require Runtime;

   # Exit unless we have some args:
   if ($ARGV[0] !~ "^-" ) {ReportError("Insufficient arguments. A shell must be given.\n")};
   
   # 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;
         }
      ReportError("Unknown Option $ARGV[0]\n");
      } 

   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 "" )
            {
            ReportError("Unable to find a file (or BuildFile) relating to ".
               $arg."\n");
            }
         }
      $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
            undef $ENV{$variable};
            }
         }

      # -- get the tool runtime environments
      my $toolrt=scrambasics()->toolruntime(_localarea());
      $toolrt->sethash(\%EnvRuntime);

      # -- create new SCRAMRT history vars.
      foreach $variable ( keys %EnvRuntime )
         {
         printoutenv($shell,"SCRAMRT_$variable",$EnvRuntime{$variable});
         }
        
      # TODO -- this stuff should dissappear with compiler description docs
      # 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
      # TODO -- we can use the runtime class method once we have removed
      # this stuff above
      foreach $variable ( keys %EnvRuntime )
         {
         printoutenv($shell,$variable,$EnvRuntime{$variable});
         }
      
      # Export a copy of LOCALTOP, renamed as a new variable:
      printoutenv($shell,"LOCALRT",$ENV{LOCALTOP});
      }
   return (0);
   }

# Support rt for runtime

sub _testfile
   {
   ###############################################################
   # _testfile()                                                 #
   ###############################################################
   # modified : Mon May 28 11:29:21 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_testfile");

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

sub _printvardoc
   {
   ###############################################################
   # _printvardoc()                                              #
   ###############################################################
   # modified : Mon May 28 11:29:25 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_printvardoc");

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

sub printoutenv
   {
   ###############################################################
   # printoutenv()                                               #
   ###############################################################
   # modified : Mon May 28 11:29:28 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
   {
   ###############################################################
   # addpath()                                                   #
   ###############################################################
   # modified : Mon May 28 11:29:32 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
   {
   ###############################################################
   # addvar()                                                    #
   ###############################################################
   # modified : Mon May 28 11:29:35 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
   {
   ###############################################################
   # FullEnvInit()                                               #
   ###############################################################
   # modified : Mon May 28 11:29:38 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("FullEnvInit");

   environmentinit();
   localtop();
   LoadEnvFile();
   }

sub environmentinit
   {
   ###############################################################
   # environmentinit()                                           #
   ###############################################################
   # modified : Mon May 28 11:29:41 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Set the environment variables needed             #
   #          : by scram (arch, home etc.)                       #
   #          :                                                  #
   ###############################################################
   &local_verbose("environmentinit");

   use Utilities::setarchitecture;

   my $name;
   my $value;

   $ENV{LatestBuildFile}=""; # stop recursive behaviour in make

   if ( ! defined $ENV{SCRAM_ARCH} )
      {
      setarchitecture::setarch();
      }
   $ENV{INTwork}="tmp/$ENV{SCRAM_ARCH}";
   $ENV{INTsrc}="src";
   $ENV{INTlog}="logs";
   $ENV{INTlib}="lib/".$ENV{SCRAM_ARCH};

   ($ENV{SCRAM_BASEDIR}=$ENV{SCRAM_HOME}) =~ s/(.*)\/.*/$1/;
   if ( ! ( exists $ENV{SCRAM_CONFIG} ) )
      {
      $ENV{SCRAM_CONFIG}="$ENV{SCRAM_HOME}/configuration";
      }
   $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
   {
   ###############################################################
   # _localarea()                                                #
   ###############################################################
   # modified : Mon May 28 11:29:47 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_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}->archname(scrambasics()->arch());
            }
         }
      else
         {
         $self->{localarea}->bootstrapfromlocation($ENV{LOCALTOP});
         }
      }
   return $self->{localarea};
   }

sub localtop_find
   {
   ###############################################################
   # localtop_find()                                             #
   ###############################################################
   # modified : Mon May 28 11:29:50 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("localtop_find");

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

sub localtop
   {
   ###############################################################
   # localtop()                                                  #
   ###############################################################
   # modified : Mon May 28 11:29:54 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Find the top directory of local release area.    #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("localtop");

   localtop_find();

   # localtop_find() should set the variable LOCALTOP if we're
   # in a project area. This behaviour should take precedence.
   if ( defined ($ENV{LOCALTOP}))
      {
      # We're in a project area. Do whatever is necessary:
      ($ENV{THISDIR}=cwd) =~ s/^\Q$ENV{LOCALTOP}\L//;
      }
   else
      {
      # Not in a project area. See if we've used "setroot" to set
      # LOCALRT. If so, use that as LOCALTOP, otherwise say goodbye:
      if ( defined ($ENV{'LOCALRT'}))
         {
         $ENV{LOCALTOP} = $ENV{'LOCALRT'};
         ($ENV{THISDIR}=cwd) =~ s/^\Q$ENV{LOCALTOP}\L//;
         }
      else
         {
         ReportError("Unable to locate the top of local release. Exitting.\n");
         }
      }
   $ENV{THISDIR} =~ s/^\///;
   }

sub LoadEnvFile
   {
   ###############################################################
   # LoadEnvFile()                                               #
   ###############################################################
   # modified : Mon May 28 11:29:58 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("LoadEnvFile");

   _localarea()->copyenv(\%ENV);
   }

sub env
   {
   ###############################################################
   # env()                                                       #
   ###############################################################
   # modified : Mon May 28 11:30:00 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("env");

   print "Sorry - Not yet\n";
   }

sub devint
   {
   ###############################################################
   # devint()                                                    #
   ###############################################################
   # modified : Mon May 28 11:30:03 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("devint");

   my $class=shift @ARGV;
   scrambasics()->scramobjectinterface($class);
   }

sub devtest
   {
   ###############################################################
   # devtest()                                                   #
   ###############################################################
   # modified : Mon May 28 11:30:06 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("devtest");

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

   my $tester;
   my $path;

   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
   {
   ###############################################################
   # install()                                                   #
   ###############################################################
   # modified : Mon May 28 11:30:09 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Install a project. Updates project.lookup        #
   #          : files found in /scramdb.                         #
   #          :                                                  #
   ###############################################################
   &local_verbose("install");

   localtop();
   
   scrambasics()->addareatoDB(_localarea(),@ARGV);
   _localarea()->align();
   return (0);
   }

sub help_install()
   {
   ###############################################################
   # help_install()                                              #
   ###############################################################
   # modified : Mon May 28 11:30:12 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for the install command.               #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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]]

project_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
   return (0);
   }

sub helpheader ($label)
   {
   ###############################################################
   # helpheader(label)                                           #
   ###############################################################
   # modified : Mon May 28 11:30:17 2001 / SFA                   #
   # params   : label for the header.                            #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Prints a header for the help command of          #
   #          : scram command "label".                           #
   #          :                                                  #
   ###############################################################
   &local_verbose("helpheader");

   my $label=shift;
   
   print <<ENDTEXT;
        
*************************************************************************
       SCRAM HELP --------- $label 
*************************************************************************

ENDTEXT
   return (0);
   }

sub version
   {
   ###############################################################
   # version()                                                   #
   ###############################################################
   # modified : Mon May 28 11:30:24 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Get the version of scram being used.             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
         require Utilities::CVSmodule;
         $cvsobject=Utilities::CVSmodule->new();
         # This will need to be changed to make it more generic:
         $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 we've finished
         $cvsobject=undef;
         print "\n";
         }
      }
   return (0);
   }

sub list
   {
   ###############################################################
   # list()                                                      #
   ###############################################################
   # modified : Mon May 28 11:30:28 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : List available projects.                         #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("list");
   &environmentinit;

   my $linebold = "$bold"."$line"."$normal";
   my $pjname = "Project Name";
   my $pjversion = "Project Version";
   my $pjlocation = "Project Location";
   my $headstring = sprintf("| %-12s  | %-24s | %-33s |",$pjname,$pjversion,$pjlocation);

   if ( ! -f $ENV{SCRAM_LOOKUPDB} )
      {
      ReportError
         ("\nNo installation database available - perhaps no projects\nhave been installed locally?\n");
      }
   print "\n","Listing installed projects....","\n\n";
   print $linebold,"\n";
   print $headstring."\n";
   print $linebold,"\n\n";
   listDB(@ARGV);
   print "\n";
   return (0);
   }

sub listcompact
   {
   ###############################################################
   # listcompact()                                               #
   ###############################################################
   # modified : Fri Aug 30 14:21:52 2002 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : List available projects in compact and non-fancy #
   #          : format. Mainly for use in scripts.               #
   #          :                                                  #
   ###############################################################
   &local_verbose("list");
   &environmentinit;

   if ( ! -f $ENV{SCRAM_LOOKUPDB} )
      {
      ReportError
         ("\nNo installation database available - perhaps no projects\nhave been installed locally?\n");
      }

   listDB('compact',@ARGV);

   return (0);
   }

sub remove
   {
   ###############################################################
   # remove(project)                                             #
   ###############################################################
   # modified : Mon May 28 11:30:31 2001 / SFA                   #
   # params   : project name, project version                    #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Remove the named project from the project.lookup #
   #          : file (scram database).                           #
   #          :                                                  #
   ###############################################################
   &local_verbose("remove");

   my $projectname=shift @ARGV;
   my $projectversion=shift @ARGV;

   # Check there were sufficient args:
   if ($projectname eq "" || $projectversion eq "")
      {
      ReportError("\"scram remove help\" for usage info.");
      }
   else
      { 
      scrambasics()->removeareafromDB($projectname,$projectversion);
      }
   return (0);
   }

sub db
   {
   ###############################################################
   # db()                                                        #
   ###############################################################
   # modified : Mon May 28 11:30:35 2001 / SFA                   #
   # params   : "link", "unlink" or "show(links )"               #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show project info stored in scramdb. Link/unlink #
   #          : project database files, or show linked databases.#
   #          :                                                  #
   ###############################################################
   &local_verbose("db");

   my $subcmd=shift @ARGV;
   my $db=shift @ARGV;
   
   # Make sure we have an argument, or tell the user:
   if ( ! defined($subcmd))
      {
      &help_db;
      print "\n";
      exit (1);
      }

   # If there is a file arg, test it to make sure it exists:
   if ( $subcmd eq 'link' || 
        $subcmd eq 'unlink' ) 
      {
      if ( -f $db )
         {
         print "Found DB file....",$db,"\n";
         }
      else
         {
         ReportError("Could not find a DB ".$db."\n");
         }
      }
   &environmentinit;

   # First, check for a database area:
   if ( ! -f $ENV{SCRAM_LOOKUPDB} )
      {
      ReportError
         ("\nNo installation database available - perhaps no projects\nhave been installed locally?\n");
      }
   print "\n","Current scram database: ";
   print $bold."$ENV{SCRAM_LOOKUPDB}".$normal."\n\n";
   
   switch :
      {
      if ( $subcmd eq 'link' )
         {
         scrambasics()->scramprojectdb()->link($db); 
         print "\n","Linked ",$db," to current scram database.","\n\n";
         last switch;
         }
      if ( $subcmd eq 'unlink' )
         {
         scrambasics()->scramprojectdb()->unlink($db);
         print "\n","Unlinked ",$db," from current scram database.","\n\n";
         last switch;
         }
      if ( $subcmd eq 'showlinks'
           || $subcmd eq 'showlink'
           || $subcmd eq 'show')
         {
         my @links=scrambasics()->scramprojectdb()->listlinks();
         # Are there any links defined?:
         if ( defined($links[0]) )
            {
            print "\n","The following scram databases are linked to the current scram database: ","\n\n";
            foreach $link ( @links )
               {
               print "   ".$link."\n";
               }
            print "\n";
            }
         else
            {
            print "There are no databases linked.","\n\n";
            }
         last switch;
         }
      } # end switch
   return (0);
   }

sub listDB
   {
   ###############################################################
   # listDB()                                                    #
   ###############################################################
   # modified : Mon May 28 11:30:39 2001 / SFA                   #
   # params   : Project name                                     #
   #          :                                                  #
   # function : List projects. Only those projects that were     #
   #          : installed on the user's current OS will be       #
   #          : displayed (slight anomaly here: some projects    #
   #          : were installed on SunOS_5.6 so won't appear if   #
   #          : the user's current platform is SunOS_5.7...).    #   
   #          :                                                  #
   ###############################################################
   &local_verbose("listDB");

   my $project="";
   my $projectexists=0;
   my @missingareas;
   my $localoption;
   
   if ( @_ )
      {
      $localoption=shift;
      if ($localoption ne 'compact' )
         {
         $project=$localoption;
         }
      else
         {
         $project=shift;
         }
      }

   my @prs=scrambasics()->scramprojectdb()->listall();

   # Check to see if there are any projects:
   if ( ! defined @prs )
      {
      print "\t\t>>>> No locally installed projects! <<<<","\n";
      return (1);
      }
   
   # Iterate over the project list:
   foreach $pr ( @prs )
      {
      my $url='NULL';

      if ( $project  eq "" || $project eq $$pr[0] )
         {
         # Check that the area exists (i.e. check that a configarea object
         # is returned before attempting to test its' location:
         my $possiblearea=scrambasics()->scramprojectdb()->getarea($$pr[0],$$pr[1]);
         
         if ( defined ($possiblearea))
            {
            $url=$possiblearea->location();
            if ($project eq $$pr[0]) {$projectexists=1};
            }

         # Check that the path to the project area is readable:
         if ( -d $url )
            {
            # Check that there exists an installation for
            # our current architecture. Check for a bin and
            # a lib directory:
            if ( -d "$url/bin/$ENV{SCRAM_ARCH}" || -d "$url/lib/$ENV{SCRAM_ARCH}" )
               {
               # For compact printing, put everything on one line:
               if ($localoption eq 'compact')
                  {
                  printf "%-15s %-25s %-50s\n",$$pr[0],$$pr[1],$url;
                  }
               else
                  # Print full, as usual:
                  {
                  # Stagger the printed lines to allow easier
                  # copying using the mouse:
                  printf "  %-15s %-25s  \n",$$pr[0],$$pr[1];
                  printf "%45s%-30s\n","--> ",$bold.$url.$normal;
                  }
               }
            }
         else
            {
            # We have an area that is unreadable. Push an entry onto the array:
            push @missingareas, sprintf ">>  Project area MISSING:   %-10s %-20s  \n",$$pr[0],$$pr[1];  
            }
         }
      }

   if ( ! $projectexists && $project ne "" )
      {
      print "\t\t>>>> No locally installed $project projects! <<<<","\n";
      return(1);
      }

   if ($localoption ne 'compact')
      {
      print "\n\n","Projects available for platform >> ".$bold."$ENV{SCRAM_ARCH}".$normal." <<\n";
      print "\n";
   
      # Print out a list of areas that are missing:
      if ( @missingareas )
         {
         ReportError(@missingareas);
         }
      }
   
   # Otherwise exit nicely:
   return(0);
   }

sub arch
   {
   ###############################################################
   # arch()                                                      #
   ###############################################################
   # modified : Mon May 28 11:30:41 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show the information about current architecture. #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("arch");
   &environmentinit();

   print "$ENV{SCRAM_ARCH}\n";
   return (0);
   }


#
# Setup a new tool
#
sub setup
   {
   ###############################################################
   # setup                                                       #
   ###############################################################
   # modified : Tue May 21 12:40:24 2002 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : setup tool box or a tool.                        #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   my $interactive=0;
   my $toolsfile;
   
   # process options
   while ( $ARGV[0] =~ "^-" )
      {
      if ( $ARGV[0] =~ /-i/ )
         {
         shift @ARGV;
         $interactive=1;
         print "Running interactive setup....","\n";
         }
      elsif ( $ARGV[0] =~ /-f/ )
         {
         shift @ARGV;
         $toolsfile=$ARGV[0];
         if ($toolsfile =~ /\.conf$/ || -d $toolsfile) # File must end in ".conf" or be a dir...
            {
            # Set the location of the tools file:
            $ENV{LOCCMSTOOLS}=$toolsfile;
            }
         else
            {
            print "Expecting a tools file filename ( \"-f\" flag) but none given....","\n";
            print "Hint: the filename MUST end with \".conf\"","\n\n";
            }
         shift @ARGV;
         }
      else
         {
         ReportError("Unknown option $ARGV[0] to setup command");
         }
      }
   
   localtop();
   
   my $area=_localarea();
   # We have a local area so we can invoke
   # method to get the sitename.
   # See if there is an environment setting:
   if ( ! $ENV{'SITENAME'})
      {
      $ENV{'SITENAME'} = $area->sitename();
      }
   $ENV{'PROJECTDIR'} = $area->location();
   
   my $toolname=shift @ARGV;
   my $insert=0;
   
   toolbox()->interactive($interactive);

   # Initialize the lookup table:
   use Scram::AutoToolSetup;
   $lookupobject = Scram::AutoToolSetup->new();
   
   # If no toolname specified then its a full setup
   if ( $toolname eq "" )
      {
      # -- add architecture specific directories
      use Utilities::AddDir;
      AddDir::adddir($ENV{'PROJECTDIR'}."/lib/$ENV{SCRAM_ARCH}");
      AddDir::adddir($ENV{'PROJECTDIR'}."/bin/$ENV{SCRAM_ARCH}");       
      # -- check the releasetop area
      # if the releasetop has the files copy them
      my $releaseobj=_releasearea();
      if ( $releaseobj->copysetup($ENV{LOCALTOP}) )
         {
         print "Doing Full Setup\n";
         # Run the full setup for the area:
         scrambasics()->setuptoolsinarea($area);
         }
      }
   else
      {
      print "Running setup for tool ",$toolname,"...","\n";
      scrambasics()->setuptoolsinarea($area, $toolname,@ARGV);
      }
   return (0);
   }

sub setroot
   {
   ###############################################################
   # setroot                                                     #
   ###############################################################
   # modified : Wed Nov  7 16:22:25 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("setroot");
   my $shell = shift @ARGV;

   # Check the shell argument...this must be supplied:
   if ($shell =~ "^-" )
      {
      # Remove the hyphen:
      $shell =~ s/-//;
      if ($shell ne "sh" && $shell ne "csh") {ReportError("No shell given! Exitting.");}
      }
   else
      {
      ReportError("No shell given! Exitting.");
      }
   
   my $projectname=shift @ARGV;
   my $projectversion=shift @ARGV;

   # Check there were sufficient args:
   if ($projectname eq "" || $projectversion eq "")
      {
      ReportError("\"scram setroot help\" for usage info.");
      }
   else
      {
      # And on we go. Let's find a release area for this project/version:
      my $releasearea = scrambasics()->scramprojectdb()->getarea($projectname,$projectversion);
      ReportError("No release area!!") if ( ! defined ($releasearea));

      # The info we need is stored in a hash and can be accessed using the key ENV.
      # If LOCALTOP is not defined, look for RELEASETOP:
      if ( ${${$releasearea}{'ENV'}}{'LOCALTOP'} eq '' )
         {
         if ( ${${$releasearea}{'ENV'}}{'RELEASETOP'} ne '' )
            {
            printoutenv($shell,"LOCALRT",${${$releasearea}{'ENV'}}{'RELEASETOP'});
            }
         }
      else
         # LOCALTOP is set so we can use it.
         # Set LOCALRT to LOCALTOP and return:
         {
         printoutenv($shell,"LOCALRT",${${$releasearea}{'ENV'}}{'LOCALTOP'});
         } 
      } 
   return (0);
   }
   

sub _releasearea
   {
   ###############################################################
   # _releasearea()                                              #
   ###############################################################
   # modified : Mon May 28 11:30:50 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("_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 local area
sub toolbox
   {
   ###############################################################
   # toolbox()                                                   #
   ###############################################################
   # modified : Mon May 28 11:30:53 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("toolbox");

   if ( ! defined $toolbox )
      {
      localtop();
      my $area=_localarea();
      $toolbox=scrambasics()->areatoolbox($area);
      }
   return $toolbox;
   }


sub local_verbose
   {
   ###############################################################
   # local_verbose                                               #
   ###############################################################
   # modified : Mon Jan 21 12:38:02 2002 / SFA                   #
   # params   : Only debug env variable (switch)                 #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Enable verbose mode for package "main" (i.e.     #
   #          : this wrapped script)                             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   my $subroutine=shift;

   if ($ENV{'SCRAMDEBUG'})
      {
      print "-------- [verbose mode]:  subname >> ",$subroutine,"\n";
      }
   }

sub help_db
   {
   ###############################################################
   # help_db()                                                   #
   ###############################################################
   # modified : Mon May 28 11:30:56 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram db command.                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
   return (0);
   }

sub help_setup
   {
   ###############################################################
   # help_setup()                                                #
   ###############################################################
   # modified : Mon May 28 11:31:02 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram setup command.               #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_setup");

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

Usage:

        $bold scram setup [-i] [-f cmstools.conf] $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.

The -f option allows the user to supply a valid path to a cmstools file (the filename
MUST end in ".conf")
   
ENDTEXT
   return (0);
   }

sub help_list
   {
   ###############################################################
   # help_list()                                                 #
   ###############################################################
   # modified : Mon May 28 11:31:09 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram list command.                #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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 [ProjectName]

ENDTEXT
   return (0);
   }

sub help_listcompact
   {
   ###############################################################
   # help_listcompact()                                          #
   ###############################################################
   # modified : Mon May 28 11:31:09 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram listcompact command.         #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_list");

   print <<ENDTEXT;
List the available projects and versions installed in the local SCRAM database
(see scram install help) but without fancy formatting or header strings.

Usage:

        $bold scram listcompact $normal [ProjectName]

The project name, version and installation directory are printed on STDOUT, separated
by spaces for use in scripts.
   
ENDTEXT
   return (0);
   }


sub help_remove
   {
   ###############################################################
   # help_remove()                                               #
   ###############################################################
   # modified : Mon May 28 11:31:12 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram remove command.              #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_remove");

   print <<ENDTEXT;
Remove a project entry from scram database file (\"project.lookup\").

Usage:

        $bold scram remove $normal [ProjectName] [Version]

ENDTEXT
   return (0);
   }

sub help_project
   {
   ###############################################################
   # help_project()                                              #
   ###############################################################
   # modified : Mon May 28 11:31:16 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram project command.             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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] [-f cmstools.conf] 

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 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 accessible file system
                        e.g.

                           file:~/myprojects/projecta/config/BootStrapFile

                              
             Use the "-f" flag followed by a valid filename (which MUST end in ".conf") to
             allow auto setup to proceed without reading files from a repository (standalone mode). 

                
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.

Some project template files can be obtained using the command:

   $bold scram project template$normal

The templates will be copied to a directory called "config" in the current directory.

ENDTEXT
   return (0);
   }

sub help_version
   {
   ###############################################################
   # help_version()                                              #
   ###############################################################
   # modified : Mon May 28 11:31:23 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram version command.             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_version");

   print <<ENDTEXT;
With no $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
   return (0);
   }

sub help_arch
   {
   ###############################################################
   # help_arch()                                                 #
   ###############################################################
   # modified : Mon May 28 11:31:33 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram arch command.                #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_arch");

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

Usage:
        $bold   scram arch $normal
ENDTEXT
   return (0);
   }

sub help_runtime
   {
   ###############################################################
   # help_runtime()                                              #
   ###############################################################
   # modified : Mon May 28 11:31:37 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function : Show help for scram runtime command.             #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("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
   return (0);
   }


sub help_setroot
   {
   ###############################################################
   # help_setroot                                                #
   ###############################################################
   # modified : Wed Nov  7 16:23:32 2001 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   #          :                                                  #
   #          :                                                  #
   ###############################################################
   &local_verbose("help_setroot");

   print <<ENDTEXT;
Set a SCRAM-aware variable which points to a particular project area. This
permits the setting of the runtime environment outside of the project area.

Usage:
        $bold scram setroot [-sh|-csh] [ProjectName] [Version] $normal

To set the environment:

        $bold eval `scram setroot [-sh|-csh] [ProjectName] [Version]` $normal

ENDTEXT
   return (0);
   }
Revision:	1.65
Committed:	Mon Nov 18 14:49:56 2002 UTC (22 years, 6 months ago) by sashby
Branch:	MAIN
CVS Tags:	V0_19_7
Branch point for:	SCRAM_V1_BRANCH
Changes since 1.64:	+11 -3 lines
Log Message:	* empty log message *