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

#

package Cl_win;

# declare variables global for module

my @Win32LibList=();

my $Win32StdHeaders;

my $BaseAddressFlag;

my $Win32Resrc;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMCheckPlatformL

	PMPlatProcessMmp

	PMStartBldList

		PMBld

	PMStartSrcList

		PMBitMapBld

		PMResrcBld

		PMAifBld

		PMStartSrc

		PMSrcDepend

			PMSrcBldDepend

			PMEndSrcBld

		PMEndSrc

	PMEndSrcList

);

use strict;

use Winutl;

use cl_generic;

use Pathutl;

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 {

	if ((&main::Plat eq 'TOOLS') and (&main::BasicTrgType ne 'EXE') and (&main::BasicTrgType ne 'LIB')) {

		die "Can't specify anything but EXE or LIB targettypes for this platform\n";

	}

}

sub PMPlatProcessMmp (@) {

	&Winutl_DoMmp(\@_, $ENV{INCLUDE});

	$BaseAddressFlag=&Winutl_BaseAddress;

	$BaseAddressFlag=~s/^(.+$)$/ \/base:\"$1\"/o;

	@Win32LibList=&Winutl_Win32LibList;

	my $MSVCVer = &Winutl_MSVCVer;

	push @Win32LibList, "kernel32.lib";

	$Win32Resrc=&Winutl_Win32Resrc;

	$Win32StdHeaders=&Winutl_Win32StdHeaders;

}

sub PMStartBldList($) {

	my ($makecmd) = @_;

	die "Cannot generate $makecmd makefiles\n" if ($makecmd ne "nmake");

	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 $MSVCVer = &Winutl_MSVCVer;

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

	push @MacroList, "__SUPPORT_CPP_EXCEPTIONS__";

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

	my $Plat=&main::Plat;

	my $ResourceStructRef=&main::ResourceStructRef;

	my $Trg=&main::Trg;

	my $TrgType=&main::TrgType;

	my $defaultWarningLevel="/W4";

	my $CompilerOption=&main::CompilerOption("MSVC");

	my $LinkAs=&main::LinkAs;

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

	my $TrgDir="";

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

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

	}

	if (&main::Plat eq "WINC") {	# target path ignored under WINC

		$TrgDir="";

	}

	&main::Output(

		"INCDIR  ="

	);

	if($VariantFile){

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

        &main::Output(

              " /FI \"$VariantFileFileName\"",

              );

	}

	foreach (@ChopUserIncPaths,@ChopSysIncPaths) {

		&main::Output(

			" /I \"$_\""

		);

	}

	&main::Output(

		"\n",

		"\n"

	);

	my $MSVCVer = &Winutl_MSVCVer;

	&main::Output(

		"CLFLAGS =",

			" /nologo",			# suppress "sign-on" banner message

			" /Zp4",			# packs structures on 4 byte boundaries

			" /GF"				# Pools strings and places them in read-only memory 

		);	

	if ($MSVCVer >= 7) {

		&main::Output(

			" /wd4996",			# C4996: 'xxxx' was declared deprecated

			" /wd4571"			# C4571: catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions

		);	

		if (&main::Plat ne 'TOOLS') {

			&main::Output(

				" /EHsc",			# Exceptions on

				" /GR"				# RTTI on

			);

			if ($MSVCVer >= 8) {

				&main::Output(

					" /GS-"			# Buffer checking off

				);

			}

		} else {

			&main::Output(

				" /EHsc",			# Exceptions on

				" /GR",				# RTTI on

				" /GS"				# Buffer checking on

			);

		}

	} else {

		if (&main::Plat ne 'TOOLS') {

			&main::Output(

				" /GX",				# Exceptions on

				" /GR"				# RTTI on

			);

		}

	}

	if ($MSVCVer >= 8) {

		&main::Output(

			" /Zc:wchar_t-"				# Don't make wchar_t a built-in; breaks mangled names

		);		

	}

	if (&main::Plat ne 'TOOLS') {

		unless ($Win32StdHeaders) {

			&main::Output(

				" /X"			# ignore standard include directories

			);

		}

	}

	if ($CompilerOption !~ /\/W\d/) {

		# Supply default warning level unless /Wn already specified via OPTION MSVC

		&main::Output(

			" $defaultWarningLevel"

		);

	}

	&main::Output(

		" $CompilerOption",		# user-supplied compiler options

		"\n",

		"\n"

	);

	&main::Output(

		"CLDEFS  ="

	);

	foreach(@MacroList) {

		&main::Output(

			" /D \"$_\""

		);

	}

	if (($BasicTrgType=~/^LIB$/o) and (&main::Plat eq 'TOOLS')) {

		&main::Output(

			" /D _MT"

		); 

	}

	&main::Output(

		" \$(USERDEFS)\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"CL$_ = cl.exe"

		);

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

			&main::Output(

				' /MT'			# Creates a multi-threaded executable file, using libcmt.lib

			);

			if (/DEB$/o) {

				&main::Output(

					'd'				# i.e. /MTd or /MLd, debug executable using debug version of LIB

				);

			}

		}

		elsif (($BasicTrgType=~/^(DLL|LIB)$/o) and (&main::Plat ne 'TOOLS')){

			&main::Output(

				' /MD'			# Creates a multithreaded DLL, using MSVCRT.LIB

			);

			if (/DEB$/o) {

				&main::Output(

					'd'				# i.e. /MDd, debug executable using debug version of LIB

				);

			}

		}

		if (/DEB$/o) {

			&main::Output(

				' /Zi',			# Generates complete debugging information

				' /Od'			# Disables optimization

			);

#			euser change to apply inlining on the _NAKED functions

			if ($BaseTrg=~/^EUSER$/oi) {

				&main::Output(

					' /Ob1'		# Specific control of expension of inline functions

				);

			}

		}

		elsif (/REL$/o) {

			&main::Output(

				' /O1'				# Creates small code

			);

			if ($MSVCVer >= 8) {

				&main::Output(

					' /fp:strict'		# Improves floating-point consistency

				);

			} else {

				&main::Output(

					' /Op'				# Improves floating-point consistency

				);

			}

		}

		&main::Output(

			' $(CLFLAGS)'

		);

		if (/DEB$/o) {

			&main::Output(

				" /Fd\"\$(EPOCTRG$_)\\$TrgDir$BaseTrg.pdb\""

			);

		}

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

			&main::Output(

				" /D $_"

			);

		}

		&main::Output(

			" \$(CLDEFS) \$(INCDIR)\n"

		);

	}

	&main::Output(

		"\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"$_ :"

		);

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

			&main::Output (

				" \\\n",

				"\t\"\$(EPOCTRG$_)\\$TrgDir$Trg\""

			);

			unless (/REL$/o) {

				&main::Output(

					" \\\n",

					"\t\"\$(EPOCTRG$_)\\$BaseTrg.bsc\""

				);

			}

			if (&Winutl_CopyForStaticLinkage) {

				&main::Output(

					" \\\n",

					"\t\"\$(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\"$file\""

			);

		}

		undef $BitMapRef;

		my $ResourceRef;

		foreach $ResourceRef (@$ResourceStructRef) {

			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$_)\\$TrgDir$$AifRef{Trg}";

			&Generic_MakeWorkFile($makework,$file);

			&main::Output(

				" \\\n",

				"\t\"$file\""

			);

		}

		undef $AifRef;

		&main::Output(

			"\n"

		);

	}

	&main::Output(

		"\n",

		"\n",

	);

	&main::Output(

		"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 ..."

				&main::Output(

					" \"\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib\"\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"

			);

		}

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

		&main::Output(

			"\n",

			"\n",

			"# REAL TARGET - LIBRARY\n",

			"\n",

			"\"\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib\" : \"$DefFile\"\n",

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

			"\tlib.exe /nologo /machine:i386 /nodefaultlib /name:\"$LibLinkAs\"    /def:\"\$(EPOCBLD)\\$ExportLibrary.prep.def\" /out:\"\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib\"\n",

			"\tdel \"\$(EPOCLIB)\\UDEB\\$ExportLibrary.exp\"\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"

		);

	}

	&main::Output(

		"\n",

		"CLEANLIBRARY :\n"

	);

	if ($DefFile and !$NoExportLibrary) {

		&main::Output(

			"\t-\$(ERASE) \"\$(EPOCLIB)\\UDEB\\$ExportLibrary.lib\"\n"

		);

	}

	&Generic_MakeWorkDir('MAKEWORKLIBRARY',"${LibPath}UDEB");

	&Generic_Releaseables;

}

sub PMBld {

	my $AifStructRef=&main::AifStructRef;

	my @SrcList=&main::SrcList;

	my $BaseTrg=&main::BaseTrg;

	my $BitMapStructRef=&main::BitMapStructRef;

	my $Bld=&main::Bld;

	my $ExportLibrary=&main::ExportLibrary;

	my $NoExportLibrary=&main::NoExportLibrary;

	my $DefFile=&main::DefFile;

	my $EPOCIncPath=&main::EPOCIncPath;

	my $FirstLib=&main::FirstLib;

	my $BasicTrgType=&main::BasicTrgType;

	my @LibList;

	my $RelPath=&main::RelPath;

	my $ResourceStructRef=&main::ResourceStructRef;

	my @StatLibList=&main::StatLibList;

	my $Trg=&main::Trg;

	my $TrgPath=&main::TrgPath;

	my $TrgType=&main::TrgType;

	my $MSVCVer = &Winutl_MSVCVer;

	my $newlib = main::NewLib(); # Check if newlib has been set in the MMP file.

    my $NewLib = 'scppnwdl.lib'; # This is where operator new and operator delete

                                 # are defined for user side targets.

    my $NewKernLib = 'scppnwdl_kern.lib'; # This is where operator new and operator delete

                                 	  # are defined for kernel side targets.

	my $WarningLevel='/WARN:3';

	if (&main::Plat() eq 'TOOLS') {

		$WarningLevel='/WARN:1';    # avoid LNK4005 warnings about unused libraries

	}

	if ($Bld =~ /DEB/) {

		@LibList=&main::DebugLibList;

	} else {

		@LibList=&main::LibList;

	}

	my $BLDTRGPATH = "\$(EPOCTRG$Bld)\\";

	my $BLDDATAPATH = "\$(EPOCTRG$Bld)\\";

	if (&main::Plat ne "WINC") {	# target paths ignored under WINC

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

			$BLDTRGPATH .= "\$(TRGDIR)\\";	    # handles TARGETPATH

		}

		$BLDDATAPATH .= "\$(DATADIR)\\";

	}

	my $Entry="";

	my $EntrySymbol='';

	my $Include="";

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

		$Entry="/noentry";

		$Include="/include:\"__E32Dll\"";

		$EntrySymbol='_E32Dll';

	}

	elsif ($TrgType=~/^EXEXP$/o) {

		$Entry="/noentry";

		$Include="/include:\"__E32Startup\"";

		$EntrySymbol='_E32Startup';

	}

	elsif ($BasicTrgType=~/^EXE$/o) {

		unless (&main::Plat eq 'TOOLS') {

			$Entry="/entry:\"_E32Bootstrap\"";

			$Include="/include:\"__E32Startup\"";

		}

	}

	my $AbsentSubst = '';

	if ($EntrySymbol) {

		$AbsentSubst = " -absent $EntrySymbol";

	}