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
#	Content
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;