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.3 by williamc, Tue Nov 28 16:12:21 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->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;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines