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

#

package Cl_codewarrior;

# declare variables global for module

my @Win32LibList=();

my $Win32StdHeaders;

my $BaseAddressFlag;

my $Win32Resrc;

my $MWCC;

my $MWLD;

my $MWIncludePath;

my $MWIncludeVar;

my $CWVersion;

my $CWVersionReadable;

my $CWBuildNum;

my $CWRuntimeLibs="";

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMCheckPlatformL

	PMPlatProcessMmp

	PMPlatCheckSource

	PMStartBldList

		PMBld

	PMStartSrcList

		PMBitMapBld

		PMResrcBld

		PMAifBld

		PMStartSrc

		PMSrcDepend

			PMSrcBldDepend

			PMEndSrcBld

		PMEndSrc

	PMEndSrcList

);

use strict;

use Winutl;

use cl_generic;

use E32Variant;

my $NamedSymLkup = 0;

my $stdcpp_tag_file = 'tag_coff';

my $stdcpp_tag_path = '$(EPOCROOT)epoc32\tools\tag';

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;

}

sub PMHelp_Mmp {

	&Winutl_Help_Mmp;

}

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 PMCheckPlatformL {

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

	# check version of CodeWarrior for Symbian OS

	if (defined($ENV{MWCSym2Includes})) {

		$MWCC = "mwccsym2.exe";

		$MWLD = "mwldsym2.exe";

	}

	if (!defined($MWCC) && defined($ENV{MWSym2Libraries})) {

		$MWCC = "mwccsym2.exe";

		$MWLD = "mwldsym2.exe";

	}

	if (!defined($MWCC) && defined($ENV{CWFolder})) {

		$MWCC = "mwcc.exe";

		$MWLD = "mwld.exe";

	}

	if (!defined($MWCC)) {

		die "ERROR: Unable to identify a valid CodeWarrior for Symbian OS installation\n";

	}

	# determine default include path

	$MWIncludeVar = 'MWCIncludes';	# default, even if it doesn't exist

	$MWIncludePath = '';			# default is empty

	foreach my $var ('MWCSym2Includes','MWCWinx86Includes','MWCIncludes') {

		if (defined($ENV{$var})) {

			$MWIncludePath = $ENV{$var};

			$MWIncludeVar = $var;

			last;

		}

	}

	open PIPE, "$MWCC |", or &main::FatalError( "Failed to find version information for $MWCC \n");

	while (<PIPE>) {

		if($_ =~ /Version\s+(\d+)\.(\d+)\.(\d+)\s+build\s+(\d+)/) {

			my $MajorVer = $1;

			my $MinorVer = $2;

			my $PatchNum = $3;

			$CWBuildNum = $4;

            $CWVersionReadable = "$1.$2.$3 build $4";

#			The CW compiler documentation says that the compiler version is a 2-byte value as

#			0xMnpp (the corresponding CW's pre-defined macro is __MWERKS__), where,

#				M is the major version number (which means it is accomodated in the first 4 bits, 

#				n is the minor version number (which means it is accomodated in the next 4 bits, 

#				pp is the patch number (which means it is accomodated in the next 8 bits.

#			Here, an integer is formed from these 3 values to uniquely identify the compiler version.

			$CWVersion = ($MajorVer << 12) + ($MinorVer << 8) + $PatchNum;

			last;

		}

	}

	close PIPE;

	if ($IsProxyWrapperOption){

		$MWCC = "$ENV{ABLD_COMPWRAP} " . $MWCC;

		$MWLD = "$ENV{ABLD_COMPWRAP} " . $MWLD;

	}

}

sub PMPlatProcessMmp (@) {

	&Winutl_DoMmp(\@_, $MWIncludePath);

	$BaseAddressFlag=&Winutl_BaseAddress;

	if ($BaseAddressFlag ne "") {

		$BaseAddressFlag=" -imagebase \"$BaseAddressFlag\"";

	}

	@Win32LibList=&Winutl_Win32LibList;

	$Win32Resrc=&Winutl_Win32Resrc;

	$Win32StdHeaders=&Winutl_Win32StdHeaders;

}

sub PMPlatCheckSource () {

	&Winutl_CheckSourceMMPMetaData ();

}

sub PMStartBldList($) {

	my ($makecmd) = @_;

	my $AifStructRef=&main::AifStructRef;

	my $BaseTrg=&main::BaseTrg;

	my $BitMapStructRef=&main::BitMapStructRef;

	my @BldList=&main::BldList;

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

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

	my $ExportLibrary=&main::ExportLibrary;

	my $NoExportLibrary=&main::NoExportLibrary;

	my $DefFile=&main::DefFile;

	my $BasicTrgType=&main::BasicTrgType;

	my $LibPath=&main::LibPath;

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

	push @MacroList, "__SUPPORT_CPP_EXCEPTIONS__";

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

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

	my $ResourceStructRef=&main::ResourceStructRef;

	my $Plat=&main::Plat;

	my $Trg=&main::Trg;

	my $TrgType=&main::TrgType;

	my $WarningLevel=&main::CompilerOption("CW");

	my $LinkAs=&main::LinkAs;

	Generic_Header(0,$makecmd);	# define standard things using absolute paths

	my $TrgDir="";

	my $AifTrgDir="";

	if (&Generic_Definition("TRGDIR") ne "") {

		$TrgDir="\$(TRGDIR)\\";

		$AifTrgDir=$TrgDir;

	}

# Handle migration of binaries to secure location

	&Winutl_AdjustTargetPath(\$TrgDir);

# Change - mwwinrc.exe uses MWWinx86Includes or MWCIncludes, but some installations

# fail to install either. Set MWCIncludes from the chosen variable as part

# of the Makefile.

	if (!defined($ENV{MWCIncludes}) && $MWIncludeVar ne 'MWCIncludes') {

		&main::Output(

			"\n",

			"MWCIncludes:=\$($MWIncludeVar)\n",

			"export MWCIncludes\n",

			"\n"

		);

	}

	if( ($CWVersion == 0x3205 && $CWBuildNum == 465)){

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

		&main::Output(

				"\n",

				"MWSym2LibraryFiles:=msl_all_mse_symbian_d.lib;gdi32.lib;user32.lib;kernel32.lib;\n",

				"export MWSym2LibraryFiles\n",

				"\n"

			);

		}

		else {

			&main::Output(

				"\n",

				"MWSym2LibraryFiles:=msl_all_static_mse_symbian_d.lib;gdi32.lib;user32.lib;kernel32.lib;\n",

				"export MWSym2LibraryFiles\n",

				"\n"

			);

		}

	}

	if($WarningLevel =~ /\-cwd\s\s*include/){	

		&main::Output(

			"# EPOC DEFINITIONS\n",

			"\n",

			"INCDIR  = -cwd include -i-"

		);

	}

	else {

		&main::Output(

			"# EPOC DEFINITIONS\n",

			"\n",

			"INCDIR  = -cwd source -i-"

		);

	}

	foreach (@ChopUserIncPaths,@ChopSysIncPaths) {

		&main::Output(

			" \\\n -i \"$_\""

		);

	}

	use Pathutl;

	if($VariantFile){

	    my $variantFilePath = Path_Split('Path',$VariantFile);

	    $VariantFile  = Path_Split('FILE',$VariantFile);

	    # workaround for codewarrior defect:

	    # codewarrior at the moment doesn't accept an absolute path with the

	    # the -include option unless it contains a drive letter, this is solved

	    # by including the directory and the file separately

	    &main::Output("\\\n -i \"$variantFilePath \" -include \"$VariantFile\"");

	}

	&main::Output(

		"\n",

		"\n"

	);

	&main::Output(

		"CWFLAGS ="		

	);

	# 'wchar_t' should be treated as default datatype for OE targets because when wchar_t option is turned off, 

	# using 'wchar_t' defaults to the unsigned short int and wrong functionality. 

	if ( $TrgType =~ /^(STDEXE|STDDLL|STDLIB)$/io || StdCppTarget() ) 

	{

		&main::Output(

			" -wchar_t on"

		);	

	}

	else 

	{

		&main::Output(

			" -wchar_t off"

		);

	}

	&main::Output(		

		" -align 4",		# long alignment

		" -warnings on",	# selection of warnings

		" -w nohidevirtual",	# turn off "hides inherited virtual function" warning

		   ",nounusedexpr",	# turn off "expression has no side effect" warning

		" -msgstyle gcc",	# use GCC-style message format

		# " -strict on",		# strict ANSI/ISO C++ checking

		" -enum int",		# use int for enumeration types

		" -str pool",		# pool strings into a single data object

		" -exc ms",			# SEH C++ exception implementation

		" -trigraphs on",		# Enable recognition of C-style trigraphs, e.g. '??/' -> '\'

		" $WarningLevel"		

	);

	if ($Win32StdHeaders or &main::Plat eq 'TOOLS') {

		&main::Output(

			" -stdinc"		# insist because mwccsym2 has -nostdinc as the default(?)

		);

	}

	else {

		&main::Output(

			" -nostdinc"	# insist because mwcc has -stdinc as the default.

		);

	}

	&main::Output(

		"\n",

		"\n"

	);

	&main::Output(

		"CWDEFS  = "

	);

	foreach(@MacroList) {

		&main::Output(

			" -d \"$_\""

		);

	}

	&main::Output(

		" \$(USERDEFS)\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"CW$_ = $MWCC"

		);

		if (/DEB$/o) {

			&main::Output(

				' -g -O0'   # debug information, no optimisation

			);

#			euser change to apply inlining on the _NAKED functions

#			stdexe/stddll change so that the inline functions dont 

#			get exported (in debug build) causing a different export list for debug and release builds

			if ($BaseTrg!~/^EUSER$/oi && $TrgType !~ /^(STDEXE|STDDLL)$/io) {

				&main::Output(

					' -inline off'

				);

			}	

		}

		elsif (/REL$/o) {

			&main::Output(

				' -O4,s'	# highest level of optimisation, optimise for space

			);

		}

		if( ($CWVersion == 0x3205 && $CWBuildNum >= 465) || $CWVersion > 0x3205){

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

				&main::Output(

					' -runtime dllmulti'

				);

			}

			else {

				&main::Output(

					' -runtime staticmulti'

				);

			}

		}

		&main::Output(

			' $(CWFLAGS)'

		);

		foreach (&main::MacroList($_)) {

			&main::Output(

				" -d $_"

			);

		}

		&main::Output(

			" \$(CWDEFS) \$(INCDIR)\n"

		);

	}

	&main::Output(

		"\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"$_ :"

		);

		if ($BasicTrgType !~ /IMPLIB/io) {

			&main::Output (

				" \\\n",

				"\t", &Generic_Quote("\$(EPOCTRG$_)\\$TrgDir$Trg")

			);

			if (&Winutl_CopyForStaticLinkage) {

				&main::Output(

					" \\\n",

					"\t", &Generic_Quote("\$(EPOCTRG$_)\\$Trg")

				);

			}

		}

#		lib has to come after the main target so that a .DEF file will be generated if the project is not frozen

		if ($DefFile and not &main::ExportUnfrozen) {

			&main::Output(

				" \\\n",

				"\tLIBRARY\n"

			);

		}

		&main::Output(

			"\n",

			"\n"

		);

	}

	foreach (@BldList) {

		my $makework="MAKEWORK$_";

		&main::Output(

			"\n",

			"RESOURCE$_ : $makework"

		);

		my $BitMapRef;

		foreach $BitMapRef (@$BitMapStructRef) {

			my $file="\$(EPOCTRG$_)\\$$BitMapRef{TrgPath}$$BitMapRef{Trg}";

			&Generic_MakeWorkFile($makework,$file);

			&main::Output(

				" \\\n",

				"\t", &Generic_Quote($file)

			);

		}

		undef $BitMapRef;

		my $ResourceRef;

		foreach $ResourceRef (@$ResourceStructRef) {

			if(! defined $$ResourceRef{Hdronly}) {

				my $file="\$(EPOCTRG$_)\\$$ResourceRef{Trg}";

				&Generic_MakeWorkFile($makework,$file);

				&main::Output(	# must come before main target because source for target will depend on the

				" \\\n",		# *.rsg file in $EPOCIncPath

				"\t", &Generic_Quote("$file")

				);

			}

		}

		undef $ResourceRef;

		my $AifRef;

		foreach $AifRef (@$AifStructRef) {

			my $file="\$(EPOCTRG$_)\\$AifTrgDir$$AifRef{Trg}";

			&Generic_MakeWorkFile($makework,$file);

			&main::Output(

				" \\\n",

				"\t", &Generic_Quote($file)

			);

		}

		undef $AifRef;

		&main::Output(

			"\n"

		);

	}

	&main::Output(

		"\n",

		"\n",

	);

	&main::Output(

		"\n",

		"# REAL TARGET - LIBRARY\n",

		"\n",

		"LIBRARY : MAKEWORKLIBRARY"

	);

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

#		code to ensure that the static libraries for all builds are built at the library stage

		foreach (@BldList) {

			&main::Output(

				" $_"

			);

		}

	}

	elsif ($DefFile and !$NoExportLibrary) {

		unless (&main::ExportUnfrozen) {

			if (-e $DefFile) { # effectively "if project frozen ..."

				my $LibLinkAs = ($BasicTrgType=~/^IMPLIB$/io) ? $LinkAs : $Trg;

				&main::Output(

					" ", &Generic_Quote("\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib"), "\n",

					"\n",

					&Generic_Quote("\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib"), " : ",

					&Generic_Quote($DefFile), "\n",

					"\tperl -S prepdef.pl ",&Generic_Quote($DefFile)," \"\$(EPOCBLD)\\$ExportLibrary.prep.def\"\n",

					"\t$MWLD \"\$(EPOCBLD)\\$ExportLibrary.prep.def\" -importlib -o \$\@",

					" -addcommand \"out:$LibLinkAs\" -warnings off",

					"\n"

				);

			} else {

				&main::Output(

					"\n",

					"\t\@echo WARNING: Not attempting to create \"\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib\".\n",

					"\t\@echo When exports are frozen in \"$DefFile\", regenerate Makefile.\n"

				);

			}

		} else {

			&main::Output(

				"\n",

				"\t\@echo Not attempting to create \"\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib\"\n",

				"\t\@echo from frozen .DEF file, since EXPORTUNFROZEN specified.\n"

			);

		}

	}

	&main::Output(

		"\n",

		"\n",

		"FREEZE :\n"

	);

	if ($DefFile and $BasicTrgType!~/^IMPLIB$/io) {

		&main::Output(

#			call perl on the script here so nmake will die if there are errors - this doesn't happen if calling perl in a batch file

			"\tperl -w -S efreeze.pl \$(EFREEZE_ALLOW_REMOVE) \"$DefFile\" \"\$(EPOCBLD)\\$ExportLibrary.def\" \n"

		);

	}

	else {

		&main::Output( "\tperl -e \"print \\\"warning: freeze could not be supported or \\

		         you need to declare an explicitly specified def file using the keyword \\

			 DEFFILE in the MMP file!\\n\\\"\""); 

	}