SCRAM/src/BuildFile.pm

package BuildFile;
require 5.001;
require Exporter;
@ISA    = qw(Exporter);
@EXPORT = qw(CheckBuildFile ParseBuildFile @BlockClassA $DefaultBuildFile);


#Parse the BuildFile
sub ParseBuildFile {
        my $base=shift;
        my $path=shift;
        my $filename=shift @_;
        my $fullfilename="$base/$path/$filename";
        #print "Processing $fullfilename\n";
        # This hash defines which Document Elements we can use
        my $SupportedTags={
                'Use' => \&OutToMakefile,
                'Use_StartTag' => \&Use_start,
                'Group' => \&OutToMakefile,
                'Group_StartTag' => \&Group_start,
                'External' => \&OutToMakefile,
                'External_StartTag' => \&External_StartTag,
                'ConfigurationClass_StartTag' => \&Class_StartTag,
                'ConfigurationClass' => \&OutToMakefile,
                'AssociateGroup' => \&AssociateGroup,
                'none' => \&OutToMakefile,
                'Bin' => 'none',
                'Bin_StartTag' => \&Bin_start,
                'ClassPath' => \&OutToMakefile,
                'ClassPath_StartTag' => \&setBlockClassPath,
                'lib' => 'none',
                'lib_StartTag' => \&lib_start,
                'lib_EndTag' => 'none'
        };
        use ActiveDoc::Switcher;
        $switch=Switcher->new($SupportedTags, $fullfilename);
        $switch->{Strict_no_cr}='no';
        #open a temporary gnumakefile to store output.
        use Utilities::AddDir;
        AddDir::adddir("$ENV{LOCALTOP}/$ENV{INTwork}/${path}");
        open ( GNUmakefile, ">$ENV{LOCALTOP}/$ENV{INTwork}/${path}/BuildFile.mk") or die 'Unable to open /$ENV{INTwork}/${path}/BuildFile.mk $!\n';
        if ( -e $ENV{LatestBuildFile} ) {
          print GNUmakefile "include $ENV{LatestBuildFile}\n";
        }
#       print "writing to :\n".
#               "$ENV{LOCALTOP}/$ENV{INTwork}/${path}/BuildFile.mk\n";
        $ENV{LatestBuildFile}="$ENV{LOCALTOP}/$ENV{INTwork}/${path}/BuildFile.mk";
        $switch->parse(); # sort out supported tags
        close GNUmakefile;
}

sub ParseBuildFile_Export {
        my $filename=shift;
        #use Tool;
        # This hash defines which Document Elements we can use
        my $SupportedTags={
                'Use' => \&OutToMakefile,
                'Use_StartTag' => \&Use_start,
                'External' => \&OutToMakefile,
                'External_StartTag' => \&External_StartTag,
                'none' => 'none',
                'export' => \&OutToMakefile,
                'export_StartTag' => \&export_start,
                'export_EndTag' => \&export_end,
                'lib_StartTag' => \&lib_start_export,
                'lib' => 'none'
        };
        use ActiveDoc::Switcher;
        $switchex=Switcher->new($SupportedTags, $filename);
        $switchex->{Strict_no_cr}='no';
        push @switchstack, $switchex;
        $switchex->parse(); # sort out supported tags
        pop @switchstack;
        $switchex=$switchstack[$#switchstack]; # Make sure we can Use multiply
}

sub initialterms() {
        my $name=shift;
        my @string=@_;

        $_=join "", @string;
        chomp;
        SWITCH: {
                  last SWITCH if /^#/;
                  if ( /^.*BlockClassPath.*/i ) {
                        s/^.*BlockClassPath *= *//;
                        _CutBlock($_);
                        last SWITCH;
                  }
                } # end SWITCH
}

# Tag routines - called by the Switcher when tag found


#-- Override a class type with the <ConfigurationClass type=xxx> tag
#   the type tag will pick up a pre-defined class type from project space.

sub Class_StartTag {
        my $name=shift;
        my $hashref;
        my @vars=@_;
        
        $hashref=$switch->SetupValueHash(\@vars);
        if ( defined $$hashref{'type'} ) {
                $ClassName=$$hashref{'type'};
        }
}
 
sub ClassPath_StartTag {
        my $name=shift;
        my @vars=@_;
        my $hashref;

        $hashref=$switch->SetupValueHash(\@vars);
        if ( defined $$hashref{'defaultpath'} ) {
        }
}

sub Bin_start {
        my $name=shift;
        my @vars=@_;
        my $hashref;
        my $fileclass;
        my @tools;
        my $tool;
        my $filename;
        my $objectname;
        
        $hashref=$switch->SetupValueHash(\@vars);
        $switch->checkparam($hashref, $name, 'file');
        if ( ! defined $$hashref{name} ) {
                ($$hashref{name}=$$hashref{file})=~s/\..*//;
        }
        # This stuff for later
        #$fileclass=$toolbox->getclass($file);
        #$toolbox->maketargets("exe",$fileclass, $$hashref{name}, $file );
        ($filename=$$hashref{file})=~s/\..*//;
        ($objectname=$$hashref{file})=~s/\..*/\.o/;
        ($objectname_d=$$hashref{file})=~s/\..*/_d\.o/;
        ($objectname_Insure=$$hashref{file})=~s/\..*/_Insure\.o/;
        print GNUmakefile "bin:$$hashref{name}\n";
        print GNUmakefile "bin_debug:$$hashref{name}_d\n";
        print GNUmakefile "bin_insure:$$hashref{name}_Insure\n";
        print GNUmakefile ".INTERMEDIATE::$$hashref{name}_d.exe\n";
        print GNUmakefile ".INTERMEDIATE::$$hashref{name}_Insure.exe\n";
        print GNUmakefile ".INTERMEDIATE::$$hashref{name}.exe\n";
        print GNUmakefile "$$hashref{name}_Insure:.psrc\n";
        print GNUmakefile "$$hashref{name}_d.exe:$objectname_d\n";
        print GNUmakefile "\t\$(CClinkCmdDebug)\n";
        print GNUmakefile "$$hashref{name}_Insure.exe:$objectname_Insure\n";
        print GNUmakefile "\t\$(CClinkCmdInsure)\n";
        print GNUmakefile "$$hashref{name}.exe:$objectname\n";
        print GNUmakefile "\t\$(CClinkCmd)\n";
        print GNUmakefile "$objectname:$$hashref{name}.dep\n";
        print GNUmakefile "$objectname_d:$$hashref{name}.dep\n";
        print GNUmakefile "$objectname_Insure:$$hashref{name}.dep\n";
        print GNUmakefile "$$hashref{name}.dep:$$hashref{file}\n";
        print GNUmakefile "-include $$hashref{name}.dep\n";
#       print GNUmakefile "$$hashref{name}:$$hashref{file}\n";
print GNUmakefile <<ENDTEXT;
$$hashref{name}_d.exe:\$(libslocal_d)
$$hashref{name}.exe:\$(libslocal)
$$hashref{name}_Insure.exe:\$(libslocal_I)
$$hashref{name}_d:$$hashref{name}_d.exe
        \@mv $$hashref{name}_d.exe \$(binarystore)/$$hashref{name}
$$hashref{name}_Insure:$$hashref{name}_Insure.exe
        \@mv $$hashref{name}_Insure.exe \$(binarystore)/$$hashref{name}_Insure
$$hashref{name}:$$hashref{name}_d.exe
        \@mv $$hashref{name}_d.exe \$(binarystore)/$$hashref{name}
$$hashref{name}_o:$$hashref{name}_o.exe
        \@mv $$hashref{name}.exe \$(binarystore)/$$hashref{name}
binfiles+=$filename
bintargets+=$$hashref{name} $$hashref{name}_d $$hashref{name}_Insure
ENDTEXT
}

sub External_StartTag {
        my $name=shift;
        my @vars=@_;
        my $hashref;
        
        $hashref=$switch->SetupValueHash(\@vars);
        if ( $Arch ) {
        $$hashref{'ref'}=~tr[A-Z][a-z];
        print GNUmakefile $$hashref{'ref'};
        if ( defined $$hashref{'version'} ) {
                print GNUmakefile "_V_".$$hashref{'version'};
        }
        print GNUmakefile "=true\n";
        }
        
}       

sub Group_start {
        my $name=shift;
        my @vars=@_;
        my $hashref;
        
        $hashref=$switch->SetupValueHash(\@vars);
        $switch->checkparam($hashref, $name, 'name');
        print GNUmakefile "GROUP_".$$hashref{'name'};
        if ( defined $$hashref{'version'} ) {
                print GNUmakefile "_V_".$$hashref{'version'};
        }
        print GNUmakefile "=true\n";
}       

sub External {
        my $name=shift;
        my @vars=@_;
        # Will simply collect string into a seperate buffer for processind
        # at the tag closure - used for specifying product defaults
        # --- Oh oh all of string already in external buffer @!
}

sub External_EndTag {
        my $name=shift;
        my @vars=@_;

        # process buffer and check consistency with product dtd
}

sub Use_start {
        my $name=shift;
        my @vars=@_;
        my $hashref;
        my $filename;
        use Utilities::SCRAMUtils;
        
        $hashref=$switch->SetupValueHash(\@vars);
        $switch->checkparam($hashref, $name, "name");
        $filename=SCRAMUtils::checkfile(
                "$ENV{INTsrc}/$$hashref{name}/BuildFile");
        if ( $filename ne "" ) {
          ParseBuildFile_Export( $filename );
        }
}

sub CheckBuildFile {
         my $classdir=shift;
         $ClassName="";
         $thisfile="$classdir/$buildfile";
 
         if ( -e $ENV{LOCALTOP}."/".$thisfile ) {
            $DefaultBuildfile="$ENV{LOCALTOP}/$thisfile";
            ParseBuildFile($ENV{LOCALTOP}, $classdir, $buildfile);
         }
         elsif ( -e $ENV{RELEASETOP}."/".$thisfile ) {
            $DefaultBuildfile="$ENV{RELEASETOP}/$thisfile";
            ParseBuildFile($ENV{RELEASETOP}, $classdir, $buildfile);
         }
         return $ClassName;
}

# List association groups between <AssociateGroup> tags
# seperated by newlines or spaces
sub AssociateGroup {
        my $name=shift;
        my @vars=@_;
        my $word;

        foreach $word ( @vars ){
                chomp $word;
                next if /^#/;
                push @groups, $word;
        }
}

# Split up the Class Block String into a useable array
sub _CutBlock {
    my $string= shift @_;
    @BlockClassA = split /\//, $string;
}

sub OutToMakefile {
        my $name=shift;
        my @vars=@_;

        print GNUmakefile @vars;
}
sub setBlockClassPath {
        my $name=shift;
        my @vars=@_;
        my $hashref;

        $hashref=$switch->SetupValueHash(\@vars);
        $switch->checkparam($hashref, $name, 'path');
        $BlockClassPath=$BlockClassPath.":".$$hashref{path};
        _CutBlock($$hashref{path});
}

sub export_start {
#Set up a toolfile object
#       $exporttool=Tool->new();
}

sub export_end {
#Write toolfile object to disk
        $exporttool->envtomake(\*GNUmakefile);
}

#
# Export Mode Lib Tag
#
sub lib_start_export {
        my $name=shift;
        my @vars=@_;
        my $hashref;

        $hashref=$switchex->SetupValueHash( \@vars );
        $switchex->checkparam($hashref, $name, 'name');
        if ( $Arch ) {
         if ( $switchex->context('export') ) {
                #If export mode then add this env to the export tool
                $exporttool->addenv('lib',$$hashref{name});
         }
        }
}

#
# Standard lib tag 
#
sub lib_start {
        my $name=shift;
        my @vars=@_;
        my $hashref;

        $hashref=$switch->SetupValueHash( \@vars );
        $switch->checkparam($hashref, $name, 'name');
        if ( $Arch ) {
           print GNUmakefile "lib+=$$hashref{name}\n";
        }
}
Revision:	1.23
Committed:	Thu Jan 20 18:26:05 2000 UTC (25 years, 3 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
CVS Tags:	ProtoEnd
Changes since 1.22:	+4 -11 lines
Log Message:	status work - Helsnki end
#	Content
1	package BuildFile;
2	require 5.001;
3	require Exporter;
4	@ISA = qw(Exporter);
5	@EXPORT = qw(CheckBuildFile ParseBuildFile @BlockClassA $DefaultBuildFile);
6
7
8	#Parse the BuildFile
9	sub ParseBuildFile {
10	my $base=shift;
11	my $path=shift;
12	my $filename=shift @_;
13	my $fullfilename="$base/$path/$filename";
14	#print "Processing $fullfilename\n";
15	# This hash defines which Document Elements we can use
16	my $SupportedTags={
17	'Use' => \&OutToMakefile,
18	'Use_StartTag' => \&Use_start,
19	'Group' => \&OutToMakefile,
20	'Group_StartTag' => \&Group_start,
21	'External' => \&OutToMakefile,
22	'External_StartTag' => \&External_StartTag,
23	'ConfigurationClass_StartTag' => \&Class_StartTag,
24	'ConfigurationClass' => \&OutToMakefile,
25	'AssociateGroup' => \&AssociateGroup,
26	'none' => \&OutToMakefile,
27	'Bin' => 'none',
28	'Bin_StartTag' => \&Bin_start,
29	'ClassPath' => \&OutToMakefile,
30	'ClassPath_StartTag' => \&setBlockClassPath,
31	'lib' => 'none',
32	'lib_StartTag' => \&lib_start,
33	'lib_EndTag' => 'none'
34	};
35	use ActiveDoc::Switcher;
36	$switch=Switcher->new($SupportedTags, $fullfilename);
37	$switch->{Strict_no_cr}='no';
38	#open a temporary gnumakefile to store output.
39	use Utilities::AddDir;
40	AddDir::adddir("$ENV{LOCALTOP}/$ENV{INTwork}/${path}");
41	open ( GNUmakefile, ">$ENV{LOCALTOP}/$ENV{INTwork}/${path}/BuildFile.mk") or die 'Unable to open /$ENV{INTwork}/${path}/BuildFile.mk $!\n';
42	if ( -e $ENV{LatestBuildFile} ) {
43	print GNUmakefile "include $ENV{LatestBuildFile}\n";
44	}
45	# print "writing to :\n".
46	# "$ENV{LOCALTOP}/$ENV{INTwork}/${path}/BuildFile.mk\n";
47	$ENV{LatestBuildFile}="$ENV{LOCALTOP}/$ENV{INTwork}/${path}/BuildFile.mk";
48	$switch->parse(); # sort out supported tags
49	close GNUmakefile;
50	}
51
52	sub ParseBuildFile_Export {
53	my $filename=shift;
54	#use Tool;
55	# This hash defines which Document Elements we can use
56	my $SupportedTags={
57	'Use' => \&OutToMakefile,
58	'Use_StartTag' => \&Use_start,
59	'External' => \&OutToMakefile,
60	'External_StartTag' => \&External_StartTag,
61	'none' => 'none',
62	'export' => \&OutToMakefile,
63	'export_StartTag' => \&export_start,
64	'export_EndTag' => \&export_end,
65	'lib_StartTag' => \&lib_start_export,
66	'lib' => 'none'
67	};
68	use ActiveDoc::Switcher;
69	$switchex=Switcher->new($SupportedTags, $filename);
70	$switchex->{Strict_no_cr}='no';
71	push @switchstack, $switchex;
72	$switchex->parse(); # sort out supported tags
73	pop @switchstack;
74	$switchex=$switchstack[$#switchstack]; # Make sure we can Use multiply
75	}
76
77	sub initialterms() {
78	my $name=shift;
79	my @string=@_;
80
81	$_=join "", @string;
82	chomp;
83	SWITCH: {
84	last SWITCH if /^#/;
85	if ( /^.BlockClassPath./i ) {
86	s/^.BlockClassPath = *//;
87	_CutBlock($_);
88	last SWITCH;
89	}
90	} # end SWITCH
91	}
92
93	# Tag routines - called by the Switcher when tag found
94
95
96
97	#-- Override a class type with the <ConfigurationClass type=xxx> tag
98	# the type tag will pick up a pre-defined class type from project space.
99
100	sub Class_StartTag {
101	my $name=shift;
102	my $hashref;
103	my @vars=@_;
104
105	$hashref=$switch->SetupValueHash(\@vars);
106	if ( defined $$hashref{'type'} ) {
107	$ClassName=$$hashref{'type'};
108	}
109	}
110
111	sub ClassPath_StartTag {
112	my $name=shift;
113	my @vars=@_;
114	my $hashref;
115
116	$hashref=$switch->SetupValueHash(\@vars);
117	if ( defined $$hashref{'defaultpath'} ) {
118	}
119	}
120
121	sub Bin_start {
122	my $name=shift;
123	my @vars=@_;
124	my $hashref;
125	my $fileclass;
126	my @tools;
127	my $tool;
128	my $filename;
129	my $objectname;
130
131	$hashref=$switch->SetupValueHash(\@vars);
132	$switch->checkparam($hashref, $name, 'file');
133	if ( ! defined $$hashref{name} ) {
134	($$hashref{name}=$$hashref{file})=~s/\..*//;
135	}
136	# This stuff for later
137	#$fileclass=$toolbox->getclass($file);
138	#$toolbox->maketargets("exe",$fileclass, $$hashref{name}, $file );
139	($filename=$$hashref{file})=~s/\..*//;
140	($objectname=$$hashref{file})=~s/\..*/\.o/;
141	($objectname_d=$$hashref{file})=~s/\..*/_d\.o/;
142	($objectname_Insure=$$hashref{file})=~s/\..*/_Insure\.o/;
143	print GNUmakefile "bin:$$hashref{name}\n";
144	print GNUmakefile "bin_debug:$$hashref{name}_d\n";
145	print GNUmakefile "bin_insure:$$hashref{name}_Insure\n";
146	print GNUmakefile ".INTERMEDIATE::$$hashref{name}_d.exe\n";
147	print GNUmakefile ".INTERMEDIATE::$$hashref{name}_Insure.exe\n";
148	print GNUmakefile ".INTERMEDIATE::$$hashref{name}.exe\n";
149	print GNUmakefile "$$hashref{name}_Insure:.psrc\n";
150	print GNUmakefile "$$hashref{name}_d.exe:$objectname_d\n";
151	print GNUmakefile "\t\$(CClinkCmdDebug)\n";
152	print GNUmakefile "$$hashref{name}_Insure.exe:$objectname_Insure\n";
153	print GNUmakefile "\t\$(CClinkCmdInsure)\n";
154	print GNUmakefile "$$hashref{name}.exe:$objectname\n";
155	print GNUmakefile "\t\$(CClinkCmd)\n";
156	print GNUmakefile "$objectname:$$hashref{name}.dep\n";
157	print GNUmakefile "$objectname_d:$$hashref{name}.dep\n";
158	print GNUmakefile "$objectname_Insure:$$hashref{name}.dep\n";
159	print GNUmakefile "$$hashref{name}.dep:$$hashref{file}\n";
160	print GNUmakefile "-include $$hashref{name}.dep\n";
161	# print GNUmakefile "$$hashref{name}:$$hashref{file}\n";
162	print GNUmakefile <<ENDTEXT;
163	$$hashref{name}_d.exe:\$(libslocal_d)
164	$$hashref{name}.exe:\$(libslocal)
165	$$hashref{name}_Insure.exe:\$(libslocal_I)
166	$$hashref{name}_d:$$hashref{name}_d.exe
167	\@mv $$hashref{name}_d.exe \$(binarystore)/$$hashref{name}
168	$$hashref{name}_Insure:$$hashref{name}_Insure.exe
169	\@mv $$hashref{name}_Insure.exe \$(binarystore)/$$hashref{name}_Insure
170	$$hashref{name}:$$hashref{name}_d.exe
171	\@mv $$hashref{name}_d.exe \$(binarystore)/$$hashref{name}
172	$$hashref{name}_o:$$hashref{name}_o.exe
173	\@mv $$hashref{name}.exe \$(binarystore)/$$hashref{name}
174	binfiles+=$filename
175	bintargets+=$$hashref{name} $$hashref{name}_d $$hashref{name}_Insure
176	ENDTEXT
177	}
178
179	sub External_StartTag {
180	my $name=shift;
181	my @vars=@_;
182	my $hashref;
183
184	$hashref=$switch->SetupValueHash(\@vars);
185	if ( $Arch ) {
186	$$hashref{'ref'}=~tr[A-Z][a-z];
187	print GNUmakefile $$hashref{'ref'};
188	if ( defined $$hashref{'version'} ) {
189	print GNUmakefile "_V_".$$hashref{'version'};
190	}
191	print GNUmakefile "=true\n";
192	}
193
194	}
195
196	sub Group_start {
197	my $name=shift;
198	my @vars=@_;
199	my $hashref;
200
201	$hashref=$switch->SetupValueHash(\@vars);
202	$switch->checkparam($hashref, $name, 'name');
203	print GNUmakefile "GROUP_".$$hashref{'name'};
204	if ( defined $$hashref{'version'} ) {
205	print GNUmakefile "_V_".$$hashref{'version'};
206	}
207	print GNUmakefile "=true\n";
208	}
209
210	sub External {
211	my $name=shift;
212	my @vars=@_;
213	# Will simply collect string into a seperate buffer for processind
214	# at the tag closure - used for specifying product defaults
215	# --- Oh oh all of string already in external buffer @!
216	}
217
218	sub External_EndTag {
219	my $name=shift;
220	my @vars=@_;
221
222	# process buffer and check consistency with product dtd
223	}
224
225	sub Use_start {
226	my $name=shift;
227	my @vars=@_;
228	my $hashref;
229	my $filename;
230	use Utilities::SCRAMUtils;
231
232	$hashref=$switch->SetupValueHash(\@vars);
233	$switch->checkparam($hashref, $name, "name");
234	$filename=SCRAMUtils::checkfile(
235	"$ENV{INTsrc}/$$hashref{name}/BuildFile");
236	if ( $filename ne "" ) {
237	ParseBuildFile_Export( $filename );
238	}
239	}
240
241	sub CheckBuildFile {
242	my $classdir=shift;
243	$ClassName="";
244	$thisfile="$classdir/$buildfile";
245
246	if ( -e $ENV{LOCALTOP}."/".$thisfile ) {
247	$DefaultBuildfile="$ENV{LOCALTOP}/$thisfile";
248	ParseBuildFile($ENV{LOCALTOP}, $classdir, $buildfile);
249	}
250	elsif ( -e $ENV{RELEASETOP}."/".$thisfile ) {
251	$DefaultBuildfile="$ENV{RELEASETOP}/$thisfile";
252	ParseBuildFile($ENV{RELEASETOP}, $classdir, $buildfile);
253	}
254	return $ClassName;
255	}
256
257	# List association groups between <AssociateGroup> tags
258	# seperated by newlines or spaces
259	sub AssociateGroup {
260	my $name=shift;
261	my @vars=@_;
262	my $word;
263
264	foreach $word ( @vars ){
265	chomp $word;
266	next if /^#/;
267	push @groups, $word;
268	}
269	}
270
271	# Split up the Class Block String into a useable array
272	sub _CutBlock {
273	my $string= shift @_;
274	@BlockClassA = split /\//, $string;
275	}
276
277	sub OutToMakefile {
278	my $name=shift;
279	my @vars=@_;
280
281	print GNUmakefile @vars;
282	}
283	sub setBlockClassPath {
284	my $name=shift;
285	my @vars=@_;
286	my $hashref;
287
288	$hashref=$switch->SetupValueHash(\@vars);
289	$switch->checkparam($hashref, $name, 'path');
290	$BlockClassPath=$BlockClassPath.":".$$hashref{path};
291	_CutBlock($$hashref{path});
292	}
293
294	sub export_start {
295	#Set up a toolfile object
296	# $exporttool=Tool->new();
297	}
298
299	sub export_end {
300	#Write toolfile object to disk
301	$exporttool->envtomake(\*GNUmakefile);
302	}
303
304	#
305	# Export Mode Lib Tag
306	#
307	sub lib_start_export {
308	my $name=shift;
309	my @vars=@_;
310	my $hashref;
311
312	$hashref=$switchex->SetupValueHash( \@vars );
313	$switchex->checkparam($hashref, $name, 'name');
314	if ( $Arch ) {
315	if ( $switchex->context('export') ) {
316	#If export mode then add this env to the export tool
317	$exporttool->addenv('lib',$$hashref{name});
318	}
319	}
320	}
321
322	#
323	# Standard lib tag
324	#
325	sub lib_start {
326	my $name=shift;
327	my @vars=@_;
328	my $hashref;
329
330	$hashref=$switch->SetupValueHash( \@vars );
331	$switch->checkparam($hashref, $name, 'name');
332	if ( $Arch ) {
333	print GNUmakefile "lib+=$$hashref{name}\n";
334	}
335	}