ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/COMP/SCRAM/src/BuildSystem/BuildFile.pm
(Generate patch)

Comparing COMP/SCRAM/src/BuildSystem/BuildFile.pm (file contents):
Revision 1.7 by williamc, Tue Sep 19 10:09:29 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
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 27 | Line 28 | sub new {
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;
# Line 48 | Line 58 | sub makefile {
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 60 | 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 69 | 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 147 | Line 193 | sub GenerateMakefile {
193          if ( -e $ENV{LatestBuildFile} ) {
194            print GNUmakefile "include $ENV{LatestBuildFile}\n";
195          }
150 –        $ENV{LatestBuildFile}=$outfile;
196          $self->{switch}->parse("makebuild"); # sort out supported tags
197          close GNUmakefile;
198 +        return $outfile;
199   }
200  
201   sub ParseBuildFile {
# Line 179 | Line 225 | sub ParseBuildFile {
225          #open a temporary gnumakefile to store output.
226          use Utilities::AddDir;
227          AddDir::adddir("$self->{localtop}/$ENV{INTwork}/$self->{path}");
228 <        $self->GenerateMakefile($fullfilename,
229 <          $self->{localtop}."/".$ENV{INTwork}."/".$self->{path}."/BuildFile.mk");
228 >        $ENV{LatestBuildFile}=$self->GenerateMakefile($fullfilename,
229 >         $self->{localtop}."/".$ENV{INTwork}."/".$self->{path}."/BuildFile.mk");
230   }
231  
232   sub classname {
# Line 288 | 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 296 | 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 322 | 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'};
327 –           foreach $dtype ( @deftypes ) {
328 –            print $fh $$hashref{'class'}."::".$$hashref{'class'}."_".
329 –                                                                $dtype."\n";
330 –           }
331 –           print $fh "\n";
561  
562             # -- generate targets for each type
563             foreach $type ( @types ) {
# Line 343 | 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  
# Line 483 | Line 713 | ENDTEXT
713  
714   # the binary specifics makefile
715          print binGNUmakefile "include ".$self->{currentenv}."\n";
716 <        print binGNUmakefile "VPATH+=$self->{localtop}/$self{path}\n";
716 >        print binGNUmakefile "VPATH+=".$self->{localtop}."/$self{path}\n";
717  
718   # alias for bin_Insure
719          print binGNUmakefile <<ENDTEXT;
# Line 922 | Line 1152 | sub Environment_end {
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