--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv1_os/e32toolp/bldmake/bldmake.pl Tue Feb 02 01:39:43 2010 +0200
@@ -0,0 +1,2326 @@
+# Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+# all variables called *Path* are set up to end with a backslash
+# all variables called *Path or *File are stored as absolute (file)paths within makmake
+# all variables called UpPath* are stored as relative paths within makmake
+#
+#
+
+use strict;
+
+use FindBin; # for FindBin::Bin
+use Getopt::Long;
+
+my $PerlLibPath; # fully qualified pathname of the directory containing our Perl modules
+
+BEGIN {
+# check user has a version of perl that will cope
+ require 5.005_03;
+# establish the path to the Perl libraries: currently the same directory as this script
+ $PerlLibPath = $FindBin::Bin; # X:/epoc32/tools
+ $PerlLibPath =~ s/\//\\/g; # X:\epoc32\tools
+ $PerlLibPath .= "\\";
+}
+sub ExportDirs ($);
+
+use lib $PerlLibPath;
+use E32env;
+use E32Plat;
+use Modload;
+use Output;
+use Pathutl;
+use E32Variant;
+use RVCT_plat2set;
+use BPABIutl;
+use wrappermakefile;
+use CheckSource;
+use File::Path; # for rmtree
+use featurevariantparser;
+
+my $BldInfName = 'BLD.INF';
+my %Options;
+my %KeepGoing;
+my @DefaultPlats=('WINSCW', 'GCCXML', 'EDG', 'X86GCC');
+my @BaseUserDefaultPlats=('ARM4', 'ARM4T', 'WINSCW', 'GCCXML', 'EDG', 'X86GCC');
+my @OptionalPlats=('VS6', 'VS2003');
+my @PlatsReq;
+
+my %CheckSourceEXPORTSMetaData;
+my %CheckSourceEXPORTSIncludes;
+my %CheckSourceMMPFILESMetaData;
+my %CheckSourceEXTENSIONSMetaData;
+my %CheckSourceBldInfIncludes;
+
+for ('ARMV4', 'ARMV5')
+{
+ push @BaseUserDefaultPlats, $_ if RVCT_plat2set::compiler_exists($_);
+}
+
+# Add ARMV5_ABIV1 platform if ENABLE_ABIV2_MODE is set in variant.cfg
+my $variantABIV2Keyword = &Variant_GetMacro();
+# Add ARMV5_ABIV1 platform only after determining the presence of RVCT compiler.
+if ($variantABIV2Keyword && RVCT_plat2set::compiler_exists('ARMV5_ABIV1') ) {
+ push @OptionalPlats, 'ARMV5_ABIV1';
+}
+
+# bldmake -k shouldn't die if Extension Makefile is missing
+our $IgnoreMissingExtensionMakefile = 0;
+
+# Add the BPABI Platforms to be added
+my @BPABIPlats = &BPABIutl_Plat_List;
+foreach my $BPABIPlat (@BPABIPlats)
+{
+ # BPABI platform related with ARMV5(eg.ARMV5_ABIV2) is added to the platform list after
+ # determining the presence of RVCT compiler
+ if(($BPABIPlat =~/^ARMV5/i))
+ {
+ if(!($BPABIPlat =~/^ARMV5$/i) && RVCT_plat2set::compiler_exists('ARMV5'))
+ {
+ push @OptionalPlats, $BPABIPlat;
+ }
+ }
+ # All other BPABI platforms(eg. gcce) are added to the platform list.
+ else
+ {
+ push @OptionalPlats, $BPABIPlat;
+ }
+}
+
+if ( RVCT_plat2set::compiler_exists('ARMV5') ) {
+ #determine the presence of ARVCT compiler
+ push @DefaultPlats, 'ARMV5';
+}
+
+# Need to add WINS and X86 if MSDEV compiler is present
+# Use MSDevDir to determine the presence of the compiler
+push @BaseUserDefaultPlats, 'WINS', 'X86' if (exists($ENV{'MSDevDir'}));
+
+my @BaseDefaultPlats = @BaseUserDefaultPlats;
+push @BaseDefaultPlats, 'X86SMP' if (grep /^X86$/, @BaseUserDefaultPlats);
+push @BaseDefaultPlats, 'ARM4SMP' if (grep /^ARM4$/, @BaseUserDefaultPlats);
+push @BaseDefaultPlats, 'ARMV4SMP' if (grep /^ARMV4$/, @BaseUserDefaultPlats);
+push @BaseDefaultPlats, 'ARMV5SMP' if (grep /^ARMV5$/, @BaseUserDefaultPlats);
+push @BaseDefaultPlats, 'X86GMP' if (grep /^X86GCC$/, @BaseUserDefaultPlats);
+
+my $variantMacroHRHFile = Variant_GetMacroHRHFile();
+sub ExportDirs ($);
+
+# THE MAIN PROGRAM SECTION
+##########################
+
+# Load default feature variant info - for the hrh file
+my %DefaultFeatureVariant = featurevariantparser->GetVariant('DEFAULT') if (featurevariantparser->DefaultExists());
+my @FeatureVariants = featurevariantparser->GetBuildableFeatureVariants();
+
+{
+ Load_SetModulePath($PerlLibPath);
+ Plat_Init($PerlLibPath);
+
+ {
+ my @PlatList = &Plat_List();
+
+ if (RVCT_plat2set::compiler_exists('ARMV6')){
+ foreach my $ARMV6Target ("ARMV6", "ARMV6_ABIV1", "ARMV6_ABIV2"){
+ if (grep /^$ARMV6Target$/, @PlatList) {
+ push @BaseUserDefaultPlats, "$ARMV6Target" if (!grep /^$ARMV6Target$/, @BaseUserDefaultPlats);
+ push @BaseDefaultPlats, "$ARMV6Target" if (!grep /^$ARMV6Target$/, @BaseDefaultPlats);
+ }
+ }
+ }
+
+ if (RVCT_plat2set::compiler_exists('ARMV7')){
+ my $rvct_ver = RVCT_plat2set::get_version_string('ARMV7');
+ if ((defined $rvct_ver) and ($rvct_ver ge "3.1.674")) {
+ if (grep /^ARMV7$/, @PlatList ) {
+ push @DefaultPlats, 'ARMV7' if (!grep /^ARMV7$/, @DefaultPlats);
+ push @BaseUserDefaultPlats, "ARMV7" if (!grep /^ARMV7$/, @BaseUserDefaultPlats);
+ push @BaseDefaultPlats, "ARMV7" if (!grep /^ARMV7$/, @BaseDefaultPlats);
+ }
+ }
+ }
+ }
+
+# process the commmand-line
+ unless (GetOptions(\%Options, 'v', "k|keepgoing", "notest", "file|f=s")) {
+ exit 1;
+ }
+ unless (@ARGV>=1) {
+ &Usage();
+ }
+ my $Command=uc shift @ARGV;
+ unless ($Command=~/^(BLDFILES|CLEAN|INF|PLAT)$/o) {
+ &Usage();
+ }
+ my $CLPlat=uc shift @ARGV;
+
+ unless ($CLPlat) {
+ $CLPlat='ALL';
+ }
+
+ if ($Command eq 'INF') {
+ &ShowBldInfSyntax();
+ exit;
+ }
+
+ if ($Command eq 'PLAT') {
+ my @PlatList = ($CLPlat);
+ my $PlatName;
+ # Variable introduced to check if the bldmake plat command is called, To be
+ # passed as an argument in Plat_GetL function call.
+ my $platcommand=1;
+ if ($CLPlat eq "ALL") {
+ @PlatList = &Plat_List();
+ print(
+ "Supported Platforms:\n",
+ " @PlatList\n\n"
+ );
+ }
+ print(
+ "Macros defined for BLD.INF preprocessing of MMPFILE sections:\n"
+ );
+ foreach $PlatName (@PlatList) {
+ my %Plat;
+ eval { &Plat_GetL($PlatName, \%Plat,{},$platcommand); };
+ die $@ if $@;
+ print(
+ "\nPlatform $PlatName:\n",
+ " @{$Plat{MmpMacros}}\n"
+ );
+ }
+ exit;
+ }
+ if ($Options{file}) {
+ $BldInfName = $Options{file};
+ }
+
+# check that the BLD.INF file exists
+# maybe BLDMAKE should allow a path to be specified leading to the BLD.INF file
+ my $BldInfPath=&Path_WorkPath;
+ unless (-e "${BldInfPath}$BldInfName") {
+ &FatalError("Can't find \"${BldInfPath}$BldInfName\"");
+ }
+
+ if (!-d $E32env::Data{EPOCPath}){
+ &FatalError("Directory \"$E32env::Data{EPOCPath}\" does not exist");
+ }
+
+# decide the output directory
+ my $OutDir=&Path_Chop($E32env::Data{BldPath}).$BldInfPath;
+
+# Work out the path for the IBY files
+ my $RomDir=&Path_Chop($E32env::Data{RomPath}).$BldInfPath;
+
+# Work out the name for the BLD.INF module
+ my @Dirs=&Path_Dirs($BldInfPath);
+ my $Module = pop @Dirs;
+ if (lc($Module) eq 'group') {
+ $Module = pop @Dirs;
+ }
+
+ if ($Command eq 'CLEAN') {
+ unlink "${BldInfPath}ABLD.BAT";
+ $OutDir=~m-(.*)\\-o;
+ if (-d $1) { # remove backslash for test because some old versions of perl can't cope
+ opendir DIR, $1;
+ my @Files=grep s/^([^\.].*)$/$OutDir$1/, readdir DIR;
+ closedir DIR;
+ unlink @Files;
+ }
+ rmtree <$OutDir\\wrappermakefiles>;
+# modified start: makefile improvement
+ rmtree <$OutDir\\FeatureVariantInfo>;
+# modified end: makefile improvement
+ exit;
+ }
+
+# parse BLD.INF - to get the platforms and the export files
+ eval { &Load_ModuleL('PREPFILE'); };
+ &FatalError($@) if $@;
+
+ my @RealPlats=();
+ my @Exports=();
+ my @TestExports=();
+ if ($Options{v}) {
+ print "Reading \"${BldInfPath}$BldInfName\" for platforms and exports\n";
+ }
+ &ParseBldInf(\@RealPlats, \@Exports, \@TestExports, $BldInfPath,
+ $E32env::Data{EPOCIncPath}, $E32env::Data{EPOCPath}, $E32env::Data{EPOCDataPath});
+
+# Add Customizations
+ my @additions;
+ foreach my $plat (@RealPlats) {
+ my @customizations = Plat_Customizations($plat);
+ foreach my $custom (@customizations) {
+ push @additions, $custom
+ unless grep /$custom/, @additions;
+ }
+ }
+ unless ($CLPlat eq 'ALL') {
+ push @RealPlats, @additions;
+ }
+
+ # Force GCCXML support for anything that compiles as ARMV5
+ if ( (grep /^ARMV5$/, @RealPlats) and not (grep /^GCCXML$/,@RealPlats) )
+ {
+ push @RealPlats, 'GCCXML';
+ }
+
+ # Force EDG support for anything that compiles as ARMV5
+ if ( (grep /^ARMV5$/, @RealPlats) and not (grep /^EDG$/,@RealPlats) )
+ {
+ push @RealPlats, 'EDG';
+ }
+
+if (0) {
+# Add ARMV5 to the platforms if ARM4 is defined
+ if (grep /^ARM4$/, @RealPlats) {
+ unless ( (grep /^ARMV4$/, @RealPlats) or (grep /^ARMV5$/, @RealPlats) ){
+ push @RealPlats, 'ARMV5';
+ push @RealPlats, 'ARMV4';
+ }
+ }
+}
+
+# get any IDE platforms required into a new platforms list, and
+# Create a hash to contain the 'real' names of the platforms, i.e. WINS rather than VC6
+ my @Plats=@RealPlats;
+ my %Real;
+ foreach (@RealPlats) { # change to get VC6 batch files
+ $Real{$_}=$_;
+ my $AssocIDE;
+ my @AssocIDEs;
+
+# Get the IDEs associated with a real platform. A real plat like,
+# WINSCW may have multiple associated IDEs like VC6 .NET2003 or CW IDE.
+ &Plat_AssocIDE($_, \@AssocIDEs);
+ next unless @AssocIDEs;
+
+ push @Plats, @AssocIDEs;
+ foreach $AssocIDE (@AssocIDEs)
+ {
+ $Real{$AssocIDE}=$Real{$_};
+ }
+
+ }
+ if ($Options{v}) {
+ print "Platforms: \"@Plats\"\n";
+ }
+
+# check that the platform specified on the command-line is acceptable
+# and sort out a list of platforms to process
+ my @DoRealPlats=@RealPlats;
+ my @DoPlats=@Plats;
+
+ unless (@Plats) {
+# include the optional platform list if no platform is specified
+ my $OptionalPlat;
+ foreach $OptionalPlat (@OptionalPlats) {
+ unless (grep /^$OptionalPlat$/i, @DoPlats) {
+ push @DoPlats, $OptionalPlat;
+ }
+ }
+ }
+
+ unless ($CLPlat eq 'ALL') {
+ unless (grep /^$CLPlat$/, @Plats) {
+ &FatalError("Platform $CLPlat not supported by \"${BldInfPath}$BldInfName\"\n");
+ }
+ @DoPlats=($CLPlat);
+ @DoRealPlats=$Real{$CLPlat};
+ }
+
+# sort out the export directories we might need to make
+ my @ExportDirs=ExportDirs(\@Exports);
+ my @TestExportDirs=ExportDirs(\@TestExports);
+
+# parse the BLD.INF file again for each platform supported by the project
+# storing the information in a big data structure
+ my %AllPlatData;
+ my %AllPlatTestData;
+ my $Plat;
+
+ if ($Options{v} and $CLPlat ne 'ALL'){
+ print "Reading \"${BldInfPath}$BldInfName\" for $CLPlat \n";
+ }
+
+ foreach $Plat (@RealPlats) {
+ if ($Options{v}) {
+ if ($CLPlat eq 'ALL') {
+ print "Reading \"${BldInfPath}$BldInfName\" for $Plat\n";
+ }
+ }
+ my (@PlatData, @PlatTestData);
+ if ($CLPlat eq 'ALL') {
+ &ParseBldInfPlat(\@PlatData, \@PlatTestData, $Plat, $BldInfPath, ($DefaultFeatureVariant{VALID} && &Plat_SupportsFeatureVariants($Plat) ? \%DefaultFeatureVariant : undef));
+ }
+ else {
+ &ParseBldInfPlat(\@PlatData, \@PlatTestData, $CLPlat, $BldInfPath, ($DefaultFeatureVariant{VALID} && &Plat_SupportsFeatureVariants($CLPlat) ? \%DefaultFeatureVariant : undef));
+ }
+ $AllPlatData{$Plat}=\@PlatData;
+ $AllPlatTestData{$Plat}=\@PlatTestData;
+ }
+ undef $Plat;
+
+ undef $CLPlat;
+ if ($Command eq 'BLDFILES') {
+
+# create the perl file, PLATFORM.PM, listing the platforms
+ if ($Options{v}) {
+ print "Creating \"${OutDir}PLATFORM.PM\"\n";
+ }
+ &CreatePlatformPm($OutDir, \@Plats, \@RealPlats, \%Real, \%AllPlatData, \%AllPlatTestData);
+
+# create the .BAT files required to call ABLD.PL
+ if ($Options{v}) {
+ print "Creating \"${BldInfPath}ABLD.BAT\"\n";
+ }
+ &CreatePerlBat($BldInfPath);
+
+# create the makefile for exporting files
+ if ($Options{v}) {
+ print "Creating \"${OutDir}EXPORT.MAKE\"\n";
+ }
+ &CreateExportMak("${OutDir}EXPORT.MAKE", \@Exports, \@ExportDirs);
+
+# create the makefile for exporting test files
+ if ($Options{v}) {
+ print "Creating \"${OutDir}EXPORTTEST.MAKE\"\n";
+ }
+ &CreateExportMak("${OutDir}EXPORTTEST.MAKE", \@TestExports, \@TestExportDirs);
+
+# modified start: makefile improvement
+ #create the feature variant infor file
+ foreach my $copyofPlat (@DoPlats)
+ {
+ my $realplat = $Real{$copyofPlat};
+ if(&Plat_SupportsFeatureVariants($copyofPlat))
+ {
+ my $variant_info = &Path_Chop($E32env::Data{BldPath}).$BldInfPath."\\FeatureVariantInfo\\".$realplat."\\";
+ eval { &Path_MakePathL($variant_info); };
+ die $@ if $@;
+ if ($Options{v}) {
+ print "Creating: \"$variant_info\"\n";
+ }
+ foreach my $featureVariant (@FeatureVariants)
+ {
+ my $variant_file = $variant_info."$realplat.$featureVariant.info";
+# modified by SV start: makefile improvement
+ my $refdata = $AllPlatData{$realplat};
+ my $testrefdata = $AllPlatTestData{$realplat};
+ if ( @$refdata ) {
+ foreach my $RefPro (@$refdata)
+ {
+ $variant_file = $variant_info."$realplat.$featureVariant.$$RefPro{Base}.info";
+ my $ref_basedir = $variant_file;
+ $ref_basedir=~s/(.*[\\\/]).*/$1/;
+ if ( ! -d $ref_basedir ){
+ eval { &Path_MakePathL($ref_basedir); };
+ die $@ if $@;
+ }
+ open VARIANTINFOR,">$variant_file" or die "ERROR: Can't open or create file \"$variant_file\"\n";
+ print VARIANTINFOR "VARIANT_PLAT_NAME_$$RefPro{Base}:=default \n";
+ close VARIANTINFOR or die "ERROR: Can't close file \"$variant_file\"\n";
+ }
+ }
+ else {
+ open VARIANTINFOR,">$variant_file" or die "ERROR: Can't open or create file \"$variant_file\"\n";
+ print VARIANTINFOR "VARIANT_PLAT_NAME:=$featureVariant \n";
+ close VARIANTINFOR or die "ERROR: Can't close file \"$variant_file\"\n";
+ print "file \"$variant_file\"\n"
+ }
+ if ($testrefdata){
+ foreach my $RefPro (@$testrefdata)
+ {
+ $variant_file = $variant_info."$realplat.$featureVariant.$$RefPro{Base}.info";
+ my $ref_basedir = $variant_file;
+ $ref_basedir=~s/(.*[\\\/]).*/$1/;
+ if ( ! -d $ref_basedir ){
+ eval { &Path_MakePathL($ref_basedir); };
+ die $@ if $@;
+ }
+ open VARIANTINFOR,">$variant_file" or die "ERROR: Can't open or create file \"$variant_file\"\n";
+ print VARIANTINFOR "VARIANT_PLAT_NAME_$$RefPro{Base}:=default \n";
+ close VARIANTINFOR or die "ERROR: Can't close file \"$variant_file\"\n";
+ }
+
+ }
+# modified by SV end: makefile improvement
+ # Close and cleanup
+ if ($Options{v}) {
+ print "Variant info file has been successfully created\n";
+ }
+ }
+ }
+ }
+# modified end: makefile improvement
+# create the platform meta-makefiles
+ foreach my $copyofPlat (@DoPlats) { # Do not use $_ here !!
+ if ($Options{v}) {
+ print "Creating \"$OutDir$copyofPlat.MAKE\"\n";
+ }
+ my $realplat = $Real{$copyofPlat};
+ &CreatePlatMak($OutDir, $E32env::Data{BldPath}, $AllPlatData{$realplat}, $copyofPlat, $realplat, $RomDir, $Module, $BldInfPath, \@Exports, '');
+
+ if (&Plat_SupportsFeatureVariants($copyofPlat))
+ {
+ foreach my $featureVariant (@FeatureVariants)
+ {
+ print "Creating \"$OutDir$copyofPlat.$featureVariant.MAKE\"\n" if ($Options{v});
+ &CreatePlatMak($OutDir, $E32env::Data{BldPath}, $AllPlatData{$realplat}, $copyofPlat, $realplat, $RomDir, $Module, $BldInfPath, \@Exports, '', ".$featureVariant");
+ }
+ }
+ }
+ foreach (@DoPlats) {
+ if ($Options{v}) {
+ print "Creating \"$OutDir${_}TEST.MAKE\"\n";
+ }
+ &CreatePlatMak($OutDir, $E32env::Data{BldPath}, $AllPlatTestData{$Real{$_}}, $_, $Real{$_}, $RomDir, $Module, $BldInfPath, \@TestExports, 'TEST');
+
+ if (&Plat_SupportsFeatureVariants($_))
+ {
+ foreach my $featureVariant (@FeatureVariants)
+ {
+ print "Creating \"$OutDir${_}.".$featureVariant."TEST.MAKE\"\n" if ($Options{v});
+ &CreatePlatMak($OutDir, $E32env::Data{BldPath}, $AllPlatTestData{$Real{$_}}, $_, $Real{$_}, $RomDir, $Module, $BldInfPath, \@TestExports, 'TEST', ".$featureVariant");
+ }
+ }
+ }
+
+# create the platform test batch files
+ foreach (@DoRealPlats) {
+ if ($Options{v}) {
+ print "Creating test batch files in \"$OutDir\" for $_\n";
+ }
+ &CreatePlatBatches($OutDir, $AllPlatTestData{$_}, $_);
+ }
+
+# modified by SV start: makefile improvement
+# create all sub directories
+ foreach my $refplat (@DoRealPlats) {
+ my $tmp = $AllPlatData{$refplat};
+ foreach my $dref (@$tmp){
+ my $builddir = $OutDir . $$dref{Base} ."\\" . $refplat . "\\";
+ if (!-d $builddir){
+ if ($Options{v}) {
+ print "Creating directory \"$builddir\" \n";
+ }
+ eval { &Path_MakePathL($builddir); };
+ &FatalError($@) if $@;
+ }
+ }
+ }
+# modified by SV end: makefile improvement
+
+# report any near-fatal errors
+ if (scalar keys %KeepGoing) {
+ print STDERR
+ "\n${BldInfPath}$BldInfName WARNING(S):\n",
+ sort keys %KeepGoing
+ ;
+ }
+
+ exit;
+ }
+}
+
+
+################ END OF MAIN PROGRAM SECTION #################
+#------------------------------------------------------------#
+##############################################################
+
+
+# SUBROUTINE SECTION
+####################
+
+sub Usage () {
+
+ eval { &Load_ModuleL('E32TPVER'); };
+ &FatalError($@) if $@;
+
+ print
+ "\n",
+ "BLDMAKE - Project building Utility (Build ",&E32tpver,")\n",
+ "\n",
+ "BLDMAKE {options} [<command>] [<platform>]\n",
+ "\n",
+ "<command>: (case insensitive)\n",
+ " BLDFILES - create build batch files\n",
+ " CLEAN - remove all files bldmake creates\n",
+ " INF - display basic BLD.INF syntax\n",
+ " PLAT - display platform macros\n",
+ "\n",
+ "<platform>: (case insensitive)\n",
+ " if not specified, defaults to \"ALL\"\n",
+ "\n",
+ "Options: (case insensitive)\n",
+ " -v -> verbose mode\n",
+ " -k -> keep going even if files are missing\n"
+ ;
+ exit 1;
+}
+
+sub ShowBldInfSyntax () {
+
+ print <<ENDHERE1;
+
+BLD.INF - Syntax
+
+/* Use C++ comments if required */
+// (Curly braces denote optional arguments)
+
+PRJ_PLATFORMS
+{DEFAULT} {-<platform> ...} {<list of platforms>}
+// list platforms your project supports here if not default
+ENDHERE1
+
+ print "// default = ".join(" ",@DefaultPlats)."\n";
+
+ print <<ENDHERE;
+
+PRJ_EXPORTS
+[<source path>\<source file>] {<destination>}
+// list each file exported from source on a separate line
+// {<destination>} defaults to \\EPOC32\\Include\\<source file>
+
+PRJ_TESTEXPORTS
+[<source path>\<source file>] {<destination>}
+// list each file exported from source on a separate line
+// {<destination>} defaults to BLD.INF dir
+
+PRJ_MMPFILES
+[<mmp path>\<mmp file>] {<qualifiers>}
+{MAKEFILE|NMAKEFILE} [<path>\<makefile>] {build_as_arm}
+// <qualifiers> are tidy, ignore, build_as_arm
+
+#if defined(<platform>)
+// .MMP statements restricted to <platform>
+#endif
+
+PRJ_TESTMMPFILES
+[<mmp path>\<mmp file>] {<qualifiers>}
+{MAKEFILE|NMAKEFILE} [<path>\<makefile>] {<qualifiers>}
+// <qualifiers> are {tidy} {ignore} {manual} {support} {build_as_arm}
+
+#if defined(<platform>)
+// .MMP statements restricted to <platform>
+#endif
+
+ENDHERE
+
+}
+
+sub WarnOrDie ($$) {
+ my ($dieref, $message) = @_;
+ if ($Options{k}) {
+ $KeepGoing{$message} = 1;
+ } else {
+ push @{$dieref}, $message;
+ }
+}
+
+sub ExtensionMakefileMissing($)
+{
+ $IgnoreMissingExtensionMakefile = @_;
+}
+
+sub ParseBldInf ($$$$$) {
+ my ($PlatsRef, $ExportsRef, $TestExportsRef, $BldInfPath, $EPOCIncPath, $EPOCPath, $EPOCDataPath)=@_;
+
+ my @Prj2D;
+ eval { &Prepfile_ProcessL(\@Prj2D, "${BldInfPath}$BldInfName",$variantMacroHRHFile); };
+ &FatalError($@) if $@;
+
+ my @SupportedPlats=&Plat_List();
+
+ my @Plats;
+ my %RemovePlats;
+
+ my $DefaultPlatsUsed=0;
+ my %PlatformCheck;
+
+ my %ExportCheck;
+ my $Section=0;
+ our @PrjFileDie;
+ my $Line;
+ my $CurFile="${BldInfPath}$BldInfName";
+ LINE: foreach $Line (@Prj2D) {
+ my $LineNum=shift @$Line;
+ $_=shift @$Line;
+ if ($LineNum eq '#') {
+ $CurFile=$_;
+ next LINE;
+ }
+
+ $CurFile = &Path_Norm ($CurFile);
+
+ if (/^PRJ_(\w*)$/io) {
+ $Section=uc $1;
+ if ($Section=~/^(PLATFORMS|EXPORTS|TESTEXPORTS|MMPFILES|TESTMMPFILES|EXTENSIONS|TESTEXTENSIONS)$/o) {
+ if (@$Line) {
+ push @PrjFileDie, "$CurFile($LineNum) : Can't specify anything on the same line as a section header\n";
+ }
+ next LINE;
+ }
+ push @PrjFileDie, "$CurFile($LineNum) : Unknown section header - $_\n";
+ $Section=0;
+ next LINE;
+ }
+ if ($Section eq 'PLATFORMS') {
+# platforms are gathered up into a big list that contains no duplicates. "DEFAULT" is
+# expanded to the list of default platforms. Platforms specified with a "-" prefix
+# are scheduled for removal from the list. After processing platforms specified
+# with the "-" prefix are removed from the list.
+
+ unshift @$Line, $_;
+ my $Candidate;
+ CANDLOOP: foreach $Candidate (@$Line) {
+ $Candidate=uc $Candidate;
+# ignore old WINC target
+ if ($Candidate eq 'WINC') {
+ next CANDLOOP;
+ }
+# expand DEFAULT
+ if ($Candidate eq 'DEFAULT') {
+ $DefaultPlatsUsed=1;
+ my $Default;
+ foreach $Default (@DefaultPlats) {
+ unless ($PlatformCheck{$Default}) {
+ push @Plats, $Default;
+ $PlatformCheck{$Default}="$CurFile: $LineNum";
+ }
+ }
+ next CANDLOOP;
+ }
+# expand BASEDEFAULT
+ if ($Candidate eq 'BASEDEFAULT') {
+ $DefaultPlatsUsed=1;
+ my $Default;
+ foreach $Default (@BaseDefaultPlats) {
+ unless ($PlatformCheck{$Default}) {
+ push @Plats, $Default;
+ $PlatformCheck{$Default}="$CurFile: $LineNum";
+ }
+ }
+ next CANDLOOP;
+ }
+# expand BASEUSERDEFAULT
+ if ($Candidate eq 'BASEUSERDEFAULT') {
+ $DefaultPlatsUsed=1;
+ my $Default;
+ foreach $Default (@BaseUserDefaultPlats) {
+ unless ($PlatformCheck{$Default}) {
+ push @Plats, $Default;
+ $PlatformCheck{$Default}="$CurFile: $LineNum";
+ }
+ }
+ next CANDLOOP;
+ }
+# check for removals
+ if ($Candidate=~/^-(.*)$/o) {
+ $Candidate=$1;
+# check default is specified
+ unless ($DefaultPlatsUsed) {
+ push @PrjFileDie, "$CurFile($LineNum) : \"DEFAULT\" must be specified before platform to be removed\n";
+ next CANDLOOP;
+ }
+ $RemovePlats{$Candidate}=1;
+ next CANDLOOP;
+ }
+# If tools platform is specified in bld.inf file then component is built for cwtools as well
+ if ($Candidate =~ /^tools/i)
+ {
+ push @Plats, 'CWTOOLS';
+ }
+# check platform is supported
+ unless (grep /^$Candidate$/, @SupportedPlats) {
+ WarnOrDie(\@PrjFileDie, "$CurFile($LineNum) : Unsupported platform $Candidate specified\n");
+ next CANDLOOP;
+ }
+# check platform is not an IDE
+ if ($Candidate=~/^VC/o) {
+ push @PrjFileDie, "$CurFile($LineNum) : No need to specify platform $Candidate here\n";
+ next CANDLOOP;
+ }
+# add the platform
+ unless ($PlatformCheck{$Candidate}) {
+ push @Plats, $Candidate;
+ my $SubPlat = sprintf("%sEDG", $Candidate);
+ push @Plats, $SubPlat
+ if (grep /^$SubPlat$/, @SupportedPlats);
+ $PlatformCheck{$Candidate}="$CurFile: $LineNum";
+ }
+ }
+ next LINE;
+ }
+
+ # Skip PRJ_TESTEXPORT section if -notest flag
+ next LINE if ($Options{notest} && ($Section=~/^(TESTEXPORTS)$/o));
+
+ if ($Section=~/^(EXPORTS|TESTEXPORTS)$/o) {
+
+# make path absolute - assume relative to group directory
+ my $Type = 'file';
+ if (/^\:(\w+)/) {
+ # Export an archive
+ $Type = lc $1;
+ unless ($Type eq 'zip') {
+ push @PrjFileDie, "$CurFile($LineNum) : Unknown archive type - $Type\n";
+ next LINE;
+ }
+ $_ = shift @$Line;
+ }
+
+ my $loggedSourceExport = $_;
+ $_ = &Path_Norm ($_);
+
+ my $Source=&Path_MakeAbs($CurFile, $_);
+ my $Releasable='';
+ my $emReleasable='';
+ my $unzip_option ='';
+ if (@$Line) {
+# get the destination file if it's specified
+ $Releasable=shift @$Line;
+ CheckSource_MetaData(%CheckSourceEXPORTSMetaData, $CurFile, "PRJ_".$Section, $Releasable, $LineNum);
+ $Releasable = &Path_Norm ($Releasable);
+ $emReleasable=ucfirst $Releasable;
+ if ($emReleasable=~/^([A-Z]):(\\.*)$/) {
+ $emReleasable=~s/://;
+ $Releasable=$EPOCDataPath.$emReleasable;
+ }
+ }
+
+ my $sourceExportTypeSuffix = "";
+ $sourceExportTypeSuffix .= " (NO DESTINATION)" if (!$Releasable && $Section =~ /^EXPORTS$/);
+ CheckSource_MetaData(%CheckSourceEXPORTSMetaData, $CurFile, "PRJ_".$Section.$sourceExportTypeSuffix, $loggedSourceExport, $LineNum, $CheckSource_PhysicalCheck);
+
+ if (@$Line) {
+ $unzip_option = shift @$Line;
+ unless ($unzip_option=~ /overwrite/i) {
+ push @PrjFileDie, "$CurFile($LineNum) : Too many arguments in exports section line\n";
+ next LINE;
+ }
+ }
+ unless ($Type eq 'zip' or &Path_Split('File', $Releasable)) {
+# use the source filename if no filename is specified in the destination
+# no filename for archives
+ $Releasable.=&Path_Split('File', $Source);
+ }
+ my $defpath;
+ if ($Type eq 'zip') {
+# archives relative to EPOCROOT
+ $defpath = $ENV{EPOCROOT};
+ }
+ elsif (($Section =~ /EXPORTS$/) && ($Releasable =~ s/^\|[\/|\\]?//)) {
+# '|' prefix forces "relative to bld.inf file" in PRJ_[TEST]EXPORTS destinations
+ $defpath = $CurFile;
+ }
+ elsif ($Section eq 'EXPORTS') {
+# assume the destination is relative to $EPOCIncPath
+ $defpath = $EPOCIncPath;
+ }
+ else {
+ $defpath = $CurFile;
+ }
+ $Releasable=&Path_MakeEAbs($EPOCPath, $defpath, $Releasable);
+
+# sanity checks!
+ if ($Type eq 'file' && $ExportCheck{uc $Releasable}) {
+ push @PrjFileDie, "$CurFile($LineNum) : Duplicate export $Releasable (from line $ExportCheck{uc $Releasable})\n";
+ next LINE;
+ }
+ $ExportCheck{uc $Releasable}="$CurFile: $LineNum";
+ if (! -e $Source) {
+ WarnOrDie(\@PrjFileDie, "$CurFile($LineNum) : Exported source file $Source not found\n");
+ }
+ elsif ($Type ne 'zip' && -d $Releasable) {
+ push @PrjFileDie, "$CurFile($LineNum) : Export target $Releasable must be a file.\n";
+ }
+ else {
+ if ($Section eq 'EXPORTS') {
+ push @$ExportsRef, {
+ 'Source'=>$Source,
+ 'Releasable'=>$Releasable,
+ 'emReleasable'=>$emReleasable,
+ 'Type'=>$Type,
+ 'UnzipOption'=>$unzip_option
+ };
+ }
+ else {
+ push @$TestExportsRef, {
+ 'Source'=>$Source,
+ 'Releasable'=>$Releasable,
+ 'emReleasable'=>$emReleasable,
+ 'Type'=>$Type,
+ 'UnzipOption'=>$unzip_option
+ };
+ }
+ }
+ next LINE;
+ }
+ }
+ if (@PrjFileDie) {
+ print STDERR
+ "\n${BldInfPath}$BldInfName FATAL ERROR(S):\n",
+ @PrjFileDie
+ ;
+ exit 1;
+ }
+
+# set the list of platforms to the default if there aren't any platforms specified,
+# else add platforms to the global list unless they're scheduled for removal,
+ unless (@Plats) {
+ @$PlatsRef=@DefaultPlats;
+ # Include the list of BPABI Platforms in a default build.
+ my $OptionalPlat;
+ foreach $OptionalPlat (@OptionalPlats) {
+ # VS6 and VS2003 are not real platforms and hence are not included in a default build
+ unless ( $OptionalPlat eq 'VS6' || $OptionalPlat eq 'VS2003') {
+ if (not grep /^$OptionalPlat$/i, @$PlatsRef) {
+ push @$PlatsRef, $OptionalPlat;
+ }
+ }
+ }
+ }
+ else {
+ my $Plat;
+ foreach $Plat (@Plats) {
+ unless ($RemovePlats{$Plat}) {
+ push @$PlatsRef, $Plat;
+ }
+ }
+ push @PlatsReq , @$PlatsRef;
+ }
+}
+
+sub ExportDirs ($) {
+ my ($ExportsRef)=@_;
+
+ my %ExportDirHash;
+ foreach (@$ExportsRef) {
+ my $dir = ($$_{Type} eq 'zip') ? $$_{Releasable} : &Path_Split('Path',$$_{Releasable});
+ if ($dir) {
+ $dir=&Path_Chop($dir);
+ $ExportDirHash{uc $dir}=$dir;
+ }
+ }
+ my @ExportDirs;
+ foreach (keys %ExportDirHash) {
+ push @ExportDirs, $ExportDirHash{$_};
+ }
+ @ExportDirs;
+}
+
+
+sub ParseBldInfPlat ($$$$) {
+ my ($DataRef, $TestDataRef, $Plat, $BldInfPath, $FeatureVar)=@_;
+
+# get the platform .MMP macros
+ my %Plat;
+ eval { &Plat_GetL($Plat,\%Plat); };
+ &FatalError($@) if $@;
+
+# get the raw data from the BLD.INF file
+ my @Prj2D;
+ eval { &Prepfile_ProcessL(\@Prj2D, "${BldInfPath}$BldInfName", ($FeatureVar ? $FeatureVar->{VARIANT_HRH} : $variantMacroHRHFile), @{$Plat{MmpMacros}}); };
+ &FatalError($@) if $@;
+
+ my %dummy;
+ my @userIncludes = ('.');
+ my @systemIncludes = ();
+ $CheckSourceBldInfIncludes{$Plat} = CheckSource_Includes("${BldInfPath}$BldInfName", %dummy, $variantMacroHRHFile, @{$Plat{MmpMacros}}, @userIncludes, @systemIncludes, $CheckSource_NoUserSystemDistinction);
+
+# process the raw data
+ my $IsExtensionBlock =0;
+ my (@ExtensionBlockData, $ErrorString);
+ my %Check;
+ my $Section=0;
+ my @PrjFileDie;
+ my $Line;
+ my $CurFile="${BldInfPath}$BldInfName";
+ LINE: foreach $Line (@Prj2D) {
+
+ my %Data;
+ my %Temp;
+
+ my $LineNum=shift @$Line;
+ if ($LineNum eq '#') {
+ $CurFile=shift @$Line;
+ next LINE;
+ }
+
+ $CurFile = &Path_Norm ($CurFile);
+
+# upper-case all the data here, but record original source case
+# in a hash so that it can be recalled for CheckSource purposes
+
+ my %originalSourceCase;
+ foreach (@$Line) {
+ $originalSourceCase{uc $_} = $_; # needed for extension template makefile MACROs
+ $_=uc $_;
+ }
+
+ $_=shift @$Line;
+
+# check for section headers - don't test for the right ones here
+# because we do that in the first parse function
+
+ if (/^PRJ_(\w*)$/o) {
+ $Section=$1;
+ next LINE;
+ }
+
+# Skip section if PRJ_TESTMMPFILES and -notest option
+ next LINE if ($Options{notest} && ($Section=~/^(TESTMMPFILES)$/o));
+
+# check for EXTENSION sections
+ if ($Section=~/^(EXTENSIONS|TESTEXTENSIONS)$/o) {
+
+# We have an extension block
+ if (/^start(\w*)$/io) {
+ if ($IsExtensionBlock) {
+ &FatalError("$CurFile($LineNum) : Cannot embed Extension Template 'start' sections\n");
+ }
+ $IsExtensionBlock =1;
+ $ErrorString = "$CurFile($LineNum)";
+ foreach (@$Line)
+ {
+ if (/^EXTENSION$/)
+ {
+ my $extensionTemplate = @$Line[scalar(@$Line)-1];
+ CheckSource_MetaData(%CheckSourceEXTENSIONSMetaData, $CurFile, "PRJ_".$Section, $originalSourceCase{$extensionTemplate}.".mk", $LineNum, $CheckSource_PhysicalCheck) if ($extensionTemplate);
+ }
+ }
+
+ push @ExtensionBlockData, $Line;
+ next LINE;
+ }
+
+ if (($IsExtensionBlock) & (! (/^end(\w*)$/io))) {
+ if (($_ ne "TOOL") & ($_ ne "OPTION") & ($_ ne "TARGET") & ($_ ne "SOURCES") & ($_ ne "DEPENDENCIES")) {
+ &FatalError("$CurFile($LineNum) : Unrecognised keyword: $_. Is there an 'end' corresponding to the 'start' for the Extension Template?\n");
+ }
+ if ($_ ne "OPTION") {
+ unshift(@$Line, $_);
+ }
+# Need to revert MACROs back to their original case
+ foreach (@$Line) {
+ $_=$originalSourceCase{$_};
+ }
+ push @ExtensionBlockData, $Line;
+ next LINE;
+ }
+
+ if (/^end(\w*)$/io) {
+ if (! $IsExtensionBlock) {
+ &FatalError("$CurFile($LineNum) : No 'start' corresponding to this 'end' in Extension Template section\n");
+ }
+ $IsExtensionBlock =0;
+ my $OutDir=Path_Chop($E32env::Data{BldPath}).$BldInfPath;
+# Generate wrapper makefile for this platform.
+ eval { &Load_ModuleL('WrapperMakefile'); };
+ &FatalError($@) if $@;
+ $OutDir=~ s/\\/\//g; # convert to unix slashes for wrappermakefile.pm
+ %Data = GenerateWrapper($Plat, $OutDir, $ErrorString, \@PrjFileDie, @ExtensionBlockData);
+ if (!$IgnoreMissingExtensionMakefile)
+ {
+ $Data{ExtensionRoot}=&Path_Split('Path', $CurFile);
+ $Data{Path}=~ s/\//\\/g; # convert unix slashes back to win32
+ $Data{Base}=~ s/\//\\/g;
+ }
+ @ExtensionBlockData = (); # clear array
+ }
+ }
+
+# check for MMP sections and get the .MMP file details
+ if ($Section=~/^(MMPFILES|TESTMMPFILES)$/o) {
+ $Data{Ext}='.MMP';
+# check for MAKEFILE statements for custom building
+ my $SubSection = "MMP";
+ if (/^MAKEFILE$/o) {
+ $SubSection = $_;
+ $Data{Makefile}=2; # treat MAKEFILE=>NMAKEFILE =1;
+ $_=shift @$Line;
+ $Data{Ext}=&Path_Split('Ext', $_);
+ }
+ if (/^NMAKEFILE$/o) {
+ $SubSection = $_;
+ $Data{Makefile}=2;
+ $_=shift @$Line;
+ $Data{Ext}=&Path_Split('Ext', $_);
+ }
+ if (/^GNUMAKEFILE$/o) {
+ $SubSection = $_;
+ $Data{Makefile}=1;
+ $_=shift @$Line;
+ $Data{Ext}=&Path_Split('Ext', $_);
+ }
+ CheckSource_MetaData(%CheckSourceMMPFILESMetaData, $CurFile, "PRJ_$Section $SubSection", $originalSourceCase{$_}, $LineNum, $CheckSource_PhysicalCheck);
+ $_ = &Path_Norm ($_);
+
+# path considered relative to the current file
+ $Data{Path}=&Path_Split('Path', &Path_MakeAbs($CurFile, $_));
+
+# this function doesn't care whether the .MMPs are listed with their extensions or not
+ $Data{Base}=&Path_Split('Base', $_);
+ my $MmpFile= $Data{Path}.$Data{Base};
+
+# check the file isn't already specified
+ if ($Check{$MmpFile}) {
+ push @PrjFileDie, "$CurFile($LineNum) : duplicate $Data{Base} (from line $Check{$MmpFile})\n";
+ next;
+ }
+ $Check{$MmpFile}="$CurFile: $LineNum";
+
+# check the file exists
+ unless (-e "$Data{Path}$Data{Base}$Data{Ext}") {
+ WarnOrDie(\@PrjFileDie, "$CurFile($LineNum) : $Data{Path}$Data{Base}$Data{Ext} does not exist\n");
+ next LINE;
+ }
+
+
+# process the file's attributes
+ if ($Section eq 'MMPFILES') {
+ foreach (@$Line) {
+ if (/^TIDY$/o) {
+ $Data{Tidy}=1;
+ next;
+ }
+ if (/^IGNORE$/o) {
+ next LINE;
+ }
+ if (/^BUILD_AS_ARM$/o) {
+ $Data{BuildAsARM}="-arm";
+ next;
+ }
+
+ push @PrjFileDie, "$CurFile($LineNum) : Don't understand .MMP file argument \"$_\"\n";
+ }
+ }
+
+# process the test .MMP file's attributes
+ elsif ($Section eq 'TESTMMPFILES') {
+ foreach (@$Line) {
+ if (/^TIDY$/o) {
+ $Data{Tidy}=1;
+ next;
+ }
+ if (/^IGNORE$/o) {
+ next LINE;
+ }
+ if (/^BUILD_AS_ARM$/o) {
+ $Data{BuildAsARM}="-arm";
+ next;
+ }
+ if (/^MANUAL$/o) {
+ $Data{Manual}=1;
+ next;
+ }
+ if (/^SUPPORT$/o) {
+ $Data{Support}=1;
+ next;
+ }
+ push @PrjFileDie, "$CurFile($LineNum) : Don't understand test .MMP file argument \"$_\"\n";
+ }
+ }
+ }
+
+# store the data
+ if (($Section eq 'MMPFILES') or ($Section eq 'EXTENSIONS')) {
+ if ($IgnoreMissingExtensionMakefile and $Section eq 'EXTENSIONS')
+ {
+ # More than more ext makefile can be missing so reset indicator
+ $IgnoreMissingExtensionMakefile = 0;
+ }
+ else
+ {
+ push @$DataRef, \%Data;
+ }
+ next LINE;
+ }
+ if (($Section eq 'TESTMMPFILES') or ($Section eq 'TESTEXTENSIONS')) {
+ if ($IgnoreMissingExtensionMakefile and $Section eq 'TESTEXTENSIONS')
+ {
+ # More than more ext makefile can be missing so reset indicator
+ $IgnoreMissingExtensionMakefile = 0;
+ }
+ else
+ {
+ push @$TestDataRef, \%Data;
+ }
+ next LINE;
+ }
+
+ }
+# line loop end
+
+# exit if there are errors
+ if (@PrjFileDie) {
+ print STDERR
+ "\n\"${BldInfPath}$BldInfName\" FATAL ERROR(S):\n",
+ @PrjFileDie
+ ;
+ exit 1;
+ }
+}
+
+
+sub FatalError (@) {
+
+ print STDERR "BLDMAKE ERROR: @_\n";
+ exit 1;
+}
+
+sub CreatePlatformPm ($$$$$$) {
+ my ($BatchPath, $PlatsRef, $RealPlatsRef, $RealHRef, $AllPlatDataHRef, $AllPlatTestDataHRef)=@_;
+
+
+# exclude GCCXML, EDG and CWTOOLS from list of RealPlats
+ my @RealPlats;
+ foreach my $Plat (@$RealPlatsRef){
+ unless (($Plat =~ /^gccxml/i) or ($Plat =~ /^edg/i) or ($Plat =~ /^cwtools/i) or ($Plat =~ /^x86gcc/i) or ($Plat =~ /^x86gmp/i)) {
+# exclude BPABI targets from list of RealPlats provided they are not specified in the platform list
+ if (grep /^$Plat$/i, @OptionalPlats) {
+ if (grep /^$Plat$/, @PlatsReq) {
+ push @RealPlats, $Plat;
+ }
+ next;
+ }
+ push @RealPlats, $Plat;
+ }
+ }
+
+
+ &Output(
+ "# Bldmake-generated perl file - PLATFORM.PM\n",
+ "\n",
+ "# use a perl integrity checker\n",
+ "use strict;\n",
+ "\n",
+ "package Platform;\n",
+ "\n",
+ "use vars qw(\@Plats \@RealPlats %Programs %TestPrograms %FeatureVariantSupportingPlats);\n",
+ "\n",
+ "\@Plats=(\'",join('\',\'',@$PlatsRef),"\');\n",
+ "\n",
+ "\@RealPlats=(\'", join('\',\'',@RealPlats),"\');\n",
+ "\n",
+ "%Programs=(\n"
+ );
+ my %All; # all programs for all platforms
+ my $TmpStr;
+ my $Plat;
+ foreach $Plat (@$PlatsRef) {
+ $TmpStr=" \'$Plat\'=>[";
+ if (@{${$AllPlatDataHRef}{$$RealHRef{$Plat}}}) {
+ my $ProgRef;
+ foreach $ProgRef (@{${$AllPlatDataHRef}{$$RealHRef{$Plat}}}) {
+ $TmpStr.="'$$ProgRef{Base}',";
+ $All{$$ProgRef{Base}}=1;
+ }
+ chop $TmpStr;
+ }
+ &Output(
+ "$TmpStr],\n"
+ );
+ }
+ $TmpStr=" ALL=>[";
+ if (keys %All) {
+ my $Prog;
+ foreach $Prog (keys %All) {
+ $TmpStr.="'$Prog',";
+ }
+ chop $TmpStr;
+ }
+ &Output(
+ "$TmpStr]\n",
+ ");\n",
+ "\n",
+ "%TestPrograms=(\n"
+ );
+ %All=();
+ foreach $Plat (@$PlatsRef) {
+ $TmpStr=" \'$Plat\'=>[";
+ if (@{${$AllPlatTestDataHRef}{$$RealHRef{$Plat}}}) {
+ my $ProgRef;
+ foreach $ProgRef (@{${$AllPlatTestDataHRef}{$$RealHRef{$Plat}}}) {
+ $TmpStr.="'$$ProgRef{Base}',";
+ $All{$$ProgRef{Base}}=1;
+ }
+ chop $TmpStr;
+ }
+ &Output("$TmpStr],\n");
+ }
+ $TmpStr=" ALL=>[";
+ if (keys %All) {
+ my $Prog;
+ foreach $Prog (keys %All) {
+ $TmpStr.="'$Prog',";
+ }
+ chop $TmpStr;
+ }
+ &Output(
+ "$TmpStr]\n",
+ ");\n",
+ "\n"
+ );
+
+ &Output(
+ "\n",
+ "%FeatureVariantSupportingPlats=("
+ );
+
+ $TmpStr = "";
+ foreach $Plat (@$PlatsRef)
+ {
+ $TmpStr .= "\n\t$Plat=>1," if (&Plat_SupportsFeatureVariants($Plat));
+ }
+
+ chop $TmpStr;
+
+ &Output(
+ "$TmpStr\n",
+ ");\n",
+ "\n",
+ "1;\n"
+ );
+
+# write the PLATFORM.PM file
+ &WriteOutFileL($BatchPath."PLATFORM.PM");
+}
+
+sub CreatePerlBat ($) {
+ my ($BldInfPath)=@_;
+
+# create ABLD.BAT, which will call ABLD.PL
+# NB. must quote $BldInfPath because it may contain spaces, but we know it definitely
+# ends with \ so we need to generate "\foo\bar\\" to avoid quoting the close double quote
+ &Output(
+ "\@ECHO OFF\n",
+ "\n",
+ "REM Bldmake-generated batch file - ABLD.BAT\n",
+ "REM ** DO NOT EDIT **",
+ "\n",
+ "\n",
+ "perl -w -S ABLD.PL \"${BldInfPath}\\\" %1 %2 %3 %4 %5 %6 %7 %8 %9\n",
+ "if errorlevel==1 goto CheckPerl\n",
+ "goto End\n",
+ "\n",
+ ":CheckPerl\n",
+ "perl -v >NUL\n",
+ "if errorlevel==1 echo Is Perl, version 5.003_07 or later, installed?\n",
+ "goto End\n",
+ "\n",
+ ":End\n"
+ );
+
+# check that the .BAT file does not already exist and is read-only
+ if ((-e "${BldInfPath}ABLD.BAT") && !(-w "${BldInfPath}ABLD.BAT")) {
+ warn "BLDMAKE WARNING: read-only ABLD.BAT will be overwritten\n";
+ chmod 0222, "${BldInfPath}ABLD.BAT";
+ }
+
+# create the .BAT file in the group directory
+ &WriteOutFileL($BldInfPath."ABLD.BAT",1);
+
+}
+
+sub GetArchiveExportList($) {
+ my ($ExportRef) = @_;
+ my $Type = $ExportRef->{Type};
+ my $Src = $ExportRef->{Source};
+ my $Dest = $ExportRef->{Releasable};
+ $Dest = '' if (!defined($Dest));
+ my @list = ();
+ if ($Type eq 'zip') {
+ unless (open PIPE, "unzip -l $Src | ") {
+ warn "Can't unzip $Src\n";
+ }
+ while (<PIPE>) {
+ if (/^\s*\d+\s+\S+\s+\S+\s+(.*?)\s*$/) {
+# ignore empty lines and anything that finishes with /
+ unless(($1=~/\/\s*$/) || ($1=~/^$/)) {
+
+ my $member = $1;
+ $member =~ s/\$/\$\$/g;
+ if (!$Dest){
+ push @list, "$ENV{EPOCROOT}$member";
+ }
+ else{
+ push @list, "$Dest\\$member";
+ }
+ }
+ }
+ }
+ close PIPE;
+ }
+ return @list;
+}
+
+sub CreateExportMak ($$$) {
+ my ($Makefile, $ExportsRef, $ExpDirsRef)=@_;
+
+# create EXPORT.MAKE
+
+ my $erasedefn = "\@erase";
+ $erasedefn = "\@erase 2>>nul" if ($ENV{OS} eq "Windows_NT");
+ &Output(
+ "ERASE = $erasedefn\n",
+ "\n",
+ "\n",
+ "EXPORT : EXPORTDIRS"
+ );
+ my $ref;
+ if (@$ExportsRef) {
+ foreach $ref (@$ExportsRef) {
+ if ($$ref{Type} eq 'zip') {
+ my @list = &GetArchiveExportList($ref);
+ foreach (@list) {
+ my $dst=$_;
+ &Output(
+ " \\\n",
+ "\t$dst"
+ );
+ }
+ } else {
+ my $name=&Path_Quote($$ref{Releasable});
+ &Output(
+ " \\\n",
+ "\t$name"
+ );
+ }
+ }
+ }
+ else {
+ &Output(
+ " \n",
+ "\t\@echo Nothing to do\n"
+ );
+ }
+ &Output(
+ "\n",
+ "\n",
+ "\n",
+ "EXPORTDIRS :"
+ );
+ my $dir;
+ foreach $dir (@$ExpDirsRef) {
+ $dir=&Path_Quote($dir);
+ &Output(
+ " $dir"
+ );
+ }
+ &Output(
+ "\n",
+ "\n"
+ );
+ foreach $dir (@$ExpDirsRef) {
+ &Output(
+ "$dir :\n",
+ "\t\@perl -w -S emkdir.pl \"\$\@\"\n",
+ "\n"
+ );
+ }
+ &Output(
+ "\n",
+ "\n"
+ );
+ foreach $ref (@$ExportsRef) {
+ my $unzipoption = $$ref{UnzipOption};
+ CheckSource_ExportedIncludes($$ref{Source}, $$ref{Releasable}, %CheckSourceEXPORTSIncludes);
+
+ if ($$ref{Type} eq 'zip') {
+ my $src = &Path_Quote($$ref{Source});
+ my $destdir = &Path_Quote($$ref{Releasable});
+ $destdir=$ENV{EPOCROOT} if (!defined($destdir) or ($destdir eq ''));
+ my @list = &GetArchiveExportList($ref);
+ foreach (@list) {
+ my $dst=$_;
+ &Output(
+ "$dst : $src\n",
+ );
+ }
+ if ($unzipoption =~ /overwrite/i){
+ &Output(
+ "\t- unzip -o $src -d \"$destdir\"\n",
+ );
+ }
+ else{
+ &Output(
+ "\t- unzip -u -o $src -d \"$destdir\"\n",
+ );
+ }
+ } else {
+ my $dst=&Path_Quote($$ref{Releasable});
+ my $src=&Path_Quote($$ref{Source});
+ &Output(
+ "$dst : $src\n",
+ "\tcopy \"\$?\" \"\$\@\"\n",
+ "\n"
+ );
+ }
+ }
+ &Output(
+ "\n",
+ "\n"
+ );
+ if (@$ExportsRef) {
+ &Output(
+ "CLEANEXPORT :\n"
+ );
+ foreach $ref (@$ExportsRef) {
+ if ($$ref{Type} eq 'zip') {
+ my @list = &GetArchiveExportList($ref);
+ foreach (@list) {
+ my $dst=$_;
+ $dst =~ s/\//\\/go;
+ &Output(
+ "\t-\$(ERASE) \"$dst\"\n"
+ );
+ }
+ } else {
+ my $dst = $$ref{Releasable};
+ $dst =~ s/\//\\/go;
+ &Output(
+ "\t-\$(ERASE) \"$dst\"\n"
+ );
+ }
+ }
+ &Output(
+ "\n",
+ "WHAT :\n"
+ );
+ foreach $ref (@$ExportsRef) {
+ if ($$ref{Type} eq 'zip') {
+ my @list = &GetArchiveExportList($ref);
+ foreach (@list) {
+ my $dst=$_;
+ $dst =~ s/\//\\/go;
+ &Output(
+ "\t\@echo \"$dst\"\n"
+ );
+ }
+ } else {
+ my $dst = $$ref{Releasable};
+ $dst =~ s/\//\\/go;
+ &Output(
+ "\t\@echo \"$dst\"\n"
+ );
+ }
+ }
+ }
+ else {
+ &Output(
+ "CLEANEXPORT :\n",
+ "\t\@echo Nothing to do\n",
+ "WHAT :\n",
+ "\t\@rem do nothing\n"
+ );
+ }
+
+ &Output(
+ "\nCHECKSOURCE :\n"
+ );
+
+ &Output (CheckSource_MakefileOutput(%CheckSourceEXPORTSMetaData));
+ &Output (CheckSource_MakefileOutput(%CheckSourceEXPORTSIncludes));
+
+ &Output("\n");
+
+# write EXPORT.MAKE
+ &WriteOutFileL($Makefile);
+}
+
+sub CreatePlatExports ($$) {
+ my ($RealPlat,$Exports)=@_;
+ my $Ref;
+ &Output(
+ "\n# Rules which handle the case when \$(CFG) is not defined\n\n" ,
+ "EXPORT: \tEXPORTUREL EXPORTUDEB\n",
+ "EXPORTCLEAN: \tEXPORTCLEANUREL EXPORTCLEANUDEB\n",
+ "EXPORTWHAT: \tEXPORTWHATUREL EXPORTWHATUDEB\n",
+
+ "\n# definitions \n",
+ "DATAx = $ENV{EPOCROOT}epoc32\\data\n",
+ "EMULx = $ENV{EPOCROOT}epoc32\\$RealPlat\n",
+ "URELx = $ENV{EPOCROOT}epoc32\\release\\$RealPlat\\urel\n",
+ "UDEBx = $ENV{EPOCROOT}epoc32\\release\\$RealPlat\\udeb\n",
+ "\n"
+ );
+
+ &Output(
+ "# Exports to emulated drive A: to Y \n\n",
+ "EXPORTGENERIC : EXPORTDIRSGENERIC",
+ );
+
+ my @dirs;
+ my @expgen;
+ my %dirsg;
+ foreach $Ref (@$Exports) {
+ if ($$Ref{emReleasable}=~/^([A-Y])(\\.*)$/){
+ my $exp="\\$$Ref{emReleasable}";
+ if ($$Ref{Type} eq 'zip') {
+ my @list = &GetArchiveExportList($Ref);
+ foreach (@list) {
+ my $dst=&Path_Quote($_);
+ if ($dst=~/([^\\]*)$/o){
+ $dst=$1;
+ }
+ my $zipdest=$dst;
+ $zipdest =~ s/\//\\/g;
+ push @expgen, "$exp\\$zipdest";
+ my $zippath= &Path_Chop(&Path_Split('Path', $zipdest));
+ if(!$zippath){
+ $dirsg{$exp}=$exp;
+ }
+ else{
+ $dirsg{"$exp\\$zippath"}="$exp\\$zippath";
+ }
+ &Output(" \\\n","\t\$(EMULx)$exp\\$zipdest");
+ }
+ }
+ else {
+ my $dir = &Path_Chop(&Path_Split('Path', $exp));
+ push @expgen, $exp;
+ $dirsg{$dir}=$dir;
+ &Output(" \\\n", "\t\$(EMULx)$exp ");
+ }
+ }
+ }
+ &Output("\n\nEXPORTDIRSGENERIC : ");
+ foreach (keys %dirsg){
+ push @dirs, "\$(EMULx)$dirsg{$_}";
+ &Output(" \\\n", "\t\$(EMULx)$_");
+ }
+ &Output("\n\n");
+ foreach (@expgen){
+ &Output(
+ "\$(EMULx)$_ : \t\$(DATAx)$_ \n",
+ "\tcopy \"\$?\" \"\$@\" \n"
+ );
+ }
+ &Output("\nEXPORTCLEANGENERIC :\n");
+ foreach (@expgen){
+ &Output("\t-@\$(ERASE) \$(EMULx)$_ \n");
+ }
+ &Output("\nEXPORTWHATGENERIC :\n");
+ foreach (@expgen){
+ &Output("\t\@echo \$(EMULx)$_ \n");
+ }
+
+ &Output(
+ "\n\n# Exports to emulated drive Z: - UREL version \n\n",
+ "EXPORTUREL : EXPORTDIRSUREL",
+ );
+
+ my @expurel;
+ my %dirsurel;
+ foreach $Ref (@$Exports) {
+ if ($$Ref{emReleasable}=~/^(Z)(\\.*)$/){
+ my $exp="\\$$Ref{emReleasable}";
+ if ($$Ref{Type} eq 'zip') {
+ my @list = &GetArchiveExportList($Ref);
+ foreach (@list) {
+ my $dst=&Path_Quote($_);
+ if ($dst=~/([^\\]*)$/o){
+ $dst=$1;
+ }
+ my $zipdest=$dst;
+ $zipdest=~ s/\//\\/g;
+ push @expurel, "$exp\\$zipdest";
+ my $zippath= &Path_Chop(&Path_Split('Path', $zipdest));
+ if(!$zippath){
+ $dirsurel{$exp}=$exp;
+ }
+ else{
+ $dirsurel{"$exp\\$zippath"}="$exp\\$zippath";
+ }
+ &Output(" \\\n","\t\$(URELx)$exp\\$zipdest");
+ }
+ }
+ else {
+ my $dir = &Path_Chop(&Path_Split('Path', $exp));
+ push @expurel, $exp;
+ $dirsurel{$dir}=$dir;
+ &Output(" \\\n", "\t\$(URELx)$exp ");
+ }
+ }
+ }
+ &Output("\n\nEXPORTDIRSUREL : ");
+ foreach (keys %dirsurel){
+ push @dirs, "\$(URELx)$dirsurel{$_}";
+ &Output(" \\\n", "\t\$(URELx)$_ ");
+ }
+ &Output("\n\n");
+ foreach (@expurel){
+ &Output(
+ "\$(URELx)$_ : \t\$(DATAx)$_ \n",
+ "\tcopy \"\$?\" \"\$@\" \n"
+ );
+ }
+ &Output("\nEXPORTCLEANUREL :\n");
+ foreach (@expurel){
+ &Output("\t-@\$(ERASE) \$(URELx)$_ \n");
+ }
+ &Output("\nEXPORTWHATUREL :\n");
+ foreach (@expurel){
+ &Output( "\t\@echo \$(URELx)$_ \n");
+ }
+
+ &Output(
+ "\n\n# Exports to emulated drive Z: - UDEB version \n\n",
+ "EXPORTUDEB : EXPORTDIRSUDEB",
+ );
+
+ my %dirsudeb=%dirsurel;
+ my @expudeb=@expurel;
+ foreach (@expudeb){
+ &Output(" \\\n", "\t\$(UDEBx)$_ ");
+ }
+ &Output("\n\nEXPORTDIRSUDEB : ");
+ foreach(keys %dirsudeb){
+ push @dirs, "\$(UDEBx)$dirsudeb{$_}";
+ &Output(" \\\n", "\t\$(UDEBx)$_ ");
+
+ }
+ &Output("\n\n");
+ foreach (@expudeb){
+ &Output(
+ "\$(UDEBx)$_ : \t\$(DATAx)$_ \n",
+ "\tcopy \"\$?\" \"\$@\" \n"
+ );
+ }
+ &Output("\nEXPORTCLEANUDEB :\n");
+ foreach (@expudeb){
+ &Output("\t-@\$(ERASE) \$(UDEBx)$_ \n");
+ }
+ &Output("\nEXPORTWHATUDEB :\n");
+ foreach (@expudeb){
+ &Output("\t\@echo \$(UDEBx)$_ \n");
+ }
+
+ &Output("\n# Directories \n\n");
+ &Output(join (" \\\n", @dirs)." :")
+ &Output("\n\t\@perl -w -S emkdir.pl \$@\n\n");
+
+}
+
+sub CreatePlatMak ($$$$$$$$$;$) {
+ my ($BatchPath, $E32MakePath, $DataRef, $Plat, $RealPlat, $RomDir, $Module, $BldInfPath, $Exports, $Test, $FeatureVariant)=@_;
+ $FeatureVariant = "" if (!$FeatureVariant);
+
+ unless ($Test) {
+ $Test='';
+ }
+ else {
+ $Test='TEST';
+ }
+
+ my $Ref;
+ my $eDrive=0;
+ if ($RealPlat =~ /^WINS/) {
+ foreach $Ref (@$Exports) {
+ if ($$Ref{emReleasable}=~/^([A-Z])(\\.*)$/) {
+ $eDrive=1;
+ last;
+ }
+ }
+ }
+
+
+ my $OutRomFile="$RomDir$RealPlat$Test.IBY";
+ my $GCCDir="gcc\$(PBUILDPID)\\bin";
+
+ my $erasedefn = "\@erase";
+ $erasedefn = "\@erase 2>>nul" if ($ENV{OS} eq "Windows_NT");
+
+# Get the root platform name to support hierarchy of customizations
+ my $root = Plat_Root($Plat);
+
+ my $config_file = "";
+
+ if (grep /^$root$/i, @BPABIPlats) {
+ $config_file = BPABIutl_Config_Path($root);
+ }
+
+ my $rvct_path = "";
+
+ if ( $config_file ) {
+
+ if ($root =~ /^ARMV\d/) {
+
+ unless ( RVCT_plat2set::compiler_exists($Plat) )
+ {
+ FatalError("Can't find any RVCT installation.");
+ }
+
+ my $rvct_ver = RVCT_plat2set::get_version_string($Plat);
+
+ if ($Plat =~ "^ARMV5" && $rvct_ver lt "2.2.559")
+ {
+ warn "BLDMAKE WARNING: ARMV5 requires at least RVCT 2.2.559.";
+ OutText();
+ return;
+ }
+
+ if ($Plat =~ "^ARMV6" && $rvct_ver lt "2.2.559")
+ {
+ warn "BLDMAKE WARNING: ARMV6 requires at least RVCT 2.2.559.";
+ OutText();
+ return;
+ }
+
+ if ($Plat =~ "^ARMV7" && $rvct_ver lt "3.1.674")
+ {
+ warn "BLDMAKE WARNING: ARMV7 requires at least RVCT 3.1.674.";
+ OutText();
+ return;
+ }
+
+ my $rvct_bin_name = RVCT_plat2set::get_bin_name($Plat);
+ my $rvct_bin_path = RVCT_plat2set::get_bin_path($Plat);
+ my $rvct_inc_name = RVCT_plat2set::get_inc_name($Plat);
+ my $rvct_inc_path = RVCT_plat2set::get_inc_path($Plat);
+ my $rvct_lib_name = RVCT_plat2set::get_lib_name($Plat);
+ my $rvct_lib_path = RVCT_plat2set::get_lib_path($Plat);
+
+ main::Output("export $rvct_bin_name:=$rvct_bin_path\n");
+ main::Output("export $rvct_inc_name:=$rvct_inc_path\n");
+ main::Output("export $rvct_lib_name:=$rvct_lib_path\n");
+
+ my ($rvct_M, $rvct_m, $rvct_b) = RVCT_plat2set::get_version_list($Plat);
+
+ Output( "\n" );
+ Output( "export RVCT_VER_MAJOR:=$rvct_M\n" );
+ Output( "export RVCT_VER_MINOR:=$rvct_m\n" );
+ Output( "export RVCT_VER_BUILD:=$rvct_b\n" );
+
+ $rvct_path = "\$($rvct_bin_name);"; # Example: '$(RVCT22BIN);'.
+ }
+
+ &Output(
+ "\n",
+ "export PLAT:=${Plat}\n\n",
+ "include $config_file\n\n"
+ );
+ }
+# modified start: makefile improvement
+ unless($FeatureVariant eq "")
+ {
+# modified by SV start: makefile improvement
+ foreach $Ref (@$DataRef) {
+ &Output(
+ "include $BatchPath"."FeatureVariantInfo\\".uc($Plat)."\\"."$Plat$FeatureVariant.$$Ref{Base}.info\n\n",
+ );
+ }
+# modified by SV end: makefile improvement
+ }
+# modified end: makefile improvement
+ # Don't hardcode the rvct path if rvct auto switch feature is not enabled.
+ if ($ENV{ABLD_PLAT_INI})
+ {
+ &Output(
+ 'export Path:=',&main::Path_Drive,$E32env::Data{EPOCPath},$GCCDir,";", $rvct_path,"\$(Path)\n",
+ "export PATH:=\$(Path)\n"
+ );
+ }
+ else
+ {
+ &Output(
+ 'export Path:=',&main::Path_Drive,$E32env::Data{EPOCPath},$GCCDir,";", "\$(Path)\n",
+ "export PATH:=\$(Path)\n"
+ );
+ }
+
+ &Output(
+ "\n",
+ "# prevent MAKEFLAGS variable from upsetting calls to NMAKE\n",
+ "unexport MAKEFLAGS\n",
+ "\n",
+ "ERASE = $erasedefn\n",
+ "\n",
+ "\n",
+ "ifdef EFREEZE_ALLOW_REMOVE\n",
+ "REMOVEMACRO := EFREEZE_ALLOW_REMOVE=-remove\n",
+ "endif\n",
+ "\n",
+ "\n"
+ );
+
+ if ($eDrive) {
+ # Generate exports into emulated drives
+ &CreatePlatExports($RealPlat,$Exports);
+ }
+ my $Command;
+ foreach $Command (qw(CLEAN CLEANMAKEFILE CLEANALL FINAL FREEZE LIBRARY MAKEFILE RESOURCE SAVESPACE TARGET LISTING WHATMAKEFILE)) {
+ &Output(
+ "$Command :"
+ );
+
+ if ($eDrive and $Command eq 'CLEAN'){
+ &Output(" EXPORTCLEANGENERIC EXPORTCLEAN\$(CFG) ");
+ foreach $Ref (@$DataRef) {
+ &Output(" $Command$$Ref{Base}");
+ }
+ }
+ elsif ($eDrive and $Command eq 'RESOURCE'){
+ &Output(" EXPORTGENERIC EXPORT\$(CFG) ");
+ foreach $Ref (@$DataRef) {
+ &Output(" $Command$$Ref{Base}");
+ }
+
+ foreach $Ref (@$DataRef) {
+ &Output("\n\nRESOURCE$$Ref{Base} : EXPORTGENERIC EXPORT\$(CFG)");
+ }
+ }
+ else {
+ if(@$DataRef){
+ foreach $Ref (@$DataRef) {
+ &Output(" $Command$$Ref{Base}");
+ }
+ }
+ else {
+ &Output("\n","\t\@echo Nothing to do\n");
+ }
+ }
+ &Output("\n","\n");
+ }
+
+ &Output(
+ "WHAT :"
+ );
+ if($eDrive){
+ &Output(" EXPORTWHATGENERIC EXPORTWHAT\$(CFG) ");
+ }
+ my $whatcount=0;
+ foreach $Ref (@$DataRef) {
+ unless ($$Ref{Tidy}) {
+ $whatcount++;
+ &Output(
+ " WHAT$$Ref{Base}"
+ );
+ }
+ }
+ if ($whatcount==0 and !$eDrive) {
+ &Output(
+ "\n",
+ "\t\@rem do nothing\n"
+ );
+ }
+
+ &Output(
+ "\n",
+ "\n",
+ "CHECKSOURCE :"
+ );
+ my $CheckSource=' CHECKSOURCE_GENERIC';
+ foreach $Ref (@$DataRef) {
+ $CheckSource.=" CHECKSOURCE$$Ref{Base}" if ($$Ref{Ext} eq ".MMP");
+ }
+ &Output(
+ "$CheckSource\n"
+ );
+
+ &Output(
+ "\n",
+ "CHECKSOURCE_GENERIC :\n"
+ );
+
+ if ($CheckSourceBldInfIncludes{$Plat})
+ {
+ my %dummy;
+ $dummy{$CheckSourceBldInfIncludes{$Plat}} = 1;
+ &Output (CheckSource_MakefileOutput(%dummy));
+ }
+
+ &Output (CheckSource_MakefileOutput(%CheckSourceMMPFILESMetaData));
+ &Output (CheckSource_MakefileOutput(%CheckSourceEXTENSIONSMetaData));
+
+ &Output(
+ "\n",
+ "\n",
+ "TIDY :"
+ );
+ my $Tidy='';
+ foreach $Ref (@$DataRef) {
+ if ($$Ref{Tidy}) {
+ $Tidy.=" TIDY$$Ref{Base}";
+ }
+ }
+ if ($Tidy) {
+ &Output(
+ "$Tidy\n"
+ );
+ }
+ else {
+ &Output(
+ "\n",
+ "\t\@echo Nothing to do\n"
+ );
+ }
+ &Output(
+ "\n",
+ "\n"
+ );
+# change for non-EPOC platforms
+ if ($RealPlat=~/^(WINS|WINSCW|WINC|TOOLS|TOOLS2)$/o) {
+ &Output(
+ "ROMFILE :\n"
+ );
+ }
+ else {
+ &Output(
+ 'ROMFILE : STARTROMFILE'
+ );
+ foreach $Ref (@$DataRef) {
+ &Output(
+ " ROMFILE$$Ref{Base}"
+ );
+ }
+ &Output(
+ "\n",
+ "\n",
+ "STARTROMFILE :\n",
+ "\t\@perl -w -S emkdir.pl \"", &Path_Chop($RomDir), "\"\n",
+ "\t\@echo // $OutRomFile > $OutRomFile\n",
+ "\t\@echo // >> $OutRomFile\n"
+ );
+ if ($Test) {
+ my ($Auto, $Manual);
+ foreach $Ref (@$DataRef) {
+ ++$Auto unless ($$Ref{Manual} or $$Ref{Support});
+ ++$Manual if ($$Ref{Manual});
+ }
+ if ($Auto) {
+ my $IbyTextFrom="data=$BatchPath$Plat.AUTO.BAT";
+ my $IbyTextTo="Test\\$Module.AUTO.BAT";
+ my $Spaces= 60>length($IbyTextFrom) ? 60-length($IbyTextFrom) : 1;
+ &Output("\t\@echo ", $IbyTextFrom, ' 'x$Spaces, $IbyTextTo, ">> $OutRomFile\n");
+ }
+ if ($Manual) {
+ my $IbyTextFrom="data=$BatchPath$Plat.MANUAL.BAT";
+ my $IbyTextTo="Test\\$Module.MANUAL.BAT";
+ my $Spaces= 60>length($IbyTextFrom) ? 60-length($IbyTextFrom) : 1;
+ &Output("\t\@echo ", $IbyTextFrom, ' 'x$Spaces, $IbyTextTo, ">> $OutRomFile\n");
+ }
+ }
+ }
+ &Output(
+ "\n",
+ "\n"
+ );
+ my $CallNmake='nmake -nologo -x - $(VERBOSE) $(KEEPGOING)';
+ my $CallGNUmake='$(MAKE) $(VERBOSE) $(KEEPGOING)';
+
+ my %PlatHash;
+ &Plat_GetL($RealPlat, \%PlatHash);
+ my $CallMake=$CallNmake;
+ if ($PlatHash{MakeCmd} eq "make") {
+ $CallMake="$CallGNUmake -r";
+ }
+ &Plat_GetL($Plat, \%PlatHash);
+
+ foreach $Ref (@$DataRef) {
+
+# standard commands
+ unless ($$Ref{Makefile}) {
+ my $MakefilePath=join('', &Path_Chop($E32MakePath), $BldInfPath, $$Ref{Base}, "\\", $RealPlat, "\\");
+# modified start: makefile improvement
+ my $RealMakefile;
+ if($FeatureVariant eq "")
+ {
+ $RealMakefile="-f \"$MakefilePath$$Ref{Base}.$RealPlat$FeatureVariant\"";
+ }
+ else{
+ $RealMakefile="-f \"$MakefilePath$$Ref{Base}.$RealPlat.\$(VARIANT_PLAT_NAME_$$Ref{Base})\"";
+ }
+# modified end: makefile improvement
+ my $MakefileBase="$MakefilePath$$Ref{Base}";
+
+ if($Plat eq 'VS6' || $Plat eq 'VS2003')
+ {
+ $CallMake .= "-f ";
+ $RealMakefile = "$MakefileBase$PlatHash{Ext}";
+ }
+ &Output(
+ "MAKEFILE$$Ref{Base}_FILES= \\\n",
+ "\t\"$MakefileBase$PlatHash{Ext}$FeatureVariant\"",
+ );
+# changes for WINS/WINSCW/WINC and VC6
+ if ($Plat =~ /^VC6/) {
+ &Output(
+ " \\\n\t\"$MakefileBase.DSW\"",
+ " \\\n\t\"$MakefileBase.SUP.MAKE\""
+ );
+ }
+ if ($Plat eq 'CW_IDE') {
+ &Output(
+ " \\\n\t\"$MakefileBase.pref\"" # Defect: actually uses $BaseTrg, not mmp file name
+ );
+ }
+ if ($RealPlat=~/^(WINS|WINSCW|WINC)$/o) {
+ &Output(
+ " \\\n\t\"$MakefileBase.UID.CPP\"" # Defect: actually uses $BaseTrg, not mmp file name
+ );
+ }
+
+ my $bld_flags="";
+ $bld_flags="\$(ABLD_FLAGS)" if (($Plat =~ /^ARMV5(_ABIV1)?$/ || grep /$Plat/i, @BPABIPlats) || (Plat_Root($Plat) =~ /^ARMV5(_ABIV1)?$/ || grep /$Plat/i, @BPABIPlats));
+
+
+ my $build_as_arm_arg="";
+ $build_as_arm_arg = $$Ref{BuildAsARM} if ($$Ref{BuildAsARM});
+
+ # Compiler Wrapper option Support
+ # Generate the flag to keep the Compiler Wrapper option information
+ my $cmp_wrap_flag="";
+ if (($Plat =~ /^ARMV5(_ABIV1)?$/ || grep /$Plat/i, @BPABIPlats) || ($Plat=~/^WINSCW$/) || (Plat_Root($Plat) =~ /^ARMV5(_ABIV1)?$/ || grep /$Plat/i, @BPABIPlats))
+ {
+ # for armv5 , armv5_abiv1, winscw and all bpabi plaforms
+ $cmp_wrap_flag="\$(ABLD_COMPWRAP_FLAG)" ;
+ }
+
+ &Output(
+ "\n",
+ "\n",
+ "MAKEFILE$$Ref{Base} :\n",
+ "\tperl -w -S makmake.pl \$(NO_DEPENDENCIES) -D $$Ref{Path}$$Ref{Base} $Plat$FeatureVariant $build_as_arm_arg $bld_flags $cmp_wrap_flag\n",
+
+ "\n",
+ "CLEANMAKEFILE$$Ref{Base} :\n",
+ "\t-\$(ERASE) \$(MAKEFILE$$Ref{Base}_FILES)\n",
+ "\n",
+ "WHATMAKEFILE$$Ref{Base} :\n",
+ "\t\@echo \$(MAKEFILE$$Ref{Base}_FILES)\n",
+ "\n",
+ "TARGET$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile \$(CFG)\n",
+ "\n",
+ "SAVESPACE$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile \$(CFG) CLEANBUILD\$(CFG)\n",
+ "\n",
+ "LISTING$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile MAKEWORK\$(CFG) LISTING\$(CFG)\$(SOURCE)\n",
+ "\n",
+ "FINAL$$Ref{Base} :\n",
+ "\t\@rem do nothing\n",
+ "\n",
+ );
+ foreach $Command (qw(CLEANALL)) {
+ &Output(
+ "CLEANALL$$Ref{Base} :\n",
+ "\tperl -w -S ermdir.pl $MakefilePath\n",
+ "\n",
+ );
+ }
+ foreach $Command (qw(CLEAN RESOURCE)) {
+ &Output(
+ "$Command$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile $Command\$(CFG)\n",
+ "\n"
+ );
+ }
+ foreach $Command (qw(LIBRARY)) {
+ &Output(
+ "$Command$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile $Command\n",
+ "\n"
+ );
+ }
+ foreach $Command (qw(FREEZE)) {
+ &Output(
+ "$Command$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile $Command \$(REMOVEMACRO)\n",
+ "\n"
+ );
+ }
+ unless ($$Ref{Tidy}) {
+ &Output(
+ "WHAT$$Ref{Base} :\n",
+ "\t\@$CallMake -s $RealMakefile WHAT\$(CFG)\n",
+ "\n"
+ );
+ }
+ else {
+ &Output(
+ "TIDY$$Ref{Base} :\n",
+ "\t$CallMake $RealMakefile CLEANRELEASE CLEANLIBRARY\n",
+ "\n"
+ );
+ }
+
+ &Output(
+ "CHECKSOURCE$$Ref{Base} :\n",
+ "\t\@$CallMake -s $RealMakefile CHECKSOURCE\n",
+ "\t\@$CallMake -s $RealMakefile CHECKSOURCE\$(CFG)\n",
+ "\n"
+ );
+ &Output(
+ "ROMFILE$$Ref{Base} :\n",
+ "\t\@$CallMake $RealMakefile ROMFILE >> $OutRomFile\n",
+ "\n",
+ "\n"
+ );
+ }
+
+# calls to custom makefiles
+ else {
+ my $ChopRefPath=&Path_Chop($$Ref{Path});
+ my $ChopBldInfPath=&Path_Chop($BldInfPath);
+ my $MakefileCall;
+ if ($$Ref{Makefile}==2) {
+ $MakefileCall="cd $ChopRefPath;$CallNmake";
+ } else {
+ $MakefileCall="$CallGNUmake -C $ChopRefPath";
+ }
+ $MakefileCall.=" -f \"$$Ref{Base}$$Ref{Ext}\" TO_ROOT=";
+ $MakefileCall.=&Path_Chop(&Path_UpToRoot($$Ref{Path}));
+ $MakefileCall.=" EPOCBLD=";
+ $MakefileCall.=join('', &Path_Chop(&Path_UpToRoot($$Ref{Path})), &Path_Chop($E32MakePath), $BldInfPath, $$Ref{Base}, "\\", $RealPlat);
+ $MakefileCall.=" TO_BLDINF=";
+ $MakefileCall.=join('', &Path_Chop(&Path_UpToRoot($$Ref{Path})), $ChopBldInfPath);
+ if ($$Ref{ExtensionRoot}) {
+ $MakefileCall.=" EXTENSION_ROOT=".&Path_Chop($$Ref{ExtensionRoot});
+ }
+ if ($$Ref{BuildAsARM}) {
+ $MakefileCall.=" BUILD_AS_ARM=1";
+ }
+ &Output(
+# should change to MAKEFILE
+ "MAKEFILE$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$Plat MAKMAKE\n",
+ "\n",
+# should call in custom makefiles maybe
+ "CLEANMAKEFILE$$Ref{Base} :\n",
+ "# $MakefileCall PLATFORM=$Plat CLEANMAKEFILE\n",
+ "\n",
+ "WHATMAKEFILE$$Ref{Base} :\n",
+ "# \@$MakefileCall -s PLATFORM=$Plat WHATMAKEFILE\n",
+ "\n",
+# should change to TARGET
+ "TARGET$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat CFG=\$(CFG) BLD\n",
+ "\n",
+# should ignore this target and just call the TARGET target instead?
+ "SAVESPACE$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat CFG=\$(CFG) SAVESPACE\n",
+ "\n",
+ "LISTING$$Ref{Base} :\n",
+ "\n",
+ "\n",
+# should change to LIBRARY
+ "LIBRARY$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat LIB\n",
+ "\n",
+ "FREEZE$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat FREEZE \$(REMOVEMACRO)\n",
+ "\n",
+ );
+
+ foreach $Command (qw(CLEANALL)) {
+ &Output(
+ "$Command$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat CFG=\$(CFG) CLEAN\n",
+ "\n"
+ );
+ }
+
+ foreach $Command (qw(CLEAN RESOURCE FINAL)) {
+ &Output(
+ "$Command$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat CFG=\$(CFG) $Command\n",
+ "\n"
+ );
+ }
+ unless ($$Ref{Tidy}) {
+# should change to WHAT
+ &Output(
+ "WHAT$$Ref{Base} :\n",
+ "\t\@$MakefileCall -s PLATFORM=$RealPlat CFG=\$(CFG) RELEASABLES\n",
+ "\n"
+ );
+ }
+ else {
+ &Output(
+ "TIDY$$Ref{Base} :\n",
+ "\t$MakefileCall PLATFORM=$RealPlat TIDY\n",
+# should change to CLEANLIBRARY
+ "\t$MakefileCall CLEANLIB\n",
+ "\n"
+ );
+ }
+ &Output(
+ "ROMFILE$$Ref{Base} :\n",
+ "\t\@$MakefileCall PLATFORM=$RealPlat ROMFILE >> $OutRomFile\n",
+ "\n",
+ "\n"
+ );
+ }
+
+ }
+
+ &WriteOutFileL("$BatchPath$Plat$FeatureVariant$Test.MAKE");
+}
+
+sub CreatePlatBatches ($$$) {
+ my ($OutDir, $DataRef, $Plat)=@_;
+
+# create the test batch files
+# this function won't work properly if the target basename is different from the .MMP basename
+# so perhaps it should call makmake on the .mmp file to check
+
+ my $AutoText;
+ my $ManualText;
+
+ my $Ref;
+ foreach $Ref (@$DataRef) {
+ if ($$Ref{Manual}) {
+ $ManualText.="$$Ref{Base}\n";
+ next;
+ }
+ if ($$Ref{Ext} eq ".MK") {
+ next;
+ }
+ if ($$Ref{Support}) {
+ next;
+ }
+ else {
+ $AutoText.="$$Ref{Base}\n";
+ }
+ }
+
+ if ($AutoText) {
+ &Output($AutoText);
+ &WriteOutFileL("$OutDir$Plat.AUTO.BAT");
+ }
+
+ if ($ManualText) {
+ &Output($ManualText);
+ &WriteOutFileL("$OutDir$Plat.MANUAL.BAT");
+ }
+}
+
+sub WriteOutFileL ($$) { # takes batch file and boolean read-only flag
+ my ($BATFILE, $ReadOnly)=@_;
+
+ $BATFILE=~ s/\//\\/g; # convert unix slashes from wrappermakefile.pm
+
+ eval { &Path_MakePathL($BATFILE); };
+ &FatalError($@) if $@;
+
+ open BATFILE,">$BATFILE" or &FatalError("Can't open or create Batch File \"$BATFILE\"");
+ print BATFILE &OutText or &FatalError("Can't write output to Batch File \"$BATFILE\"");
+ close BATFILE or &FatalError("Can't close Batch File \"$BATFILE\"");
+}
+
+