src/BuildSystem/ToolDoc.pm

#
# ToolDoc.pm
#
# Originally Written by Christopher Williams
#
# Description
# -----------
# SimpleDoc interface to initialise Tool objects
#
# Interface
# ---------
# new()         : A new ToolDoc object
# tool(toolobj) : set the tool object for the class
# toolsearcher(searcher) : set the searcher for finding reference tools
# setup(file,$name,$version) : setup a tool object from the specified file
#                               return 0 for OK 1 for cancel
# interactive([0|1]) : set the interactive node 0=off 1=on

package BuildSystem::ToolDoc;
require 5.004;
use ActiveDoc::SimpleDoc;
use Utilities::Verbose;
@ISA=qw(Utilities::Verbose);

sub new {
        my $class=shift;
        $self={};
        bless $self, $class;
        $self->init();
        return $self;
}

sub init {
        my $self=shift;
        $self->{switch}=ActiveDoc::SimpleDoc->new();
        $self->{switch}->newparse("setup");
        $self->{switch}->addtag("setup","Tool",\&Tool_Start, $self,     
                                                "", $self,
                                                \&Tool_End, $self);
        $self->{switch}->addtag("setup","Lib",\&Lib, $self,     
                                                "", $self,
                                                "", $self);
        $self->{switch}->addtag("setup","External",\&External_Start, $self,     
                                                "", $self,
                                                "", $self);
        $self->{switch}->addtag("setup","Client",\&Client_start, $self, 
                                                "", $self,
                                                \&Client_end, $self);
        $self->{switch}->addtag("setup","Environment",
                                                \&Environment_Start, $self,     
                                                \&Env_text, $self,
                                                \&Environment_End, $self);
        $self->{switch}->grouptag("Tool","setup");
        $self->{switch}->addtag("setup","Architecture",
                                        \&Arch_Start,$self,
                                        "", $self,
                                        \&Arch_End,$self);
        $self->{Arch}=1;
        push @{$self->{ARCHBLOCK}}, $self->{Arch};

}

sub interactive {
        my $self=shift;
        
        @_?$self->{interactive}=shift
          :((defined $self->{interactive})?$self->{interactive}:0);
}

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

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

sub setup {
        my $self=shift;
        my $file=shift;
        my $name=shift;
        my $version=shift;

        $self->{ToolEnv}{'SCRAMtoolname'}=$name;
        $self->{ToolEnv}{'SCRAMtoolversion'}=$version;
        $self->{ToolEnv}{'SCRAM_ARCH'}=$ENV{'SCRAM_ARCH'};

        $name=~tr[A-Z][a-z];
        $self->{tool}->name($name);
        $self->{tool}->version($version);
        $self->{switch}->filetoparse($file);
        $self->{toolfound}=1;
        $self->{switch}->parse("setup");
        return $self->{toolfound};
}

sub featuretext {
        my $self=shift;
        my $feature=shift;

        if ( @_ ) {
          $self->{featuretext}{$feature}=shift;
        }
        else {
          return ($self->{featuretext}{$feature});
        }
}

sub _checkdefault {
        my $self=shift;
        my $hashref=shift;

        if ( defined $$hashref{'default'} ) { #check default
          my $default;
          foreach $default ( split /:/, $$hashref{'default'} ) {
            $default=~s/\"//;
            if ($self->_testlocation($default,
               [ $self->{tool}->getfeature($$hashref{'type'})] )) { return 1; }
          }
        }
        return 0;
}

sub _testlocation {
        my $self=shift;
        my $default=shift;
        my $testfiles=shift;
        my $OK='false';
        my $file;

        chomp $default;
        $default=$self->_expandvars($default);
        print "Trying $default .... ";
        if ( -f $default ) {
                $OK="true";
        }
        else {
          my $fh=FileHandle->new();
          opendir $fh,  $default or do { print "No \n"; return 0; };
         ($#{$testfiles}==-1) ? $OK='false' : $OK='true';
          print "\n";
          my @files=readdir $fh;
          undef $fh;
          foreach $file ( @$testfiles ) {
                print "   Checking for $file .... ";
                # now check that the required files are actually there
                if ( ( $number = grep /\Q$file\L/, @files) == 0 ) {
                   $OK='false';
                   print "not found\n";
                   last;
                }
                print "found\n";
          }
        }
        if ( $OK eq 'true' ) {
                print "Directory Check Complete\n";
                return 1
        }
        return 0
}

sub _expandvars {
        my $self=shift;
        my $string=shift;

        return "" , if ( ! defined $string );
        $string=~s{
                \$\((\w+)\)
        }{
          if (defined $self->{ToolEnv}{$1}) {
                $self->_expandvars($self->{ToolEnv}{$1});
          } else {
                "\$$1";
          }
        }egx;
        $string=~s{
                \$(\w+)
        }{
          if (defined $self->{ToolEnv}{$1}) {
                $self->_expandvars($self->{ToolEnv}{$1});
          } else {
                "\$$1";
          }
        }egx;
        return $string;
}


sub _askuser {
        my $self=shift;
        my $querystring=shift;
        my $varname=shift;

        print $self->featuretext($self->{EnvContext});
        for  ( ;; ) {
         print "\n".$querystring." (RETURN to log as missing)\nset $varname = ";
         $path=<STDIN>;
         chomp $path;
         if ( $path ne "" ) {
          if ( defined $self->{'client'}) { # must be a location
           if ( $self->_testlocation($path , "H", $Envtype{$type} )) {
             return $path;
           }
           print "Error : ".$path." does not exist.\n";
           next;
          }
         }
         else {
           return $path;
         }
        } #end for

}

#
# Propgate through the searcher collecting matching tools
#
sub _searchtools {
        my $self=shift;
        my $tool=shift;

        my @tools=();
        my $area;
        my $rtool;
        if ( defined $self->{toolboxsearcher} ) {
           my $it=$self->{toolboxsearcher}->newiterator();
           while ( ! $it->last()  ) {
             $area=$it->next();
             if ( defined $area ) {
              $self->verbose("Searching for ".$tool->name()." ".
                 $tool->version()." in ".$area->location());
              $rtool=$area->toolbox()->gettool($tool->name(),$tool->version());
              if ( (defined $rtool) && $rtool->equals($tool) ) {
                push @tools,$rtool;
              }
             }
           }
        }
        return @tools; 
}

# search toolboxes for a nice list
#
sub _toolparamcopy {
        my $self=shift;
        my $tool=shift;
        my $param=shift;

        my $rv=0;
        $self->verbose("Check Other Projects for tool");
        my @validtools=$self->_searchtools($tool);
        if ( ! $self->interactive() ) {
          if ( $#validtools >=0 ) {
           my @params=$validtools[0]->getfeature($param);
           if ( $#params >=0 ) {
                $self->verbose("Extracting Feature $param from tool".
                        " (= @params )\n");
                $tool->setfeature($param,@params);
                $rv=1;
           }
          }
        }
        return $rv;
}

# -- Tag Routines

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

        if ( $self->{Arch} ) {
          $self->{'client'}=1;
        }
}

sub Client_end {
        my $self=shift;
        if ( $self->{Arch} ) {
        undef $self->{'client'};
        }
}
        
sub Tool_Start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->{switch}->checktag($name, $hashref, 'name');
        $self->{switch}->checktag($name, $hashref, 'version');
        $self->{switch}->opengroup("Toolactive");

        # lower case the name
        $$hashref{'name'}=~tr[A-Z][a-z];
        # make sure we only pick up the tool requested
        if ( ( $self->{tool}->name() eq $$hashref{'name'} ) && 
                ($self->{tool}->version() eq $$hashref{'version'})) {
          $self->{switch}->
                allowgroup("Toolactive",$self->{switch}->currentparsename());
          $self->{ToolEnv}{'SCRAMtoolname'}=$$hashref{'name'};
          $self->{ToolEnv}{'SCRAMtoolversion'}=$$hashref{'version'};
          $self->{toolfound}=0;
        }
        else {
          $self->{switch}->disallowgroup("Toolactive",
                                $self->{switch}->currentparsename());
        }
}

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

        $self->{switch}->closegroup("Toolactive");
}

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

        $self->{switch}->checktag($name, $hashref, 'name');
        if ( $self->{Arch} ) {
          if ( defined $self->{EnvContext} ) {
            $self->parserror(" Attempted to open new <$name> context".
                        " without closing the previous one");
          }
          $self->{currentenvtext}="";
          $self->{EnvContext}=$$hashref{'name'};
          undef $self->{Envvalue};
          if ( exists $$hashref{'type'} ) {
            $$hashref{'type'}=~tr[A-Z][a-z];
            $self->{tool}->type($$hashref{'name'},$$hashref{'type'});
          }
          if ( exists $$hashref{'value'}) {
            $self->{Envvalue}=$$hashref{'value'};
          }
          elsif ( ! $self->interactive() ) {
           # check other installed copies of the tool
           if ( $self->_toolparamcopy($self->{tool},$$hashref{'name'}) ) {
              my @tmp=$self->{tool}->getfeature($$hashref{'name'});
              $self->{Envvalue}=$tmp[0]; # assume single val parameter!
           }
           elsif ( defined $ENV{$$hashref{'name'}} ) {
              # check the environment
              $self->{Envvalue}=$ENV{$$hashref{'name'}};
           }
           elsif ( $self->_checkdefault($hashref) ) {
              $self->{Envvalue}=$$hashref{'default'};
           }
          }
        }
}

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

        if ( $self->{Arch} ) {
          $self->{currentenvtext}=$self->{currentenvtext}.$string;
        }
}

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

        if ( $self->{Arch} ) {
          if ( ! defined $self->{EnvContext} ) {
            $self->{switch}->parseerror("</$name> without an opening context");
          }
          # - set the help text
          $self->featuretext($self->{EnvContext},$self->{currentenvtext});
          if ( ! defined $self->{Envvalue} ) {
            $self->{Envvalue}=$self->_askuser("Please Enter the Value Below:",
                        $self->{EnvContext});
          }
          $self->{Envvalue}=$self->_expandvars($self->{Envvalue});
          $self->{tool}->addfeature($self->{EnvContext}, $self->{Envvalue});
          $self->{ToolEnv}{$self->{EnvContext}}=$self->{Envvalue};
          undef $self->{EnvContext};
          undef $self->{Envvalue};
        }
}

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

        $self->{switch}->checktag($name, $hashref, 'name');
        if ( $self->{Arch} ) {
          $self->{tool}->addfeature("lib",$$hashref{'name'});
        }
}

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

        $self->{switch}->checktag($name, $hashref,'ref');
        if ( $self->{Arch} ) {
          $self->{tool}->addfeature("_externals",$$hashref{'ref'});
        }
}

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

        $self->{switch}->checktag($name, $hashref,'name');
        ( ($ENV{SCRAM_ARCH}=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
                                                : ($self->{Arch}=0);
        push @{$self->{ARCHBLOCK}}, $self->{Arch};
}

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

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


Revision:	1.1.2.11
Committed:	Tue Jun 20 12:52:18 2000 UTC (24 years, 10 months ago) by williamc
Content type:	text/plain
Branch:	V0_9branch
Changes since 1.1.2.10:	+71 -4 lines
Log Message:	updates to tool searching mechanism - now only take parameters requested rather than copying the whole tool
#	User	Rev	Content
1	williamc	1.1.2.1	#
2			# ToolDoc.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7			# -----------
8			# SimpleDoc interface to initialise Tool objects
9			#
10			# Interface
11			# ---------
12			# new() : A new ToolDoc object
13			# tool(toolobj) : set the tool object for the class
14	williamc	1.1.2.11	# toolsearcher(searcher) : set the searcher for finding reference tools
15	williamc	1.1.2.1	# setup(file,$name,$version) : setup a tool object from the specified file
16	williamc	1.1.2.3	# return 0 for OK 1 for cancel
17	williamc	1.1.2.1	# interactive([0\|1]) : set the interactive node 0=off 1=on
18
19			package BuildSystem::ToolDoc;
20			require 5.004;
21			use ActiveDoc::SimpleDoc;
22	williamc	1.1.2.11	use Utilities::Verbose;
23			@ISA=qw(Utilities::Verbose);
24	williamc	1.1.2.1
25			sub new {
26			my $class=shift;
27			$self={};
28			bless $self, $class;
29			$self->init();
30			return $self;
31			}
32
33			sub init {
34			my $self=shift;
35			$self->{switch}=ActiveDoc::SimpleDoc->new();
36			$self->{switch}->newparse("setup");
37			$self->{switch}->addtag("setup","Tool",\&Tool_Start, $self,
38			"", $self,
39			\&Tool_End, $self);
40			$self->{switch}->addtag("setup","Lib",\&Lib, $self,
41			"", $self,
42			"", $self);
43			$self->{switch}->addtag("setup","External",\&External_Start, $self,
44			"", $self,
45			"", $self);
46			$self->{switch}->addtag("setup","Client",\&Client_start, $self,
47			"", $self,
48			\&Client_end, $self);
49			$self->{switch}->addtag("setup","Environment",
50			\&Environment_Start, $self,
51			\&Env_text, $self,
52			\&Environment_End, $self);
53			$self->{switch}->grouptag("Tool","setup");
54			$self->{switch}->addtag("setup","Architecture",
55			\&Arch_Start,$self,
56			"", $self,
57			\&Arch_End,$self);
58			$self->{Arch}=1;
59	williamc	1.1.2.6	push @{$self->{ARCHBLOCK}}, $self->{Arch};
60	williamc	1.1.2.1
61			}
62
63			sub interactive {
64			my $self=shift;
65
66			@_?$self->{interactive}=shift
67			:((defined $self->{interactive})?$self->{interactive}:0);
68			}
69
70			sub tool {
71			my $self=shift;
72			$self->{tool}=shift;
73			}
74
75	williamc	1.1.2.11	sub toolsearcher {
76			my $self=shift;
77			if ( @_ ) {
78			$self->{toolboxsearcher}=shift;
79			}
80			return $self->{toolboxsearcher};
81			}
82
83	williamc	1.1.2.1	sub setup {
84			my $self=shift;
85			my $file=shift;
86			my $name=shift;
87			my $version=shift;
88
89			$self->{ToolEnv}{'SCRAMtoolname'}=$name;
90			$self->{ToolEnv}{'SCRAMtoolversion'}=$version;
91			$self->{ToolEnv}{'SCRAM_ARCH'}=$ENV{'SCRAM_ARCH'};
92
93			$name=~tr[A-Z][a-z];
94			$self->{tool}->name($name);
95			$self->{tool}->version($version);
96			$self->{switch}->filetoparse($file);
97	williamc	1.1.2.4	$self->{toolfound}=1;
98	williamc	1.1.2.1	$self->{switch}->parse("setup");
99	williamc	1.1.2.4	return $self->{toolfound};
100	williamc	1.1.2.1	}
101
102			sub featuretext {
103			my $self=shift;
104			my $feature=shift;
105
106			if ( @_ ) {
107			$self->{featuretext}{$feature}=shift;
108			}
109			else {
110			return ($self->{featuretext}{$feature});
111			}
112			}
113
114			sub _checkdefault {
115			my $self=shift;
116			my $hashref=shift;
117
118			if ( defined $$hashref{'default'} ) { #check default
119			my $default;
120			foreach $default ( split /:/, $$hashref{'default'} ) {
121			$default=~s/\"//;
122			if ($self->_testlocation($default,
123			[ $self->{tool}->getfeature($$hashref{'type'})] )) { return 1; }
124			}
125			}
126			return 0;
127			}
128
129			sub _testlocation {
130			my $self=shift;
131			my $default=shift;
132			my $testfiles=shift;
133			my $OK='false';
134			my $file;
135
136			chomp $default;
137			$default=$self->_expandvars($default);
138			print "Trying $default .... ";
139			if ( -f $default ) {
140			$OK="true";
141			}
142			else {
143			my $fh=FileHandle->new();
144			opendir $fh, $default or do { print "No \n"; return 0; };
145			($#{$testfiles}==-1) ? $OK='false' : $OK='true';
146			print "\n";
147			my @files=readdir $fh;
148			undef $fh;
149			foreach $file ( @$testfiles ) {
150			print " Checking for $file .... ";
151			# now check that the required files are actually there
152			if ( ( $number = grep /\Q$file\L/, @files) == 0 ) {
153			$OK='false';
154			print "not found\n";
155			last;
156			}
157			print "found\n";
158			}
159			}
160			if ( $OK eq 'true' ) {
161			print "Directory Check Complete\n";
162			return 1
163			}
164			return 0
165			}
166
167			sub _expandvars {
168			my $self=shift;
169			my $string=shift;
170
171			return "" , if ( ! defined $string );
172			$string=~s{
173			\$\((\w+)\)
174			}{
175			if (defined $self->{ToolEnv}{$1}) {
176			$self->_expandvars($self->{ToolEnv}{$1});
177			} else {
178			"\$$1";
179			}
180			}egx;
181			$string=~s{
182			\$(\w+)
183			}{
184			if (defined $self->{ToolEnv}{$1}) {
185			$self->_expandvars($self->{ToolEnv}{$1});
186			} else {
187			"\$$1";
188			}
189			}egx;
190			return $string;
191			}
192
193
194			sub _askuser {
195			my $self=shift;
196			my $querystring=shift;
197			my $varname=shift;
198
199			print $self->featuretext($self->{EnvContext});
200			for ( ;; ) {
201			print "\n".$querystring." (RETURN to log as missing)\nset $varname = ";
202			$path=<STDIN>;
203			chomp $path;
204			if ( $path ne "" ) {
205			if ( defined $self->{'client'}) { # must be a location
206			if ( $self->_testlocation($path , "H", $Envtype{$type} )) {
207			return $path;
208			}
209			print "Error : ".$path." does not exist.\n";
210			next;
211			}
212			}
213			else {
214			return $path;
215			}
216			} #end for
217
218			}
219
220	williamc	1.1.2.11	#
221			# Propgate through the searcher collecting matching tools
222			#
223			sub _searchtools {
224			my $self=shift;
225			my $tool=shift;
226
227			my @tools=();
228			my $area;
229			my $rtool;
230			if ( defined $self->{toolboxsearcher} ) {
231			my $it=$self->{toolboxsearcher}->newiterator();
232			while ( ! $it->last() ) {
233			$area=$it->next();
234			if ( defined $area ) {
235			$self->verbose("Searching for ".$tool->name()." ".
236			$tool->version()." in ".$area->location());
237			$rtool=$area->toolbox()->gettool($tool->name(),$tool->version());
238			if ( (defined $rtool) && $rtool->equals($tool) ) {
239			push @tools,$rtool;
240			}
241			}
242			}
243			}
244			return @tools;
245			}
246
247			# search toolboxes for a nice list
248			#
249			sub _toolparamcopy {
250			my $self=shift;
251			my $tool=shift;
252			my $param=shift;
253
254			my $rv=0;
255			$self->verbose("Check Other Projects for tool");
256			my @validtools=$self->_searchtools($tool);
257			if ( ! $self->interactive() ) {
258			if ( $#validtools >=0 ) {
259			my @params=$validtools[0]->getfeature($param);
260			if ( $#params >=0 ) {
261			$self->verbose("Extracting Feature $param from tool".
262			" (= @params )\n");
263			$tool->setfeature($param,@params);
264			$rv=1;
265			}
266			}
267			}
268			return $rv;
269			}
270
271	williamc	1.1.2.1	# -- Tag Routines
272
273			sub Client_start {
274			my $self=shift;
275			my $name=shift;
276			my $hashref=shift;
277
278			if ( $self->{Arch} ) {
279			$self->{'client'}=1;
280			}
281			}
282
283			sub Client_end {
284			my $self=shift;
285			if ( $self->{Arch} ) {
286			undef $self->{'client'};
287			}
288			}
289
290			sub Tool_Start {
291			my $self=shift;
292			my $name=shift;
293			my $hashref=shift;
294
295			$self->{switch}->checktag($name, $hashref, 'name');
296			$self->{switch}->checktag($name, $hashref, 'version');
297			$self->{switch}->opengroup("Toolactive");
298
299			# lower case the name
300			$$hashref{'name'}=~tr[A-Z][a-z];
301			# make sure we only pick up the tool requested
302			if ( ( $self->{tool}->name() eq $$hashref{'name'} ) &&
303			($self->{tool}->version() eq $$hashref{'version'})) {
304			$self->{switch}->
305			allowgroup("Toolactive",$self->{switch}->currentparsename());
306			$self->{ToolEnv}{'SCRAMtoolname'}=$$hashref{'name'};
307			$self->{ToolEnv}{'SCRAMtoolversion'}=$$hashref{'version'};
308	williamc	1.1.2.4	$self->{toolfound}=0;
309	williamc	1.1.2.1	}
310			else {
311			$self->{switch}->disallowgroup("Toolactive",
312			$self->{switch}->currentparsename());
313			}
314			}
315
316			sub Tool_End {
317			my $self=shift;
318			my $name=shift;
319			my $hashref=shift;
320
321			$self->{switch}->closegroup("Toolactive");
322			}
323
324			sub Environment_Start {
325			my $self=shift;
326			my $name=shift;
327			my $hashref=shift;
328
329			$self->{switch}->checktag($name, $hashref, 'name');
330			if ( $self->{Arch} ) {
331			if ( defined $self->{EnvContext} ) {
332			$self->parserror(" Attempted to open new <$name> context".
333			" without closing the previous one");
334			}
335			$self->{currentenvtext}="";
336			$self->{EnvContext}=$$hashref{'name'};
337			undef $self->{Envvalue};
338	williamc	1.1.2.10	if ( exists $$hashref{'type'} ) {
339			$$hashref{'type'}=~tr[A-Z][a-z];
340			$self->{tool}->type($$hashref{'name'},$$hashref{'type'});
341	williamc	1.1.2.1	}
342			if ( exists $$hashref{'value'}) {
343			$self->{Envvalue}=$$hashref{'value'};
344			}
345			elsif ( ! $self->interactive() ) {
346	williamc	1.1.2.11	# check other installed copies of the tool
347			if ( $self->_toolparamcopy($self->{tool},$$hashref{'name'}) ) {
348			my @tmp=$self->{tool}->getfeature($$hashref{'name'});
349			$self->{Envvalue}=$tmp[0]; # assume single val parameter!
350			}
351			elsif ( defined $ENV{$$hashref{'name'}} ) {
352			# check the environment
353			$self->{Envvalue}=$ENV{$$hashref{'name'}};
354	williamc	1.1.2.5	}
355			elsif ( $self->_checkdefault($hashref) ) {
356	williamc	1.1.2.11	$self->{Envvalue}=$$hashref{'default'};
357	williamc	1.1.2.1	}
358			}
359			}
360			}
361
362			sub Env_text {
363			my $self=shift;
364			my $name=shift;
365			my $string=shift;
366
367			if ( $self->{Arch} ) {
368			$self->{currentenvtext}=$self->{currentenvtext}.$string;
369			}
370			}
371
372			sub Environment_End {
373			my $self=shift;
374			my $name=shift;
375
376			if ( $self->{Arch} ) {
377			if ( ! defined $self->{EnvContext} ) {
378	williamc	1.1.2.8	$self->{switch}->parseerror("</$name> without an opening context");
379	williamc	1.1.2.1	}
380			# - set the help text
381			$self->featuretext($self->{EnvContext},$self->{currentenvtext});
382			if ( ! defined $self->{Envvalue} ) {
383			$self->{Envvalue}=$self->_askuser("Please Enter the Value Below:",
384			$self->{EnvContext});
385			}
386			$self->{Envvalue}=$self->_expandvars($self->{Envvalue});
387			$self->{tool}->addfeature($self->{EnvContext}, $self->{Envvalue});
388			$self->{ToolEnv}{$self->{EnvContext}}=$self->{Envvalue};
389			undef $self->{EnvContext};
390			undef $self->{Envvalue};
391			}
392			}
393
394			sub Lib {
395			my $self=shift;
396			my $name=shift;
397			my $hashref=shift;
398
399			$self->{switch}->checktag($name, $hashref, 'name');
400			if ( $self->{Arch} ) {
401			$self->{tool}->addfeature("lib",$$hashref{'name'});
402			}
403			}
404
405			sub External_Start {
406			my $self=shift;
407			my $name=shift;
408			my $hashref=shift;
409
410			$self->{switch}->checktag($name, $hashref,'ref');
411			if ( $self->{Arch} ) {
412	williamc	1.1.2.2	$self->{tool}->addfeature("_externals",$$hashref{'ref'});
413	williamc	1.1.2.1	}
414			}
415
416			sub Arch_Start {
417			my $self=shift;
418			my $name=shift;
419			my $hashref=shift;
420
421	williamc	1.1.2.5	$self->{switch}->checktag($name, $hashref,'name');
422	williamc	1.1.2.1	( ($ENV{SCRAM_ARCH}=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
423			: ($self->{Arch}=0);
424			push @{$self->{ARCHBLOCK}}, $self->{Arch};
425			}
426
427			sub Arch_End {
428			my $self=shift;
429			my $name=shift;
430
431			pop @{$self->{ARCHBLOCK}};
432			$self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
433			}
434
435