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.28 2005/03/09 19:28:19 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::skiptagOpen, $self,
                              \&BuildSystem::TagUtils::skiptagMessage, $self,
                              \&BuildSystem::TagUtils::skiptagClose, $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;
   }

sub skippeddirs()
   {
   my $self=shift;
   my ($here)=@_;
   my $skipped;

   if ($self->{content}->{SKIPPEDDIRS}->[0] == 1)
      {
      $skipped = [ @{$self->{content}->{SKIPPEDDIRS}} ];
      delete $self->{content}->{SKIPPEDDIRS};
      }
   
   delete $self->{content}->{SKIPPEDDIRS};
   return $skipped;
   }

#
# All data access methods are inherited from BuildDataUtils.
#
1;
Revision:	1.29
Committed:	Fri Aug 5 16:44:40 2005 UTC (19 years, 9 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V1_0_3-p4, V1_0_3-p3, V1_0_3-p2, before110xmlBRmerge, V1_0_4p1, V1_0_3-p1, V1_0_3, V1_0_2, V1_0_2_p1
Branch point for:	v103_with_xml, v103_branch
Changes since 1.28:	+1 -2 lines
Log Message:	* empty log message *
#	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.29	# Revision: $Id: BuildFile.pm,v 1.28 2005/03/09 19:28:19 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	sashby	1.28	\&BuildSystem::TagUtils::skiptagOpen, $self,
112			\&BuildSystem::TagUtils::skiptagMessage, $self,
113			\&BuildSystem::TagUtils::skiptagClose, $self);
114	sashby	1.27
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			# We're done with the SimpleDoc object so delete it:
162			delete $self->{simpledoc};
163	sashby	1.19	}
164	williamc	1.2
165	sashby	1.26	sub _initbranchparser()
166	sashby	1.17	{
167			my $self=shift;
168	sashby	1.26
169			$self->{simpledoc}=ActiveDoc::SimpleDoc->new();
170			$self->{simpledoc}->newparse("branchbuilder");
171			$self->{simpledoc}->addignoretags("branchbuilder");
172
173			# For blank lines do nothing:
174			$self->{simpledoc}->addtag("branchbuilder","none",
175			"", $self,
176			"", $self,
177			"", $self);
178
179			# Define the tags to be used in this class:
180			$self->{simpledoc}->addtag("branchbuilder","productstore",
181			\&BuildSystem::TagUtils::productstoretagOpen, $self,
182			"", $self,
183			"", $self);
184
185			$self->{simpledoc}->addtag("branchbuilder","architecture",
186			\&BuildSystem::TagUtils::archtagOpen, $self,
187			"", $self,
188			\&BuildSystem::TagUtils::archtagClose, $self);
189
190			$self->{simpledoc}->addtag("branchbuilder","include_path",
191			\&BuildSystem::TagUtils::includetagOpen, $self,
192			"", $self,
193			"", $self);
194
195			$self->{simpledoc}->addtag("branchbuilder","export",
196			\&BuildSystem::TagUtils::exporttagOpen, $self,
197			"", $self,
198			\&BuildSystem::TagUtils::exporttagClose, $self);
199
200			$self->{simpledoc}->addtag("branchbuilder","define_group",
201			\&BuildSystem::TagUtils::groupdeftagOpen, $self,
202			"", $self,
203			\&BuildSystem::TagUtils::groupdeftagClose, $self);
204
205			$self->{simpledoc}->addtag("branchbuilder","group",
206			\&BuildSystem::TagUtils::grouptagOpen, $self,
207			"", $self,
208			"", $self);
209
210			$self->{simpledoc}->addtag("branchbuilder","lib",
211			\&BuildSystem::TagUtils::libtagOpen, $self,
212			"", $self,
213			"", $self);
214
215			$self->{simpledoc}->addtag("branchbuilder","use",
216			\&BuildSystem::TagUtils::usetagOpen, $self,
217			"", $self,
218			"", $self);
219
220			$self->{simpledoc}->addtag("branchbuilder","libtype",
221			\&BuildSystem::TagUtils::libtypetagOpen, $self,
222			"", $self,
223			"", $self);
224
225			$self->{simpledoc}->addtag("branchbuilder","makefile",
226			\&BuildSystem::TagUtils::makefiletagOpen, $self,
227			\&BuildSystem::TagUtils::makefiletagContent, $self,
228			\&BuildSystem::TagUtils::makefiletagClose, $self);
229
230			$self->{simpledoc}->addtag("branchbuilder","flags",
231			\&BuildSystem::TagUtils::flagstagOpen, $self,
232			"", $self,
233			"", $self);
234
235			$self->{simpledoc}->addtag("branchbuilder","bin",
236			\&BuildSystem::TagUtils::binarytagOpen, $self,
237			"", $self,
238			\&BuildSystem::TagUtils::binarytagClose, $self);
239
240			$self->{simpledoc}->addtag("branchbuilder","module",
241			\&BuildSystem::TagUtils::moduletagOpen, $self,
242			"", $self,
243			\&BuildSystem::TagUtils::moduletagClose, $self);
244
245			$self->{simpledoc}->addtag("branchbuilder","application",
246			\&BuildSystem::TagUtils::applicationtagOpen, $self,
247			"", $self,
248			\&BuildSystem::TagUtils::applicationtagClose, $self);
249
250			$self->{simpledoc}->addtag("branchbuilder","library",
251			\&BuildSystem::TagUtils::librarytagOpen, $self,
252			"", $self,
253			\&BuildSystem::TagUtils::librarytagClose, $self);
254	sashby	1.17
255	sashby	1.26	return $self->{simpledoc};
256	sashby	1.17	}
257	williamc	1.2
258	sashby	1.26	sub parsebranchfiles()
259	sashby	1.15	{
260			my $self=shift;
261	sashby	1.26	my ($filenames)=@_; # array ref
262			# List of buildfiles:
263			$self->{localpaths}=$filenames;
264			$self->{simpledoc}=$self->_initbranchparser();
265			# We iterate over an array of files to be read in turn: all
266			# build data will be stored in the same BuildFile object:
267			$self->{simpledoc}->parsefilelist("branchbuilder",$filenames);
268			# We're done with the SimpleDoc object so delete it:
269			delete $self->{simpledoc};
270	sashby	1.15	}
271	williamc	1.1
272	sashby	1.26	sub productcollector()
273	sashby	1.23	{
274			my $self=shift;
275	sashby	1.26	my ($name,$typeshort,$typefull)=@_;
276			# Create a new Product object for storage of data:
277			use BuildSystem::Product;
278			my $product = BuildSystem::Product->new();
279			# Store the name:
280			$product->name($name);
281			$product->type($typeshort);
282			# Store the files:
283			$product->_files($self->{id}->{'file'},$self->{localpaths});
284			# Store the data content:
285			$product->_data($self->{tagcontent});
286			# And store in a hash (all build products in same place):
287			$self->{content}->{BUILDPRODUCTS}->{$typefull}->{$name} = $product;
288	sashby	1.23	}
289	williamc	1.1
290	sashby	1.26	sub pushlevel
291	sashby	1.17	{
292	sashby	1.26	my $self = shift;
293			my ($info)=@_;
294	sashby	1.17
295	sashby	1.26	$self->{id} = $info if (defined $info);
296			$self->{nested} = 1;
297			$self->{tagcontent}={};
298			}
299	sashby	1.15
300	sashby	1.26	sub poplevel
301			{
302			my $self = shift;
303			delete $self->{id};
304			delete $self->{nested};
305			delete $self->{tagcontent};
306	sashby	1.17	}
307	williamc	1.2
308	sashby	1.26	sub dependencies()
309	sashby	1.19	{
310			my $self=shift;
311	sashby	1.26	# Make a copy of the variable so that
312			# we don't have a DEPENDENCIES entry in RAWDATA:
313			my %DEPS=%{$self->{DEPENDENCIES}};
314			delete $self->{DEPENDENCIES};
315			return \%DEPS;
316	sashby	1.19	}
317
318	sashby	1.28	sub skippeddirs()
319			{
320			my $self=shift;
321			my ($here)=@_;
322			my $skipped;
323
324			if ($self->{content}->{SKIPPEDDIRS}->[0] == 1)
325			{
326			$skipped = [ @{$self->{content}->{SKIPPEDDIRS}} ];
327			delete $self->{content}->{SKIPPEDDIRS};
328			}
329
330			delete $self->{content}->{SKIPPEDDIRS};
331			return $skipped;
332			}
333
334	williamc	1.2	#
335	sashby	1.26	# All data access methods are inherited from BuildDataUtils.
336	williamc	1.2	#
337	sashby	1.26	1;