src/BuildSystem/BuildFile.pm

#____________________________________________________________________ 
# File: BuildFile.pm
#____________________________________________________________________ 
#  
# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
# Update: 2003-12-03 19:03:15+0100
# Revision: $Id: BuildFile.pm,v 1.26 2004/12/10 13:41:37 sashby Exp $ 
#
# Copyright: 2003 (C) Shaun Ashby
#
#--------------------------------------------------------------------
package BuildSystem::BuildFile;
require 5.004;
use Exporter;
use BuildSystem::TagUtils;
use BuildSystem::BuildDataUtils;
use ActiveDoc::SimpleDoc;

@ISA=qw(Exporter BuildSystem::BuildDataUtils);
@EXPORT_OK=qw( );

#
sub new()
   ###############################################################
   # new                                                         #
   ###############################################################
   # modified : Wed Dec  3 19:03:22 2003 / SFA                   #
   # params   :                                                  #
   #          :                                                  #
   # function :                                                  #
   #          :                                                  #
   ###############################################################
   {
   my $proto=shift;
   my $class=ref($proto) || $proto;
   my $self={};
   
   bless $self,$class;

   $self->{DEPENDENCIES} = {};
   $self->{content} = {};
   return $self;
   }

sub _initparser()
   {
   my $self=shift;

   $self->{simpledoc}=ActiveDoc::SimpleDoc->new();
   $self->{simpledoc}->newparse("builder");
   $self->{simpledoc}->addignoretags("builder");

   # For blank lines do nothing:
   $self->{simpledoc}->addtag("builder","none",
                              "", $self,
                              "", $self,
                              "", $self);
   
   # Define the tags to be used in this class:
   $self->{simpledoc}->addtag("builder","classpath",
                              \&BuildSystem::TagUtils::classpathtagOpen, $self,
                              "", $self,
                              "", $self);

   $self->{simpledoc}->addtag("builder","productstore",
                              \&BuildSystem::TagUtils::productstoretagOpen, $self,
                              "", $self,
                              "", $self);

   $self->{simpledoc}->addtag("builder","architecture",
                              \&BuildSystem::TagUtils::archtagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::archtagClose, $self);

   $self->{simpledoc}->addtag("builder","include_path",
                              \&BuildSystem::TagUtils::includetagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("builder","define_group",
                              \&BuildSystem::TagUtils::groupdeftagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::groupdeftagClose, $self);
   
   $self->{simpledoc}->addtag("builder","group",
                              \&BuildSystem::TagUtils::grouptagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("builder","lib",
                              \&BuildSystem::TagUtils::libtagOpen, $self,
                              "", $self,
                              "", $self);

   $self->{simpledoc}->addtag("builder","export",
                              \&BuildSystem::TagUtils::exporttagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::exporttagClose, $self);

   $self->{simpledoc}->addtag("builder","use",
                              \&BuildSystem::TagUtils::usetagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("builder","libtype",
                              \&BuildSystem::TagUtils::libtypetagOpen, $self,
                              "", $self,
                              "", $self);

   $self->{simpledoc}->addtag("builder","skip",
                              \&BuildSystem::TagUtils::skippedtagOpen, $self,
                              "", $self,
                              "", $self);

   $self->{simpledoc}->addtag("builder","makefile",
                              \&BuildSystem::TagUtils::makefiletagOpen, $self,
                              \&BuildSystem::TagUtils::makefiletagContent, $self,
                              \&BuildSystem::TagUtils::makefiletagClose, $self);

   $self->{simpledoc}->addtag("builder","flags",
                              \&BuildSystem::TagUtils::flagstagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("builder","bin",
                              \&BuildSystem::TagUtils::binarytagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::binarytagClose, $self);
   
   $self->{simpledoc}->addtag("builder","module",
                              \&BuildSystem::TagUtils::moduletagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::moduletagClose, $self);
   
   $self->{simpledoc}->addtag("builder","application",
                              \&BuildSystem::TagUtils::applicationtagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::applicationtagClose, $self);

   $self->{simpledoc}->addtag("builder","library",
                              \&BuildSystem::TagUtils::librarytagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::librarytagClose, $self);

#    $self->{simpledoc}->addtag("builder"," ",
#                             \&BuildSystem::TagUtils::  ,$self,
#                             \&BuildSystem::TagUtils::  ,$self,
#                             \&BuildSystem::TagUtils::  ,$self);
 
   return $self->{simpledoc};
   }

sub parse()
   {
   my $self=shift;
   my ($filename)=@_;

   $self->{simpledoc}=$self->_initparser();
   $self->{simpledoc}->filetoparse($filename);
   $self->{simpledoc}->parse("builder");
   
   # We're done with the SimpleDoc object so delete it:
   delete $self->{simpledoc};
   }

sub _initbranchparser()
   {
   my $self=shift;

   $self->{simpledoc}=ActiveDoc::SimpleDoc->new();
   $self->{simpledoc}->newparse("branchbuilder");
   $self->{simpledoc}->addignoretags("branchbuilder");

   # For blank lines do nothing:
   $self->{simpledoc}->addtag("branchbuilder","none",
                              "", $self,
                              "", $self,
                              "", $self);
   
   # Define the tags to be used in this class:
   $self->{simpledoc}->addtag("branchbuilder","productstore",
                              \&BuildSystem::TagUtils::productstoretagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("branchbuilder","architecture",
                              \&BuildSystem::TagUtils::archtagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::archtagClose, $self);

   $self->{simpledoc}->addtag("branchbuilder","include_path",
                              \&BuildSystem::TagUtils::includetagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("branchbuilder","export",
                              \&BuildSystem::TagUtils::exporttagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::exporttagClose, $self);

   $self->{simpledoc}->addtag("branchbuilder","define_group",
                              \&BuildSystem::TagUtils::groupdeftagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::groupdeftagClose, $self);
   
   $self->{simpledoc}->addtag("branchbuilder","group",
                              \&BuildSystem::TagUtils::grouptagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("branchbuilder","lib",
                              \&BuildSystem::TagUtils::libtagOpen, $self,
                              "", $self,
                              "", $self);

   $self->{simpledoc}->addtag("branchbuilder","use",
                              \&BuildSystem::TagUtils::usetagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("branchbuilder","libtype",
                              \&BuildSystem::TagUtils::libtypetagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("branchbuilder","makefile",
                              \&BuildSystem::TagUtils::makefiletagOpen, $self,
                              \&BuildSystem::TagUtils::makefiletagContent, $self,
                              \&BuildSystem::TagUtils::makefiletagClose, $self);

   $self->{simpledoc}->addtag("branchbuilder","flags",
                              \&BuildSystem::TagUtils::flagstagOpen, $self,
                              "", $self,
                              "", $self);
   
   $self->{simpledoc}->addtag("branchbuilder","bin",
                              \&BuildSystem::TagUtils::binarytagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::binarytagClose, $self);
   
   $self->{simpledoc}->addtag("branchbuilder","module",
                              \&BuildSystem::TagUtils::moduletagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::moduletagClose, $self);
   
   $self->{simpledoc}->addtag("branchbuilder","application",
                              \&BuildSystem::TagUtils::applicationtagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::applicationtagClose, $self);

   $self->{simpledoc}->addtag("branchbuilder","library",
                              \&BuildSystem::TagUtils::librarytagOpen, $self,
                              "", $self,
                              \&BuildSystem::TagUtils::librarytagClose, $self);
   
   return $self->{simpledoc};
   }

sub parsebranchfiles()
   {
   my $self=shift;
   my ($filenames)=@_; # array ref
   # List of buildfiles:
   $self->{localpaths}=$filenames;
   $self->{simpledoc}=$self->_initbranchparser();
   # We iterate over an array of files to be read in turn: all
   # build data will be stored in the same BuildFile object:
   $self->{simpledoc}->parsefilelist("branchbuilder",$filenames);
   # We're done with the SimpleDoc object so delete it:
   delete $self->{simpledoc};
   }

sub productcollector()
   {
   my $self=shift;
   my ($name,$typeshort,$typefull)=@_;
   # Create a new Product object for storage of data:
   use BuildSystem::Product;
   my $product = BuildSystem::Product->new();
   # Store the name:
   $product->name($name);
   $product->type($typeshort);
   # Store the files:
   $product->_files($self->{id}->{'file'},$self->{localpaths});
   # Store the data content:
   $product->_data($self->{tagcontent});
   # And store in a hash (all build products in same place):
   $self->{content}->{BUILDPRODUCTS}->{$typefull}->{$name} = $product;
   }

sub pushlevel
   {
   my $self = shift;
   my ($info)=@_;
   
   $self->{id} = $info if (defined $info);
   $self->{nested} = 1;
   $self->{tagcontent}={};
   }

sub poplevel
   {
   my $self = shift;
   delete $self->{id};
   delete $self->{nested};
   delete $self->{tagcontent};
   }

sub dependencies()
   {
   my $self=shift;
   # Make a copy of the variable so that
   # we don't have a DEPENDENCIES entry in RAWDATA:
   my %DEPS=%{$self->{DEPENDENCIES}};
   delete $self->{DEPENDENCIES};
   return \%DEPS;
   }

#
# All data access methods are inherited from BuildDataUtils.
#
1;
Revision:	1.27
Committed:	Wed Feb 16 18:02:59 2005 UTC (20 years, 2 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
Changes since 1.26:	+7 -2 lines
Log Message:	First attempt at skipp function. Updates to templates.
#	User	Rev	Content
1	sashby	1.26	#____________________________________________________________________
2			# File: BuildFile.pm
3			#____________________________________________________________________
4			#
5			# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
6			# Update: 2003-12-03 19:03:15+0100
7	sashby	1.27	# Revision: $Id: BuildFile.pm,v 1.26 2004/12/10 13:41:37 sashby Exp $
8	williamc	1.1	#
9	sashby	1.26	# Copyright: 2003 (C) Shaun Ashby
10			#
11			#--------------------------------------------------------------------
12	williamc	1.1	package BuildSystem::BuildFile;
13	sashby	1.26	require 5.004;
14			use Exporter;
15			use BuildSystem::TagUtils;
16			use BuildSystem::BuildDataUtils;
17	williamc	1.2	use ActiveDoc::SimpleDoc;
18
19	sashby	1.26	@ISA=qw(Exporter BuildSystem::BuildDataUtils);
20			@EXPORT_OK=qw( );
21
22			#
23			sub new()
24			###############################################################
25			# new #
26			###############################################################
27			# modified : Wed Dec 3 19:03:22 2003 / SFA #
28			# params : #
29			# : #
30			# function : #
31			# : #
32			###############################################################
33			{
34			my $proto=shift;
35			my $class=ref($proto) \|\| $proto;
36			my $self={};
37
38			bless $self,$class;
39
40			$self->{DEPENDENCIES} = {};
41			$self->{content} = {};
42			return $self;
43			}
44
45			sub _initparser()
46			{
47			my $self=shift;
48
49			$self->{simpledoc}=ActiveDoc::SimpleDoc->new();
50			$self->{simpledoc}->newparse("builder");
51			$self->{simpledoc}->addignoretags("builder");
52
53			# For blank lines do nothing:
54			$self->{simpledoc}->addtag("builder","none",
55			"", $self,
56			"", $self,
57			"", $self);
58
59			# Define the tags to be used in this class:
60			$self->{simpledoc}->addtag("builder","classpath",
61			\&BuildSystem::TagUtils::classpathtagOpen, $self,
62			"", $self,
63			"", $self);
64
65			$self->{simpledoc}->addtag("builder","productstore",
66			\&BuildSystem::TagUtils::productstoretagOpen, $self,
67			"", $self,
68			"", $self);
69
70			$self->{simpledoc}->addtag("builder","architecture",
71			\&BuildSystem::TagUtils::archtagOpen, $self,
72			"", $self,
73			\&BuildSystem::TagUtils::archtagClose, $self);
74
75			$self->{simpledoc}->addtag("builder","include_path",
76			\&BuildSystem::TagUtils::includetagOpen, $self,
77			"", $self,
78			"", $self);
79
80			$self->{simpledoc}->addtag("builder","define_group",
81			\&BuildSystem::TagUtils::groupdeftagOpen, $self,
82			"", $self,
83			\&BuildSystem::TagUtils::groupdeftagClose, $self);
84
85			$self->{simpledoc}->addtag("builder","group",
86			\&BuildSystem::TagUtils::grouptagOpen, $self,
87			"", $self,
88			"", $self);
89
90			$self->{simpledoc}->addtag("builder","lib",
91			\&BuildSystem::TagUtils::libtagOpen, $self,
92			"", $self,
93			"", $self);
94
95			$self->{simpledoc}->addtag("builder","export",
96			\&BuildSystem::TagUtils::exporttagOpen, $self,
97			"", $self,
98			\&BuildSystem::TagUtils::exporttagClose, $self);
99
100			$self->{simpledoc}->addtag("builder","use",
101			\&BuildSystem::TagUtils::usetagOpen, $self,
102			"", $self,
103			"", $self);
104
105			$self->{simpledoc}->addtag("builder","libtype",
106			\&BuildSystem::TagUtils::libtypetagOpen, $self,
107			"", $self,
108			"", $self);
109	sashby	1.27
110			$self->{simpledoc}->addtag("builder","skip",
111			\&BuildSystem::TagUtils::skippedtagOpen, $self,
112			"", $self,
113			"", $self);
114
115	sashby	1.26	$self->{simpledoc}->addtag("builder","makefile",
116			\&BuildSystem::TagUtils::makefiletagOpen, $self,
117			\&BuildSystem::TagUtils::makefiletagContent, $self,
118			\&BuildSystem::TagUtils::makefiletagClose, $self);
119
120			$self->{simpledoc}->addtag("builder","flags",
121			\&BuildSystem::TagUtils::flagstagOpen, $self,
122			"", $self,
123			"", $self);
124
125			$self->{simpledoc}->addtag("builder","bin",
126			\&BuildSystem::TagUtils::binarytagOpen, $self,
127			"", $self,
128			\&BuildSystem::TagUtils::binarytagClose, $self);
129
130			$self->{simpledoc}->addtag("builder","module",
131			\&BuildSystem::TagUtils::moduletagOpen, $self,
132			"", $self,
133			\&BuildSystem::TagUtils::moduletagClose, $self);
134
135			$self->{simpledoc}->addtag("builder","application",
136			\&BuildSystem::TagUtils::applicationtagOpen, $self,
137			"", $self,
138			\&BuildSystem::TagUtils::applicationtagClose, $self);
139
140			$self->{simpledoc}->addtag("builder","library",
141			\&BuildSystem::TagUtils::librarytagOpen, $self,
142			"", $self,
143			\&BuildSystem::TagUtils::librarytagClose, $self);
144
145			# $self->{simpledoc}->addtag("builder"," ",
146			# \&BuildSystem::TagUtils:: ,$self,
147			# \&BuildSystem::TagUtils:: ,$self,
148			# \&BuildSystem::TagUtils:: ,$self);
149
150			return $self->{simpledoc};
151			}
152	williamc	1.2
153	sashby	1.26	sub parse()
154	sashby	1.19	{
155			my $self=shift;
156	sashby	1.26	my ($filename)=@_;
157
158			$self->{simpledoc}=$self->_initparser();
159			$self->{simpledoc}->filetoparse($filename);
160			$self->{simpledoc}->parse("builder");
161	sashby	1.19
162	sashby	1.26	# We're done with the SimpleDoc object so delete it:
163			delete $self->{simpledoc};
164	sashby	1.19	}
165	williamc	1.2
166	sashby	1.26	sub _initbranchparser()
167	sashby	1.17	{
168			my $self=shift;
169	sashby	1.26
170			$self->{simpledoc}=ActiveDoc::SimpleDoc->new();
171			$self->{simpledoc}->newparse("branchbuilder");
172			$self->{simpledoc}->addignoretags("branchbuilder");
173
174			# For blank lines do nothing:
175			$self->{simpledoc}->addtag("branchbuilder","none",
176			"", $self,
177			"", $self,
178			"", $self);
179
180			# Define the tags to be used in this class:
181			$self->{simpledoc}->addtag("branchbuilder","productstore",
182			\&BuildSystem::TagUtils::productstoretagOpen, $self,
183			"", $self,
184			"", $self);
185
186			$self->{simpledoc}->addtag("branchbuilder","architecture",
187			\&BuildSystem::TagUtils::archtagOpen, $self,
188			"", $self,
189			\&BuildSystem::TagUtils::archtagClose, $self);
190
191			$self->{simpledoc}->addtag("branchbuilder","include_path",
192			\&BuildSystem::TagUtils::includetagOpen, $self,
193			"", $self,
194			"", $self);
195
196			$self->{simpledoc}->addtag("branchbuilder","export",
197			\&BuildSystem::TagUtils::exporttagOpen, $self,
198			"", $self,
199			\&BuildSystem::TagUtils::exporttagClose, $self);
200
201			$self->{simpledoc}->addtag("branchbuilder","define_group",
202			\&BuildSystem::TagUtils::groupdeftagOpen, $self,
203			"", $self,
204			\&BuildSystem::TagUtils::groupdeftagClose, $self);
205
206			$self->{simpledoc}->addtag("branchbuilder","group",
207			\&BuildSystem::TagUtils::grouptagOpen, $self,
208			"", $self,
209			"", $self);
210
211			$self->{simpledoc}->addtag("branchbuilder","lib",
212			\&BuildSystem::TagUtils::libtagOpen, $self,
213			"", $self,
214			"", $self);
215
216			$self->{simpledoc}->addtag("branchbuilder","use",
217			\&BuildSystem::TagUtils::usetagOpen, $self,
218			"", $self,
219			"", $self);
220
221			$self->{simpledoc}->addtag("branchbuilder","libtype",
222			\&BuildSystem::TagUtils::libtypetagOpen, $self,
223			"", $self,
224			"", $self);
225
226			$self->{simpledoc}->addtag("branchbuilder","makefile",
227			\&BuildSystem::TagUtils::makefiletagOpen, $self,
228			\&BuildSystem::TagUtils::makefiletagContent, $self,
229			\&BuildSystem::TagUtils::makefiletagClose, $self);
230
231			$self->{simpledoc}->addtag("branchbuilder","flags",
232			\&BuildSystem::TagUtils::flagstagOpen, $self,
233			"", $self,
234			"", $self);
235
236			$self->{simpledoc}->addtag("branchbuilder","bin",
237			\&BuildSystem::TagUtils::binarytagOpen, $self,
238			"", $self,
239			\&BuildSystem::TagUtils::binarytagClose, $self);
240
241			$self->{simpledoc}->addtag("branchbuilder","module",
242			\&BuildSystem::TagUtils::moduletagOpen, $self,
243			"", $self,
244			\&BuildSystem::TagUtils::moduletagClose, $self);
245
246			$self->{simpledoc}->addtag("branchbuilder","application",
247			\&BuildSystem::TagUtils::applicationtagOpen, $self,
248			"", $self,
249			\&BuildSystem::TagUtils::applicationtagClose, $self);
250
251			$self->{simpledoc}->addtag("branchbuilder","library",
252			\&BuildSystem::TagUtils::librarytagOpen, $self,
253			"", $self,
254			\&BuildSystem::TagUtils::librarytagClose, $self);
255	sashby	1.17
256	sashby	1.26	return $self->{simpledoc};
257	sashby	1.17	}
258	williamc	1.2
259	sashby	1.26	sub parsebranchfiles()
260	sashby	1.15	{
261			my $self=shift;
262	sashby	1.26	my ($filenames)=@_; # array ref
263			# List of buildfiles:
264			$self->{localpaths}=$filenames;
265			$self->{simpledoc}=$self->_initbranchparser();
266			# We iterate over an array of files to be read in turn: all
267			# build data will be stored in the same BuildFile object:
268			$self->{simpledoc}->parsefilelist("branchbuilder",$filenames);
269			# We're done with the SimpleDoc object so delete it:
270			delete $self->{simpledoc};
271	sashby	1.15	}
272	williamc	1.1
273	sashby	1.26	sub productcollector()
274	sashby	1.23	{
275			my $self=shift;
276	sashby	1.26	my ($name,$typeshort,$typefull)=@_;
277			# Create a new Product object for storage of data:
278			use BuildSystem::Product;
279			my $product = BuildSystem::Product->new();
280			# Store the name:
281			$product->name($name);
282			$product->type($typeshort);
283			# Store the files:
284			$product->_files($self->{id}->{'file'},$self->{localpaths});
285			# Store the data content:
286			$product->_data($self->{tagcontent});
287			# And store in a hash (all build products in same place):
288			$self->{content}->{BUILDPRODUCTS}->{$typefull}->{$name} = $product;
289	sashby	1.23	}
290	williamc	1.1
291	sashby	1.26	sub pushlevel
292	sashby	1.17	{
293	sashby	1.26	my $self = shift;
294			my ($info)=@_;
295	sashby	1.17
296	sashby	1.26	$self->{id} = $info if (defined $info);
297			$self->{nested} = 1;
298			$self->{tagcontent}={};
299			}
300	sashby	1.15
301	sashby	1.26	sub poplevel
302			{
303			my $self = shift;
304			delete $self->{id};
305			delete $self->{nested};
306			delete $self->{tagcontent};
307	sashby	1.17	}
308	williamc	1.2
309	sashby	1.26	sub dependencies()
310	sashby	1.19	{
311			my $self=shift;
312	sashby	1.26	# Make a copy of the variable so that
313			# we don't have a DEPENDENCIES entry in RAWDATA:
314			my %DEPS=%{$self->{DEPENDENCIES}};
315			delete $self->{DEPENDENCIES};
316			return \%DEPS;
317	sashby	1.19	}
318
319	williamc	1.2	#
320	sashby	1.26	# All data access methods are inherited from BuildDataUtils.
321	williamc	1.2	#
322	sashby	1.26	1;