ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/SCRAM/src/BuildSystem/BuildFile.pm

Comparing COMP/SCRAM/src/BuildSystem/BuildFile.pm (file contents):
Revision 1.2 by williamc, Mon Aug 28 08:23:08 2000 UTC vs.
Revision 1.10 by williamc, Sat Oct 14 17:29:05 2000 UTC

#	Line 2 | Line 2
2		#
3		# Interface
4		# ---------
5	<	# new(toolbox)
5	>	# new(ConfigArea)
6		# ParseBuildFile($base,$path,$file)
7		# ParseBuildFileExport(filename)
8	+	# BlockParse(Block) : perform a parse to modify the block
9		# BlockClassPath() : Return the class path
10		# ignore()      : return 1 if directory should be ignored 0 otherwise
11	+	# classname()   : get/set the associated class
12	+	# buildfile()   : get/set BuildFile location
13	+	# makefile()    : get the generated makefile
14
15		package BuildSystem::BuildFile;
16		use ActiveDoc::SimpleDoc;
#	Line 21 | Line 25 | sub new {
25		my $class=shift;
26		my $self={};
27		bless $self, $class;
28	<	$self->{toolbox}=shift;
28	>	$self->{area}=shift;
29	>	$self->{toolbox}=$self->{area}->toolbox();
30	>	$self->{localtop}=$self->{area}->location();
31	>	# -- set RELEASTOP
32	>	my $rarea=$self->{area}->linkarea();
33	>	if ( ! defined $rarea ) {
34	>	$self->{releasetop}=$self->{localtop};
35	>	}
36	>	else {
37	>	$self->{releasetop}=$rarea->location();
38	>	}
39	>	$self->{releasetop}=$self->{area}->location();
40		$self->{Arch}=1;
41		push @{$self->{ARCHBLOCK}}, $self->{Arch};
42		return $self;
43		}
44
45	+	sub buildfile {
46	+	my $self=shift;
47	+	if ( @_ ) {
48	+	$self->{buildfile}=shift;
49	+	}
50	+	return $self->{buildfile};
51	+	}
52	+
53	+	sub makefile {
54	+	my $self=shift;
55	+	if ( @_ ) {
56	+	$self->{makefile}=shift;
57	+	}
58	+	return $self->{makefile};
59	+	}
60	+
61	+	sub BlockParse {
62	+	my $self=shift;
63	+	$self->{block}=shift;
64	+
65	+	# -- set up the block parse
66	+	my $switch=$self->_initswitcher();
67	+	my $parse="block";
68	+	$switch->newparse($parse);
69	+	$switch->addignoretags($parse);
70	+	$switch->addtag($parse,"BuildParam", \&BuildBlock_start, $self);
71	+
72	+	# -- parse away
73	+	$self->{switch}->parse("block");
74	+	}
75	+
76	+	sub Parsetofh {
77	+	my $self=shift;
78	+	my $fh=shift;
79	+	$self->{buildblock}=shift;
80	+
81	+	# -- set up for parse
82	+	@{$self->{filehandlestack}}=($fh);
83	+	$self->{switch}->filetoparse($self->buildfile());
84	+	*GNUmakefile=$fh;
85	+
86	+	# -- generate makefile
87	+	$self->{switch}->parse("makebuild"); # sort out supported tags
88	+
89	+	# -- Clean up
90	+	close GNUmakefile;
91	+	}
92	+
93		sub ignore {
94		my $self=shift;
95		return (defined $self->{ignore})?$self->{ignore}:0;
#	Line 39 | Line 102 | sub _initswitcher {
102		$switch->newparse($parse);
103		$switch->addignoretags($parse);
104		$self->_commontags($switch,$parse);
105	<	$switch->addtag($parse,"Build", \&Build_start, $self);
105	>	#$switch->addtag($parse,"Build", \&Build_start, $self);
106		$switch->addtag($parse,"none",
107		\&OutToMakefile,$self,
108		\&OutToMakefile, $self,
#	Line 48 | Line 111 | sub _initswitcher {
111		\&Bin_start,$self,
112		\&OutToScreen, $self,
113		"", $self);
114	+	$switch->addtag($parse,"ProductStore",
115	+	\&Store_start,$self,
116	+	"", $self,
117	+	"", $self);
118		$switch->addtag($parse,"LibType",
119		\&LibType_Start,$self,
120		\&LibType_text, $self,
#	Line 107 | Line 174 | sub _commontags {
174		return $switch;
175		}
176
177	+	sub GenerateMakefile {
178	+	my $self=shift;
179	+	my $infile=shift;
180	+	my $outfile=shift;
181	+
182	+	$self->{switch}=$self->_initswitcher();
183	+	$self->{switch}->filetoparse($infile);
184	+
185	+	# open a temporary gnumakefile to store output.
186	+	my $fh=FileHandle->new();
187	+	open ( $fh, ">$outfile") or die "Unable to open $outfile for output ".
188	+	"$!\n";
189	+	@{$self->{filehandlestack}}=($fh);
190	+
191	+	#  -- make an alias
192	+	*GNUmakefile=$fh;
193	+	if ( -e $ENV{LatestBuildFile} ) {
194	+	print GNUmakefile "include $ENV{LatestBuildFile}\n";
195	+	}
196	+	$self->{switch}->parse("makebuild"); # sort out supported tags
197	+	close GNUmakefile;
198	+	return $outfile;
199	+	}
200	+
201		sub ParseBuildFile {
202		my $self=shift;
203		my $base=shift;
#	Line 124 | Line 215 | sub ParseBuildFile {
215		$numbins=0;
216		$self->{envnum}=0;
217		$self->{envlevel}=0;
218	<	$self->{currentenv}="$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/".
218	>	$self->{makefile}="$self->{localtop}/$ENV{INTwork}/$self->{path}/".
219		"BuildFile.mk";
220	+	$self->{currentenv}=$self->{makefile};
221		$self->{switch}=$self->_initswitcher();
222		$self->{switch}->filetoparse($fullfilename);
223
224		#       $self->{switch}->{Strict_no_cr}='no';
225		#open a temporary gnumakefile to store output.
226		use Utilities::AddDir;
227	<	AddDir::adddir("$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}");
228	<	my $fh=FileHandle->new();
229	<	open ( $fh, ">$ENV{LOCALTOP}/$ENV{INTwork}/".$self->{path}."/BuildFile.mk"
230	<	) or die 'Unable to open /$ENV{INTwork}/".$self->{path}."/BuildFile.mk $!\n';
231	<	@{$self->{filehandlestack}}=($fh);
232	<	# make an alias
233	<	*GNUmakefile=$fh;
234	<	if ( -e $ENV{LatestBuildFile} ) {
235	<	print GNUmakefile "include $ENV{LatestBuildFile}\n";
144	<	}
145	<	#       print "writing to :\n".
146	<	#               "$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/BuildFile.mk\n";
147	<	$ENV{LatestBuildFile}="$ENV{LOCALTOP}/$ENV{INTwork}/".$self->{path}."/BuildFile.mk";
148	<	$self->{switch}->parse("makebuild"); # sort out supported tags
149	<	if ( $numbins > 0 ) {
150	<	print GNUmakefile <<ENDTEXT;
151	<	ifndef BINMODE
152	<	help::
153	<	\t\@echo Generic Binary targets
154	<	\t\@echo ----------------------
155	<	endif
156	<	ENDTEXT
157	<	foreach $target ( keys %$targettypes ) {
158	<	print GNUmakefile <<ENDTEXT;
159	<	ifndef BINMODE
160	<	help::
161	<	\t\@echo $target
162	<	endif
163	<	ENDTEXT
164	<	}
227	>	AddDir::adddir("$self->{localtop}/$ENV{INTwork}/$self->{path}");
228	>	$ENV{LatestBuildFile}=$self->GenerateMakefile($fullfilename,
229	>	$self->{localtop}."/".$ENV{INTwork}."/".$self->{path}."/BuildFile.mk");
230	>	}
231	>
232	>	sub classname {
233	>	my $self=shift;
234	>	if ( @_ ) {
235	>	$self->{classname}=shift;
236		}
237	<	close GNUmakefile;
237	>	return $self->{classname};
238		}
239
240		sub ParseBuildFile_Export {
241		my $self=shift;
242		my $filename=shift;
243	<	my $bf=BuildSystem::BuildFile->new($self->{toolbox});
243	>	my $bf=BuildSystem::BuildFile->new($self->{area});
244		if ( defined $self->{remoteproject} ) {
245		$bf->{remoteproject}=$self->{remoteproject};
246		}
#	Line 245 | Line 316 | sub Class_StartTag {
316
317		if ( $self->{Arch} ) {
318		if ( defined $$hashref{'type'} ) {
319	<	$ClassName=$$hashref{'type'};
319	>	$self->classname($$hashref{'type'});
320		}
321		}
322		}
#	Line 263 | Line 334 | sub IncludePath_Start {
334		}
335
336		#
337	+	# --- <Build class=> tag
338	+	#
339	+
340	+	#
341	+	# Parameter collection
342	+	#
343	+	sub BuildBlock_start {
344	+	my $self=shift;
345	+	my $name=shift;
346	+	my $hashref=shift;
347	+
348	+
349	+	my $blockobjid=$self->__blockobjid($hashref);
350	+
351	+	if ( $self->{Arch} ) {
352	+
353	+
354	+	# -- get any objects that match
355	+	my $inheritobj=$self->{block}->getobj($blockobjid);
356	+
357	+	# -- create an object with inherited properties
358	+	my $obj;
359	+	if ( ! defined $inheritobj ) {
360	+	# -- check we have a lookup for the class type
361	+	my $mapper=$self->_toolmapper();
362	+	if ( ! $mapper->exists($$hashref{'class'}) ) {
363	+	$self->{switch}->parseerror("Unknown class : ".
364	+	$$hashref{'class'});
365	+	}
366	+	$obj=BuildSystem::BuildClass->new();
367	+	}
368	+	else {
369	+	# -- inherit the properties from class with the same id class
370	+	$obj=$inheritobj->child();
371	+	}
372	+
373	+	# -- add changes from our tag
374	+	$obj->paramupdate($hashref);
375	+
376	+	# -- store the new object in the block
377	+	$self->{block}->setobj($obj,$blockobjid);
378	+	}
379	+	}
380	+
381	+	sub BuilderClass_buildmakefile {
382	+	my $self=shift;
383	+	my $name=shift;
384	+	my $hashref=shift;
385	+
386	+	my $blockobjid=$self->__blockobjid($hashref);
387	+
388	+	if ( $self->{Arch} ) {
389	+	# -- get the matching block object
390	+	my $blockobj=$self->{buildblock}->getobj($blockobjid);
391	+
392	+	# -- top level buildfile
393	+	my $fh=$self->{filehandlestack}[0];
394	+
395	+	# -- var initialisation
396	+	my @deftypes=();
397	+	my $buildname="";
398	+	my @types=$self->_toolmapper()->types($$hashref{'class'});
399	+
400	+	# -- error checking
401	+	if ( ! defined $blockobj->param("default") ) {
402	+	$self->error("No default build parameter defined for ".
403	+	$$hashref{'class'}." ".$$hashref{'id'});
404	+	}
405	+	if ( ! defined $blockobj->param("name") ) {
406	+	$self->error("\"name\" parameter defined for ".
407	+	$$hashref{'class'}." ".$$hashref{'id'});
408	+	}
409	+
410	+
411	+	foreach $param ( $blockobj->paramlist() ) {
412	+	# -- check for params that need special handling
413	+	if ( $param eq "default" ) {
414	+	@deftypes=split /,/, $param;
415	+	}
416	+	elsif ( $param eq "name" ) {
417	+	$buildname=$blockobj->param($param);
418	+	}
419	+	else {
420	+	# -- simple transfer of block object parameters to makefile
421	+	print $fh $param.":=".$blockobj->param($param)."\n";
422	+	}
423	+	}
424	+
425	+	# -- construct the targets in the top makefile
426	+	$self->_generatedefaulttargets($fh,$$hashref{'class'},@deftypes);
427	+	$self->_generatetypetargets($fh,$$hashref{'class'},$buildname,@types);
428	+
429	+	}
430	+	}
431	+
432	+	sub _blockobjid {
433	+	my $self=shift;
434	+	my $hashref=shift;
435	+
436	+	$self->{switch}->checktag($name,$hashref,'class');
437	+	$self->{switch}->checktag($name,$hashref,'id');
438	+	my $blockobjid="bc_".$$hashref{'class'},"_".$$hashref{'id'};
439	+
440	+	return $blockobjid;
441	+	}
442	+
443	+	sub _generatedefaulttargets {
444	+	my $self=shift;
445	+	my $fh=shift;
446	+	my $class=shift;
447	+
448	+	my @deftypes=shift;
449	+
450	+	print $fh "# -- Default type targets\n";
451	+	foreach $dtype ( @deftypes ) {
452	+	print $fh $class."::".$class."_".$dtype."\n";
453	+	}
454	+	print $fh "\n";
455	+	}
456	+
457	+	sub _generatetypetargets {
458	+	my $self=shift;
459	+	my $fh=shift;
460	+	my $class=shift;
461	+	my $name=shift;
462	+
463	+	my @types=shift;
464	+
465	+	print $fh "# -- Generic type targets\n";
466	+	foreach $type ( @types ) {
467	+	my $pattern=$class."_".$type;
468	+	my $dirname=$class."_".$type."_".$name;
469	+	my $makefile=$here."/BuildFile.mk";
470	+
471	+	# -- map to generic name for each type
472	+	print $fh "# ------ $pattern rules ---------------\n";
473	+	print $fh $class."_".$type."::".$class.
474	+	"_".$type."_$name\n\n";
475	+
476	+	print $fh "# -- Link Targets to $type directories\n";
477	+	print $fh "$dirname: make_$dirname\n";
478	+	print $fh "\t\@cd $here; \\\n";
479	+	print $fh "\t\$(MAKE) LatestBuildFile=$makefile _BuildLink_=1".
480	+	" workdir=$here ".
481	+	" -f \$(TOOL_HOME)/basics.mk datestamp \$\@; \n\n";
482	+
483	+	# -- write target to make makefile for each directory
484	+	print $fh "# -- Build target directories\n";
485	+	print $fh "make_$dirname:\n";
486	+	print $fh "\tif [ ! -e \"$makefile\" ]; then \\\n";
487	+	print $fh "\t if [ ! -d \"$here\" ]; then \\\n";
488	+	print $fh "\t  mkdir $here; \\\n";
489	+	print $fh "\t fi;\\\n";
490	+	print $fh "\t cd $dirname; \\\n";
491	+	print $fh "\t echo include ".$self->{currentenv}." > ".
492	+	"$makefile; \\\n";
493	+	print $fh "\t echo VPATH+=$self->{localtop}/".$self->{path}.
494	+	" >> $makefile; \\\n";
495	+	print $fh "\t echo buildname=$name >> $makefile;\\\n";
496	+	print $fh "\t echo ".$dirname.":".$pattern." >> $makefile;\\\n";
497	+	if ( defined (my @file=$mapper->rulesfile($class)) ) {
498	+	foreach $f ( @file ) {
499	+	print $fh "\t echo -include $f >> $makefile; \\\n";
500	+	}
501	+	}
502	+	print $fh "\tfi\n";
503	+	print $fh "\n";
504	+
505	+	# -- cleaning targets
506	+	push @targets, "clean_$dirname";
507	+	print $fh "# -- cleaning targets\n";
508	+	print $fh "clean::clean_$dirname\n";
509	+	print $fh "clean_".$dirname."::\n";
510	+	print $fh "\t\@echo cleaning $dirname\n";
511	+	print $fh "\t\@if [ -d $here ]; then \\\n";
512	+	print $fh "\tcd $here; \\\n";
513	+	print $fh "\t\$(MAKE) LatestBuildFile=$makefile workdir=".
514	+	$here." _BuildLink_=1 -f ".
515	+	"\$(TOOL_HOME)/basics.mk clean; \\\n";
516	+	print $fh "\tfi\n\n";
517	+
518	+	}
519	+	print $fh "\n";
520	+	}
521	+
522	+	#
523		# generic build tag
524		#
525		sub Build_start {
#	Line 271 | Line 528 | sub Build_start {
528		my $hashref=shift;
529
530		$self->{switch}->checktag($name,$hashref,'class');
531	+	$self->{switch}->checktag($name,$hashref,'id');
532		if ( $self->{Arch} ) {
533
534		# -- determine the build products name
#	Line 297 | Line 555 | sub Build_start {
555
556		# -- generate generic targets
557		print $fh "ifndef _BuildLink_\n";
558	<	print $fh "# -- Generic targets\n";
558	>	$self->_generatedefaulttargets($fh,$$hashref{'class'},@deftypes);
559	>
560		push @targets, $$hashref{'class'};
302	–	foreach $dtype ( @deftypes ) {
303	–	print $fh $$hashref{'class'}."::".$$hashref{'class'}."_".
304	–	$dtype."\n";
305	–	}
306	–	print $fh "\n";
561
562		# -- generate targets for each type
563		foreach $type ( @types ) {
#	Line 318 | Line 572 | sub Build_start {
572		# -- create a new directory for each type
573		push @targets, $pattern;
574		my $dirname=$$hashref{'class'}."_".$type."_".$name;
575	<	my $here="$ENV{LOCALTOP}/$ENV{INTwork}/".$self->{path}."/".$dirname;
575	>	my $here="$self->{localtop}/$ENV{INTwork}/".$self->{path}.
576	>	"/".$dirname;
577		my $makefile=$here."/BuildFile.mk";
578		#           AddDir::adddir($here);
579
#	Line 341 | Line 596 | sub Build_start {
596		print $fh "\t cd $dirname; \\\n";
597		print $fh "\t echo include ".$self->{currentenv}." > ".
598		"$makefile; \\\n";
599	<	print $fh "\t echo VPATH+=$ENV{LOCALTOP}/".$self->{path}.
599	>	print $fh "\t echo VPATH+=$self->{localtop}/".$self->{path}.
600		" >> $makefile; \\\n";
601		print $fh "\t echo buildname=$name >> $makefile;\\\n";
602		print $fh "\t echo ".$dirname.":".$pattern." >> $makefile;\\\n";
#	Line 356 | Line 611 | sub Build_start {
611		#           print $typefile "\t\$(_quietbuild_)";
612		#           print $typefile $mapper->template($$hashref{'class'},$type)."\n";
613		#           print $typefile "\t\$(_quietstamp_)";
614	<	#           print $typefile "$(SCRAMPERL) $(SCRAM_HOME)/src/scramdatestamp \$@.ds \$@ \$^\n";
614	>	#           print $typefile "\$(SCRAMPERL) \$(SCRAM_HOME)/src/scramdatestamp \$@.ds \$@ \$^\n";
615
616		# -- cleaning targets
617		push @targets, "clean_$dirname";
#	Line 407 | Line 662 | sub Bin_start {
662
663		# Create a new directory for each binary target
664		my $dirname="bin_".$$hashref{name};
665	<	AddDir::adddir("$ENV{LOCALTOP}/$ENV{INTwork}/".$self->{path}."/$dirname");
665	>	AddDir::adddir("$self->{localtop}/$ENV{INTwork}/".$self->{path}."/$dirname");
666		open (binGNUmakefile,
667	<	">$ENV{LOCALTOP}/$ENV{INTwork}/".$self->{path}."/$dirname/BuildFile.mk") or die           "Unable to make $ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/$dirname/".
667	>	">$self->{localtop}/$ENV{INTwork}/".$self->{path}."/$dirname/BuildFile.mk") or die           "Unable to make $self->{localtop}/$ENV{INTwork}/$self->{path}/$dirname/".
668		"BuildFile.mk $!\n";
669
670		# Create the link targets
#	Line 425 | Line 680 | endif
680		ifndef BINMODE
681
682		define stepdown_$$hashref{'name'}
683	<	if [ -d "$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/$dirname" ]; then \\
684	<	cd $ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/$dirname; \\
685	<	\$(MAKE) BINMODE=true LatestBuildFile=$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/$dirname/BuildFile.mk workdir=\$(workdir)/$dirname -f \$(TOOL_HOME)/basics.mk datestamp \$\@; \\
683	>	if [ -d "$self->{localtop}/$ENV{INTwork}/$self->{path}/$dirname" ]; then \\
684	>	cd $self->{localtop}/$ENV{INTwork}/$self->{path}/$dirname; \\
685	>	\$(MAKE) BINMODE=true LatestBuildFile=$self->{localtop}/$ENV{INTwork}/$self->{path}/$dirname/BuildFile.mk workdir=\$(workdir)/$dirname -f \$(TOOL_HOME)/basics.mk datestamp \$\@; \\
686		fi
687		endef
688
689		define stepdown2_$$hashref{'name'}
690	<	if [ -d "$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/$dirname" ]; then \\
691	<	cd $ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/$dirname; \\
692	<	\$(MAKE) BINMODE=true LatestBuildFile=$ENV{LOCALTOP}/$ENV{INTwork}/$self{path}/$dirname/BuildFile.mk workdir=\$(workdir)/$dirname -f \$(TOOL_HOME)/basics.mk datestamp \$\*; \\
690	>	if [ -d "$self->{localtop}/$ENV{INTwork}/$self->{path}/$dirname" ]; then \\
691	>	cd $self->{localtop}/$ENV{INTwork}/$self->{path}/$dirname; \\
692	>	\$(MAKE) BINMODE=true LatestBuildFile=$self->{localtop}/$ENV{INTwork}/$self{path}/$dirname/BuildFile.mk workdir=\$(workdir)/$dirname -f \$(TOOL_HOME)/basics.mk datestamp \$\*; \\
693		fi
694
695		endef
#	Line 458 | Line 713 | ENDTEXT
713
714		# the binary specifics makefile
715		print binGNUmakefile "include ".$self->{currentenv}."\n";
716	<	print binGNUmakefile "VPATH+=$ENV{LOCALTOP}/$self{path}\n";
716	>	print binGNUmakefile "VPATH+=".$self->{localtop}."/$self{path}\n";
717
718		# alias for bin_Insure
719		print binGNUmakefile <<ENDTEXT;
#	Line 514 | Line 769 | ENDTEXT
769		print binGNUmakefile "$$hashref{name}_Insure.exe:.psrc\n";
770		print binGNUmakefile "$$hashref{name}_d.exe:$objectname_d\n";
771		print binGNUmakefile "\t\$(CClinkCmdDebug)\n";
772	<	print binGNUmakefile "\t\@\$(SCRAMPERL) $(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
772	>	print binGNUmakefile "\t\@\$(SCRAMPERL) \$(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
773		print binGNUmakefile "$$hashref{name}_l_d.exe:$objectname_d\n";
774		print binGNUmakefile "\t\$(CClinkCmdDebugLocal)\n";
775	<	print binGNUmakefile "\t\@\$(SCRAMPERL) $(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
775	>	print binGNUmakefile "\t\@\$(SCRAMPERL) \$(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
776		print binGNUmakefile "$$hashref{name}_Insure.exe:$objectname_Insure\n";
777		print binGNUmakefile "\t\$(CClinkCmdInsure)\n";
778	<	print binGNUmakefile "\t\@\$(SCRAMPERL) $(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
778	>	print binGNUmakefile "\t\@\$(SCRAMPERL) \$(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
779		print binGNUmakefile "$$hashref{name}_o.exe:$objectname_o\n";
780		print binGNUmakefile "\t\$(CClinkCmd)\n";
781	<	print binGNUmakefile "\t\@\$(SCRAMPERL) $(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
781	>	print binGNUmakefile "\t\@\$(SCRAMPERL) \$(SCRAM_HOME)/src/scramdatestamp \$\@\.ds \$\@ \$\^\n";
782		print binGNUmakefile "$$hashref{name}.dep:$$hashref{file}\n";
783		print binGNUmakefile "-include $$hashref{name}.dep\n";
784		print binGNUmakefile <<ENDTEXT;
#	Line 653 | Line 908 | sub Use_start {
908		}
909		}
910
656	–	sub CheckBuildFile {
657	–	my $self=shift;
658	–	my $classdir=shift;
659	–	my $ClassName="";
660	–	my $thisfile="$classdir/$buildfile";
661	–
662	–	if ( -e $ENV{LOCALTOP}."/".$thisfile ) {
663	–	$DefaultBuildfile="$ENV{LOCALTOP}/$thisfile";
664	–	$self->ParseBuildFile($ENV{LOCALTOP}, $classdir, $buildfile);
665	–	}
666	–	elsif ( -e $ENV{RELEASETOP}."/".$thisfile ) {
667	–	$DefaultBuildfile="$ENV{RELEASETOP}/$thisfile";
668	–	$self->ParseBuildFile($ENV{RELEASETOP}, $classdir, $buildfile);
669	–	}
670	–	return $ClassName;
671	–	}
672	–
911		# List association groups between <AssociateGroup> tags
912		# seperated by newlines or spaces
913		sub AssociateGroup {
#	Line 865 | Line 1103 | sub Environment_start {
1103		$self->{envnum}++;
1104
1105		# open a new Environment File
1106	<	my $envfile="$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/Env_".
1106	>	my $envfile="$self->{localtop}/$ENV{INTwork}/$self->{path}/Env_".
1107		$self->{envnum}.".mk";
1108		use FileHandle;
1109		my $fh=FileHandle->new();
#	Line 875 | Line 1113 | sub Environment_start {
1113
1114		# include the approprate environment file
1115		if ( $self->{envlevel} == 0 ) {
1116	<	print GNUmakefile "include $ENV{LOCALTOP}/$ENV{INTwork}/".
1116	>	print GNUmakefile "include $self->{localtop}/$ENV{INTwork}/".
1117		$self->{path}."/BuildFile.mk\n";
1118		}
1119		else {
1120	<	print GNUmakefile "include $ENV{LOCALTOP}/$ENV{INTwork}/".
1120	>	print GNUmakefile "include $self->{localtop}/$ENV{INTwork}/".
1121		$self->{path}."/Env_".$self->{Envlevels}[$self->{envlevel}].".mk\n";
1122		}
1123		$self->{envlevel}++;
1124		$self->{Envlevels}[$self->{envlevel}]=$self->{envnum};
1125	<	$self->{currentenv}="$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/Env_$self->{envnum}.mk";
1125	>	$self->{currentenv}="$self->{localtop}/$ENV{INTwork}/$self->{path}/Env_$self->{envnum}.mk";
1126		}
1127		}
1128
#	Line 904 | Line 1142 | sub Environment_end {
1142		close $fd;
1143		*GNUmakefile=$self->{filehandlestack}[$#{$self->{filehandlestack}}];
1144		if ( $self->{envlevel} < 1 ) {
1145	<	$self->{currentenv}="$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/".
1145	>	$self->{currentenv}="$self->{localtop}/$ENV{INTwork}/$self->{path}/".
1146		"BuildFile.mk";
1147		}
1148		else {
1149		$self->{currentenv}=
1150	<	"$ENV{LOCALTOP}/$ENV{INTwork}/$self->{path}/Env_".
1150	>	$self->{localtop}."/$ENV{INTwork}/$self->{path}/Env_".
1151		$self->{Envlevels}[$self->{envlevel}];
1152		}
1153		}
1154		}
1155	+
1156	+	sub Store_start {
1157	+	my $self=shift;
1158	+	my $name=shift;
1159	+	my $hashref=shift;
1160	+
1161	+	if ( $self->{Arch} ) {
1162	+	$self->{switch}->checktag( $name, $hashref, 'name' );
1163	+
1164	+	# -- store creation
1165	+	my $dir=$$hashref{'name'};
1166	+	AddDir::adddir($self->{area}->location()."/".$dir);
1167	+	if ( exists $$hashref{'type'} ) {
1168	+	# -- architecture specific store
1169	+	if ( $$hashref{'type'}=~/^arch/i ) {
1170	+	$dir=$dir."/".$ENV{SCRAM_ARCH};
1171	+	AddDir::adddir($self->{area}->location()."/".$dir);
1172	+	}
1173	+	else {
1174	+	$self->parseerror("Unknown type in <$name> tag");
1175	+	}
1176	+	}
1177	+
1178	+	# -- set make variables for the store
1179	+	print GNUmakefile "SCRAMSTORENAME_".$$hashref{'name'}.":=".$dir."\n";
1180	+	print GNUmakefile "SCRAMSTORE_".$$hashref{'name'}.":=".
1181	+	$self->{localtop}."/".$dir."\n";
1182	+	print GNUmakefile "VPATH+=".$self->{localtop}
1183	+	."/".$dir.":".$self->{releasetop}."/".$dir."\n";
1184	+	}
1185	+	}
1186	+
1187	+	sub DropDown {
1188	+	my $self=shift;
1189	+	my $name=shift;
1190	+	my $hashref=shift;
1191	+
1192	+	if ( $self->{Arch} ) {
1193	+	# - default values must always be specified
1194	+	$self->{switch}->checktag( $name, $hashref, 'defaults' );
1195	+	my @blockdirs=split /,/ , $$hashref{'defaults'};
1196	+	$self->{block}->defaultblocks(@blockdirs);
1197	+	}
1198	+	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines