15 |
|
# distributionurl(tool,version) : return the dist info url for the tool |
16 |
|
|
17 |
|
package BuildSystem::Requirements; |
18 |
+ |
|
19 |
+ |
BEGIN |
20 |
+ |
{ |
21 |
+ |
die "\n\n".__PACKAGE__.": this package has been moved to Configuration::Requirements. This one is obsolete and can be removed.\n\n"; |
22 |
+ |
} |
23 |
+ |
|
24 |
|
use ActiveDoc::ActiveDoc; |
25 |
|
use Utilities::Verbose; |
26 |
|
|
27 |
|
require 5.004; |
28 |
|
@ISA=qw(Utilities::Verbose); |
29 |
+ |
$BuildSystem::Requirements::self; |
30 |
+ |
|
31 |
+ |
sub new |
32 |
+ |
{ |
33 |
+ |
my $class=shift; |
34 |
+ |
# Initialise the global package variable: |
35 |
+ |
no strict 'refs'; |
36 |
+ |
$self = defined $self ? $self |
37 |
+ |
: (bless {}, $class ); |
38 |
+ |
$self->{dbstore}=shift; |
39 |
+ |
$self->{file}=shift; |
40 |
+ |
$self->{cache}=$self->{dbstore}->cache(); |
41 |
+ |
|
42 |
+ |
if ( @_ ) |
43 |
+ |
{ |
44 |
+ |
$self->arch(shift); |
45 |
+ |
} |
46 |
+ |
$self->verbose("Initialising a new Requirements Doc"); |
47 |
+ |
$self->{mydoctype} = "BuildSystem::Requirements"; |
48 |
+ |
$self->{mydocversion}="2.0"; |
49 |
+ |
# Counter for downloaded tools: zero it here. It will |
50 |
+ |
# be auto-incremented as each tool is selected: |
51 |
+ |
$self->{selectcounter}=0; |
52 |
+ |
|
53 |
+ |
$self->{Arch}=1; |
54 |
+ |
push @{$self->{ARCHBLOCK}}, $self->{Arch}; |
55 |
+ |
$self->init($self->{file}); |
56 |
+ |
return $self; |
57 |
+ |
} |
58 |
+ |
|
59 |
+ |
sub toolmanager |
60 |
+ |
{ |
61 |
+ |
my $self=shift; |
62 |
+ |
|
63 |
+ |
@_ ? $self->{toolmanagerobject} = shift |
64 |
+ |
: $self->{toolmanagerobject}; |
65 |
+ |
|
66 |
+ |
} |
67 |
+ |
|
68 |
+ |
sub configversion |
69 |
+ |
{ |
70 |
+ |
my $self=shift; |
71 |
+ |
@_ ? $self->{configversion} = shift |
72 |
+ |
: $self->{configversion}; |
73 |
+ |
} |
74 |
+ |
|
75 |
+ |
sub url |
76 |
+ |
{ |
77 |
+ |
my $self=shift; |
78 |
+ |
|
79 |
+ |
if ( @_ ) |
80 |
+ |
{ |
81 |
+ |
$self->{file}=shift; |
82 |
+ |
} |
83 |
+ |
return $self->{file}; |
84 |
+ |
} |
85 |
+ |
|
86 |
+ |
sub tools |
87 |
+ |
{ |
88 |
+ |
my $self=shift; |
89 |
+ |
return @{$self->{tools}}; |
90 |
+ |
} |
91 |
+ |
|
92 |
+ |
sub toolcomment |
93 |
+ |
{ |
94 |
+ |
my $self=shift; |
95 |
+ |
my $tool=shift; |
96 |
+ |
my $version=shift; |
97 |
+ |
|
98 |
+ |
return $self->{reqtext}{$tool}{$version}; |
99 |
+ |
} |
100 |
+ |
|
101 |
+ |
sub distributionurl |
102 |
+ |
{ |
103 |
+ |
my $self=shift; |
104 |
+ |
my $tool=shift; |
105 |
+ |
my $version=shift; |
106 |
+ |
|
107 |
+ |
return ( defined $self->{dist}{$tool}{$version})? |
108 |
+ |
$self->{dist}{$tool}{$version}:undef; |
109 |
+ |
} |
110 |
+ |
|
111 |
+ |
sub version |
112 |
+ |
{ |
113 |
+ |
my $self=shift; |
114 |
+ |
my $tool=shift; |
115 |
+ |
return $self->{'version'}{$tool}; |
116 |
+ |
} |
117 |
+ |
|
118 |
+ |
sub toolurl |
119 |
+ |
{ |
120 |
+ |
my $self=shift; |
121 |
+ |
my $tool=shift; |
122 |
+ |
return $self->{'url'}{$tool}; |
123 |
+ |
} |
124 |
+ |
|
125 |
+ |
sub init |
126 |
+ |
{ |
127 |
+ |
my $self=shift; |
128 |
+ |
my $url=shift; |
129 |
+ |
my $scramdoc=ActiveDoc::ActiveDoc->new($self->{dbstore}); |
130 |
+ |
$scramdoc->verbosity($self->verbosity()); |
131 |
+ |
$scramdoc->url($url); |
132 |
+ |
$scramdoc->newparse("ordering",$self->{mydoctype},'Subs'); |
133 |
+ |
$self->{reqcontext}=0; |
134 |
+ |
$self->{scramdoc}=$scramdoc; |
135 |
+ |
undef $self->{restrictstack}; |
136 |
+ |
@{$self->{tools}}=(); |
137 |
+ |
@{$self->{ArchStack}}=(); |
138 |
+ |
$self->verbose("Initial Document Parse"); |
139 |
+ |
$self->{scramdoc}->parse("ordering"); |
140 |
+ |
# Set the config version. If there isn't a version, it means that we |
141 |
+ |
# have a stand-alone repository for the toolbox, rather than a CVS |
142 |
+ |
# one. Hence, no CVS tag (== version): |
143 |
+ |
($scramdoc->{configurl}->param('version') eq '') ? |
144 |
+ |
$self->configversion("STANDALONE") : |
145 |
+ |
$self->configversion($scramdoc->{configurl}->param('version')); |
146 |
+ |
} |
147 |
+ |
|
148 |
+ |
sub arch |
149 |
+ |
{ |
150 |
+ |
my $self=shift; |
151 |
+ |
# $self->arch is the SCRAM_ARCH value: |
152 |
+ |
if ( @_ ) |
153 |
+ |
{ |
154 |
+ |
$self->{arch}=shift; |
155 |
+ |
} |
156 |
+ |
else |
157 |
+ |
{ |
158 |
+ |
if ( ! defined $self->{arch} ) |
159 |
+ |
{ |
160 |
+ |
$self->{arch}=""; |
161 |
+ |
} |
162 |
+ |
} |
163 |
+ |
return $self->{arch}; |
164 |
+ |
} |
165 |
+ |
|
166 |
+ |
sub archlist |
167 |
+ |
{ |
168 |
+ |
my $self=shift; |
169 |
+ |
return @{$self->{ArchStack}}; |
170 |
+ |
} |
171 |
+ |
|
172 |
+ |
sub getreqforarch |
173 |
+ |
{ |
174 |
+ |
my $self=shift; |
175 |
+ |
my $arch=shift; |
176 |
+ |
|
177 |
+ |
if ( ! defined $self->{reqsforarch}{$arch} ) |
178 |
+ |
{ |
179 |
+ |
$self->{reqsforarch}{$arch}= |
180 |
+ |
BuildSystem::Requirements->new($self->{dbstore},$self->{file}, |
181 |
+ |
$arch); |
182 |
+ |
} |
183 |
+ |
return $self->{reqsforarch}{$arch}; |
184 |
+ |
} |
185 |
+ |
|
186 |
+ |
sub download |
187 |
+ |
{ |
188 |
+ |
my $self=shift; |
189 |
+ |
my $tool; |
190 |
+ |
$| = 1; # Unbuffer the output |
191 |
+ |
|
192 |
+ |
print "Downloading tool descriptions....","\n"; |
193 |
+ |
print " "; |
194 |
+ |
foreach $tool ( $self->tools() ) |
195 |
+ |
{ |
196 |
+ |
print "#"; |
197 |
+ |
$self->verbose("Downloading ".$self->toolurl($tool)); |
198 |
+ |
# get into the cache: |
199 |
+ |
$self->{scramdoc}->urlget($self->toolurl($tool)); |
200 |
+ |
} |
201 |
+ |
print "\nDone.","\n"; |
202 |
+ |
# So now add the list of downloaded tools, and which were |
203 |
+ |
# selected, to tool cache: |
204 |
+ |
print "Tool info cached locally.","\n","\n"; |
205 |
+ |
|
206 |
+ |
# Now copy required info from this object to ToolManager (ToolCache): |
207 |
+ |
$self->toolmanager()->downloadedtools($self->{tools}); |
208 |
+ |
$self->toolmanager()->defaultversions($self->{version}); |
209 |
+ |
$self->toolmanager()->toolurls($self->{url}); |
210 |
+ |
$self->toolmanager()->selected($self->{selected}); |
211 |
+ |
} |
212 |
+ |
|
213 |
+ |
#sub _autoselect |
214 |
+ |
# { |
215 |
+ |
# my $self=shift; |
216 |
+ |
# if ( @_ ) |
217 |
+ |
# { |
218 |
+ |
# $self->{autoselect}=shift; |
219 |
+ |
# } |
220 |
+ |
# # -- default is true |
221 |
+ |
# return ((defined $self->{autoselect})?$self->{autoselect}:1); |
222 |
+ |
# } |
223 |
+ |
|
224 |
+ |
sub require() |
225 |
+ |
{ |
226 |
+ |
my $self=shift; |
227 |
+ |
my $name=shift; |
228 |
+ |
my $hashref=shift; |
229 |
+ |
|
230 |
+ |
$self->{scramdoc}->checktag( $name, $hashref, 'version'); |
231 |
+ |
$self->{scramdoc}->checktag( $name, $hashref, 'name'); |
232 |
+ |
$self->{scramdoc}->checktag( $name, $hashref, 'url'); |
233 |
+ |
|
234 |
+ |
if ( $self->{reqcontext} == 1 ) |
235 |
+ |
{ |
236 |
+ |
$self->{scramdoc}->parseerror( |
237 |
+ |
"Open new $name context without previous </$name>"); |
238 |
+ |
} |
239 |
+ |
$self->{reqcontext}=1; |
240 |
+ |
$$hashref{'name'}=~tr[A-Z][a-z]; |
241 |
+ |
|
242 |
+ |
# Add protection so that architecture tags are obeyed during download: |
243 |
+ |
if ( $self->{Arch} ) |
244 |
+ |
{ |
245 |
+ |
# Add tool to the tool array: |
246 |
+ |
push @{$self->{tools}}, $$hashref{'name'}; |
247 |
+ |
|
248 |
+ |
# If the tool already has an entry, modify the version string to |
249 |
+ |
# include both versions. The versions can later be separated and |
250 |
+ |
# parsed as normal: |
251 |
+ |
if (defined $self->{version}{$$hashref{'name'}}) |
252 |
+ |
{ |
253 |
+ |
# Don't need an extra entry for this tool onto tool array: |
254 |
+ |
pop @{$self->{tools}}, $$hashref{'name'}; |
255 |
+ |
# Modify the version string to append the other tool version. |
256 |
+ |
# Separate using a colon: |
257 |
+ |
my $newversion=$self->{version}{$$hashref{'name'}}.":".$$hashref{'version'}; |
258 |
+ |
$self->{version}{$$hashref{'name'}}=$newversion; |
259 |
+ |
} |
260 |
+ |
else |
261 |
+ |
{ |
262 |
+ |
$self->{version}{$$hashref{'name'}}=$$hashref{'version'}; |
263 |
+ |
} |
264 |
+ |
# -- make sure the full url is taken |
265 |
+ |
my $urlobj=$self->{scramdoc}->expandurl($$hashref{'url'}); |
266 |
+ |
$self->{url}{$$hashref{'name'}}=$urlobj->url(); |
267 |
+ |
|
268 |
+ |
$self->{creqtool}=$$hashref{'name'}; |
269 |
+ |
$self->{creqversion}=$$hashref{'version'}; |
270 |
+ |
$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=""; |
271 |
+ |
} |
272 |
+ |
} |
273 |
+ |
|
274 |
+ |
sub require_text |
275 |
+ |
{ |
276 |
+ |
my $self=shift; |
277 |
+ |
my $name=shift; |
278 |
+ |
my $string=shift; |
279 |
+ |
|
280 |
+ |
chomp $string; |
281 |
+ |
$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}= |
282 |
+ |
$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}. |
283 |
+ |
$string; |
284 |
+ |
} |
285 |
+ |
|
286 |
+ |
sub require_end |
287 |
+ |
{ |
288 |
+ |
my $self=shift; |
289 |
+ |
my $name=shift; |
290 |
+ |
|
291 |
+ |
if ( $self->{reqcontext} != 1 ) |
292 |
+ |
{ |
293 |
+ |
$self->{scramdoc}->parseerror("No matching tag for </$name>"); |
294 |
+ |
} |
295 |
+ |
else |
296 |
+ |
{ |
297 |
+ |
$self->{reqcontext}=0; |
298 |
+ |
} |
299 |
+ |
} |
300 |
+ |
|
301 |
+ |
sub select_start |
302 |
+ |
{ |
303 |
+ |
my $self=shift; |
304 |
+ |
my $name=shift; |
305 |
+ |
my $hashref=shift; |
306 |
+ |
|
307 |
+ |
$self->{scramdoc}->checktag( $name, $hashref, 'name'); |
308 |
+ |
$$hashref{'name'}=~tr[A-Z][a-z]; |
309 |
+ |
if ( $self->{Arch} ) |
310 |
+ |
{ |
311 |
+ |
$self->verbose("Selecting ".$$hashref{'name'}); |
312 |
+ |
# Increment counter: |
313 |
+ |
$self->{selectcounter}++; |
314 |
+ |
$self->{selected}{$$hashref{'name'}}=$self->{selectcounter}; |
315 |
+ |
} |
316 |
+ |
} |
317 |
+ |
|
318 |
+ |
sub Arch_Start |
319 |
+ |
{ |
320 |
+ |
my $self=shift; |
321 |
+ |
my $name=shift; |
322 |
+ |
my $hashref=shift; |
323 |
+ |
|
324 |
+ |
# Check the architecture tag: |
325 |
+ |
$self->{scramdoc}->checktag($name, $hashref,'name'); |
326 |
+ |
( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1) |
327 |
+ |
: ($self->{Arch}=0); |
328 |
+ |
|
329 |
+ |
$self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name}); |
330 |
+ |
push @{$self->{ARCHBLOCK}}, $self->{Arch}; |
331 |
+ |
push @{$self->{ArchStack}}, $$hashref{'name'}; |
332 |
+ |
} |
333 |
+ |
|
334 |
+ |
sub Arch_End |
335 |
+ |
{ |
336 |
+ |
my $self=shift; |
337 |
+ |
my $name=shift; |
338 |
+ |
pop @{$self->{ARCHBLOCK}}; |
339 |
+ |
$self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}]; |
340 |
+ |
} |
341 |
+ |
|
342 |
+ |
sub disttag |
343 |
+ |
{ |
344 |
+ |
my $self=shift; |
345 |
+ |
my $name=shift; |
346 |
+ |
my $hashref=shift; |
347 |
+ |
|
348 |
+ |
if ( exists $$hashref{'url'} ) |
349 |
+ |
{ |
350 |
+ |
$self->{dist}{$self->{creqtool}}{$self->{creqversion}}= |
351 |
+ |
$$hashref{'url'}; |
352 |
+ |
} |
353 |
+ |
} |
354 |
+ |
|
355 |
+ |
sub select() |
356 |
+ |
{ |
357 |
+ |
my ($xmlparser,$name,%attributes)=@_; |
358 |
+ |
# print "Selecting ".$attributes{'name'},"\n"; |
359 |
+ |
} |
360 |
+ |
|
361 |
+ |
sub select_() |
362 |
+ |
{} |
363 |
+ |
|
364 |
+ |
sub AUTOLOAD() |
365 |
+ |
{ |
366 |
+ |
my ($xmlparser,$name,%attributes)=@_; |
367 |
+ |
return if $AUTOLOAD =~ /::DESTROY$/; |
368 |
+ |
my $name=$AUTOLOAD; |
369 |
+ |
$name =~ s/.*://; |
370 |
+ |
# Delegate missing function calls to the doc parser class: |
371 |
+ |
$self->{scramdoc}->$name(%attributes); |
372 |
+ |
} |
373 |
|
|
374 |
< |
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 |
< |
} |
49 |
< |
|
50 |
< |
sub setup { |
51 |
< |
my $self=shift; |
52 |
< |
my $toolbox=shift; |
53 |
< |
|
54 |
< |
my $tool; |
55 |
< |
foreach $tool ( $self->selectedtools() ) { |
56 |
< |
$self->verbose("Setting Up Tool $tool"); |
57 |
< |
$toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool)); |
58 |
< |
} |
59 |
< |
} |
60 |
< |
|
61 |
< |
sub tools { |
62 |
< |
my $self=shift; |
63 |
< |
return @{$self->{tools}}; |
64 |
< |
} |
65 |
< |
|
66 |
< |
sub selectedtools { |
67 |
< |
my $self=shift; |
68 |
< |
my @toollist=(); |
69 |
< |
foreach $tool ( @{$self->{tools}} ) { |
70 |
< |
if ( $self->{selected}{$tool} == 1 ) { |
71 |
< |
push @toollist, $tool; |
72 |
< |
} |
73 |
< |
} |
74 |
< |
return @toollist; |
75 |
< |
} |
76 |
< |
|
77 |
< |
sub toolcomment { |
78 |
< |
my $self=shift; |
79 |
< |
my $tool=shift; |
80 |
< |
my $version=shift; |
81 |
< |
|
82 |
< |
return $self->{reqtext}{$tool}{$version}; |
83 |
< |
} |
84 |
< |
|
85 |
< |
sub distributionurl { |
86 |
< |
my $self=shift; |
87 |
< |
my $tool=shift; |
88 |
< |
my $version=shift; |
89 |
< |
|
90 |
< |
return ( defined $self->{dist}{$tool}{$version})? |
91 |
< |
$self->{dist}{$tool}{$version}:undef; |
92 |
< |
} |
93 |
< |
|
94 |
< |
sub version { |
95 |
< |
my $self=shift; |
96 |
< |
my $tool=shift; |
97 |
< |
return $self->{'version'}{$tool}; |
98 |
< |
} |
99 |
< |
|
100 |
< |
sub toolurl { |
101 |
< |
my $self=shift; |
102 |
< |
my $tool=shift; |
103 |
< |
return $self->{'url'}{$tool}; |
104 |
< |
} |
105 |
< |
|
106 |
< |
sub init { |
107 |
< |
my $self=shift; |
108 |
< |
my $url=shift; |
109 |
< |
|
110 |
< |
my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore}); |
111 |
< |
$switch->verbosity($self->verbosity()); |
112 |
< |
$switch->url($url); |
113 |
< |
$switch->newparse("ordering"); |
114 |
< |
$switch->addbasetags("ordering"); |
115 |
< |
$switch->addtag("ordering","Architecture", |
116 |
< |
\&Arch_Start,$self, |
117 |
< |
"", $self, |
118 |
< |
\&Arch_End, $self); |
119 |
< |
$switch->addtag("ordering","Restrict", |
120 |
< |
\&Restrict_start,$self, |
121 |
< |
"", $self, |
122 |
< |
\&Restrict_end, $self); |
123 |
< |
$switch->addtag("ordering","deselect", |
124 |
< |
\&deselect_start,$self, |
125 |
< |
"", $self, |
126 |
< |
"", $self); |
127 |
< |
$switch->addtag("ordering","select", |
128 |
< |
\&select_start,$self, |
129 |
< |
"", $self, |
130 |
< |
"", $self); |
131 |
< |
$switch->addtag("ordering","distribution", |
132 |
< |
\&disttag,$self); |
133 |
< |
$switch->grouptag("Architecture","ordering"); |
134 |
< |
$switch->addtag("ordering","require", |
135 |
< |
\&require_start,$self, |
136 |
< |
\&require_text, $self, |
137 |
< |
\&require_end, $self); |
138 |
< |
|
139 |
< |
$self->{reqcontext}=0; |
140 |
< |
$self->{switch}=$switch; |
141 |
< |
undef $self->{restrictstack}; |
142 |
< |
@{$self->{tools}}=(); |
143 |
< |
|
144 |
< |
my($doctype,$docversion)=$switch->doctype(); |
145 |
< |
# -- for backwards compatability only parse if we have a docversion |
146 |
< |
# defined |
147 |
< |
if ( defined $docversion ) { |
148 |
< |
if ( $docversion eq $self->{mydocversion} ) { |
149 |
< |
@{$self->{ArchStack}}=(); |
150 |
< |
$self->verbose("Initial Document Parse"); |
151 |
< |
$self->{switch}->parse("ordering"); |
152 |
< |
} |
153 |
< |
else { |
154 |
< |
$self->verbose("wrong doc version - not parsing"); |
155 |
< |
} |
156 |
< |
} |
157 |
< |
else { |
158 |
< |
$self->verbose("wrong doc type - not parsing"); |
159 |
< |
#print "wrong doc version - not parsing\n"; |
160 |
< |
} |
161 |
< |
} |
162 |
< |
|
163 |
< |
sub arch { |
164 |
< |
my $self=shift; |
165 |
< |
if ( @_ ) { |
166 |
< |
$self->{arch}=shift |
167 |
< |
} |
168 |
< |
else { |
169 |
< |
if ( ! defined $self->{arch} ) { |
170 |
< |
$self->{arch}=""; |
171 |
< |
} |
172 |
< |
} |
173 |
< |
return $self->{arch}; |
174 |
< |
} |
175 |
< |
|
176 |
< |
sub archlist { |
177 |
< |
my $self=shift; |
178 |
< |
return @{$self->{ArchStack}}; |
179 |
< |
} |
180 |
< |
|
181 |
< |
sub getreqforarch { |
182 |
< |
my $self=shift; |
183 |
< |
my $arch=shift; |
184 |
< |
|
185 |
< |
if ( ! defined $self->{reqsforarch}{$arch} ) { |
186 |
< |
$self->{reqsforarch}{$arch}= |
187 |
< |
BuildSystem::Requirements->new($self->{dbstore},$self->{file}, |
188 |
< |
$arch); |
189 |
< |
} |
190 |
< |
return $self->{reqsforarch}{$arch}; |
191 |
< |
} |
192 |
< |
|
193 |
< |
|
194 |
< |
sub download { |
195 |
< |
my $self=shift; |
196 |
< |
|
197 |
< |
my $tool; |
198 |
< |
foreach $tool ( $self->tools() ) { |
199 |
< |
$self->verbose("Downloading ".$self->toolurl($tool)); |
200 |
< |
# get into the cache |
201 |
< |
$self->{switch}->urlget($self->toolurl($tool)); |
202 |
< |
} |
203 |
< |
} |
204 |
< |
|
205 |
< |
sub _autoselect { |
206 |
< |
my $self=shift; |
207 |
< |
if ( @_ ) { |
208 |
< |
$self->{autoselect}=shift; |
209 |
< |
} |
210 |
< |
# -- default is true |
211 |
< |
return ((defined $self->{autoselect})?$self->{autoselect}:1); |
212 |
< |
} |
213 |
< |
|
214 |
< |
# ---- Tag routines |
215 |
< |
|
216 |
< |
sub Restrict_start { |
217 |
< |
my $self=shift; |
218 |
< |
my $name=shift; |
219 |
< |
my $hashref=shift; |
220 |
< |
|
221 |
< |
$self->{switch}->checktag( $name, $hashref, 'autoselect'); |
222 |
< |
if ( $self->{Arch} ) { |
223 |
< |
# -- create selection state stack |
224 |
< |
push @{$self->{restrictstack}}, $self->_autoselect(); |
225 |
< |
$self->_autoselect( |
226 |
< |
(($$hashref{'autoselect'}=~/true/i)?1:0)); |
227 |
< |
} |
228 |
< |
} |
229 |
< |
|
230 |
< |
sub Restrict_end { |
231 |
< |
my $self=shift; |
232 |
< |
my $name=shift; |
233 |
< |
|
234 |
< |
if ( $self->{Arch} ) { |
235 |
< |
if ( $#{$self->{restrictstack}} >= 0 ) { |
236 |
< |
$self->_autoselect(pop @{$self->{restrictstack}}); |
237 |
< |
} |
238 |
< |
else { |
239 |
< |
$self->{switch}->parseerror("Unmatched </$name>"); |
240 |
< |
} |
241 |
< |
} |
242 |
< |
} |
243 |
< |
|
244 |
< |
sub require_start { |
245 |
< |
my $self=shift; |
246 |
< |
my $name=shift; |
247 |
< |
my $hashref=shift; |
248 |
< |
|
249 |
< |
$self->{switch}->checktag( $name, $hashref, 'version'); |
250 |
< |
$self->{switch}->checktag( $name, $hashref, 'name'); |
251 |
< |
$self->{switch}->checktag( $name, $hashref, 'url'); |
252 |
< |
|
253 |
< |
if ( $self->{reqcontext} == 1 ) { |
254 |
< |
$self->{switch}->parseerror( |
255 |
< |
"Open new $name conext without previous </$name>"); |
256 |
< |
} |
257 |
< |
$self->{reqcontext}=1; |
258 |
< |
$$hashref{'name'}=~tr[A-Z][a-z]; |
259 |
< |
push @{$self->{tools}}, $$hashref{'name'}; |
260 |
< |
$self->{version}{$$hashref{'name'}}=$$hashref{'version'}; |
261 |
< |
# -- make sure the full url is taken |
262 |
< |
my $urlobj=$self->{switch}->expandurl($$hashref{'url'}); |
263 |
< |
$self->{url}{$$hashref{'name'}}=$urlobj->url(); |
264 |
< |
|
265 |
< |
# -- selection |
266 |
< |
if ( $self->{Arch} ) { |
267 |
< |
if ( $self->_autoselect() ) { |
268 |
< |
$self->{selected}{$$hashref{'name'}}=1; |
269 |
< |
} |
270 |
< |
else { |
271 |
< |
$self->{selected}{$$hashref{'name'}}=0; |
272 |
< |
} |
273 |
< |
} |
274 |
< |
$self->{creqtool}=$$hashref{'name'}; |
275 |
< |
$self->{creqversion}=$$hashref{'version'}; |
276 |
< |
$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=""; |
277 |
< |
} |
278 |
< |
|
279 |
< |
sub require_text { |
280 |
< |
my $self=shift; |
281 |
< |
my $name=shift; |
282 |
< |
my $string=shift; |
283 |
< |
|
284 |
< |
chomp $string; |
285 |
< |
$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}= |
286 |
< |
$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}. |
287 |
< |
$string; |
288 |
< |
|
289 |
< |
} |
290 |
< |
|
291 |
< |
sub require_end { |
292 |
< |
my $self=shift; |
293 |
< |
my $name=shift; |
294 |
< |
|
295 |
< |
if ( $self->{reqcontext} != 1 ) { |
296 |
< |
$self->{switch}->parseerror("No matching tag for </$name>"); |
297 |
< |
} |
298 |
< |
else { |
299 |
< |
$self->{reqcontext}=0; |
300 |
< |
} |
301 |
< |
} |
302 |
< |
|
303 |
< |
sub select_start { |
304 |
< |
my $self=shift; |
305 |
< |
my $name=shift; |
306 |
< |
my $hashref=shift; |
307 |
< |
|
308 |
< |
$self->{switch}->checktag( $name, $hashref, 'name'); |
309 |
< |
$$hashref{'name'}=~tr[A-Z][a-z]; |
310 |
< |
if ( $self->{Arch} ) { |
311 |
< |
$self->verbose("Selecting ".$$hashref{'name'}); |
312 |
< |
$self->{selected}{$$hashref{'name'}}=1; |
313 |
< |
} |
314 |
< |
} |
315 |
< |
|
316 |
< |
sub deselect_start { |
317 |
< |
my $self=shift; |
318 |
< |
my $name=shift; |
319 |
< |
my $hashref=shift; |
320 |
< |
|
321 |
< |
$self->{switch}->checktag( $name, $hashref, 'name'); |
322 |
< |
$$hashref{'name'}=~tr[A-Z][a-z]; |
323 |
< |
if ( $self->{Arch} ) { |
324 |
< |
$self->verbose("Deselecting ".$$hashref{'name'}); |
325 |
< |
$self->{selected}{$$hashref{'name'}}=0; |
326 |
< |
} |
327 |
< |
} |
328 |
< |
|
329 |
< |
sub Arch_Start { |
330 |
< |
my $self=shift; |
331 |
< |
my $name=shift; |
332 |
< |
my $hashref=shift; |
333 |
< |
|
334 |
< |
$self->{switch}->checktag($name, $hashref,'name'); |
335 |
< |
|
336 |
< |
( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1) |
337 |
< |
: ($self->{Arch}=0); |
338 |
< |
$self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name}); |
339 |
< |
push @{$self->{ARCHBLOCK}}, $self->{Arch}; |
340 |
< |
push @{$self->{ArchStack}}, $$hashref{'name'}; |
341 |
< |
} |
342 |
< |
|
343 |
< |
sub Arch_End { |
344 |
< |
my $self=shift; |
345 |
< |
my $name=shift; |
346 |
< |
|
347 |
< |
pop @{$self->{ARCHBLOCK}}; |
348 |
< |
$self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}]; |
349 |
< |
} |
350 |
< |
|
351 |
< |
sub disttag { |
352 |
< |
my $self=shift; |
353 |
< |
my $name=shift; |
354 |
< |
my $hashref=shift; |
355 |
< |
|
356 |
< |
if ( exists $$hashref{'url'} ) { |
357 |
< |
$self->{dist}{$self->{creqtool}}{$self->{creqversion}}= |
358 |
< |
$$hashref{'url'}; |
359 |
< |
} |
360 |
< |
} |
374 |
> |
1; |