# 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:

#

# This package contains routines to handle Base Platform ABI (BPABI) Platforms.

package Cl_bpabi;

my @commonOptions;

my @thumbOptions;

my @armOptions;

my @kernelOptions;

my @invariantOptions;

my @linkerOptions;

my @archiverOptions;

my @debugFormat;

my $ArmIncDir;

my @ArmLibList;

my %configVariables;

#Check if Function call Logger is enabled

my $Function_Call_Logger=&main::IsFunctionCallLogging();

# Get the information regarding supporting Compiler Wrapper Option

my $IsCompilerWrapperOption=&main::CompilerWrapperOption();

my $IsProxyWrapperOption=&main::ProxyWrapperOption();

# takes an 'expression'  to evaluate with $_ bound to each of the

# remaining args

sub PrintList

{

    my $expr = shift @_;

    foreach (@_) {

	my $str = eval($expr);

	&main::Output($str);

    }

}

sub DepLinkList

{

    my $expr = shift @_;

    my @arr;

    foreach (@_) {

	my $str = eval($expr);

	push @arr, $str;

    }

    return @arr;

}

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMPlatProcessMmp

	PMStartBldList

		PMBld

	PMStartSrcList

		PMBitMapBld

		PMResrcBld

		PMStartSrc

		PMAifBld

		PMSrcDepend

			PMSrcBldDepend

			PMEndSrcBld

		PMEndSrc

	PMEndSrcList

	PMPrefixFile

	PMToolChainIncDir

	PMSupportsFeatureVariants

);

use Cwd;

# Armutl package does various ancillary things for armedg modules

use Armutl;

use BPABIutl;

use E32Plat;

use RVCT_plat2set;

use gcce_plat2set;

# This is the RVCT Version information required by Armutl package

my $RVCTMajorVersion;

my $RVCTMinorVersion;

my $RVCTVersion;

my $GCCEMajorVersion;

my $GCCEMinorVersion;

my $GCCEVersion;

# The name of the build platform, e.g. ARMV6.

my $PlatName = main::Plat();

# The name of the root platform. This is useful if the plaform is derived using a

# BSF file. If the current platform is not derived, $RootName will be the same as

# $PlatName.

my $RootName = E32Plat::Plat_Root($PlatName);

# cl_generic package contains generic routines to handle bits of makefiles which are

# common to all of the platforms. Currently it deals with AIF, MBM amd RSC files.

use cl_generic;

# E32env package contains information for makmake and associated e32tools perl programs

# within the Epoc32 Environment

use E32env;

# Genutl package contains utility subroutines for MAKMAKE and associated scripts

use Genutl;

# Modload package is the runtime module-loading routine for loading e32tools modules into

# 'main' module

use Modload;

use constant NOCOMPRESSIONMETHOD => 0;

use constant INFLATECOMPRESSIONMETHOD => 1;

use constant BYTEPAIRCOMPRESSIONMETHOD => 2;

use constant NOTPAGED => 0;

use constant UNPAGED => 1;

use constant PAGED => 2;

use constant NON_DEBUGGABLE => 0;

use constant DEBUGGABLE => 1;

use constant DEBUGGABLE_UDEBONLY => 2;

my %plat = &main::PlatRec();

my $CustomizedARMV5Plat = 0;

if (($plat{'CUSTOMIZES'}) && (($plat{'ROOTPLATNAME'} eq "ARMV5") || ($plat{'ROOTPLATNAME'} eq "ARMV5_ABIV2"))) {

# The following flag is set to handle the exceptions related to ARMV5 toolchain.

	$CustomizedARMV5Plat = 1;		

}

#this fucntion will be used for cw_ide platform to update the PlatName and reinitialize the hashtable

sub getVariableForNewPlat

{

	$PlatName = main::Plat();	

	undef(%configVariables);

}

sub PMHelp_Mmp {

# Help Text for ARM Platform, lists out the MMP keywords used incase of ARM Compiler

	if($PlatName eq "ARMV5" || $PlatName eq "ARMV5_ABIV2" || $CustomizedARMV5Plat)

	{

		return &Armutl_Help_Mmp;

	}

	else

	{

		return "";

	}

}

my $ToolChainIncDir;

my @ToolChainLibList;

my $ArmRT = 0;

my %AsmFiles = ();

my %AsmDirs = ();

my $NamedSymLkup = 0;

my $InterWorking = '';

sub PMPlatProcessMmp (@) {

	&InitToolChain(@_);

	$ToolChainIncDir = &GetToolChainIncDir;

	&main::SetStdIncPaths($ToolChainIncDir);

	@ToolChainLibList = &GetLibList;

# Variable to check if the target forms part of the run time libraries, if it is so

# shouldn't be linked against itself or other runtime libs

	$ArmRT = &IsTargetRT;

	my @AsmFileList = &GetToolChainAsmFileList;

	foreach (@AsmFileList) { $AsmFiles{ucfirst lc $_} = 1; }

}

my $preinclude;

my $Makecmd;

sub PMStartBldList($) {

	($Makecmd) = @_;

	my $ABI=&main::ABI;

	my $BaseTrg=&main::BaseTrg;

	my $BasicTrgType=&main::BasicTrgType;

	my @BldList=&main::BldList;

	my @ChopSysIncPaths=&main::Path_Chop(&main::SysIncPaths);

	my @ChopUserIncPaths=&main::Path_Chop(&main::UserIncPaths);

	my $DefFile=&main::DefFile;

	my $EPOCPath=&main::EPOCPath;

	my $LinkAs=&main::LinkAs;

	my $LibPath=&main::LibPath.'LIB\\';

	my @MacroList=&main::MacroList();

	push @MacroList, "__SUPPORT_CPP_EXCEPTIONS__";

	push @MacroList, "__SYMBIAN_STDCPP_SUPPORT__" if ( StdCppTarget() );

  	my $Plat=&main::Plat;

  	my $Trg=&main::Trg;

  	my $TrgType=&main::TrgType;

  # This horrible change (presumably to allow GCCE to work with edll.lib etc.

  # produced by RVCT breaks SMP (and also breaks any optimized platform

  # builds such as ARMV6, and also Thumb2 builds).

  # Work round for now by conditioning the horrible change on the absence of

  # SMP in the platform definition.

  	my %PlatHash = &main::PlatRec();

  	unless ($PlatHash{SMP}) {

		my $myStatLinkPath;

		$myStatLinkPath = "$E32env::Data{LinkPath}";

		$myStatLinkPath .= "ARMV5";

		&main::SetStatLinkPath($myStatLinkPath);

	}

	my $VariantFile=&ChangeSlash(&main::VariantFile);

	my @UidList=&main::UidList;

    my $SystemTrg = &main::SystemTrg;

    my $ExportLibrary=&main::ExportLibrary;

    my $NoExportLibrary=&main::NoExportLibrary;

    # N.B. should get better way to detect kernel probably!!

    $SystemTrg = 1 if ($ExportLibrary =~ /EKERN/i);

    # N.B. should get better way to detect this

    $SystemTrg = 1 if ($Trg =~ /KSRT/i);

	my %Version = &main::Version();

	my $ExtraExportLibrary;

	my $PrimaryExportLibrary = $ExportLibrary;

	unless ($Version{explicit}) {

		$ExtraExportLibrary = $ExportLibrary;

		$ExtraExportLibrary =~ s/\{(\d|a|b|c|d|e|f){8}\}//i;

		$PrimaryExportLibrary = $ExtraExportLibrary;

	}

#	set up LinkAs

	$UidList[2]=~/^0x(.*)$/o;

	if ($1 ne '00000000') { # have to make sure than series of noughts in brackets doesn't appear in name for null uids

		$LinkAs=join '', &main::Path_Split('Base',$LinkAs),"[$1]",&main::Path_Split('Ext',$LinkAs);

	}

	# Required for .lib generation

	$InterWorking = ($ABI eq 'ARMV4') ? "" : "--inter";

	# need to add config file for makmake invocation

	my $config_file = BPABIutl_Config_Path($PlatName);

	&main::Output("\n", "include $config_file\n", "\n");

	&Generic_Header(0,$Makecmd, 1);	# define standard things using absolute paths and request that a make function

									# is provided to provide optional conversion of absolute paths to Unix slashes

# modified start: makefile improvement 

	&main::Output(

		"CHECKVMAP : CHECKVMAPUDEB CHECKVMAPUREL",

		"\n"

	);

# modified end: makefile improvement 

	if ($Makecmd eq "nmake") {

		&main::Output(

			"\n",

  			"PATH=",&main::Path_Drive,$EPOCPath,"gcc\$(PBUILDPID)\\bin;\$(PATH)\n",

			"\n"

		);

	}

	else {

		&main::Output(

			"\n",

			"# must set both PATH and Path to make it work correctly\n",

  			"Path:=",&main::Path_Drive,$EPOCPath,"gcc\$(PBUILDPID)\\bin;\$(Path)\n",

			"PATH:=\$(Path)\n",

			"\n"

		);

	}

	if ($BasicTrgType=~/^(DLL|EXE)/o)

	{

		my $OtherLinkerOpts;

		my $toolchain = getConfigVariable('COMPILER_PLAT');

		# In case of GCCE releases, '--map' option was supported only from build 3.4.3 Q1C release

		# Hence this is a special case, where GCCE platform is checked to ensure that the --map option

		# is accepted in the correct relase. Even if the option is provided in the config file, it will be

		# ignored for versions before 3.4.3 Q1C 2005 release.

		# Check to be included in the Makefile, so that the map filename is provided as input only

		# when the MAP option is supplied

		&main::Output("ifdef LINKER_SYMBOLS_MAP_OPTION\n");

		foreach (@BldList)

			{

			&main::Output("\t$_"."_MAP_FILE=\"\$(EPOCTRG$_)\\".&main::Trg($_).".map\"\n");

			}

		&main::Output("else\n");

		foreach (@BldList)

			{

			&main::Output("\t$_"."_MAP_FILE=\n");

			}

		&main::Output("endif\n");

		#	In some compiler toolchains, the start address may be required to be provided using the appropriate option.

		#	Incase if the option is provided by the toolchain, then pass we need to pass in the start address.

		&main::Output(

			"\nifdef CODE_SEGMENT_START\n",

			"\tCODE_SEGMENT_START += 0x8000 \n",

			"endif\n",

		);

		# In some compiler toolchain, the symboled archives may have to be listed

		&main::Output(

			"ifdef START_GROUP_SYMBOL\n",

			"\tEEXE_OBJECT=\$(START_GROUP_SYMBOL)UC_EXE_.o\$(END_GROUP_SYMBOL)\n",

			"\tEDLL_OBJECT=\$(START_GROUP_SYMBOL)UC_DLL_.o\$(END_GROUP_SYMBOL)\n",

			"\tDENTRY_OBJECT=\$(START_GROUP_SYMBOL)D_ENTRY_.o\$(END_GROUP_SYMBOL)\n",

			"\tLENTRY_OBJECT=\$(START_GROUP_SYMBOL)L_ENTRY_.o\$(END_GROUP_SYMBOL)\n",

			"\tXENTRY_OBJECT=\$(START_GROUP_SYMBOL)X_ENTRY_.o\$(END_GROUP_SYMBOL)\n",

			"\tVENTRY_OBJECT=\$(START_GROUP_SYMBOL)V_ENTRY_.o\$(END_GROUP_SYMBOL)\n",

			"\tKENTRY_OBJECT=\$(START_GROUP_SYMBOL)K_ENTRY_.o\$(END_GROUP_SYMBOL)\n",

			"endif\n\n"

		);

		# put the extra linker options from MMP file into the linker flags

		$OtherLinkerOpts=&main::LinkerOption($toolchain);

		if($OtherLinkerOpts) {

			&main::Output(

				"\n# ADDITIONAL LINKER OPTIONS\n",

				"ifdef SYMBIAN_UREL_LINK_FLAGS\n",

				"\tSYMBIAN_UREL_LINK_FLAGS += $OtherLinkerOpts \n",

				"else\n",

				"\tSYMBIAN_UREL_LINK_FLAGS = $OtherLinkerOpts \n",

				"endif\n",

				"ifdef SYMBIAN_UDEB_LINK_FLAGS\n",

				"\tSYMBIAN_UDEB_LINK_FLAGS += $OtherLinkerOpts \n",

				"else\n",

				"\tSYMBIAN_UDEB_LINK_FLAGS = $OtherLinkerOpts \n",

				"endif\n\n"

			);

		}

	}

	&main::Output(

		"INCDIR ="

	);

	PrintList("\"  \\\$(INCLUDE_OPTION) \$_\"", @ChopUserIncPaths);

	PrintList("\" \\\$(INCLUDE_OPTION) \$_\"", @ChopSysIncPaths);

	$ToolchainIncDir = &GetToolChainIncDir;

	if($ToolchainIncDir ne '')

	{

		&main::Output(

			" \$(INCLUDE_OPTION) ","\"$ToolchainIncDir\"");

	}

	&main::Output(

		"\n",

		"\n"

	);

	#Function call logger takes -I as include option

	my $FCLogger_inc_option = getConfigVariable('FC_LOGGER_INCLUDE_OPTION'); 

	if ($Function_Call_Logger)	{

		&main::Output(

			"INCDIR_FCLOGGER  ="

		);

		PrintList("\" $FCLogger_inc_option \$_\"", @ChopUserIncPaths);

		PrintList("\" $FCLogger_inc_option \$_\"", @ChopSysIncPaths);

		$ToolchainIncDir = &GetToolChainIncDir;

		if($ToolchainIncDir ne '')	{

			&main::Output(

				" $FCLogger_inc_option \"$ToolchainIncDir\""

			);

		}

		&main::Output(

			"\n",

			"\n"

		);

	}

  	# Set control warnings and errors options for building Standard C++ application

  	if( StdCppTarget() ) {

  		&main::Output("CC_WARNINGS_CONTROL_OPTION=\$(CC_STDCPP_WARNINGS_CONTROL_OPTION)","\n");

  		&main::Output("CC_ERRORS_CONTROL_OPTION=\$(CC_STDCPP_ERRORS_CONTROL_OPTION)","\n");

  		&main::Output("\n",	"\n");

  	}

	Read_BSF_Options() if ($plat{'CUSTOMIZES'});

	my $kernelOption=0;

	my $buildAsArmOption=0;

	my $thumbOption=0;

	if (SysTrg())

	{

		$kernelOption=1;

	}

	elsif (main::BuildAsARM() or ($ABI eq 'ARMV4'))

	{

		$buildAsArmOption=1;

	}

	else

	{

		$thumbOption=1;

	}

	my $OtherOpts = undef;	

	my $toolchain = getConfigVariable('COMPILER_PLAT');

	$OtherOpts = &main::CompilerOption($toolchain);

	if($kernelOption==1)

	{

		if(@kernelOptions) {

# Kernel options as read from BSF file (KERNEL_OPTIONS keyword)

			Set_BSF_Options('KERNEL_OPTIONS',\@kernelOptions);

		}

		$OtherOpts .= " \$(KERNEL_OPTIONS) ";

	}

	elsif($buildAsArmOption==1)

	{	

		if(@armOptions) {

# Arm options as read from BSF file (ARM_OPTIONS keyword)

			Set_BSF_Options('ARM_OPTIONS',\@armOptions);

		}

		$OtherOpts .= " \$(ARM_OPTIONS) ";

	}

	elsif($thumbOption==1)

	{

		if(@thumbOptions) {

# Thumb options as read from BSF file (THUMB_OPTIONS keyword)

			Set_BSF_Options('THUMB_OPTIONS',\@thumbOptions);

		}

		$OtherOpts .= " \$(THUMB_OPTIONS) ";

	}

	if($thumbOption==1 || $buildAsArmOption==1 || $kernelOption ==1 )

	{

		if (&main::ARMFPU && (&main::ARMFPU =~ /^VFPV2$/i))

		{

			$OtherOpts .=	" \$(VFP2MODE_OPTION) ";

		}

		else

		{

			$OtherOpts .=	" \$(SOFTVFPMODE_OPTION) ";

		}

	}

	if ($thumbOption==1)

	{

		$OtherOpts .= " \$(COMPILER_THUMB_DEFINES) ";

	}

	$OtherOpts .= " \$(COMPILER_INTERWORK_DEFINES) ";

	# Options to export symbols by default, for OE

	if($TrgType=~/^STDDLL$/o || $TrgType=~/^STDEXE$/o || $TrgType=~/^STDLIB$/o) {

		$OtherOpts .= " \$(OE_OPTIONS) ";

	}

	if($OtherOpts)

	{

		&main::Output(

			"OTHEROPTIONS=$OtherOpts",

			"\n",

			"CCFLAGS += \$(OTHEROPTIONS)",

			"\n"

		);

	}

	if(@invariantOptions) {

# Invariant options as read from BSF file (INVARIANT_OPTIONS keyword)

		Set_BSF_Options('INVARIANT_OPTIONS',\@invariantOptions);

	}

	if(@commonOptions) {

# Common options as read from BSF file (COMMON_OPTIONS keyword)

		Set_BSF_Options('COMMON_OPTIONS',\@commonOptions);

	}

	if(@linkerOptions) {

# Linker options as read from BSF file (LD_OPTIONS keyword)

		Set_BSF_Options('LD_OPTIONS',\@linkerOptions);

	}	

	if ($BasicTrgType=~/^LIB$/o) {

		if(@archiverOptions) {

# Archiver options as read from BSF file (AR_OPTIONS keyword)

		Set_BSF_Options('AR_OPTIONS',\@archiverOptions);

		}

	}		

	if(@debugFormat) {

		Set_BSF_Options('DEBUG_FORMAT',\@debugFormat);

	}	

	&main::Output(

		"CCDEFS = \$(COMPILER_DEFINES) "

	);

	PrintList("\" -D\$_\"", @MacroList);

	&main::Output(

		" \$(PLATFORM_DEFINES) "

	);

	&main::Output(

	);

	if($kernelOption==1)

	{

		&main::Output(

			"-D__KERNEL_MODE__ "

		);

	}

	if($VariantFile){

		#Function Call Logger