src/BuildSystem/ToolData.pm

#____________________________________________________________________ 
# File: ToolData.pm
#____________________________________________________________________ 
#  
# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
# Update: 2003-11-21 15:26:07+0100
# Revision: $Id: ToolData.pm,v 1.1.2.9 2004/10/27 12:35:25 sashby Exp $ 
#
# Copyright: 2003 (C) Shaun Ashby
#
#--------------------------------------------------------------------
package BuildSystem::ToolData;
require 5.004;

use Exporter;

@ISA=qw(Exporter);
#
sub new
  ###############################################################
  # new                                                         #
  ###############################################################
  # modified : Fri Nov 21 15:26:14 2003 / SFA                   #
  # params   :                                                  #
  #          :                                                  #
  # function :                                                  #
  #          :                                                  #
  ###############################################################
  {
  my $proto=shift;
  my $class=ref($proto) || $proto;
  my $self={SCRAM_PROJECT => 0};
  bless $self,$class;
  return $self;
  }

sub toolname()
   {
   my $self=shift;
   @_ ? $self->{TOOLNAME} = shift
      : $self->{TOOLNAME};
   }

sub toolversion()
   {
   my $self=shift;
   @_ ? $self->{TOOLVERSION} = shift
      : $self->{TOOLVERSION};
   }

sub lib()
   {
   my $self=shift;
   # Add libs to array:
   @_ ? push(@{$self->{LIB}},@{$_[0]})
      : @{$self->{LIB}};
   }

sub include()
   {
   my $self=shift;
   # Add libs to array:
   @_ ? push(@{$self->{INCLUDE}},@{$_[0]})
      : @{$self->{INCLUDE}};
   }

sub libdir()
   {
   my $self=shift;
   # Add libdir to array:
   @_ ? push(@{$self->{LIBDIR}},@{$_[0]})
      : @{$self->{LIBDIR}};
   }

sub use()
   {
   my $self=shift;
   # Add deps to array:
   @_ ? push(@{$self->{USE}},@{$_[0]})
      : @{$self->{USE}};
   }

sub makefile()
   {
   my $self=shift;
   @_ ? push(@{$self->{MAKEFILE}},@{$_[0]})
      : @{$self->{MAKEFILE}};
   }

sub flags()
   {
   my $self=shift;
   my ($flag,$flagvalue) = @_;

   if ($flag && $flagvalue)
      {
      if (exists ($self->{FLAGS}->{$flag}))
         {
         # Add each flag ONLY if it doesn't already exist:
         foreach my $F (@$flagvalue)
            {
            push(@{$self->{FLAGS}->{$flag}},$F),
            if (! grep($F eq $_,@{$self->{FLAGS}->{$flag}}));
            }
         }
      else
         {
         $self->{FLAGS}->{$flag} = [ @$flagvalue ];
         }
      }
   elsif ($flag && $self->{FLAGS}->{$flag}->[0] ne '')
      {
      return @{$self->{FLAGS}->{$flag}};
      }
   else
      {
      return "";
      }
   }

sub allflags()
   {
   my $self=shift;
   (scalar(keys %{$self->{FLAGS}}) > 0) ? return $self->{FLAGS} : return undef;
   }

sub scram_project()
   {
   my $self=shift;
   @_ ? $self->{SCRAM_PROJECT} = shift
      : $self->{SCRAM_PROJECT};
   }

sub variable_data()
   {
   my $self=shift;
   my ($varname,$varvalue) = @_;
   
   if ($varname && $varvalue)
      {
      $self->{$varname} = $varvalue; # Maybe need to handle more than one value?
      # Keep track of all variables:
      if (! grep($varname eq $_, @{$self->{VARIABLES}}))# Remove duplicates!!
         {
         push(@{$self->{VARIABLES}},$varname);      
         }
      }
   else
      {
      return $self->{$varname};
      }
   }

sub list_variables
   {
   my $self=shift;
   return @{$self->{VARIABLES}};
   }

sub runtime()
   {
   my $self=shift;
   my ($rt,$rtvalue) = @_;

   # If both a runtime name and value are supplied, store this variable:
   if ($rt && $rtvalue)
      {
      # Check to see if the environment already exists:
      if (exists ($self->{RUNTIME}->{$rt}))
         {
         push(@{$self->{RUNTIME}->{$rt}},@$rtvalue);
         }
      else
         {
         # Doesn't already exist so just set the value, in an array:
         $self->{RUNTIME}->{$rt} = [ @$rtvalue ];
         }
      }
   elsif ($rt)
      {
      # Return the value for this runtime var name:
      return $self->{RUNTIME}->{$rt};
      }
   else
      {
      # Return all RT settings:
      return $self->{RUNTIME};
      }
   }

sub getfeatures()
   {
   my $self=shift;
   my ($feature)=@_;
   my @feature_vars=$self->list_variables();
   my @features;
   push (@features, @feature_vars, qw(LIB LIBDIR INCLUDE MAKEFILE USE));

   # Make sure feature name is uppercase:
   $feature =~ tr/a-z/A-Z/;
   if ($feature) # A feature name was given
      {
      # Check to see if this feature is valid and is defined for this tool:
      if (grep($feature eq $_, @features) && exists($self->{$feature}))
         {
         (ref($self->{$feature}) eq 'ARRAY') ? print join(" ",@{$self->{$feature}})
            : print join(" ",$self->{$feature});
         print "\n";
         }
      else
         {
         # This feature isn't a valid feature or is valid but doens't
         # have a value for this tool:
         print "SCRAM: No type of variable called \"",$feature,"\" ","defined for this tool.\n";
         }
      }
   else
      {
      # No feature name so dump list of valid features for current tool:
      map
         {
         print $_,"\n", if (exists ($self->{$_}));
         } @features;
      }
   }

sub summarize_features()
   {
   my $self=shift;
   my @variables = $self->list_variables();

   # Show whether this tool is a SCRAM project or not:
   print "SCRAM_PROJECT=";
   ($self->scram_project() == 1) ? print "yes" : print "no";
   print "\n";

   # Print out any variables:
   foreach my $var (@variables)
      {
      print $var,"=",$self->{$var},"\n";
      }

   # Makefile and flags first:
   if (exists($self->{'MAKEFILE'}) && $#{$self->{'MAKEFILE'}} != -1)
      {
      print join(" ",@{$self->{'MAKEFILE'}}),"\n\n";
      }

   if (exists($self->{'FLAGS'}) && (my ($nkeys) = scalar(keys %{$self->{'FLAGS'}}) > 0 ))
      {
      my $flags=$self->allflags();
      
      while (my ($f,$fv) = each %{$flags})
         {
         print $f,"+=",join(" ",@{$fv}),"\n";
         }      
      }

   foreach my $feature (qw( LIB LIBDIR INCLUDE USE ))
      {
      if (exists($self->{$feature}) && $#{$self->{$feature}} != -1)
         {
         print $feature,"=",join(" ",@{$self->{$feature}}),"\n";
         }
      }

   # Finally, look for runtime vars:
   if (exists($self->{'RUNTIME'}) && (my ($nkeys) = scalar(keys %{$self->{'RUNTIME'}}) > 0 ))
      {
      while (my ($rt,$val) = each %{$self->{$feature}})
         {
         if ($rt =~ /:/)
            {
            my ($type,$name) = split(":",$rt);
            print $name,"=",join(":",@$val),"\n";
            }
         else
            {
            print $rt,"=",join(":",@$val),"\n";
            }
         }
      }
   
   print "\n";
   }

   
sub addreleasetoself()
   {
   my $self=shift;
   # Go through the settings obtained so far (only from SELF) and, for
   # every LIBDIR/INCLUDE/RUNTIME path, add another value with
   # LOCALTOP==RELEASETOP:
   my $relldir = [];
   my $relinc = [];
   my @locallibdirs = $self->libdir();
   my @localincdirs = $self->include();
   
   foreach my $libdir (@locallibdirs)
      {
      # Convert LOCAL to RELEASE top:
      $libdir =~ s/$ENV{LOCALTOP}/$ENV{RELEASETOP}/g;
      push(@$relldir, $libdir);
      }
   
   # Add the new libdirs to our object:
   $self->libdir($relldir);
   
   foreach my $incdir (@localincdirs)
      {
      # Convert LOCAL to RELEASE top:
      $incdir =~ s/$ENV{LOCALTOP}/$ENV{RELEASETOP}/g;
      push(@$relinc, $incdir);
      }
   
   # Add the new libdirs to our object:
   $self->include($relinc);

   # Handle runtime settings:
   my $runtime=$self->runtime();
   
   while (my ($rt,$val) = each %{$runtime})
      {
      # Only handle anything that's a PATH:
      if ($rt =~ /:/)
         {
         my ($type,$name) = split(":",$rt);
         
         if ($type eq 'PATH')
            {
            my @PATHS=@$val;
            my $RELPATHS=[];
            
            # Process the values for this path:
            foreach my $rtpath (@PATHS)
               {
               $rtpath =~ s/$ENV{LOCALTOP}/$ENV{RELEASETOP}/g;
               push(@$RELPATHS,$rtpath);
               }
            
            # Add the new settings:
            $self->runtime($rt,$RELPATHS);
            }
         }
      }
   
   }

1;
Revision:	1.2
Committed:	Fri Dec 10 13:41:37 2004 UTC (20 years, 4 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V1_0_0
Changes since 1.1:	+349 -0 lines
Log Message:	Merged V1_0 branch to HEAD
#	User	Rev	Content
1	sashby	1.2	#____________________________________________________________________
2			# File: ToolData.pm
3			#____________________________________________________________________
4			#
5			# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
6			# Update: 2003-11-21 15:26:07+0100
7			# Revision: $Id: ToolData.pm,v 1.1.2.9 2004/10/27 12:35:25 sashby Exp $
8			#
9			# Copyright: 2003 (C) Shaun Ashby
10			#
11			#--------------------------------------------------------------------
12			package BuildSystem::ToolData;
13			require 5.004;
14
15			use Exporter;
16
17			@ISA=qw(Exporter);
18			#
19			sub new
20			###############################################################
21			# new #
22			###############################################################
23			# modified : Fri Nov 21 15:26:14 2003 / SFA #
24			# params : #
25			# : #
26			# function : #
27			# : #
28			###############################################################
29			{
30			my $proto=shift;
31			my $class=ref($proto) \|\| $proto;
32			my $self={SCRAM_PROJECT => 0};
33			bless $self,$class;
34			return $self;
35			}
36
37			sub toolname()
38			{
39			my $self=shift;
40			@_ ? $self->{TOOLNAME} = shift
41			: $self->{TOOLNAME};
42			}
43
44			sub toolversion()
45			{
46			my $self=shift;
47			@_ ? $self->{TOOLVERSION} = shift
48			: $self->{TOOLVERSION};
49			}
50
51			sub lib()
52			{
53			my $self=shift;
54			# Add libs to array:
55			@_ ? push(@{$self->{LIB}},@{$_[0]})
56			: @{$self->{LIB}};
57			}
58
59			sub include()
60			{
61			my $self=shift;
62			# Add libs to array:
63			@_ ? push(@{$self->{INCLUDE}},@{$_[0]})
64			: @{$self->{INCLUDE}};
65			}
66
67			sub libdir()
68			{
69			my $self=shift;
70			# Add libdir to array:
71			@_ ? push(@{$self->{LIBDIR}},@{$_[0]})
72			: @{$self->{LIBDIR}};
73			}
74
75			sub use()
76			{
77			my $self=shift;
78			# Add deps to array:
79			@_ ? push(@{$self->{USE}},@{$_[0]})
80			: @{$self->{USE}};
81			}
82
83			sub makefile()
84			{
85			my $self=shift;
86			@_ ? push(@{$self->{MAKEFILE}},@{$_[0]})
87			: @{$self->{MAKEFILE}};
88			}
89
90			sub flags()
91			{
92			my $self=shift;
93			my ($flag,$flagvalue) = @_;
94
95			if ($flag && $flagvalue)
96			{
97			if (exists ($self->{FLAGS}->{$flag}))
98			{
99			# Add each flag ONLY if it doesn't already exist:
100			foreach my $F (@$flagvalue)
101			{
102			push(@{$self->{FLAGS}->{$flag}},$F),
103			if (! grep($F eq $_,@{$self->{FLAGS}->{$flag}}));
104			}
105			}
106			else
107			{
108			$self->{FLAGS}->{$flag} = [ @$flagvalue ];
109			}
110			}
111			elsif ($flag && $self->{FLAGS}->{$flag}->[0] ne '')
112			{
113			return @{$self->{FLAGS}->{$flag}};
114			}
115			else
116			{
117			return "";
118			}
119			}
120
121			sub allflags()
122			{
123			my $self=shift;
124			(scalar(keys %{$self->{FLAGS}}) > 0) ? return $self->{FLAGS} : return undef;
125			}
126
127			sub scram_project()
128			{
129			my $self=shift;
130			@_ ? $self->{SCRAM_PROJECT} = shift
131			: $self->{SCRAM_PROJECT};
132			}
133
134			sub variable_data()
135			{
136			my $self=shift;
137			my ($varname,$varvalue) = @_;
138
139			if ($varname && $varvalue)
140			{
141			$self->{$varname} = $varvalue; # Maybe need to handle more than one value?
142			# Keep track of all variables:
143			if (! grep($varname eq $_, @{$self->{VARIABLES}}))# Remove duplicates!!
144			{
145			push(@{$self->{VARIABLES}},$varname);
146			}
147			}
148			else
149			{
150			return $self->{$varname};
151			}
152			}
153
154			sub list_variables
155			{
156			my $self=shift;
157			return @{$self->{VARIABLES}};
158			}
159
160			sub runtime()
161			{
162			my $self=shift;
163			my ($rt,$rtvalue) = @_;
164
165			# If both a runtime name and value are supplied, store this variable:
166			if ($rt && $rtvalue)
167			{
168			# Check to see if the environment already exists:
169			if (exists ($self->{RUNTIME}->{$rt}))
170			{
171			push(@{$self->{RUNTIME}->{$rt}},@$rtvalue);
172			}
173			else
174			{
175			# Doesn't already exist so just set the value, in an array:
176			$self->{RUNTIME}->{$rt} = [ @$rtvalue ];
177			}
178			}
179			elsif ($rt)
180			{
181			# Return the value for this runtime var name:
182			return $self->{RUNTIME}->{$rt};
183			}
184			else
185			{
186			# Return all RT settings:
187			return $self->{RUNTIME};
188			}
189			}
190
191			sub getfeatures()
192			{
193			my $self=shift;
194			my ($feature)=@_;
195			my @feature_vars=$self->list_variables();
196			my @features;
197			push (@features, @feature_vars, qw(LIB LIBDIR INCLUDE MAKEFILE USE));
198
199			# Make sure feature name is uppercase:
200			$feature =~ tr/a-z/A-Z/;
201			if ($feature) # A feature name was given
202			{
203			# Check to see if this feature is valid and is defined for this tool:
204			if (grep($feature eq $_, @features) && exists($self->{$feature}))
205			{
206			(ref($self->{$feature}) eq 'ARRAY') ? print join(" ",@{$self->{$feature}})
207			: print join(" ",$self->{$feature});
208			print "\n";
209			}
210			else
211			{
212			# This feature isn't a valid feature or is valid but doens't
213			# have a value for this tool:
214			print "SCRAM: No type of variable called \"",$feature,"\" ","defined for this tool.\n";
215			}
216			}
217			else
218			{
219			# No feature name so dump list of valid features for current tool:
220			map
221			{
222			print $_,"\n", if (exists ($self->{$_}));
223			} @features;
224			}
225			}
226
227			sub summarize_features()
228			{
229			my $self=shift;
230			my @variables = $self->list_variables();
231
232			# Show whether this tool is a SCRAM project or not:
233			print "SCRAM_PROJECT=";
234			($self->scram_project() == 1) ? print "yes" : print "no";
235			print "\n";
236
237			# Print out any variables:
238			foreach my $var (@variables)
239			{
240			print $var,"=",$self->{$var},"\n";
241			}
242
243			# Makefile and flags first:
244			if (exists($self->{'MAKEFILE'}) && $#{$self->{'MAKEFILE'}} != -1)
245			{
246			print join(" ",@{$self->{'MAKEFILE'}}),"\n\n";
247			}
248
249			if (exists($self->{'FLAGS'}) && (my ($nkeys) = scalar(keys %{$self->{'FLAGS'}}) > 0 ))
250			{
251			my $flags=$self->allflags();
252
253			while (my ($f,$fv) = each %{$flags})
254			{
255			print $f,"+=",join(" ",@{$fv}),"\n";
256			}
257			}
258
259			foreach my $feature (qw( LIB LIBDIR INCLUDE USE ))
260			{
261			if (exists($self->{$feature}) && $#{$self->{$feature}} != -1)
262			{
263			print $feature,"=",join(" ",@{$self->{$feature}}),"\n";
264			}
265			}
266
267			# Finally, look for runtime vars:
268			if (exists($self->{'RUNTIME'}) && (my ($nkeys) = scalar(keys %{$self->{'RUNTIME'}}) > 0 ))
269			{
270			while (my ($rt,$val) = each %{$self->{$feature}})
271			{
272			if ($rt =~ /:/)
273			{
274			my ($type,$name) = split(":",$rt);
275			print $name,"=",join(":",@$val),"\n";
276			}
277			else
278			{
279			print $rt,"=",join(":",@$val),"\n";
280			}
281			}
282			}
283
284			print "\n";
285			}
286
287
288			sub addreleasetoself()
289			{
290			my $self=shift;
291			# Go through the settings obtained so far (only from SELF) and, for
292			# every LIBDIR/INCLUDE/RUNTIME path, add another value with
293			# LOCALTOP==RELEASETOP:
294			my $relldir = [];
295			my $relinc = [];
296			my @locallibdirs = $self->libdir();
297			my @localincdirs = $self->include();
298
299			foreach my $libdir (@locallibdirs)
300			{
301			# Convert LOCAL to RELEASE top:
302			$libdir =~ s/$ENV{LOCALTOP}/$ENV{RELEASETOP}/g;
303			push(@$relldir, $libdir);
304			}
305
306			# Add the new libdirs to our object:
307			$self->libdir($relldir);
308
309			foreach my $incdir (@localincdirs)
310			{
311			# Convert LOCAL to RELEASE top:
312			$incdir =~ s/$ENV{LOCALTOP}/$ENV{RELEASETOP}/g;
313			push(@$relinc, $incdir);
314			}
315
316			# Add the new libdirs to our object:
317			$self->include($relinc);
318
319			# Handle runtime settings:
320			my $runtime=$self->runtime();
321
322			while (my ($rt,$val) = each %{$runtime})
323			{
324			# Only handle anything that's a PATH:
325			if ($rt =~ /:/)
326			{
327			my ($type,$name) = split(":",$rt);
328
329			if ($type eq 'PATH')
330			{
331			my @PATHS=@$val;
332			my $RELPATHS=[];
333
334			# Process the values for this path:
335			foreach my $rtpath (@PATHS)
336			{
337			$rtpath =~ s/$ENV{LOCALTOP}/$ENV{RELEASETOP}/g;
338			push(@$RELPATHS,$rtpath);
339			}
340
341			# Add the new settings:
342			$self->runtime($rt,$RELPATHS);
343			}
344			}
345			}
346
347			}
348
349			1;