src/BuildSystem/XMLBuildFile.pm

#____________________________________________________________________ 
# File: XMLBuildFile.pm
#____________________________________________________________________ 
#  
# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
# Update: 2005-04-22 15:22:06+0200
# Revision: $Id: XMLBuildFile.pm,v 1.1 2005/04/28 09:17:46 sashby Exp $ 
#
# Copyright: 2005 (C) Shaun Ashby
#
#--------------------------------------------------------------------
package BuildSystem::XMLBuildFile;
require 5.004;
use Exporter;
use BuildSystem::XMLTagUtils;
use BuildSystem::BuildDataUtils;
use ActiveDoc::SimpleXMLDoc;

@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->{content} = {};
   return $self;
   }

sub _parser()
   {
   my $self=shift;

   # Initialise the doc and a XML::Parser instance, passing in
   # the default handlers for start, end and char types:
   $self->{simplexmldoc} = ActiveDoc::SimpleXMLDoc->new(\&BuildSystem::XMLTagUtils::OpenTagHandler,
                                                        \&BuildSystem::XMLTagUtils::ClosingTagHandler,
                                                        \&BuildSystem::XMLTagUtils::CharHandler,
                                                        "builder");
   
   # Pass a ref to parent object so that tag data can be stored
   # directly in the XMLBuildFile object:
   &BuildSystem::XMLTagUtils::datastore($self);
   
   # Register the specific tag routines with expected attributes. If no checking should be done
   # then just put 0. For nested tags, last element is 1:
   $self->{simplexmldoc}->registerTag("builder",
                                      "classpath",
                                      \&BuildSystem::XMLTagUtils::classpathtaghandler,
                                      [ "path" ],
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "productstore",
                                      \&BuildSystem::XMLTagUtils::productstoretaghandler,
                                      [ "name" ],
                                      0);

   $self->{simplexmldoc}->registerTag("builder",
                                      "include_path",
                                      \&BuildSystem::XMLTagUtils::includetaghandler,
                                      [ "path" ],
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "use",
                                      \&BuildSystem::XMLTagUtils::usetaghandler,
                                      [ "name" ],
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "lib",
                                      \&BuildSystem::XMLTagUtils::libtaghandler,
                                      [ "name" ],
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "group",
                                      \&BuildSystem::XMLTagUtils::grouptaghandler,
                                      [ "name" ],
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "libtype",
                                      \&BuildSystem::XMLTagUtils::libtypetaghandler,
                                      [ "type" ],
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "flags",
                                      \&BuildSystem::XMLTagUtils::flagstaghandler,
                                      0,
                                      0);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "skip",
                                      \&BuildSystem::XMLTagUtils::skiptaghandler,
                                      0,
                                      1);
   
   # Nested tags (i.e. tags that can contain other tags):
   $self->{simplexmldoc}->registerTag("builder",
                                      "export",
                                      \&BuildSystem::XMLTagUtils::exporttaghandler,
                                      0,
                                      1);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "makefile",
                                      \&BuildSystem::XMLTagUtils::makefiletaghandler,
                                      0,
                                      1);

   $self->{simplexmldoc}->registerTag("builder",
                                      "architecture",
                                      \&BuildSystem::XMLTagUtils::archtaghandler,
                                      0,
                                      1);

   $self->{simplexmldoc}->registerTag("builder",
                                      "define_group",
                                      \&BuildSystem::XMLTagUtils::groupdeftaghandler,
                                      [ "name" ],
                                      1);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "bin",
                                      \&BuildSystem::XMLTagUtils::binarytaghandler,
                                      [ "file" ],
                                      1);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "module",
                                      \&BuildSystem::XMLTagUtils::moduletaghandler,
                                      [ "file" ],
                                      1);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "plugin",
                                      \&BuildSystem::XMLTagUtils::plugintaghandler,
                                      [ "file" ],
                                      1);

   $self->{simplexmldoc}->registerTag("builder",
                                      "application",
                                      \&BuildSystem::XMLTagUtils::applicationtaghandler,
                                      [ "file" ],
                                      1);
   
   $self->{simplexmldoc}->registerTag("builder",
                                      "library",
                                      \&BuildSystem::XMLTagUtils::librarytaghandler,
                                      [ "file" ],
                                      1);

   # Register the XML parsing tag routines (default ones, plus those added above):
   $self->{simplexmldoc}->setHandlers();
   
   # Return the parser object:
   return $self->{simplexmldoc};
   }

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

sub parse()
   {
   my $self=shift;
   my ($filename)=@_;
   # Parse the file:
   $self->_parser()->parsefile($filename);
   # We're done with the simpleXMLDoc object:
   delete $self->{simplexmldoc};
   }

sub parsebranchfiles()
   {
   my $self=shift;
   my ($filenames)=@_; # array ref
   # Now just run parse(), with only one file as arg:
   my $file = $filenames->[0];
   $self->parse($file);
   }

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;
   }

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;
   }

1;
Revision:	1.2
Committed:	Fri Apr 29 16:18:56 2005 UTC (20 years 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, v102p1
Branch point for:	v103_with_xml, v103_branch
Changes since 1.1:	+13 -3 lines
Log Message:	UPdates Scram to SCRAM
#	User	Rev	Content
1	sashby	1.1	#____________________________________________________________________
2			# File: XMLBuildFile.pm
3			#____________________________________________________________________
4			#
5			# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
6			# Update: 2005-04-22 15:22:06+0200
7	sashby	1.2	# Revision: $Id: XMLBuildFile.pm,v 1.1 2005/04/28 09:17:46 sashby Exp $
8	sashby	1.1	#
9			# Copyright: 2005 (C) Shaun Ashby
10			#
11			#--------------------------------------------------------------------
12			package BuildSystem::XMLBuildFile;
13			require 5.004;
14			use Exporter;
15			use BuildSystem::XMLTagUtils;
16	sashby	1.2	use BuildSystem::BuildDataUtils;
17	sashby	1.1	use ActiveDoc::SimpleXMLDoc;
18
19	sashby	1.2	@ISA=qw(Exporter BuildSystem::BuildDataUtils);
20	sashby	1.1	@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			$self->{content} = {};
40			return $self;
41			}
42
43			sub _parser()
44			{
45			my $self=shift;
46
47			# Initialise the doc and a XML::Parser instance, passing in
48			# the default handlers for start, end and char types:
49			$self->{simplexmldoc} = ActiveDoc::SimpleXMLDoc->new(\&BuildSystem::XMLTagUtils::OpenTagHandler,
50			\&BuildSystem::XMLTagUtils::ClosingTagHandler,
51			\&BuildSystem::XMLTagUtils::CharHandler,
52			"builder");
53
54			# Pass a ref to parent object so that tag data can be stored
55			# directly in the XMLBuildFile object:
56			&BuildSystem::XMLTagUtils::datastore($self);
57
58			# Register the specific tag routines with expected attributes. If no checking should be done
59			# then just put 0. For nested tags, last element is 1:
60			$self->{simplexmldoc}->registerTag("builder",
61			"classpath",
62			\&BuildSystem::XMLTagUtils::classpathtaghandler,
63			[ "path" ],
64			0);
65
66			$self->{simplexmldoc}->registerTag("builder",
67			"productstore",
68			\&BuildSystem::XMLTagUtils::productstoretaghandler,
69			[ "name" ],
70			0);
71
72			$self->{simplexmldoc}->registerTag("builder",
73	sashby	1.2	"include_path",
74	sashby	1.1	\&BuildSystem::XMLTagUtils::includetaghandler,
75			[ "path" ],
76			0);
77
78			$self->{simplexmldoc}->registerTag("builder",
79			"use",
80			\&BuildSystem::XMLTagUtils::usetaghandler,
81			[ "name" ],
82			0);
83
84			$self->{simplexmldoc}->registerTag("builder",
85			"lib",
86			\&BuildSystem::XMLTagUtils::libtaghandler,
87			[ "name" ],
88			0);
89
90			$self->{simplexmldoc}->registerTag("builder",
91			"group",
92			\&BuildSystem::XMLTagUtils::grouptaghandler,
93			[ "name" ],
94			0);
95
96			$self->{simplexmldoc}->registerTag("builder",
97			"libtype",
98			\&BuildSystem::XMLTagUtils::libtypetaghandler,
99			[ "type" ],
100			0);
101
102			$self->{simplexmldoc}->registerTag("builder",
103			"flags",
104			\&BuildSystem::XMLTagUtils::flagstaghandler,
105			0,
106			0);
107
108			$self->{simplexmldoc}->registerTag("builder",
109			"skip",
110			\&BuildSystem::XMLTagUtils::skiptaghandler,
111			0,
112			1);
113
114			# Nested tags (i.e. tags that can contain other tags):
115			$self->{simplexmldoc}->registerTag("builder",
116			"export",
117			\&BuildSystem::XMLTagUtils::exporttaghandler,
118			0,
119			1);
120
121			$self->{simplexmldoc}->registerTag("builder",
122			"makefile",
123			\&BuildSystem::XMLTagUtils::makefiletaghandler,
124			0,
125			1);
126
127			$self->{simplexmldoc}->registerTag("builder",
128			"architecture",
129			\&BuildSystem::XMLTagUtils::archtaghandler,
130			0,
131			1);
132
133			$self->{simplexmldoc}->registerTag("builder",
134			"define_group",
135			\&BuildSystem::XMLTagUtils::groupdeftaghandler,
136			[ "name" ],
137			1);
138
139			$self->{simplexmldoc}->registerTag("builder",
140			"bin",
141			\&BuildSystem::XMLTagUtils::binarytaghandler,
142			[ "file" ],
143			1);
144
145			$self->{simplexmldoc}->registerTag("builder",
146			"module",
147			\&BuildSystem::XMLTagUtils::moduletaghandler,
148			[ "file" ],
149			1);
150
151			$self->{simplexmldoc}->registerTag("builder",
152			"plugin",
153			\&BuildSystem::XMLTagUtils::plugintaghandler,
154			[ "file" ],
155			1);
156
157			$self->{simplexmldoc}->registerTag("builder",
158			"application",
159			\&BuildSystem::XMLTagUtils::applicationtaghandler,
160			[ "file" ],
161			1);
162
163			$self->{simplexmldoc}->registerTag("builder",
164			"library",
165			\&BuildSystem::XMLTagUtils::librarytaghandler,
166			[ "file" ],
167			1);
168
169			# Register the XML parsing tag routines (default ones, plus those added above):
170			$self->{simplexmldoc}->setHandlers();
171
172			# Return the parser object:
173			return $self->{simplexmldoc};
174			}
175
176			sub simplexmldoc()
177			{
178			my $self=shift;
179			@_ ? $self->{simplexmldoc} = shift
180			: $self->{simplexmldoc};
181			}
182
183			sub parse()
184			{
185			my $self=shift;
186			my ($filename)=@_;
187			# Parse the file:
188			$self->_parser()->parsefile($filename);
189			# We're done with the simpleXMLDoc object:
190			delete $self->{simplexmldoc};
191			}
192
193	sashby	1.2	sub parsebranchfiles()
194			{
195			my $self=shift;
196			my ($filenames)=@_; # array ref
197			# Now just run parse(), with only one file as arg:
198			my $file = $filenames->[0];
199			$self->parse($file);
200			}
201
202	sashby	1.1	sub pushlevel
203			{
204			my $self = shift;
205			my ($info)=@_;
206
207			$self->{id} = $info if (defined $info);
208			$self->{nested} = 1;
209			$self->{tagcontent}={};
210			}
211
212			sub poplevel
213			{
214			my $self = shift;
215			delete $self->{id};
216			delete $self->{nested};
217			delete $self->{tagcontent};
218			}
219
220			sub dependencies()
221			{
222			my $self=shift;
223			# Make a copy of the variable so that
224			# we don't have a DEPENDENCIES entry in RAWDATA:
225			my %DEPS=%{$self->{DEPENDENCIES}};
226			delete $self->{DEPENDENCIES};
227			return \%DEPS;
228			}
229
230			sub skippeddirs()
231			{
232			my $self=shift;
233			my ($here)=@_;
234			my $skipped;
235
236			if ($self->{content}->{SKIPPEDDIRS}->[0] == 1)
237			{
238			$skipped = [ @{$self->{content}->{SKIPPEDDIRS}} ];
239			delete $self->{content}->{SKIPPEDDIRS};
240			}
241
242			delete $self->{content}->{SKIPPEDDIRS};
243			return $skipped;
244			}
245
246			sub productcollector()
247			{
248			my $self=shift;
249			my ($name,$typeshort,$typefull)=@_;
250			# Create a new Product object for storage of data:
251			use BuildSystem::Product;
252			my $product = BuildSystem::Product->new();
253			# Store the name:
254			$product->name($name);
255			$product->type($typeshort);
256			# Store the files:
257			$product->_files($self->{id}->{'file'},$self->{localpaths});
258			# Store the data content:
259			$product->_data($self->{tagcontent});
260			# And store in a hash (all build products in same place):
261			$self->{content}->{BUILDPRODUCTS}->{$typefull}->{$name} = $product;
262			}
263
264			1;