ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/COMP/SCRAM/src/BuildSystem/Requirements.pm
(Generate patch)

Comparing COMP/SCRAM/src/BuildSystem/Requirements.pm (file contents):
Revision 1.2 by williamc, Mon Aug 28 08:23:09 2000 UTC vs.
Revision 1.23 by sashby, Tue Feb 27 11:59:44 2007 UTC

# Line 15 | Line 15
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->{mydocversion}="2.0";
35 <        $self->{Arch}=1;
36 <        push @{$self->{ARCHBLOCK}}, $self->{Arch};
37 <        $self->init($self->{file});
38 <        return $self;
39 < }
40 <
41 < sub url {
42 <        my $self=shift;
43 <        if ( @_ ) {
44 <          $self->{file}=shift;
45 <        }
46 <        return $self->{file}
47 < }
48 <
49 < sub setup {
50 <        my $self=shift;
51 <        my $toolbox=shift;
52 <
53 <        my $tool;
54 <        foreach $tool ( $self->selectedtools() ) {
55 <          $self->verbose("Setting Up Tool $tool");
56 <          $toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool));
57 <        }
58 < }
59 <
60 < sub tools {
61 <        my $self=shift;
62 <        return @{$self->{tools}};
63 < }
64 <
65 < sub selectedtools {
66 <        my $self=shift;
67 <        my @toollist=();
68 <        foreach $tool (  @{$self->{tools}} ) {
69 <          if ( $self->{selected}{$tool} == 1 ) {
70 <                push @toollist, $tool;
71 <          }
72 <        }
73 <        return @toollist;
74 < }
75 <
76 < sub toolcomment {
77 <        my $self=shift;
78 <        my $tool=shift;
79 <        my $version=shift;
80 <
81 <        return $self->{reqtext}{$tool}{$version};
82 < }
83 <
84 < sub distributionurl {
85 <        my $self=shift;
86 <        my $tool=shift;
87 <        my $version=shift;
88 <
89 <        return ( defined $self->{dist}{$tool}{$version})?
90 <                        $self->{dist}{$tool}{$version}:undef;
91 < }
92 <
93 < sub version {
94 <        my $self=shift;
95 <        my $tool=shift;
96 <        return $self->{'version'}{$tool};
97 < }
98 <
99 < sub toolurl {
100 <        my $self=shift;
101 <        my $tool=shift;
102 <        return $self->{'url'}{$tool};
103 < }
104 <
105 < sub init {
106 <        my $self=shift;
107 <        my $url=shift;
108 <
109 <        my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
110 <        $switch->verbosity($self->verbosity());
111 <        $switch->url($url);
112 <        $switch->newparse("ordering");
113 <        $switch->addbasetags("ordering");
114 <        $switch->addtag("ordering","Architecture",
115 <                                        \&Arch_Start,$self,
116 <                                        "", $self,
117 <                                        \&Arch_End, $self);
118 <        $switch->addtag("ordering","Restrict",
119 <                                        \&Restrict_start,$self,
120 <                                        "", $self,
121 <                                        \&Restrict_end, $self);
122 <        $switch->addtag("ordering","deselect",
123 <                                        \&deselect_start,$self,
124 <                                        "", $self,
125 <                                        "", $self);
126 <        $switch->addtag("ordering","select",
127 <                                        \&select_start,$self,
128 <                                        "", $self,
129 <                                        "", $self);
130 <        $switch->addtag("ordering","distribution",
131 <                                        \&disttag,$self);
132 <        $switch->grouptag("Architecture","ordering");
133 <        $switch->addtag("ordering","require",
134 <                                        \&require_start,$self,
135 <                                        \&require_text, $self,
136 <                                        \&require_end, $self);
137 <
138 <        $self->{reqcontext}=0;
139 <        $self->{switch}=$switch;
140 <        undef $self->{restrictstack};
141 <        @{$self->{tools}}=();
142 <        
143 <        my($doctype,$docversion)=$switch->doctype();
144 <        # -- for backwards compatability only parse if we have a docversion
145 <        #    defined
146 <        if ( defined $docversion ) {
147 <          if ( $docversion eq $self->{mydocversion} ) {
148 <            @{$self->{ArchStack}}=();
149 <            $self->{switch}->parse("ordering");
150 <          }
151 <        }
152 <        else {
153 <          #print "wrong doc version - not parsing\n";
154 <        }
155 < }
156 <
157 < sub arch {
158 <        my $self=shift;
159 <        if ( @_ ) {
160 <          $self->{arch}=shift
161 <        }
162 <        else {
163 <          if ( ! defined $self->{arch} ) {
164 <            $self->{arch}="";
165 <          }
166 <        }
167 <        return $self->{arch};
168 < }
169 <
170 < sub archlist {
171 <        my $self=shift;
172 <        return @{$self->{ArchStack}};
173 < }
174 <
175 < sub getreqforarch {
176 <        my $self=shift;
177 <        my $arch=shift;
178 <
179 <        if ( ! defined $self->{reqsforarch}{$arch} ) {
180 <          $self->{reqsforarch}{$arch}=
181 <                BuildSystem::Requirements->new($self->{dbstore},$self->{file},
182 <                                                $arch);
183 <        }
184 <        return $self->{reqsforarch}{$arch};
185 < }
186 <
187 <
188 < sub download {
189 <        my $self=shift;
190 <
191 <        my $tool;
192 <        foreach $tool ( $self->tools() ) {
193 <          $self->verbose("Downloading ".$self->toolurl($tool));
194 <          # get into the cache
195 <          $self->{switch}->urlget($self->toolurl($tool));
196 <        }
197 < }
198 <
199 < sub _autoselect {
200 <        my $self=shift;
201 <        if ( @_ ) {
202 <          $self->{autoselect}=shift;
203 <        }
204 <        # -- default is true
205 <        return ((defined $self->{autoselect})?$self->{autoselect}:1);
206 < }
207 <
208 < # ---- Tag routines
209 <
210 < sub Restrict_start {
211 <        my $self=shift;
212 <        my $name=shift;
213 <        my $hashref=shift;
214 <
215 <        $self->{switch}->checktag( $name, $hashref, 'autoselect');
216 <        if ( $self->{Arch} ) {
217 <        # -- create selection state stack
218 <        push @{$self->{restrictstack}}, $self->_autoselect();
219 <        $self->_autoselect(
220 <                (($$hashref{'autoselect'}=~/true/i)?1:0));
221 <        }
222 < }
223 <
224 < sub Restrict_end {
225 <        my $self=shift;
226 <        my $name=shift;
227 <
228 <        if ( $self->{Arch} ) {
229 <        if ( $#{$self->{restrictstack}} >= 0 ) {
230 <          $self->_autoselect(pop @{$self->{restrictstack}});
231 <        }
232 <        else {
233 <          $self->{switch}->parseerror("Unmatched </$name>");
234 <        }
235 <        }
236 < }
237 <
238 < sub require_start {
239 <        my $self=shift;
240 <        my $name=shift;
241 <        my $hashref=shift;
242 <        
243 <        $self->{switch}->checktag( $name, $hashref, 'version');
244 <        $self->{switch}->checktag( $name, $hashref, 'name');
245 <        $self->{switch}->checktag( $name, $hashref, 'url');
246 <
247 <        if ( $self->{reqcontext} == 1 ) {
248 <          $self->{switch}->parseerror(
249 <                "Open new $name conext without previous </$name>");
250 <        }
251 <        $self->{reqcontext}=1;
252 <        $$hashref{'name'}=~tr[A-Z][a-z];
253 <        push @{$self->{tools}}, $$hashref{'name'};
254 <        $self->{version}{$$hashref{'name'}}=$$hashref{'version'};
255 <        # -- make sure the full url is taken
256 <        my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
257 <        $self->{url}{$$hashref{'name'}}=$urlobj->url();
258 <
259 <        # -- selection
260 <        if ( $self->{Arch} ) {
261 <          if ( $self->_autoselect() ) {
262 <             $self->{selected}{$$hashref{'name'}}=1;
263 <          }
264 <          else {
265 <             $self->{selected}{$$hashref{'name'}}=0;
266 <          }
267 <        }
268 <        $self->{creqtool}=$$hashref{'name'};
269 <        $self->{creqversion}=$$hashref{'version'};
270 <        $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
271 < }
272 <
273 < sub require_text {
274 <        my $self=shift;
275 <        my $name=shift;
276 <        my $string=shift;
277 <
278 <        chomp $string;
279 <        $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
280 <                $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
281 <                $string;
282 <                
283 < }
284 <
285 < sub require_end {
286 <        my $self=shift;
287 <        my $name=shift;
288 <
289 <        if ( $self->{reqcontext} != 1 ) {
290 <          $self->{switch}->parseerror("No matching tag for </$name>");
291 <        }
292 <        else {
293 <          $self->{reqcontext}=0;
294 <        }
295 < }
296 <
297 < sub select_start {
298 <        my $self=shift;
299 <        my $name=shift;
300 <        my $hashref=shift;
301 <
302 <        $self->{switch}->checktag( $name, $hashref, 'name');
303 <        $$hashref{'name'}=~tr[A-Z][a-z];
304 <        if ( $self->{Arch} ) {
305 <           $self->verbose("Selecting ".$$hashref{'name'});
306 <           $self->{selected}{$$hashref{'name'}}=1;
307 <        }
308 < }
309 <
310 < sub deselect_start {
311 <        my $self=shift;
312 <        my $name=shift;
313 <        my $hashref=shift;
314 <
315 <        $self->{switch}->checktag( $name, $hashref, 'name');
316 <        $$hashref{'name'}=~tr[A-Z][a-z];
317 <        if ( $self->{Arch} ) {
318 <           $self->verbose("Deselecting ".$$hashref{'name'});
319 <           $self->{selected}{$$hashref{'name'}}=0;
320 <        }
321 < }
322 <
323 < sub Arch_Start {
324 <        my $self=shift;
325 <        my $name=shift;
326 <        my $hashref=shift;
327 <
328 <        $self->{switch}->checktag($name, $hashref,'name');
329 <        
330 <        ( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
331 <                                                : ($self->{Arch}=0);
332 <        $self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
333 <        push @{$self->{ARCHBLOCK}}, $self->{Arch};
334 <        push @{$self->{ArchStack}}, $$hashref{'name'};
335 < }
336 <
337 < sub Arch_End {
338 <        my $self=shift;
339 <        my $name=shift;
340 <
341 <        pop @{$self->{ARCHBLOCK}};
342 <        $self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
343 < }
344 <
345 < sub disttag {
346 <        my $self=shift;
347 <        my $name=shift;
348 <        my $hashref=shift;
349 <
350 <        if ( exists $$hashref{'url'} ) {
351 <          $self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
352 <                                                        $$hashref{'url'};
353 <        }
354 < }
374 > 1;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines