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.9 by williamc, Fri Sep 29 10:32:18 2000 UTC vs.
Revision 1.10 by williamc, Sat Oct 14 17:29:05 2000 UTC

#	Line 5 | Line 5
5		# new(ConfigArea)
6		# ParseBuildFile($base,$path,$file)
7		# ParseBuildFileExport(filename)
8	<	# blockparse(Block) : perform a parse to modify the block
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
#	Line 58 | Line 58 | sub makefile {
58		return $self->{makefile};
59		}
60
61	<	sub blockparse {
61	>	sub BlockParse {
62		my $self=shift;
63		$self->{block}=shift;
64
65	<	$self->{switch}=$self->_initswitcher();
66	<	$self->_initblockparse($self->{switch});
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 {
#	Line 118 | Line 142 | sub _initswitcher {
142		return $switch;
143		}
144
121	–	sub _initblockparse {
122	–	my $self=shift;
123	–	my $switch=shift;
124	–
125	–	my $parse="block";
126	–	$switch->newparse($parse);
127	–	$switch->addignoretags($parse);
128	–	$switch->addtag($parse,"DropDown",
129	–	\&DropDown_start,$self,
130	–	"", $self,
131	–	"", $self);
132	–	$switch->addtag($parse,"Build", \&Build_start, $self);
133	–	}
134	–
145		sub _commontags {
146		my $self=shift;
147		my $switch=shift;
#	Line 216 | Line 226 | sub ParseBuildFile {
226		use Utilities::AddDir;
227		AddDir::adddir("$self->{localtop}/$ENV{INTwork}/$self->{path}");
228		$ENV{LatestBuildFile}=$self->GenerateMakefile($fullfilename,
229	<	$self->{localtop}."/".$ENV{INTwork}."/".$self->{path}."/BuildFile.mk");
229	>	$self->{localtop}."/".$ENV{INTwork}."/".$self->{path}."/BuildFile.mk");
230		}
231
232		sub classname {
#	Line 324 | 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 359 | 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'};
364	–	foreach $dtype ( @deftypes ) {
365	–	print $fh $$hashref{'class'}."::".$$hashref{'class'}."_".
366	–	$dtype."\n";
367	–	}
368	–	print $fh "\n";
561
562		# -- generate targets for each type
563		foreach $type ( @types ) {
#	Line 380 | 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="$self->{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

Diff Legend

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