src/BuildSystem/XMLBuildFile.pm

#____________________________________________________________________ 
# File: XMLBuildFile.pm
#____________________________________________________________________ 
#  
# Author: Shaun Ashby <Shaun.Ashby@cern.ch>
# Update: 2005-04-22 15:22:06+0200
# Revision: $Id$ 
#
# Copyright: 2005 (C) Shaun Ashby
#
#--------------------------------------------------------------------
package BuildSystem::XMLBuildFile;
require 5.004;
use Exporter;
use BuildSystem::XMLTagUtils;
use ActiveDoc::SimpleXMLDoc;

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