src/BuildSystem/ToolManager.pm

#____________________________________________________________________ 
# File: ToolManager.pm
#____________________________________________________________________ 
#  
# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
# Update: 2003-11-12 15:04:16+0100
# Revision: $Id: ToolManager.pm,v 1.19.2.2 2008/02/19 15:06:03 muzaffar Exp $ 
#
# Copyright: 2003 (C) Shaun Ashby
#
#--------------------------------------------------------------------
package BuildSystem::ToolManager;
require 5.004;

use Exporter;
use BuildSystem::ToolCache;
use BuildSystem::ToolParser;
use Utilities::AddDir;
use Utilities::Verbose;
use SCRAM::MsgLog;

@ISA=qw(BuildSystem::ToolCache Utilities::Verbose);
@EXPORT_OK=qw( );
#

sub new
   {
   my $proto=shift;
   my $class=ref($proto) || $proto;
   my $self=$class->SUPER::new();    # Inherit from ToolCache
   bless $self,$class;
   $self->init (shift);
   return $self;
   }

sub init ()
   {
   my $self=shift;
   my $projectarea=shift;
   $self->{topdir}=$projectarea->location();
   $self->{configdir}=$self->{topdir}."/".$projectarea->configurationdir();
   $self->{archstore}=$projectarea->archdir();
   $self->{toolcache}=$self->{configdir}."/toolbox/".$projectarea->arch()."/tools";
   $self->name($projectarea->toolcachename());
   $self->dirty();
   }
  
sub interactive()
   {
   my $self=shift;
   # Interactive mode on/off:
   @_ ? $self->{interactive} = shift
      : ((defined $self->{interactive}) ? $self->{interactive} : 0);
   }

sub setupalltools()
   {
   my $self = shift;
   my @selected=();
   my $tooldir=$self->{toolcache}."/selected";
   foreach my $tool (@{&getfileslist($tooldir)})
      {
      if ($tool=~/^(.+)\.xml$/) {push @selected,$1;}
      }
   foreach my $tool (@selected){$self->coresetup("${tooldir}/${tool}.xml");}
   scramlogmsg("\n");
   }

sub coresetup()
   {
   my $self=shift;
   my ($toolfile) = @_;
   
   my $toolparser = BuildSystem::ToolParser->new();
   $toolparser->filehead('<?xml version="1.0" encoding="UTF-8" standalone="yes"?><doc type="BuildSystem::ToolDoc" version="1.0">');
   $toolparser->filetail('</doc>');
   $toolparser->parse($toolfile);
   my $toolname = $toolparser->toolname();
   my $toolversion = $toolparser->toolversion();
   scramlogmsg("\n",$::bold."Setting up ",$toolname," version ",$toolversion,":  ".$::normal,"\n");
   
   # Next, set up the tool:
   my $store = $toolparser->processrawtool($self->interactive());

   # Check to see if this tool is a compiler. If so, store it.
   # Also store the language that this compiler supprots, and a
   # compiler name (e.g. gcc323) which, in conjunction with a stem
   # architecture name like slc3_ia32_, can be used to build a complete arch string:
   if ($store->scram_compiler() == 1)
      {
      my @supported_language = $store->flags("SCRAM_LANGUAGE_TYPE");
      my @compilername = $store->flags("SCRAM_COMPILER_NAME");
      $self->scram_compiler($supported_language[0],$toolname,$compilername[0]);
      }
   
   # Store the ToolData object in the cache:   
   $self->storeincache($toolname,$store);
   my $srcfile=Utilities::AddDir::fixpath($toolfile);
   my $desfile=Utilities::AddDir::fixpath($self->{toolcache}."/selected/${toolname}.xml");
   use File::Copy;
   if ($srcfile ne $desfile)
      {
      use File::Copy;
      my $desfile1=Utilities::AddDir::fixpath($self->{toolcache}."/available/${toolname}.xml");
      if ($srcfile ne $desfile1)
         {
         copy($srcfile,$desfile1);
         }
      symlink("../available/${toolname}.xml",$desfile); 
      }
   return $self;
   }

sub setupself()
   {
   my $self=shift;
   # Process the file "Self" in local config directory. This is used to
   # set all the paths/runtime settings for this project:
   my $filename=$self->{configdir}."/Self.xml";

   if ( -f $filename )
      {
      scramlogmsg("\n",$::bold."Setting up SELF:".$::normal,"\n");
      # Self file exists so process it:
      $selfparser = BuildSystem::ToolParser->new();
      $selfparser->filehead ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?><doc type="BuildSystem::ToolDoc" version="1.0">');
      $selfparser->filehead ('</doc>');
      $selfparser->parse($filename);

      # Next, set up the tool:
      $store = $selfparser->processrawtool($self->interactive());

      # If we are in a developer area, also add RELEASETOP paths:
      if (exists($ENV{RELEASETOP}))
         {
         print "\nAdding RELEASE area settings to self....OK","\n", if ($ENV{SCRAM_DEBUG});
         $store->addreleasetoself();
         }
      
      # Store the ToolData object in the cache:
      $self->storeincache($selfparser->toolname(),$store);
      scramlogmsg("\n");
      }
   else
      {
      scramlogdump();
      print "\n";
      print "SCRAM: No file config/Self.xml...nothing to do.";
      print "\n";
      return;
      }
   }

sub update()
   {
   my $self=shift;
   my $area=shift;
   $self->init($area);
   $self->setupself();
   $self->dirty ()
   }
   
sub storeincache()
   {
   my $self=shift;
   my ($toolname,$dataobject)=@_;

   # Store ToolData object (for a set-up tool) in cache:
   if (ref($dataobject) eq 'BuildSystem::ToolData')
      {
      $self->updatetooltimestamp($dataobject, $toolname);
      delete $self->{SETUP}->{$toolname};
      $self->{SETUP}->{$toolname} = $dataobject;
      }
   else
      {
      $::scram->scramerror("ToolManager: BuildSystem::ToolData object reference expected.")
      }
   }

sub tools()
   {
   my $self = shift;
   my @tools;
   
   map
      {
      if ($_ ne "self")
         {
         push(@tools, $_);
         }
      } keys %{$self->{SETUP}};
   
   # Return list of set-up tools:
   return @tools;
   }

sub toolsdata()
   {
   my $self = shift;
   my $tooldata = [];
   $self->{internal}{donetools}={};
   $self->{internal}{scram_tools}={};
   foreach my $tool (sort keys %{$self->{SETUP}})
      {
      if ($self->{SETUP}{$tool}->scram_project()) {$self->{internal}{scram_tools}{$tool}=1;}
      elsif ($tool ne "self")
         {
         $self->_toolsdata($tool,$tooldata);
         }
      }
   foreach my $tool (keys %{$self->{internal}{scram_tools}})
      {
      $self->_toolsdata_scram($tool,$tooldata);
      }
   delete $self->{internal}{donetools};
   delete $self->{internal}{scram_tools};
   return $tooldata;
   }

sub _toolsdata()
   {
   my $self = shift;
   my $tool=shift;
   my $data=shift || [];
   if(exists $self->{internal}{donetools}{$tool}){return;}
   $self->{internal}{donetools}{$tool}=1;
   if (exists $self->{SETUP}{$tool})
      {
      if (exists $self->{SETUP}{$tool}{USE})
         {
         foreach my $use (@{$self->{SETUP}{$tool}{USE}}){$self->_toolsdata(lc($use),$data);}
         }
      push @$data,$self->{SETUP}{$tool};
      }
   }

sub _toolsdata_scram()
   {
   my $self = shift;
   my $tool=shift;
   my $data=shift || [];
   if(exists $self->{internal}{donetools}{$tool}){return;}
   if(!exists $self->{internal}{scram_tools}{$tool}){return;}
   $self->{internal}{donetools}{$tool}=1;
   use Configuration::ConfigArea;
   use Cache::CacheUtilities;
   my $cache=uc($tool)."_BASE";
   $cache=$self->{SETUP}{$tool}{$cache};
   if (!-d $cache)
      {
      print "ERROR: Release area \"$cache\" for \"$tool\" is not available.\n";
      return;
      }
   my $area=Configuration::ConfigArea->new();
   $area->location($cache);
   my $cachefile=$area->toolcachename();
   if (!-f $cachefile)
      {
      print "ERROR: Tools cache file for release area \"$cache\" is not available.\n";
      $self->{internal}{donetools}{$tool}=1;
      return;
      }
   $cache=&Cache::CacheUtilities::read($cachefile);
   my $tools=$cache->setup();
   foreach my $use (keys %$tools)
      {
      if ($tools->{$use}->scram_project() == 1)
         {
         $self->_toolsdata_scram($use,$data);
         }
      }
   push @$data,$self->{SETUP}{$tool};
   }
   
sub checkifsetup()
   {
   my $self=shift;
   my ($tool)=@_;
   # Return the ToolData object if the tool has been set up:
   (exists $self->{SETUP}->{$tool}) ? return ($self->{SETUP}->{$tool})
      : return undef;
   }

sub remove_tool()
   {
   my $self=shift;
   my ($toolname)=@_;
   my $tool = $self->{SETUP}{$toolname};
   if ($tool->scram_compiler() == 1)
      {
      while (my ($langtype, $ctool) = each %{$self->{SCRAM_COMPILER}})
         {
         if ($toolname eq $ctool->[0]){delete $self->{SCRAM_COMPILER}->{$langtype};}
         }
      }
   delete $self->{SETUP}{$toolname};
   print "Deleting $toolname from cache.","\n";
   $self->updatetooltimestamp (undef, $toolname);
   $self->writecache();
   my $file1=$self->{toolcache}."/selected/${toolname}.xml";
   my $file2=$self->{toolcache}."/available/${toolname}.xml";
   if ((!-f $file2) && (-f $file1))
      {
      use File::Copy;
      copy ($file1,$file2);
      }
   unlink ($file1);
   }

sub scram_projects()
   {
   my $self=shift;
   my $scram_projects={};

   foreach my $t ($self->tools())
      {
      # Get the ToolData object:
      my $td=$self->{SETUP}->{$t};
      $scram_projects->{$t}=$td->variable_data(uc($t)."_BASE"), if ($td->scram_project());
      }
   
   return $scram_projects;
   }

sub scram_compiler()
   {
   my $self=shift;
   my ($langtype, $toolname, $compilername)=@_;

   if ($langtype)
      {
      # Store the compiler info according to supported
      # language types.
      #
      # ---------------------- e.g C++      cxxcompiler    gcc323
      $self->{SCRAM_COMPILER}->{$langtype}=[ $toolname, $compilername ];
      }
   else
      {
      return $self->{SCRAM_COMPILER};
      }
   }

sub updatetooltimestamp ()
   {
   my $self=shift;
   my $obj=shift;
   my $toolname=shift;
   my $samevalues=0;
   my $stampdir = $self->{archstore}."/timestamps";
   my $stampfile="${stampdir}/${toolname}";
   if (exists $self->{SETUP}->{$toolname})
      {
      $samevalues=$self->comparetoolsdata($self->{SETUP}->{$toolname},$obj);
      }
   if ($toolname ne "self")
      {
      my $instdir = $self->{archstore}."/InstalledTools";
      my $tfile = "${instdir}/${toolname}";
      if ((!defined $obj) && (-f $tfile)) {unlink $tfile;}
      elsif ((defined $obj) && (!-f $tfile))
         {
         Utilities::AddDir::adddir($instdir);
         my $ref;
         open($ref,">$tfile");
         close($ref);
         }
      }
   if ((!$samevalues) || (!-f $stampfile))
      {
      if (!-d $stampdir)
         {
         Utilities::AddDir::adddir($stampdir);
         }
      my $ref;
      open($ref,">$stampfile");
      close($ref);
      if (!$samevalues){$self->dirty();}
      }
   }

sub comparetoolsdata ()
   {
   my $self=shift;
   my $data1=shift || ();
   my $data2=shift || ();
  
   my $ref1=ref($data1);
   my $ref2=ref($data2);
  
   if ($ref1 ne $ref2)
      {
      return 0;
      }
   elsif ($ref1 eq "CODE")
      {
      return 1;
      }
   elsif(($ref1 eq "SCALAR") || ($ref1 eq ""))
      {
      if ($data1 eq $data2)
         {
         return 1;
         }
      return 0;
      }
   elsif ($ref1 eq "ARRAY")
      {
      my $count = scalar(@$data1);
      if ($count != scalar(@$data2))
         {
         return 0;
         }
      for (my $i=0; $i<$count; $i++)
          {
          if (! $self->comparetoolsdata($data1->[$i],$data2->[$i]))
             {
             return 0;
             }
          }
      return 1;
      }
   else
      {
      foreach my $k (keys %{$data1})
         {
         if (! exists $data2->{$k})
            {
            return 0;
            }
         }
      foreach my $k (keys %{$data2})
         {
         if (! exists $data1->{$k})
            {
            return 0;
            }
         }
      foreach my $k (keys %{$data2})
         {
         if (! $self->comparetoolsdata($data1->{$k},$data2->{$k}))
            {
            return 0;
            }
         }
      return 1;
      }
   }

1;
Revision:	1.19.2.2.2.1
Committed:	Thu Mar 13 12:54:50 2008 UTC (17 years, 1 month ago) by muzaffar
Content type:	text/plain
Branch:	SCRAM_V2_0
CVS Tags:	V2_0_4_relcand1, V2_0_3, V2_0_3_relcand3, V2_0_3_relcand2, V2_0_3_relcand1, V2_0_2, V2_0_2_relcand1, V2_0_1, V2_0_1_relcand4, V2_0_1_relcand3, V2_0_1_relcand2, V2_0_1_relcand1, V2_0_0_relcand4, V2_0_0, V2_0_0_relcand3, V2_0_0_relcand2, V2_0_0_relcand1
Changes since 1.19.2.2:	+139 -388 lines
Log Message:	scram v2.0 for multiple arch support and big lib stuff
#	User	Rev	Content
1	sashby	1.2	#____________________________________________________________________
2			# File: ToolManager.pm
3			#____________________________________________________________________
4			#
5			# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
6			# Update: 2003-11-12 15:04:16+0100
7	muzaffar	1.19.2.2.2.1	# Revision: $Id: ToolManager.pm,v 1.19.2.2 2008/02/19 15:06:03 muzaffar Exp $
8	sashby	1.2	#
9			# Copyright: 2003 (C) Shaun Ashby
10			#
11			#--------------------------------------------------------------------
12			package BuildSystem::ToolManager;
13			require 5.004;
14
15			use Exporter;
16			use BuildSystem::ToolCache;
17			use BuildSystem::ToolParser;
18			use Utilities::AddDir;
19			use Utilities::Verbose;
20	muzaffar	1.19	use SCRAM::MsgLog;
21	sashby	1.2
22			@ISA=qw(BuildSystem::ToolCache Utilities::Verbose);
23			@EXPORT_OK=qw( );
24			#
25	sashby	1.9
26	sashby	1.2	sub new
27			{
28			my $proto=shift;
29			my $class=ref($proto) \|\| $proto;
30			my $self=$class->SUPER::new(); # Inherit from ToolCache
31			bless $self,$class;
32	muzaffar	1.19.2.2.2.1	$self->init (shift);
33	sashby	1.2	return $self;
34			}
35
36	muzaffar	1.19.2.2.2.1	sub init ()
37	sashby	1.2	{
38			my $self=shift;
39			my $projectarea=shift;
40			$self->{topdir}=$projectarea->location();
41			$self->{configdir}=$self->{topdir}."/".$projectarea->configurationdir();
42	muzaffar	1.19.2.2.2.1	$self->{archstore}=$projectarea->archdir();
43			$self->{toolcache}=$self->{configdir}."/toolbox/".$projectarea->arch()."/tools";
44	sashby	1.2	$self->name($projectarea->toolcachename());
45	muzaffar	1.19.2.2.2.1	$self->dirty();
46	sashby	1.2	}
47	muzaffar	1.19.2.2.2.1
48	sashby	1.2	sub interactive()
49			{
50			my $self=shift;
51			# Interactive mode on/off:
52			@_ ? $self->{interactive} = shift
53			: ((defined $self->{interactive}) ? $self->{interactive} : 0);
54			}
55
56			sub setupalltools()
57			{
58			my $self = shift;
59	muzaffar	1.19.2.2.2.1	my @selected=();
60			my $tooldir=$self->{toolcache}."/selected";
61			foreach my $tool (@{&getfileslist($tooldir)})
62	sashby	1.2	{
63	muzaffar	1.19.2.2.2.1	if ($tool=~/^(.+)\.xml$/) {push @selected,$1;}
64	sashby	1.2	}
65	muzaffar	1.19.2.2.2.1	foreach my $tool (@selected){$self->coresetup("${tooldir}/${tool}.xml");}
66	muzaffar	1.19	scramlogmsg("\n");
67	sashby	1.2	}
68
69			sub coresetup()
70			{
71			my $self=shift;
72	muzaffar	1.19.2.2.2.1	my ($toolfile) = @_;
73	sashby	1.2
74	muzaffar	1.19.2.2.2.1	my $toolparser = BuildSystem::ToolParser->new();
75			$toolparser->filehead('<?xml version="1.0" encoding="UTF-8" standalone="yes"?><doc type="BuildSystem::ToolDoc" version="1.0">');
76			$toolparser->filetail('</doc>');
77			$toolparser->parse($toolfile);
78			my $toolname = $toolparser->toolname();
79			my $toolversion = $toolparser->toolversion();
80	muzaffar	1.19	scramlogmsg("\n",$::bold."Setting up ",$toolname," version ",$toolversion,": ".$::normal,"\n");
81	sashby	1.2
82			# Next, set up the tool:
83			my $store = $toolparser->processrawtool($self->interactive());
84	sashby	1.8
85			# Check to see if this tool is a compiler. If so, store it.
86			# Also store the language that this compiler supprots, and a
87			# compiler name (e.g. gcc323) which, in conjunction with a stem
88			# architecture name like slc3_ia32_, can be used to build a complete arch string:
89			if ($store->scram_compiler() == 1)
90			{
91			my @supported_language = $store->flags("SCRAM_LANGUAGE_TYPE");
92			my @compilername = $store->flags("SCRAM_COMPILER_NAME");
93			$self->scram_compiler($supported_language[0],$toolname,$compilername[0]);
94			}
95
96	sashby	1.16	# Store the ToolData object in the cache:
97	muzaffar	1.19.2.2.2.1	$self->storeincache($toolname,$store);
98			my $srcfile=Utilities::AddDir::fixpath($toolfile);
99			my $desfile=Utilities::AddDir::fixpath($self->{toolcache}."/selected/${toolname}.xml");
100			use File::Copy;
101			if ($srcfile ne $desfile)
102			{
103			use File::Copy;
104			my $desfile1=Utilities::AddDir::fixpath($self->{toolcache}."/available/${toolname}.xml");
105			if ($srcfile ne $desfile1)
106			{
107			copy($srcfile,$desfile1);
108	sashby	1.2	}
109	muzaffar	1.19.2.2.2.1	symlink("../available/${toolname}.xml",$desfile);
110	sashby	1.2	}
111			return $self;
112			}
113
114			sub setupself()
115			{
116			my $self=shift;
117			# Process the file "Self" in local config directory. This is used to
118			# set all the paths/runtime settings for this project:
119	muzaffar	1.19.2.2.2.1	my $filename=$self->{configdir}."/Self.xml";
120	sashby	1.16
121	sashby	1.2	if ( -f $filename )
122			{
123	muzaffar	1.19	scramlogmsg("\n",$::bold."Setting up SELF:".$::normal,"\n");
124	sashby	1.2	# Self file exists so process it:
125			$selfparser = BuildSystem::ToolParser->new();
126	muzaffar	1.18	$selfparser->filehead ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?><doc type="BuildSystem::ToolDoc" version="1.0">');
127			$selfparser->filehead ('</doc>');
128	muzaffar	1.19.2.2.2.1	$selfparser->parse($filename);
129	sashby	1.2
130			# Next, set up the tool:
131			$store = $selfparser->processrawtool($self->interactive());
132	muzaffar	1.19
133	sashby	1.2	# If we are in a developer area, also add RELEASETOP paths:
134			if (exists($ENV{RELEASETOP}))
135			{
136			print "\nAdding RELEASE area settings to self....OK","\n", if ($ENV{SCRAM_DEBUG});
137			$store->addreleasetoself();
138			}
139
140			# Store the ToolData object in the cache:
141			$self->storeincache($selfparser->toolname(),$store);
142	muzaffar	1.19	scramlogmsg("\n");
143	sashby	1.2	}
144			else
145			{
146	muzaffar	1.19	scramlogdump();
147	sashby	1.2	print "\n";
148	sashby	1.16	print "SCRAM: No file config/Self.xml...nothing to do.";
149	sashby	1.2	print "\n";
150			return;
151			}
152			}
153
154	muzaffar	1.19.2.2.2.1	sub update()
155	sashby	1.2	{
156	muzaffar	1.19.2.2.2.1	my $self=shift;
157			my $area=shift;
158			$self->init($area);
159			$self->setupself();
160			$self->dirty ()
161	sashby	1.2	}
162	muzaffar	1.19.2.2.2.1
163	sashby	1.2	sub storeincache()
164			{
165			my $self=shift;
166			my ($toolname,$dataobject)=@_;
167
168			# Store ToolData object (for a set-up tool) in cache:
169			if (ref($dataobject) eq 'BuildSystem::ToolData')
170			{
171	sashby	1.16	$self->updatetooltimestamp($dataobject, $toolname);
172	muzaffar	1.19.2.2.2.1	delete $self->{SETUP}->{$toolname};
173	sashby	1.2	$self->{SETUP}->{$toolname} = $dataobject;
174			}
175			else
176			{
177			$::scram->scramerror("ToolManager: BuildSystem::ToolData object reference expected.")
178			}
179			}
180
181			sub tools()
182			{
183			my $self = shift;
184			my @tools;
185
186			map
187			{
188			if ($_ ne "self")
189			{
190			push(@tools, $_);
191			}
192			} keys %{$self->{SETUP}};
193
194			# Return list of set-up tools:
195			return @tools;
196			}
197
198			sub toolsdata()
199			{
200			my $self = shift;
201			my $tooldata = [];
202	muzaffar	1.19.2.2.2.1	$self->{internal}{donetools}={};
203			$self->{internal}{scram_tools}={};
204			foreach my $tool (sort keys %{$self->{SETUP}})
205	sashby	1.2	{
206	muzaffar	1.19.2.2.2.1	if ($self->{SETUP}{$tool}->scram_project()) {$self->{internal}{scram_tools}{$tool}=1;}
207			elsif ($tool ne "self")
208	sashby	1.2	{
209	muzaffar	1.19.2.2.2.1	$self->_toolsdata($tool,$tooldata);
210	sashby	1.2	}
211			}
212	muzaffar	1.19.2.2.2.1	foreach my $tool (keys %{$self->{internal}{scram_tools}})
213			{
214			$self->_toolsdata_scram($tool,$tooldata);
215			}
216			delete $self->{internal}{donetools};
217			delete $self->{internal}{scram_tools};
218			return $tooldata;
219	sashby	1.2	}
220
221	muzaffar	1.19.2.2.2.1	sub _toolsdata()
222	sashby	1.2	{
223	muzaffar	1.19.2.2.2.1	my $self = shift;
224			my $tool=shift;
225			my $data=shift \|\| [];
226			if(exists $self->{internal}{donetools}{$tool}){return;}
227			$self->{internal}{donetools}{$tool}=1;
228			if (exists $self->{SETUP}{$tool})
229			{
230			if (exists $self->{SETUP}{$tool}{USE})
231			{
232			foreach my $use (@{$self->{SETUP}{$tool}{USE}}){$self->_toolsdata(lc($use),$data);}
233			}
234			push @$data,$self->{SETUP}{$tool};
235			}
236	sashby	1.2	}
237
238	muzaffar	1.19.2.2.2.1	sub _toolsdata_scram()
239			{
240			my $self = shift;
241			my $tool=shift;
242			my $data=shift \|\| [];
243			if(exists $self->{internal}{donetools}{$tool}){return;}
244			if(!exists $self->{internal}{scram_tools}{$tool}){return;}
245			$self->{internal}{donetools}{$tool}=1;
246			use Configuration::ConfigArea;
247			use Cache::CacheUtilities;
248			my $cache=uc($tool)."_BASE";
249			$cache=$self->{SETUP}{$tool}{$cache};
250			if (!-d $cache)
251			{
252			print "ERROR: Release area \"$cache\" for \"$tool\" is not available.\n";
253			return;
254			}
255			my $area=Configuration::ConfigArea->new();
256			$area->location($cache);
257			my $cachefile=$area->toolcachename();
258			if (!-f $cachefile)
259			{
260			print "ERROR: Tools cache file for release area \"$cache\" is not available.\n";
261			$self->{internal}{donetools}{$tool}=1;
262			return;
263			}
264			$cache=&Cache::CacheUtilities::read($cachefile);
265			my $tools=$cache->setup();
266			foreach my $use (keys %$tools)
267			{
268			if ($tools->{$use}->scram_project() == 1)
269			{
270			$self->_toolsdata_scram($use,$data);
271			}
272			}
273			push @$data,$self->{SETUP}{$tool};
274			}
275
276	sashby	1.2	sub checkifsetup()
277			{
278			my $self=shift;
279			my ($tool)=@_;
280			# Return the ToolData object if the tool has been set up:
281			(exists $self->{SETUP}->{$tool}) ? return ($self->{SETUP}->{$tool})
282			: return undef;
283			}
284
285			sub remove_tool()
286			{
287			my $self=shift;
288			my ($toolname)=@_;
289	muzaffar	1.19.2.2.2.1	my $tool = $self->{SETUP}{$toolname};
290			if ($tool->scram_compiler() == 1)
291	sashby	1.2	{
292	muzaffar	1.19.2.2.2.1	while (my ($langtype, $ctool) = each %{$self->{SCRAM_COMPILER}})
293			{
294			if ($toolname eq $ctool->[0]){delete $self->{SCRAM_COMPILER}->{$langtype};}
295	sashby	1.2	}
296			}
297	muzaffar	1.19.2.2.2.1	delete $self->{SETUP}{$toolname};
298			print "Deleting $toolname from cache.","\n";
299			$self->updatetooltimestamp (undef, $toolname);
300	sashby	1.2	$self->writecache();
301	muzaffar	1.19.2.2.2.1	my $file1=$self->{toolcache}."/selected/${toolname}.xml";
302			my $file2=$self->{toolcache}."/available/${toolname}.xml";
303			if ((!-f $file2) && (-f $file1))
304			{
305			use File::Copy;
306			copy ($file1,$file2);
307			}
308			unlink ($file1);
309	sashby	1.2	}
310
311			sub scram_projects()
312			{
313			my $self=shift;
314			my $scram_projects={};
315
316			foreach my $t ($self->tools())
317			{
318			# Get the ToolData object:
319			my $td=$self->{SETUP}->{$t};
320			$scram_projects->{$t}=$td->variable_data(uc($t)."_BASE"), if ($td->scram_project());
321			}
322
323			return $scram_projects;
324			}
325
326	sashby	1.8	sub scram_compiler()
327			{
328			my $self=shift;
329			my ($langtype, $toolname, $compilername)=@_;
330
331			if ($langtype)
332			{
333			# Store the compiler info according to supported
334			# language types.
335			#
336			# ---------------------- e.g C++ cxxcompiler gcc323
337			$self->{SCRAM_COMPILER}->{$langtype}=[ $toolname, $compilername ];
338			}
339			else
340			{
341			return $self->{SCRAM_COMPILER};
342			}
343			}
344
345	sashby	1.16	sub updatetooltimestamp ()
346			{
347			my $self=shift;
348			my $obj=shift;
349			my $toolname=shift;
350			my $samevalues=0;
351	muzaffar	1.18	my $stampdir = $self->{archstore}."/timestamps";
352			my $stampfile="${stampdir}/${toolname}";
353	sashby	1.16	if (exists $self->{SETUP}->{$toolname})
354			{
355			$samevalues=$self->comparetoolsdata($self->{SETUP}->{$toolname},$obj);
356			}
357	muzaffar	1.19.2.2.2.1	if ($toolname ne "self")
358			{
359			my $instdir = $self->{archstore}."/InstalledTools";
360			my $tfile = "${instdir}/${toolname}";
361			if ((!defined $obj) && (-f $tfile)) {unlink $tfile;}
362			elsif ((defined $obj) && (!-f $tfile))
363			{
364			Utilities::AddDir::adddir($instdir);
365			my $ref;
366			open($ref,">$tfile");
367			close($ref);
368			}
369			}
370	muzaffar	1.18	if ((!$samevalues) \|\| (!-f $stampfile))
371	sashby	1.16	{
372	muzaffar	1.18	if (!-d $stampdir)
373	sashby	1.16	{
374	muzaffar	1.19.2.2	Utilities::AddDir::adddir($stampdir);
375	sashby	1.16	}
376	muzaffar	1.19.2.2.2.1	my $ref;
377			open($ref,">$stampfile");
378			close($ref);
379			if (!$samevalues){$self->dirty();}
380	sashby	1.16	}
381			}
382
383			sub comparetoolsdata ()
384			{
385			my $self=shift;
386			my $data1=shift \|\| ();
387			my $data2=shift \|\| ();
388
389			my $ref1=ref($data1);
390			my $ref2=ref($data2);
391
392			if ($ref1 ne $ref2)
393			{
394			return 0;
395			}
396			elsif ($ref1 eq "CODE")
397			{
398			return 1;
399			}
400			elsif(($ref1 eq "SCALAR") \|\| ($ref1 eq ""))
401			{
402			if ($data1 eq $data2)
403			{
404			return 1;
405			}
406			return 0;
407			}
408			elsif ($ref1 eq "ARRAY")
409			{
410			my $count = scalar(@$data1);
411			if ($count != scalar(@$data2))
412			{
413			return 0;
414			}
415			for (my $i=0; $i<$count; $i++)
416			{
417			if (! $self->comparetoolsdata($data1->[$i],$data2->[$i]))
418			{
419			return 0;
420			}
421			}
422			return 1;
423			}
424			else
425			{
426			foreach my $k (keys %{$data1})
427			{
428			if (! exists $data2->{$k})
429			{
430			return 0;
431			}
432			}
433			foreach my $k (keys %{$data2})
434			{
435			if (! exists $data1->{$k})
436			{
437			return 0;
438			}
439			}
440			foreach my $k (keys %{$data2})
441			{
442			if (! $self->comparetoolsdata($data1->{$k},$data2->{$k}))
443			{
444			return 0;
445			}
446			}
447			return 1;
448			}
449			}
450
451	sashby	1.2	1;