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
#	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: XMLBuildFile.pm,v 1.1 2005/04/28 09:17:46 sashby Exp $
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 BuildSystem::BuildDataUtils;
17	use ActiveDoc::SimpleXMLDoc;
18
19	@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	$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	"include_path",
74	\&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	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	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;