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.1.2.4.2.5 by williamc, Mon Aug 21 18:05:47 2000 UTC vs.
Revision 1.1.2.4.2.9 by williamc, Mon Aug 28 06:54:52 2000 UTC

# Line 2 | Line 2
2   #
3   # Interface
4   # ---------
5 < # new(url,URLcache,ObjectStore)     : new requirements doc
5 > # new(ActiveStore,url[,arch])     : new requirements doc
6   # setup(toolbox): set up the requirements into the specified toolbox object
7   # download(toolbox)    : download description files (into toolbox cache)
8 < # tools()       : Return list of requirements (ordered)
8 > # tools()       : Return list of ALL requirements (ordered)
9 > # selectedtools() : Return list of only those tools selected
10   # version(tool) : return the version of a given tool
11 < # url(tool)     : return the url of a given tool
11 > # toolurl(tool)     : return the url of a given tool
12 > # getreqforarch(arch) : Return a RequirementsObject corresponding to the
13 > #                       specified architecture
14 > # toolcomment(tool,version) : return the comment string for the specified tool
15 > # distributionurl(tool,version) : return the dist info url for the tool
16  
17   package BuildSystem::Requirements;
18   use ActiveDoc::ActiveDoc;
# Line 20 | Line 25 | sub new {
25          my $class=shift;
26          my $self={};
27          bless $self, $class;
23        $self->{file}=shift;
24        $self->{cache}=shift;
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};
# Line 30 | Line 38 | sub new {
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->tools() ) {
54 >        foreach $tool ( $self->selectedtools() ) {
55            $self->verbose("Setting Up Tool $tool");
56 <          $toolbox->toolsetup($tool, $self->version($tool), $self->url($tool));
56 >          $toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool));
57          }
58   }
59  
# Line 46 | Line 62 | sub tools {
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 url {
99 > sub toolurl {
100          my $self=shift;
101          my $tool=shift;
102          return $self->{'url'}{$tool};
# Line 62 | Line 106 | sub init {
106          my $self=shift;
107          my $url=shift;
108  
109 <        my $switch=ActiveDoc::ActiveDoc->new($self->{cache},$self->{dbstore});
66 <        #$switch->filetoparse($file);
109 >        my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
110          $switch->verbosity($self->verbosity());
111          $switch->url($url);
112          $switch->newparse("ordering");
# Line 72 | Line 115 | sub init {
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 <                                        "", $self,
136 <                                        "", $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();
# Line 86 | Line 145 | sub init {
145          #    defined
146          if ( defined $docversion ) {
147            if ( $docversion eq $self->{mydocversion} ) {
148 +            @{$self->{ArchStack}}=();
149              $self->{switch}->parse("ordering");
150            }
151          }
# Line 94 | Line 154 | sub init {
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->url($tool));
193 >          $self->verbose("Downloading ".$self->toolurl($tool));
194            # get into the cache
195 <          $self->{switch}->urlget($self->url($tool));
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;
# Line 115 | Line 243 | sub require_start {
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 <          push @{$self->{tools}}, $$hashref{'name'};
319 <          $self->{version}{$$hashref{'name'}}=$$hashref{'version'};
121 <          # -- make sure the full url is taken
122 <          my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
123 <          $self->{url}{$$hashref{'name'}}=$urlobj->url();
318 >           $self->verbose("Deselecting ".$$hashref{'name'});
319 >           $self->{selected}{$$hashref{'name'}}=0;
320          }
321   }
322  
# Line 130 | Line 326 | sub Arch_Start {
326          my $hashref=shift;
327  
328          $self->{switch}->checktag($name, $hashref,'name');
329 <        ( ($ENV{SCRAM_ARCH}=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
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 {
# Line 142 | Line 341 | sub Arch_End {
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 + }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines