# 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",