src/BuildSystem/Requirements.pm

# Requirements Doc - just to get ordering info
#
# Interface
# ---------
# new(ActiveStore,url[,arch])     : new requirements doc
# setup(toolbox): set up the requirements into the specified toolbox object
# download(toolbox)    : download description files (into toolbox cache)
# tools()       : Return list of ALL requirements (ordered)
# selectedtools() : Return list of only those tools selected
# version(tool) : return the version of a given tool
# toolurl(tool)     : return the url of a given tool
# getreqforarch(arch) : Return a RequirementsObject corresponding to the
#                       specified architecture
# toolcomment(tool,version) : return the comment string for the specified tool
# distributionurl(tool,version) : return the dist info url for the tool

package BuildSystem::Requirements;
use ActiveDoc::ActiveDoc;
use Utilities::Verbose;

require 5.004;
@ISA=qw(Utilities::Verbose);

sub new {
        my $class=shift;
        my $self={};
        bless $self, $class;
        $self->{dbstore}=shift;
        $self->{file}=shift;
        $self->{cache}=$self->{dbstore}->cache();
        if ( @_ ) {
          $self->arch(shift);
        }
        $self->{mydocversion}="2.0";
        $self->{Arch}=1;
        push @{$self->{ARCHBLOCK}}, $self->{Arch};
        $self->init($self->{file});
        return $self;
}

sub url {
        my $self=shift;
        if ( @_ ) {
          $self->{file}=shift;
        }
        return $self->{file}
}

sub setup {
        my $self=shift;
        my $toolbox=shift;

        my $tool;
        foreach $tool ( $self->selectedtools() ) {
          $self->verbose("Setting Up Tool $tool");
          $toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool));
        }
}

sub tools {
        my $self=shift;
        return @{$self->{tools}};
}

sub selectedtools {
        my $self=shift;
        my @toollist=();
        foreach $tool (  @{$self->{tools}} ) {
          if ( $self->{selected}{$tool} == 1 ) {
                push @toollist, $tool;
          }
        }
        return @toollist;
}

sub toolcomment {
        my $self=shift;
        my $tool=shift;
        my $version=shift;

        return $self->{reqtext}{$tool}{$version};
}

sub distributionurl {
        my $self=shift;
        my $tool=shift;
        my $version=shift;

        return ( defined $self->{dist}{$tool}{$version})?
                        $self->{dist}{$tool}{$version}:undef;
}

sub version {
        my $self=shift;
        my $tool=shift;
        return $self->{'version'}{$tool};
}

sub toolurl {
        my $self=shift;
        my $tool=shift;
        return $self->{'url'}{$tool};
}

sub init {
        my $self=shift;
        my $url=shift;

        my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
        $switch->verbosity($self->verbosity());
        $switch->url($url);
        $switch->newparse("ordering");
        $switch->addbasetags("ordering");
        $switch->addtag("ordering","Architecture",
                                        \&Arch_Start,$self,
                                        "", $self,
                                        \&Arch_End, $self);
        $switch->addtag("ordering","Restrict",
                                        \&Restrict_start,$self,
                                        "", $self,
                                        \&Restrict_end, $self);
        $switch->addtag("ordering","deselect",
                                        \&deselect_start,$self,
                                        "", $self,
                                        "", $self);
        $switch->addtag("ordering","select",
                                        \&select_start,$self,
                                        "", $self,
                                        "", $self);
        $switch->addtag("ordering","distribution",
                                        \&disttag,$self);
        $switch->grouptag("Architecture","ordering");
        $switch->addtag("ordering","require",
                                        \&require_start,$self,
                                        \&require_text, $self,
                                        \&require_end, $self);

        $self->{reqcontext}=0;
        $self->{switch}=$switch;
        undef $self->{restrictstack};
        @{$self->{tools}}=();
        
        my($doctype,$docversion)=$switch->doctype();
        # -- for backwards compatability only parse if we have a docversion
        #    defined
        if ( defined $docversion ) { 
          if ( $docversion eq $self->{mydocversion} ) {
            @{$self->{ArchStack}}=();
            $self->{switch}->parse("ordering");
          }
        }
        else {
          #print "wrong doc version - not parsing\n";
        }
}

sub arch {
        my $self=shift;
        if ( @_ ) {
          $self->{arch}=shift
        }
        else {
          if ( ! defined $self->{arch} ) {
            $self->{arch}="";
          }
        }
        return $self->{arch};
}

sub archlist {
        my $self=shift;
        return @{$self->{ArchStack}};
}

sub getreqforarch {
        my $self=shift;
        my $arch=shift;

        if ( ! defined $self->{reqsforarch}{$arch} ) {
          $self->{reqsforarch}{$arch}=
                BuildSystem::Requirements->new($self->{dbstore},$self->{file},
                                                $arch);
        }
        return $self->{reqsforarch}{$arch};
}


sub download {
        my $self=shift;

        my $tool;
        foreach $tool ( $self->tools() ) {
          $self->verbose("Downloading ".$self->toolurl($tool));
          # get into the cache
          $self->{switch}->urlget($self->toolurl($tool));
        }
}

sub _autoselect {
        my $self=shift;
        if ( @_ ) {
          $self->{autoselect}=shift;
        }
        # -- default is true
        return ((defined $self->{autoselect})?$self->{autoselect}:1);
}

# ---- Tag routines 

sub Restrict_start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->{switch}->checktag( $name, $hashref, 'autoselect');
        if ( $self->{Arch} ) {
        # -- create selection state stack
        push @{$self->{restrictstack}}, $self->_autoselect();
        $self->_autoselect(
                (($$hashref{'autoselect'}=~/true/i)?1:0));
        }
}

sub Restrict_end {
        my $self=shift;
        my $name=shift;

        if ( $self->{Arch} ) {
        if ( $#{$self->{restrictstack}} >= 0 ) {
          $self->_autoselect(pop @{$self->{restrictstack}});
        }
        else {
          $self->{switch}->parseerror("Unmatched </$name>");
        }
        }
}

sub require_start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;
        
        $self->{switch}->checktag( $name, $hashref, 'version');
        $self->{switch}->checktag( $name, $hashref, 'name');
        $self->{switch}->checktag( $name, $hashref, 'url');

        if ( $self->{reqcontext} == 1 ) {
          $self->{switch}->parseerror(
                "Open new $name conext without previous </$name>");
        }
        $self->{reqcontext}=1;
        $$hashref{'name'}=~tr[A-Z][a-z];
        push @{$self->{tools}}, $$hashref{'name'};
        $self->{version}{$$hashref{'name'}}=$$hashref{'version'};
        # -- make sure the full url is taken
        my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
        $self->{url}{$$hashref{'name'}}=$urlobj->url();

        # -- selection
        if ( $self->{Arch} ) {
          if ( $self->_autoselect() ) {
             $self->{selected}{$$hashref{'name'}}=1;
          }
          else {
             $self->{selected}{$$hashref{'name'}}=0;
          }
        }
        $self->{creqtool}=$$hashref{'name'};
        $self->{creqversion}=$$hashref{'version'};
        $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
}

sub require_text {
        my $self=shift;
        my $name=shift;
        my $string=shift;

        chomp $string;
        $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
                $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
                $string;
                
}

sub require_end {
        my $self=shift;
        my $name=shift;

        if ( $self->{reqcontext} != 1 ) {
          $self->{switch}->parseerror("No matching tag for </$name>");
        }
        else {
          $self->{reqcontext}=0;
        }
}

sub select_start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->{switch}->checktag( $name, $hashref, 'name');
        $$hashref{'name'}=~tr[A-Z][a-z];
        if ( $self->{Arch} ) {
           $self->verbose("Selecting ".$$hashref{'name'});
           $self->{selected}{$$hashref{'name'}}=1;
        }
}

sub deselect_start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->{switch}->checktag( $name, $hashref, 'name');
        $$hashref{'name'}=~tr[A-Z][a-z];
        if ( $self->{Arch} ) {
           $self->verbose("Deselecting ".$$hashref{'name'});
           $self->{selected}{$$hashref{'name'}}=0;
        }
}

sub Arch_Start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->{switch}->checktag($name, $hashref,'name');
        
        ( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
                                                : ($self->{Arch}=0);
        $self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
        push @{$self->{ARCHBLOCK}}, $self->{Arch};
        push @{$self->{ArchStack}}, $$hashref{'name'};
}

sub Arch_End {
        my $self=shift;
        my $name=shift;

        pop @{$self->{ARCHBLOCK}};
        $self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
}

sub disttag {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        if ( exists $$hashref{'url'} ) {
          $self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
                                                        $$hashref{'url'};
        }
}
Revision:	1.1.2.4.2.9
Committed:	Mon Aug 28 06:54:52 2000 UTC (24 years, 8 months ago) by williamc
Content type:	text/plain
Branch:	HPWbranch
CVS Tags:	BuildSystemProto1, V0_18_0, V0_18_0model, V0_17_1, V0_18_0alpha, V0_17_0, V0_16_4, V0_16_3, V0_16_2, V0_16_1, V0_16_0, V0_15_1, V0_15_0, V0_15_0beta
Branch point for:	V0_17branch, V0_16branch, V0_15branch
Changes since 1.1.2.4.2.8:	+108 -14 lines
Log Message:	Add informational tag processing
#	User	Rev	Content
1	williamc	1.1.2.1	# Requirements Doc - just to get ordering info
2			#
3			# Interface
4			# ---------
5	williamc	1.1.2.4.2.9	# new(ActiveStore,url[,arch]) : new requirements doc
6	williamc	1.1.2.2	# setup(toolbox): set up the requirements into the specified toolbox object
7			# download(toolbox) : download description files (into toolbox cache)
8	williamc	1.1.2.4.2.7	# tools() : Return list of ALL requirements (ordered)
9			# selectedtools() : Return list of only those tools selected
10	williamc	1.1.2.1	# version(tool) : return the version of a given tool
11	williamc	1.1.2.4.2.8	# toolurl(tool) : return the url of a given tool
12	williamc	1.1.2.4.2.9	# 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	williamc	1.1.2.1
17			package BuildSystem::Requirements;
18	williamc	1.1.2.4.2.4	use ActiveDoc::ActiveDoc;
19	williamc	1.1.2.2	use Utilities::Verbose;
20
21	williamc	1.1.2.1	require 5.004;
22	williamc	1.1.2.2	@ISA=qw(Utilities::Verbose);
23	williamc	1.1.2.1
24			sub new {
25			my $class=shift;
26			my $self={};
27			bless $self, $class;
28	williamc	1.1.2.4.2.4	$self->{dbstore}=shift;
29	williamc	1.1.2.4.2.8	$self->{file}=shift;
30			$self->{cache}=$self->{dbstore}->cache();
31	williamc	1.1.2.4.2.9	if ( @_ ) {
32			$self->arch(shift);
33			}
34	williamc	1.1.2.4.2.2	$self->{mydocversion}="2.0";
35	williamc	1.1.2.1	$self->{Arch}=1;
36	williamc	1.1.2.3	push @{$self->{ARCHBLOCK}}, $self->{Arch};
37	williamc	1.1.2.1	$self->init($self->{file});
38			return $self;
39			}
40
41	williamc	1.1.2.4.2.9	sub url {
42			my $self=shift;
43			if ( @_ ) {
44			$self->{file}=shift;
45			}
46			return $self->{file}
47			}
48
49	williamc	1.1.2.2	sub setup {
50			my $self=shift;
51			my $toolbox=shift;
52
53			my $tool;
54	williamc	1.1.2.4.2.7	foreach $tool ( $self->selectedtools() ) {
55	williamc	1.1.2.4.2.1	$self->verbose("Setting Up Tool $tool");
56	williamc	1.1.2.4.2.8	$toolbox->toolsetup($tool, $self->version($tool), $self->toolurl($tool));
57	williamc	1.1.2.2	}
58			}
59
60	williamc	1.1.2.1	sub tools {
61			my $self=shift;
62			return @{$self->{tools}};
63			}
64
65	williamc	1.1.2.4.2.7	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	williamc	1.1.2.4.2.9	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	williamc	1.1.2.1	sub version {
94			my $self=shift;
95			my $tool=shift;
96			return $self->{'version'}{$tool};
97			}
98
99	williamc	1.1.2.4.2.8	sub toolurl {
100	williamc	1.1.2.2	my $self=shift;
101			my $tool=shift;
102			return $self->{'url'}{$tool};
103			}
104
105	williamc	1.1.2.1	sub init {
106			my $self=shift;
107	williamc	1.1.2.4.2.5	my $url=shift;
108	williamc	1.1.2.1
109	williamc	1.1.2.4.2.8	my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
110	williamc	1.1.2.4.2.5	$switch->verbosity($self->verbosity());
111			$switch->url($url);
112	williamc	1.1.2.1	$switch->newparse("ordering");
113	williamc	1.1.2.4.2.1	$switch->addbasetags("ordering");
114	williamc	1.1.2.3	$switch->addtag("ordering","Architecture",
115			\&Arch_Start,$self,
116			"", $self,
117			\&Arch_End, $self);
118	williamc	1.1.2.4.2.7	$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	williamc	1.1.2.4.2.9	$switch->addtag("ordering","distribution",
131			\&disttag,$self);
132	williamc	1.1.2.3	$switch->grouptag("Architecture","ordering");
133	williamc	1.1.2.1	$switch->addtag("ordering","require",
134			\&require_start,$self,
135	williamc	1.1.2.4.2.9	\&require_text, $self,
136	williamc	1.1.2.4.2.7	\&require_end, $self);
137	williamc	1.1.2.4.2.2
138	williamc	1.1.2.4.2.7	$self->{reqcontext}=0;
139	williamc	1.1.2.1	$self->{switch}=$switch;
140	williamc	1.1.2.4.2.7	undef $self->{restrictstack};
141	williamc	1.1.2.1	@{$self->{tools}}=();
142	williamc	1.1.2.4
143	williamc	1.1.2.4.2.5	my($doctype,$docversion)=$switch->doctype();
144	williamc	1.1.2.4	# -- for backwards compatability only parse if we have a docversion
145			# defined
146	williamc	1.1.2.4.2.5	if ( defined $docversion ) {
147			if ( $docversion eq $self->{mydocversion} ) {
148	williamc	1.1.2.4.2.9	@{$self->{ArchStack}}=();
149	williamc	1.1.2.4.2.2	$self->{switch}->parse("ordering");
150			}
151	williamc	1.1.2.4	}
152	williamc	1.1.2.4.2.1	else {
153			#print "wrong doc version - not parsing\n";
154			}
155	williamc	1.1.2.2	}
156
157	williamc	1.1.2.4.2.9	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	williamc	1.1.2.4.2.8	my $self=shift;
177	williamc	1.1.2.4.2.9	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	williamc	1.1.2.4.2.8	}
186
187	williamc	1.1.2.4.2.9
188	williamc	1.1.2.2	sub download {
189			my $self=shift;
190
191			my $tool;
192			foreach $tool ( $self->tools() ) {
193	williamc	1.1.2.4.2.8	$self->verbose("Downloading ".$self->toolurl($tool));
194	williamc	1.1.2.4.2.1	# get into the cache
195	williamc	1.1.2.4.2.8	$self->{switch}->urlget($self->toolurl($tool));
196	williamc	1.1.2.2	}
197	williamc	1.1.2.1	}
198
199	williamc	1.1.2.4.2.7	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	williamc	1.1.2.1	# ---- Tag routines
209	williamc	1.1.2.4
210	williamc	1.1.2.4.2.7	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	williamc	1.1.2.1	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	williamc	1.1.2.4.2.1	$self->{switch}->checktag( $name, $hashref, 'url');
246	williamc	1.1.2.4.2.9
247	williamc	1.1.2.4.2.7	if ( $self->{reqcontext} == 1 ) {
248			$self->{switch}->parseerror(
249			"Open new $name conext without previous </$name>");
250			}
251			$self->{reqcontext}=1;
252	williamc	1.1.2.4.2.9	$$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	williamc	1.1.2.1	if ( $self->{Arch} ) {
261	williamc	1.1.2.4.2.7	if ( $self->_autoselect() ) {
262			$self->{selected}{$$hashref{'name'}}=1;
263			}
264			else {
265			$self->{selected}{$$hashref{'name'}}=0;
266			}
267			}
268	williamc	1.1.2.4.2.9	$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	williamc	1.1.2.4.2.7	}
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	williamc	1.1.2.4.2.9	$$hashref{'name'}=~tr[A-Z][a-z];
304	williamc	1.1.2.4.2.7	if ( $self->{Arch} ) {
305	williamc	1.1.2.4.2.9	$self->verbose("Selecting ".$$hashref{'name'});
306	williamc	1.1.2.4.2.7	$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	williamc	1.1.2.4.2.9	$$hashref{'name'}=~tr[A-Z][a-z];
317	williamc	1.1.2.4.2.7	if ( $self->{Arch} ) {
318	williamc	1.1.2.4.2.9	$self->verbose("Deselecting ".$$hashref{'name'});
319	williamc	1.1.2.4.2.7	$self->{selected}{$$hashref{'name'}}=0;
320	williamc	1.1.2.1	}
321			}
322	williamc	1.1.2.3
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	williamc	1.1.2.4.2.9
330			( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
331	williamc	1.1.2.3	: ($self->{Arch}=0);
332	williamc	1.1.2.4.2.9	$self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
333	williamc	1.1.2.3	push @{$self->{ARCHBLOCK}}, $self->{Arch};
334	williamc	1.1.2.4.2.9	push @{$self->{ArchStack}}, $$hashref{'name'};
335	williamc	1.1.2.3	}
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	williamc	1.1.2.4.2.9	}
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	williamc	1.1.2.4.2.2	}