# 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_vscw;

# declare variables global for module

my @Win32LibList=();

my $Win32StdHeaders;

my $BaseAddressFlag;

my $Win32Resrc;

my $MWCC;

my $MWLD;

my $MWIncludePath;

my $MWIncludeVar;

# declare variables global for VS6

my %IdeBlds=();

my %PrjHdrs=();

my $DspText='';

my $VcprojText='';

my $PlatName=&main::PlatName;

my $guid='';

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMCheckPlatformL

	PMPlatProcessMmp

	PMStartBldList

		PMBld

	PMStartSrcList

		PMBitMapBld

		PMResrcBld

		PMAifBld

		PMDoc

		PMStartSrc

		PMSrcDepend

			PMSrcBldDepend

			PMEndSrcBld

		PMEndSrc

	PMEndSrcList

);

use Winutl;

use cl_generic;

use E32Variant;

use lockit_info;

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 {

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

		}

	}

}

sub PMPlatProcessMmp (@) {

	&Winutl_DoMmp(\@_, $MWIncludePath);

	$BaseAddressFlag=&Winutl_BaseAddress;

	if ($BaseAddressFlag ne "") {

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

	}

	@Win32LibList=&Winutl_Win32LibList;

	$Win32Resrc=&Winutl_Win32Resrc;

	$Win32StdHeaders=&Winutl_Win32StdHeaders;

}

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__";

	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;

	&main::Output(

			"PATH=$ENV{EPOCROOT}epoc32\\tools\\;$ENV{PATH}",

			"\n",

			"Path=\$(PATH)",

			"\n"

			);

# Get the drive letter to call the Lada compiler to call it with absolute path

	&main::Output(

			"COMPILER_PATH=\"$ENV{EPOCROOT}epoc32\\tools\\nokia_compiler\\Symbian_Tools\\Command_Line_Tools\\\"",

			"\n"

	);

	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"

		);

	}

	my $CompilerLibPath="$ENV{EPOCROOT}epoc32\\tools\\nokia_compiler\\Symbian_Support\\Runtime\\Runtime_x86\\Runtime_Win32\\Libs;$ENV{EPOCROOT}epoc32\\tools\\nokia_compiler\\Symbian_Support\\Win32-x86 Support\\Libraries\\Win32 SDK";

	&main::Output(

			"\n",

		"MWLibraries:=\+$CompilerLibPath\n",

		"export MWLibraries\n",

		"\n"

		);

	&main::Output(

			"\n",

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

		"export MWLibraryFiles\n",

		"\n"

		);

	&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 off",	# do not treat wchar_t as a predefined type

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

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

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

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

		" $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$_ = perl -w -S err_formatter.pl \$(COMPILER_PATH)$MWCC -msgstyle parseable "

		);

		if (/DEB$/o) {

			if($PlatName eq "VS6") {

				&main::Output(

					' -sym codeview'

				);

			}

			else

			{

				&main::Output(

					' -sym codeview_new'

				);

			}

#			euser change to apply inlining on the _NAKED functions

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

				&main::Output(

					' -inline off'

				);

			}	

		}

		elsif (/REL$/o) {

			&main::Output(

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

			);

		}

		&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) {

			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 -w -S prepdef.pl ",&Generic_Quote($DefFile)," \"\$(EPOCBLD)\\$ExportLibrary.prep.def\"\n",

					"\t\$(COMPILER_PATH)$MWLD -msgstyle gcc \"\$(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"

		);

	}

	&main::Output(

		"\n",

		"CLEANLIBRARY :\n"

	);

	if ($DefFile and !$NoExportLibrary) {

		&main::Output(

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

		);

	}

	&main::Output(

		"\n"

	);

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

	&Generic_Releaseables;

	if($PlatName eq "VS6") {

		VS6StartBldList();

	}

	elsif($PlatName eq "VS2003") 

	{

		VS2003StartBldList();

	}

}

sub VS6StartBldList(){

	my $BaseTrg=&main::BaseTrg;

	my @BldList=&main::BldList;

	my $Plat=&main::Plat;

	# set up global IDE builds variable

	%IdeBlds= (

		UREL=> "$BaseTrg - Win32 Release",

		UDEB=> "$BaseTrg - Win32 Debug",

	);

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

		%IdeBlds= (

			REL=> "$BaseTrg - Win32 Release",

			DEB=> "$BaseTrg - Win32 Debug",

		);

	}

	$DspText=join('',

		"# Microsoft Developer Studio Project File - Name=\"$BaseTrg\" - Package Owner=<4>\n",

		"# Microsoft Developer Studio Generated Build File, Format Version 6.00\n",

		"# ** DO NOT EDIT **\n",

		"\n"

	);

	$DspText.=join('',

		"# TARGTYPE \"Win32 (x86) External Target\" 0x0106\n",

		"\n",

		"CFG=",$IdeBlds{$BldList[0]},"\n",

		"!MESSAGE This is not a valid makefile. To build this project using NMAKE,\n",

		"!MESSAGE use the Export Makefile command and run\n",

		"!MESSAGE \n",

		"!MESSAGE NMAKE /f \"",$BaseTrg,".mak\".\n",

		"!MESSAGE \n",

		"!MESSAGE You can specify a configuration when running NMAKE\n",

		"!MESSAGE by defining the macro CFG on the command line. For example:\n",

		"!MESSAGE \n",

		"!MESSAGE NMAKE /f \"",$BaseTrg,".mak\" CFG=\"".$IdeBlds{$BldList[0]}."\"\n",

		"!MESSAGE \n",

		"!MESSAGE Possible choices for configuration are:\n",

		"!MESSAGE \n"

	);

	foreach (reverse @BldList) {

		$DspText.=join('',

			"!MESSAGE \"",$IdeBlds{$_},"\" (based on \"Win32 (x86) External Target\")"