ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/SCRAM/src/BuildSystem/Requirements.pm

Comparing COMP/SCRAM/src/BuildSystem/Requirements.pm (file contents):
Revision 1.14 by sashby, Fri Oct 11 14:23:24 2002 UTC vs.
Revision 1.22 by sashby, Wed Feb 15 17:14:17 2006 UTC

#	Line 21 | Line 21 | use Utilities::Verbose;
21		require 5.004;
22		@ISA=qw(Utilities::Verbose);
23
24	<	sub new {
25	<	my $class=shift;
26	<	my $self={};
27	<	bless $self, $class;
28	<	$self->{dbstore}=shift;
29	<	$self->{file}=shift;
30	<	$self->{cache}=$self->{dbstore}->cache();
31	<	if ( @_ ) {
32	<	$self->arch(shift);
33	<	}
34	<	$self->verbose("Initialising a new Requirements Doc");
35	<	$self->{mydocversion}="2.0";
36	<	$self->{Arch}=1;
37	<	push @{$self->{ARCHBLOCK}}, $self->{Arch};
38	<	$self->init($self->{file});
39	<	return $self;
40	<	}
41	<
42	<	sub url {
43	<	my $self=shift;
44	<	if ( @_ ) {
45	<	$self->{file}=shift;
46	<	}
47	<	return $self->{file}
48	<	}
24	>	sub new
25	>	{
26	>	my $class=shift;
27	>	my $self={};
28	>	bless $self, $class;
29	>	$self->{dbstore}=shift;
30	>	$self->{file}=shift;
31	>	$self->{cache}=$self->{dbstore}->cache();
32	>
33	>	if ( @_ )
34	>	{
35	>	$self->arch(shift);
36	>	}
37	>	$self->verbose("Initialising a new Requirements Doc");
38	>	$self->{mydocversion}="2.0";
39	>	# Counter for downloaded tools: zero it here. It will
40	>	# be auto-incremented as each tool is selected:
41	>	$self->{selectcounter}=0;
42	>
43	>	$self->{Arch}=1;
44	>	push @{$self->{ARCHBLOCK}}, $self->{Arch};
45	>	$self->init($self->{file});
46	>	return $self;
47	>	}
48
49	<	sub setup
49	>	sub toolmanager
50		{
51		my $self=shift;
52	<	my $toolbox=shift;
53	<	my $tool;
52	>
53	>	@_ ? $self->{toolmanagerobject} = shift
54	>	: $self->{toolmanagerobject};
55	>
56	>	}
57	>
58	>	sub configversion
59	>	{
60	>	my $self=shift;
61	>	@_ ? $self->{configversion} = shift
62	>	: $self->{configversion};
63	>	}
64
65	<	foreach $tool ( $self->selectedtools() )
65	>	sub url
66	>	{
67	>	my $self=shift;
68	>
69	>	if ( @_ )
70		{
71	<	$self->verbose("Setting Up Tool $tool");
59	<	$toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool));
71	>	$self->{file}=shift;
72		}
73	+	return $self->{file};
74	+	}
75	+
76	+	sub tools
77	+	{
78	+	my $self=shift;
79	+	return @{$self->{tools}};
80	+	}
81	+
82	+	sub toolcomment
83	+	{
84	+	my $self=shift;
85	+	my $tool=shift;
86	+	my $version=shift;
87	+
88	+	return $self->{reqtext}{$tool}{$version};
89	+	}
90	+
91	+	sub distributionurl
92	+	{
93	+	my $self=shift;
94	+	my $tool=shift;
95	+	my $version=shift;
96	+
97	+	return ( defined $self->{dist}{$tool}{$version})?
98	+	$self->{dist}{$tool}{$version}:undef;
99		}
100
101	<	sub tools {
102	<	my $self=shift;
103	<	return @{$self->{tools}};
104	<	}
101	>	sub version
102	>	{
103	>	my $self=shift;
104	>	my $tool=shift;
105	>	return $self->{'version'}{$tool};
106	>	}
107
108	+	sub toolurl
109	+	{
110	+	my $self=shift;
111	+	my $tool=shift;
112	+	return $self->{'url'}{$tool};
113	+	}
114
115	<	sub selectedtools
115	>	sub init
116		{
71	–	###############################################################
72	–	# selectedtools()                                             #
73	–	###############################################################
74	–	# modified : Wed Dec  5 15:39:39 2001 / SFA                   #
75	–	# params   :                                                  #
76	–	#          :                                                  #
77	–	#          :                                                  #
78	–	#          :                                                  #
79	–	# function : New version of routine. Return a list of tools   #
80	–	#          : that were selected after parsing RequirementsDoc #
81	–	#          :                                                  #
82	–	#          :                                                  #
83	–	###############################################################
117		my $self=shift;
118	<	my @toolarray = ();
118	>	my $url=shift;
119
120	<	# Grab the arrays of tools:
121	<	my ($toolref,$deseltoolref,$unseltoolref) = $self->grabtools();
120	>	my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
121	>	$switch->verbosity($self->verbosity());
122	>	$switch->url($url);
123	>	$switch->newparse("ordering");
124	>	$switch->addbasetags("ordering");
125
126	<	my @tools = @{$toolref};
127	<	my @deseltools = @{$deseltoolref};
128	<	my @unseltools = @{$unseltoolref};
126	>	$switch->addtag("ordering","Architecture",
127	>	\&Arch_Start,$self,
128	>	"", $self,
129	>	\&Arch_End, $self);
130	>	$switch->addtag("ordering","select",
131	>	\&select_start,$self,
132	>	"", $self,
133	>	"", $self);
134	>	$switch->grouptag("Architecture","ordering");
135	>	$switch->addtag("ordering","require",
136	>	\&require_start,$self,
137	>	\&require_text, $self,
138	>	\&require_end, $self);
139
140	<	if ($#tools == -1)
141	<	{
142	<	$self->verbose(">> No tools SELECTED. Checking for DESELECTED tools");
143	<
144	<	# No tools "SELECTED". We return the tools that were "UNSELECTED"
145	<	# (these are the tools that remain after unwanted tools are deselected):
146	<	if ($#unseltools != -1)
140	>	$self->{reqcontext}=0;
141	>	$self->{switch}=$switch;
142	>	undef $self->{restrictstack};
143	>	@{$self->{tools}}=();
144	>
145	>	my($doctype,$docversion)=$switch->doctype();
146	>	# -- for backwards compatability only parse if we have a docversion
147	>	#    defined:
148	>	if ( defined $docversion )
149	>	{
150	>	if ($docversion eq $self->{mydocversion})
151		{
152	<	$self->verbose(">> Using the tools remaining after DESELECTION ops");
153	<	# The array has elements:
154	<	return @unseltools;
152	>	@{$self->{ArchStack}}=();
153	>	$self->verbose("Initial Document Parse");
154	>	$self->{switch}->parse("ordering");
155	>	# Set the config version. If there isn't a version, it means that we
156	>	# have a stand-alone repository for the toolbox, rather than a CVS
157	>	# one. Hence, no CVS tag (== version):
158	>	($switch->{configurl}->param('version') eq '') ?
159	>	$self->configversion("STANDALONE") :
160	>	$self->configversion($switch->{configurl}->param('version'));
161		}
162		else
163		{
164	<	$self->verbose(">> No UNSELECTED tools.....");
164	>	$self->verbose("wrong doc version - not parsing");
165		}
166		}
167		else
168		{
169	<	# We will return the selected tools but only after checking
114	<	# for subsequently deselected tools (unlikely but...):
115	<	foreach $selected (@tools)
116	<	{
117	<	# If the tool exists in the deselected tool array, pass.
118	<	if ( ! grep /$selected/, @deseltools)
119	<	{
120	<	push @toolarray, $selected;
121	<	}
122	<	else
123	<	{
124	<	$self->verbose(">> Tool $selected was subsequently deselected.");
125	<	}
126	<	}
169	>	$self->verbose("wrong doc type - not parsing");
170		}
128	–	return @toolarray;
171		}
172
173	<
132	<	sub grabtools
173	>	sub arch
174		{
134	–	###############################################################
135	–	# grabtools()                                                 #
136	–	###############################################################
137	–	# modified : Wed Dec  5 14:41:56 2001 / SFA                   #
138	–	# params   :                                                  #
139	–	#          :                                                  #
140	–	#          :                                                  #
141	–	#          :                                                  #
142	–	# function : Loop over the tools read from RequirementsDoc    #
143	–	#          : and fill arrays for selected, deselected and     #
144	–	#          : unselected tools.                                #
145	–	#          :                                                  #
146	–	###############################################################
175		my $self=shift;
176	<	my @toollist=();
177	<	my @deseltoollist=();
150	<	my @unseltoollist=();
151	<
152	<	foreach $tool (  @{$self->{tools}} )
176	>	# $self->arch is the SCRAM_ARCH value:
177	>	if ( @_ )
178		{
179	<	if ( $self->{selected}{$tool} eq "SELECTED" )
180	<	{
181	<	push @toollist, $tool;
182	<	}
183	<	elsif ( $self->{selected}{$tool} eq "DESELECTED" )
159	<	{
160	<	push @deseltoollist, $tool;
161	<	}
162	<	elsif ( $self->{selected}{$tool} eq "UNSELECTED" )
163	<	{
164	<	push @unseltoollist, $tool;
165	<	}
166	<	else
179	>	$self->{arch}=shift;
180	>	}
181	>	else
182	>	{
183	>	if ( ! defined $self->{arch} )
184		{
185	<	$self->verbose(">> Looks like an unknown sel flag for tool ".$tool." ");
185	>	$self->{arch}="";
186		}
187		}
188	<	return \(@toollist, @deseltoollist, @unseltoollist);
188	>	return $self->{arch};
189		}
190
191	+	sub archlist
192	+	{
193	+	my $self=shift;
194	+	return @{$self->{ArchStack}};
195	+	}
196
197	<	sub toolcomment {
198	<	my $self=shift;
199	<	my $tool=shift;
200	<	my $version=shift;
201	<
202	<	return $self->{reqtext}{$tool}{$version};
203	<	}
204	<
205	<	sub distributionurl {
206	<	my $self=shift;
207	<	my $tool=shift;
208	<	my $version=shift;
209	<
188	<	return ( defined $self->{dist}{$tool}{$version})?
189	<	$self->{dist}{$tool}{$version}:undef;
190	<	}
191	<
192	<	sub version {
193	<	my $self=shift;
194	<	my $tool=shift;
195	<	return $self->{'version'}{$tool};
196	<	}
197	<
198	<	sub toolurl {
199	<	my $self=shift;
200	<	my $tool=shift;
201	<	return $self->{'url'}{$tool};
202	<	}
203	<
204	<	sub init {
205	<	my $self=shift;
206	<	my $url=shift;
207	<
208	<	my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
209	<	$switch->verbosity($self->verbosity());
210	<	$switch->url($url);
211	<	$switch->newparse("ordering");
212	<	$switch->addbasetags("ordering");
213	<	$switch->addtag("ordering","Architecture",
214	<	\&Arch_Start,$self,
215	<	"", $self,
216	<	\&Arch_End, $self);
217	<	$switch->addtag("ordering","Restrict",
218	<	\&Restrict_start,$self,
219	<	"", $self,
220	<	\&Restrict_end, $self);
221	<	$switch->addtag("ordering","deselect",
222	<	\&deselect_start,$self,
223	<	"", $self,
224	<	"", $self);
225	<	$switch->addtag("ordering","select",
226	<	\&select_start,$self,
227	<	"", $self,
228	<	"", $self);
229	<	$switch->addtag("ordering","distribution",
230	<	\&disttag,$self);
231	<	$switch->grouptag("Architecture","ordering");
232	<	$switch->addtag("ordering","require",
233	<	\&require_start,$self,
234	<	\&require_text, $self,
235	<	\&require_end, $self);
236	<
237	<	$self->{reqcontext}=0;
238	<	$self->{switch}=$switch;
239	<	undef $self->{restrictstack};
240	<	@{$self->{tools}}=();
241	<
242	<	my($doctype,$docversion)=$switch->doctype();
243	<	# -- for backwards compatability only parse if we have a docversion
244	<	#    defined
245	<	if ( defined $docversion ) {
246	<	if ( $docversion eq $self->{mydocversion} ) {
247	<	@{$self->{ArchStack}}=();
248	<	$self->verbose("Initial Document Parse");
249	<	$self->{switch}->parse("ordering");
250	<	}
251	<	else {
252	<	$self->verbose("wrong doc version - not parsing");
253	<	}
254	<	}
255	<	else {
256	<	$self->verbose("wrong doc type - not parsing");
257	<	}
258	<	}
259	<
260	<	sub arch {
261	<	my $self=shift;
262	<	# $self->arch is the SCRAM_ARCH value:
263	<	if ( @_ ) {
264	<	$self->{arch}=shift
265	<	}
266	<	else {
267	<	if ( ! defined $self->{arch} ) {
268	<	$self->{arch}="";
269	<	}
270	<	}
271	<	return $self->{arch};
272	<	}
273	<
274	<	sub archlist {
275	<	my $self=shift;
276	<	return @{$self->{ArchStack}};
277	<	}
278	<
279	<	sub getreqforarch {
280	<	my $self=shift;
281	<	my $arch=shift;
282	<
283	<	if ( ! defined $self->{reqsforarch}{$arch} ) {
284	<	$self->{reqsforarch}{$arch}=
285	<	BuildSystem::Requirements->new($self->{dbstore},$self->{file},
286	<	$arch);
287	<	}
288	<	return $self->{reqsforarch}{$arch};
289	<	}
290	<
197	>	sub getreqforarch
198	>	{
199	>	my $self=shift;
200	>	my $arch=shift;
201	>
202	>	if ( ! defined $self->{reqsforarch}{$arch} )
203	>	{
204	>	$self->{reqsforarch}{$arch}=
205	>	BuildSystem::Requirements->new($self->{dbstore},$self->{file},
206	>	$arch);
207	>	}
208	>	return $self->{reqsforarch}{$arch};
209	>	}
210
211		sub download
212		{
#	Line 301 | Line 220 | sub download
220		{
221		print "#";
222		$self->verbose("Downloading ".$self->toolurl($tool));
223	<	# get into the cache
223	>	# get into the cache:
224		$self->{switch}->urlget($self->toolurl($tool));
225		}
226	<	print "\nDone.","\n","\n";
226	>	print "\nDone.","\n";
227	>	# So now add the list of downloaded tools, and which were
228	>	# selected, to tool cache:
229	>	print "Tool info cached locally.","\n","\n";
230	>
231	>	# Now copy required info from this object to ToolManager (ToolCache):
232	>	$self->toolmanager()->downloadedtools($self->{tools});
233	>	$self->toolmanager()->defaultversions($self->{version});
234	>	$self->toolmanager()->toolurls($self->{url});
235	>	$self->toolmanager()->selected($self->{selected});
236		}
237
238	<	sub _autoselect {
239	<	my $self=shift;
240	<	if ( @_ ) {
241	<	$self->{autoselect}=shift;
242	<	}
243	<	# -- default is true
244	<	return ((defined $self->{autoselect})?$self->{autoselect}:1);
245	<	}
246	<
247	<	# ---- Tag routines
320	<
321	<	sub Restrict_start {
322	<	my $self=shift;
323	<	my $name=shift;
324	<	my $hashref=shift;
325	<
326	<	$self->{switch}->checktag( $name, $hashref, 'autoselect');
327	<	if ( $self->{Arch} ) {
328	<	# -- create selection state stack
329	<	push @{$self->{restrictstack}}, $self->_autoselect();
330	<	$self->_autoselect(
331	<	(($$hashref{'autoselect'}=~/true/i)?1:0));
332	<	}
333	<	}
334	<
335	<	sub Restrict_end {
336	<	my $self=shift;
337	<	my $name=shift;
338	<
339	<	if ( $self->{Arch} ) {
340	<	if ( $#{$self->{restrictstack}} >= 0 ) {
341	<	$self->_autoselect(pop @{$self->{restrictstack}});
342	<	}
343	<	else {
344	<	$self->{switch}->parseerror("Unmatched </$name>");
345	<	}
346	<	}
347	<	}
348	<
349	<	sub require_start {
350	<	my $self=shift;
351	<	my $name=shift;
352	<	my $hashref=shift;
353	<
354	<	$self->{switch}->checktag( $name, $hashref, 'version');
355	<	$self->{switch}->checktag( $name, $hashref, 'name');
356	<	$self->{switch}->checktag( $name, $hashref, 'url');
357	<
358	<	if ( $self->{reqcontext} == 1 ) {
359	<	$self->{switch}->parseerror(
360	<	"Open new $name context without previous </$name>");
361	<	}
362	<	$self->{reqcontext}=1;
363	<	$$hashref{'name'}=~tr[A-Z][a-z];
364	<	print "Adding ",$$hashref{'name'}," to the tool stack","\n";
365	<	push @{$self->{tools}}, $$hashref{'name'};
366	<	$self->{version}{$$hashref{'name'}}=$$hashref{'version'};
367	<	print "       version: ",$self->{version}{$$hashref{'name'}},"\n";
368	<	# -- make sure the full url is taken
369	<	my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
370	<	$self->{url}{$$hashref{'name'}}=$urlobj->url();
371	<
372	<	# Disable the auto select mechanism. Now, we start with
373	<	# all tools having a flag "UNSELECTED". Then we choose
374	<	# which we wish to select:
375	<	if ( $self->{Arch} )
376	<	{
377	<	$self->{selected}{$$hashref{'name'}}="UNSELECTED";
378	<	}
379	<	# Output the tool name here with the value
380	<	# of its' select flag:
381	<	$self->verbose(">> Tool name: ".$$hashref{'name'}." sel/desel flag value: ".
382	<	$self->{selected}{$$hashref{'name'}} ." ");
383	<
384	<	$self->{creqtool}=$$hashref{'name'};
385	<	$self->{creqversion}=$$hashref{'version'};
386	<	$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
387	<	}
388	<
389	<	sub require_text {
390	<	my $self=shift;
391	<	my $name=shift;
392	<	my $string=shift;
393	<
394	<	chomp $string;
395	<	$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
396	<	$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
397	<	$string;
398	<
399	<	}
400	<
401	<	sub require_end {
402	<	my $self=shift;
403	<	my $name=shift;
404	<
405	<	if ( $self->{reqcontext} != 1 ) {
406	<	$self->{switch}->parseerror("No matching tag for </$name>");
407	<	}
408	<	else {
409	<	$self->{reqcontext}=0;
410	<	}
411	<	}
238	>	sub _autoselect
239	>	{
240	>	my $self=shift;
241	>	if ( @_ )
242	>	{
243	>	$self->{autoselect}=shift;
244	>	}
245	>	# -- default is true
246	>	return ((defined $self->{autoselect})?$self->{autoselect}:1);
247	>	}
248
249	<	sub select_start
249	>	sub require_start
250		{
251		my $self=shift;
252		my $name=shift;
253		my $hashref=shift;
254	<
254	>
255	>	$self->{switch}->checktag( $name, $hashref, 'version');
256		$self->{switch}->checktag( $name, $hashref, 'name');
257	+	$self->{switch}->checktag( $name, $hashref, 'url');
258	+
259	+	if ( $self->{reqcontext} == 1 )
260	+	{
261	+	$self->{switch}->parseerror(
262	+	"Open new $name context without previous </$name>");
263	+	}
264	+	$self->{reqcontext}=1;
265		$$hashref{'name'}=~tr[A-Z][a-z];
266	+
267	+	# Add protection so that architecture tags are obeyed during download:
268		if ( $self->{Arch} )
269		{
270	<	$self->verbose("Selecting ".$$hashref{'name'});
271	<	$self->{selected}{$$hashref{'name'}} = "SELECTED";
272	<	$self->verbose(">> Tool select flag = ".$self->{selected}{$$hashref{'name'}}."\n");
270	>	# Add tool to the tool array:
271	>	push @{$self->{tools}}, $$hashref{'name'};
272	>
273	>	# If the tool already has an entry, modify the version string to
274	>	# include both versions. The versions can later be separated and
275	>	# parsed as normal:
276	>	if (defined $self->{version}{$$hashref{'name'}})
277	>	{
278	>	# Don't need an extra entry for this tool onto tool array:
279	>	pop @{$self->{tools}}, $$hashref{'name'};
280	>	# Modify the version string to append the other tool version.
281	>	# Separate using a colon:
282	>	my $newversion=$self->{version}{$$hashref{'name'}}.":".$$hashref{'version'};
283	>	$self->{version}{$$hashref{'name'}}=$newversion;
284	>	}
285	>	else
286	>	{
287	>	$self->{version}{$$hashref{'name'}}=$$hashref{'version'};
288	>	}
289	>	# -- make sure the full url is taken
290	>	my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
291	>
292	>	$self->{url}{$$hashref{'name'}}=$urlobj->url();
293	>
294	>	$self->{creqtool}=$$hashref{'name'};
295	>	$self->{creqversion}=$$hashref{'version'};
296	>	$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
297		}
298		}
299
300	<	sub deselect_start
300	>	sub require_text
301	>	{
302	>	my $self=shift;
303	>	my $name=shift;
304	>	my $string=shift;
305	>
306	>	chomp $string;
307	>	$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
308	>	$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
309	>	$string;
310	>	}
311	>
312	>	sub require_end
313		{
314		my $self=shift;
315		my $name=shift;
433	–	my $hashref=shift;
316
317	+	if ( $self->{reqcontext} != 1 )
318	+	{
319	+	$self->{switch}->parseerror("No matching tag for </$name>");
320	+	}
321	+	else
322	+	{
323	+	$self->{reqcontext}=0;
324	+	}
325	+	}
326	+
327	+	sub select_start
328	+	{
329	+	my $self=shift;
330	+	my $name=shift;
331	+	my $hashref=shift;
332	+
333		$self->{switch}->checktag( $name, $hashref, 'name');
334		$$hashref{'name'}=~tr[A-Z][a-z];
335		if ( $self->{Arch} )
336		{
337	<	$self->verbose("Deselecting ".$$hashref{'name'});
338	<	$self->{selected}{$$hashref{'name'}} = "DESELECTED";
339	<	$self->verbose(">> Tool select flag = ".$self->{selected}{$$hashref{'name'}}."\n");
337	>	$self->verbose("Selecting ".$$hashref{'name'});
338	>	# Increment counter:
339	>	$self->{selectcounter}++;
340	>	$self->{selected}{$$hashref{'name'}}=$self->{selectcounter};
341		}
342		}
343
#	Line 447 | Line 346 | sub Arch_Start
346		my $self=shift;
347		my $name=shift;
348		my $hashref=shift;
349	+
350		# Check the architecture tag:
351	<	$self->{switch}->checktag($name, $hashref,'name');
452	<	# Look for a match between the architecture flag read
453	<	# from the RequirementsDoc ($$hashref{name}) and scram arch:
454	<	#if ($self->arch() =~ /$$hashref{name}.*/)
455	<	#   {
456	<
457	<	#  }
458	<	#elsif ($self->arch() =~ /$$hashref{name}/)
459	<	#   {
460	<	#   }
461	<	#else
462	<	#   {
463	<	#   }
351	>	$self->{switch}->checktag($name, $hashref,'name');
352		( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
353		: ($self->{Arch}=0);
466	–	#   ( ($self->arch()=~/$$hashref{name}[BLAH]/) )? ($self->{Arch}=1)
467	–	#      : ($self->{Arch}=0);
468	–
354
355		$self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
356		push @{$self->{ARCHBLOCK}}, $self->{Arch};
357		push @{$self->{ArchStack}}, $$hashref{'name'};
358		}
359
360	<	sub Arch_End {
361	<	my $self=shift;
362	<	my $name=shift;
363	<
364	<	pop @{$self->{ARCHBLOCK}};
365	<	$self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
366	<	}
367	<
368	<	sub disttag {
369	<	my $self=shift;
370	<	my $name=shift;
371	<	my $hashref=shift;
372	<
373	<	if ( exists $$hashref{'url'} ) {
374	<	$self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
375	<	$$hashref{'url'};
376	<	}
377	<	}
360	>	sub Arch_End
361	>	{
362	>	my $self=shift;
363	>	my $name=shift;
364	>	pop @{$self->{ARCHBLOCK}};
365	>	$self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
366	>	}
367	>
368	>	sub disttag
369	>	{
370	>	my $self=shift;
371	>	my $name=shift;
372	>	my $hashref=shift;
373	>
374	>	if ( exists $$hashref{'url'} )
375	>	{
376	>	$self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
377	>	$$hashref{'url'};
378	>	}
379	>	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines