# Copyright (c) 2001-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:

# Makmake-module for creating XML files which can be imported as CodeWarrior IDE projects

# 

#

package Ide_cw;

my $CW_minimum_supported_version = 2.8;

# declare variables global for module

my $BaseAddress="";

my %IdeBlds=();

my %PrjHdrs=();

my @Win32LibList=();

my $Win32Resrc;

my $Win32StdHeaders;

my $ExtraFilesPath="";

my @KnownRoots=();

my @addedFiles=();

my $addHeaders = 1;

my $addDocuments = 1;

my %processedPlatforms;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMCheckPlatformL

	PMPlatProcessMmp

	PMStartBldList

		PMBld

			PMResrcBld

	PMEndSrcList

);

require Cl_bpabi;

use strict;

use BPABIutl;

use E32Variant;

use E32Plat; 

use Winutl;

use Armutl;

use Pathutl;

use Win32API::Registry qw( :ALL );

use Preprocessor;

use RVCT_plat2set;

sub PMHelp_Mmp {

	&Winutl_Help_Mmp;

}

my $RVCTMajorVersion = Armutl_RVCTMajorVersion();

my $RVCTMinorVersion = Armutl_RVCTMinorVersion();

my $RVCTVersion = "${RVCTMajorVersion}_${RVCTMinorVersion}";

my $oP = "--";

$oP = "-" if ($RVCTMajorVersion == 2 && $RVCTMinorVersion < 2);

my $cfgMacro = &Variant_GetMacro();

use FindBin;

use lib $FindBin::Bin."\\perllib";

#use the DOM xml module

use XML::DOM;

my $projectTemplate;

my $linkDescriptorTemplate;

my $xmlParser;

my $xmlProjectDoc;

my $xmlLinkDescriptorDoc;

my $xmlLinkDescriptorCommandParent;

my $xmlLinkDescriptorSymbolParent;

my $xmlLinkDescriptorDumpFileParent;

my $xmlLinkOrder;		# for accumulating the link order

my $xmlFileList;		# for accumulating the file list

my $xmlSourceGroup;		# for accumulating the source

my $xmlHeadersGroup;	# for accumulating local header files

my $xmlRootGroup;		# for accumulating files to be added outside of project groups

my $xmlLinkGroup;		# for accumulating the link descriptor files

my $xmlLibGroup;		# for accumulating the libraries

my $xmlResourcesGroup;	# for accumulating resource related files

my $xmlDocumentsGroup;	# for accumulating supported files specified with DOCUMENT in the .mmp file

my $MmpFile;

my $VariantFile;

my $PrefixFile;

my $CW_major_version;

my $CW_minor_version;

my $CW_libpath;

my @CW_librarypath;

my @ToolChainLibList;

# Hash to store configuration makefile data for furthur processing

my %configdata;

sub RoundUp1k($) {

	# Accept C hexadecimal number (0xNNN).  Convert argument to Kb

	# rounded up to the next 1kb boundary.

	use integer;

	return (hex($_[0]) + 1023) / 1024;

}

use Genutl;

use cl_generic;

my $ToolPrefix='';

my $HelperLib='';

my %PlatOpt=(

	'Dlltool'=>'',

	'Entry'=>'-e',

	'Gcc'=>'',

	'Ld'=>'',

	'Petran'=>'',

	'Optimize'=>'-O'

);

my $Dlltool;

my $Archive;

my $Link;

my $Objcopy;

my %CompatibleABIs=(

	ARMI=>['ARM4', 'THUMB'],

	ARM4=>['ARMI'],

	THUMB=>['ARMI'],

	ARMV5=>['ARMV5_ABIV1'],

	GCCE=>['GCCE'],

	BPABI=>['ARMV5_ABIV2']

);

my @CompatibleABIs;

my $Makecmd;

my %ABILibPath=();

sub SystemTarget() {

	return 1 if &main::SystemTrg;

	my $ExportLibrary=&main::ExportLibrary;

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

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

	return 0;

}

sub SysTrg () {

	return 1 if &main::SystemTrg;

	my $ExportLibrary=&main::ExportLibrary;

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

	my $Trg=&main::Trg;

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

	return 0;

}

sub PMUnderlyingABI($) {

	my ($ABI) = @_;

	if ($ABI eq 'ARM4T') {

		if (&main::BuildAsARM) {

			return 'ARMI';

		}

		elsif (SystemTarget()) {

			return 'ARM4';

		}

		else {

			return 'ARMV4';

		}

	}

	return $ABI;

}

##### ARMV5 specific options #####

my $diag_suppressions;

my $diag_warnings;

my $diag_errors;

#The options here are handcoded for ABIV1 mode.

my $contingentOptions;

my $exceptions = ' --exceptions --exceptions_unwind';

my $thumbOptions = '--thumb ';

my $armOptions = '--arm ';

my $kernelOptions = '--arm --no_exceptions --no_exceptions_unwind';

my $invariantOptions = 

  '--cpu 5T --enum_is_int -Ono_known_library --fpmode ieee_no_fenv --export_all_vtbl --no_vfe --apcs /inter';

$invariantOptions .= ' --dllimport_runtime' unless ($RVCTMajorVersion == 2 && $RVCTMinorVersion < 2);  

# specify floating point model here

my $floatingpointmodel = "softvfp";

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

	$floatingpointmodel = "vfpv2";

}

my $floatingpoint = ' --fpu '.$floatingpointmodel.'';

# Set compiler settings

$diag_suppressions = '--diag_suppress 66,161,611,654,997,1152,1300,1464,1488,6318,6331';

$diag_warnings = '';

$diag_errors = '--diag_error 1267';

my $commonOptions = "$diag_suppressions $diag_warnings $diag_errors";  

# variables added to fetch the options from the BSF files

my @commonOptions;

my @thumbOptions;

my @armOptions;

my @kernelOptions;

my @invariantOptions;

my @linkerOptions;

my @archiverOptions;

my $linkCommand = "";		

# variables to process and store the default and BSF file options

my $invopts = $invariantOptions;

my $linkeropts;

my $archiveropts;

#varible to store the BSF add options

my $bsfaddoptions = undef;

#variable to store the compiler flags, defs and other options

my $CCFLAGS = undef;

my $CCDEFS = undef;

my $CCUREL = undef;

my $CCUDEB = undef;

#GCCE specific OPIONS

my $GCCE_CompilerOption = '-march=armv5t -mthumb-interwork -mapcs';

$GCCE_CompilerOption .= " -msoft-float -fexceptions -pipe -nostdinc -Wall -Wno-ctor-dtor-privacy -Wno-unknown-pragmas";

#Flag to check for the customized GCCE platform

my $CustGCCE=0;

#Variable to fetch the Customized platform

my %CustPlat=&main::PlatRec;

#Flags to read the options

my $kernelOption=0;

my $buildAsArmOption=0;

my $thumbOption=0;

my $ArmIncDir;

my @ArmLibList;

my $ArmRT;

my %BSF_keywords = (

		    COMMON_OPTIONS => 1,

		    THUMB_OPTIONS => 1,

		    ARM_OPTIONS => 1,

		    KERNEL_OPTIONS => 1,

		    INVARIANT_OPTIONS => 1,

			LD_OPTIONS => 1,

			AR_OPTIONS => 1

		   );

sub PMStartBldList($) 

{

	($Makecmd) = @_;

	my @BldList=&main::BldList;

	my $BasicTrgType=&main::BasicTrgType;

	my $ABI=&main::ABI;

	my $kernelOption=0;

	my $buildAsArmOption=0;

	my $thumbOption=0;

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

	push @MacroList, "__SUPPORT_CPP_EXCEPTIONS__ ";

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

	$CCFLAGS = "";

	$CCDEFS = "";

	$CCUREL = "";

	$CCUDEB = "";

	$VariantFile=&main::VariantFile();	

	#read the configuration make file into the hash for only the BPABI platforms

	my $config_file = BPABIutl_Config_Path(&main::Plat);

	if ($config_file) {

		collect_config_data($config_file);

	}

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

	if (SysTrg()) {

		$kernelOption=1;

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

		$buildAsArmOption=1;

	} else {

		$thumbOption=1;

	}

	my $OtherOpts = undef;

	my $toolchain = $configdata{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 .= " ".fetch_config_data($configdata{KERNEL_OPTIONS});

	}

	elsif($buildAsArmOption==1)

	{	

		if(@armOptions) {

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

			Set_BSF_Options('ARM_OPTIONS',\@armOptions);

		}

		$OtherOpts .= " ".fetch_config_data($configdata{ARM_OPTIONS});	

	}

	elsif($thumbOption==1)

	{

		if(@thumbOptions) {

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

			Set_BSF_Options('THUMB_OPTIONS',\@thumbOptions);

		}

		$OtherOpts .= " ".fetch_config_data($configdata{THUMB_OPTIONS});

	}

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

	{

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

		{

			$OtherOpts .= "	".$configdata{VFP2MODE_OPTION};

		}

		else

		{

			$OtherOpts .= "	".$configdata{SOFTVFPMODE_OPTION};

		}

	}

	if ($thumbOption==1)

	{

		$OtherOpts .= "	".$configdata{COMPILER_THUMB_DEFINES};

	}

	$OtherOpts .= "	".$configdata{COMPILER_INTERWORK_DEFINES};

	if((&main::Plat eq "ARMV5_ABIV1") || (&main::Plat eq "ARMV5" && !$cfgMacro)

	|| ($CustPlat{'CUSTOMIZES'} 

	&& (($CustPlat{'ROOTPLATNAME'} eq "ARMV5_ABIV1" && $cfgMacro) 

	|| ($CustPlat{'ROOTPLATNAME'} eq "ARMV5" && !$cfgMacro)))) {

		ComputeCompilerOpts();

	}

	elsif($config_file) {

		$CCFLAGS = &Cl_bpabi::getConfigVariable('CCFLAGS');

	}

	$CCFLAGS .= $OtherOpts;

	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)

	{

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

		Set_BSF_Options('LD_OPTIONS',\@linkerOptions);

	}

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

		if(@archiverOptions)

		{

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

			Set_BSF_Options('AR_OPTIONS',\@archiverOptions);

		}	

	}

	if($bsfaddoptions)

	{

		fixbsfoptions($bsfaddoptions);

	}

	$CCFLAGS .= $bsfaddoptions;

	$CCDEFS = $configdata{COMPILER_DEFINES};

	$CCDEFS .= printlist("-D", @MacroList);

	$CCDEFS .= $configdata{PLATFORM_DEFINES};

	if($kernelOption==1)

	{

		$CCDEFS .= -D__KERNEL_MODE__;

	}

	if($VariantFile) { 

		$CCDEFS .= " -D__PRODUCT_INCLUDE__="."\\\"".&main::Path_Split('File',$VariantFile)."\\\"";

	}

	foreach (@BldList) 

	{

		if($kernelOption == 0)

		{

			if (/DEB$/o) {

				$CCUDEB .= " ".$configdata{EXCEPTIONS};

			}

			else {

				$CCUREL .= " ".$configdata{EXCEPTIONS};

			}

		}

		#collect the options and macro's depending on the whether it is a UREL or UDEB		

		my @ml = &main::MacroList($_);

		if (/DEB$/o) {

			$CCUDEB .= " ".$CCFLAGS;

			$CCUDEB .= printlist("-D", @ml);

			$CCUDEB .= " ".$CCDEFS;

		}

		else {

			$CCUREL .= " ".$CCFLAGS;

			$CCUREL .= printlist("-D", @ml);

			$CCUREL .= " ".$CCDEFS;

		}

	}

}

sub ComputeCompilerOpts() {

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

	my $ABI=&main::ABI;

	my $TrgType=&main::TrgType;

	if (SysTrg()) {

	        $contingentOptions = $kernelOptions;

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

	        $contingentOptions = $armOptions.$floatingpoint.$exceptions;

	    } else {

			$contingentOptions = $thumbOptions.$floatingpoint.$exceptions.' -D__MARM_THUMB__';	

	}

	# change support for ARMV4

	if ($ABI eq 'ARMV4') {

		$invopts =~ s/5T/4/;

		$invopts =~ s/inter/nointer/;

	} else {

		$contingentOptions .= ' -D__MARM_INTERWORK__';

	}

	$CCFLAGS = $commonOptions.' '.$contingentOptions.' '.$invopts.' -c '.' '.&main::CompilerOption("ARMCC");

}

sub GetMajorVersion ($)

	{

	my ($versionString) = @_;

	if ($versionString =~ /^\d\.\d\.\d$/)

		{

		$versionString =~ s/\.\d$//;

		}

	return $versionString;

	}

sub GetMinorVersion ($)

	{

	my ($versionString) = @_;

	if ($versionString =~ /^\d\.\d\.\d$/)

		{

		$versionString =~ s/^\d\.\d\.//;

		}

	else

		{

		$versionString = 0;

		}

	return $versionString;

	}

sub PMCheckPlatformL {

	# check version of CodeWarrior for Symbian OS

	my @compatibleCWInstallations;

	$CW_major_version = 0;

	$CW_minor_version = 0;

	my $minimumMajorVersion = GetMajorVersion ($CW_minimum_supported_version);

	my $minimumMinorVersion = GetMinorVersion ($CW_minimum_supported_version);

	if (defined $ENV{CW_SYMBIAN_VERSION})

		{

		# CW_SYMBIAN_VERSION is set - either MAKMAKE is being executed by an IDE's .mmp Importer,

		# or the user is specifying a specific CW version to target from the command line.

		# Either way, we've been given a single version to target, so we attempt to do just that.

		$CW_major_version = GetMajorVersion ($ENV{CW_SYMBIAN_VERSION});

		$CW_minor_version = GetMinorVersion ($ENV{CW_SYMBIAN_VERSION});

		push @compatibleCWInstallations, $ENV{CW_SYMBIAN_VERSION};

		}

	else

		{

		# CW_SYMBIAN_VERSION isn't set - either MAKMAKE is being executed by a pre-OEM3.0 IDE .mmp

		# Importer or from the command line.  Either way, we delve into the registry and attempt to

		# target the latest CW for Symbian OS installed, recording all CW for Symbian OS installations

		# too.

		my $regKeyHandle;

		my $topLevelKey = HKEY_LOCAL_MACHINE;

		my $productVersionKey = 'SOFTWARE\\Metrowerks\\CodeWarrior\\Product Versions';

		if (!RegOpenKeyEx($topLevelKey, $productVersionKey, 0, KEY_READ, $regKeyHandle))

			{		    		

			die "Can't read \"HKEY_LOCAL_MACHINE\\$productVersionKey\" : ", regLastError(), "\n";

		    }

		my $subKeyIndex = 0;

		my $subKeySize = 0;

		my $subKeyName;

		my @installedCWForSymbianKeys;

		while (RegEnumKeyEx($regKeyHandle, $subKeyIndex, $subKeyName, $subKeySize, [], [], [], []))

			{

			push (@installedCWForSymbianKeys, $productVersionKey."\\".$subKeyName) unless ($subKeyName !~ /Symbian/);