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

my $GccPrefix='';

my $ToolPrefix='';

my $HelperLib='';

my %PlatOpt=(

	'Dlltool'=>'',

	'Entry'=>'--entry',

	'Gcc'=>'',

	'Ld'=>'',

	'Petran'=>'',

	'Optimize'=>'-O'

);

my $Dlltool;

my $Archive;

my $Link;

my $Objcopy;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	PMHelp_Mmp

	PMPlatProcessMmp

	PMUnderlyingABI

	PMStartBldList

		PMBld

	PMStartSrcList

		PMBitMapBld

		PMResrcBld

		PMAifBld

		PMStartSrc

		PMSrcDepend

			PMSrcBldDepend

			PMEndSrcBld

		PMEndSrc

	PMEndSrcList

	PMPrefixFile

);

use cl_generic;

use Genutl;

use constant NOCOMPRESSIONMETHOD => 0;

use constant INFLATECOMPRESSIONMETHOD => 1;

use constant BYTEPAIRCOMPRESSIONMETHOD => 2;

use constant NOTPAGED => 0;

use constant UNPAGED => 1;

use constant PAGED => 2;

sub PMHelp_Mmp {

	&Winutl_Help_Mmp;

}

sub PMCheckPlatformL {

}

sub PMPlatProcessMmp (@) {

	my $MMPFILE=&main::MmpFile;

	# set up START MARM ... END block module variables

	my @MmpWarn=();

	my $Line;

	LINE: foreach $Line (@_) {

		my $LineInfo=shift @$Line;

		$_=shift @$Line;

		push @MmpWarn, "$LineInfo : Unrecognised Keyword \"$_\"\n";

	}

	undef $Line;

	if (@MmpWarn) {

		warn

			"\nMMPFILE \"$MMPFILE\"\n",

			"START .. END BLOCK WARNINGS(S)\n",

			@MmpWarn,

			"\n"

		;

	}

	undef @MmpWarn;

}

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 PMUnderlyingABI($) {

	my ($ABI) = @_;

	if ($ABI eq 'X86gcc') {

			return 'X86gcc';

	}

	return $ABI;

}

my $Makecmd;

my %ABILibPath=();

my $genDefFile;

sub PMStartBldList($) {

	($Makecmd) = @_;

	my $ABI=&main::ABI;

	my $UnderlyingABI=PMUnderlyingABI($ABI);

	my $BaseTrg=&main::BaseTrg;

	my $BasicTrgType=&main::BasicTrgType;

	my @BldList=&main::BldList;

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

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

	my $DefFile=&main::DefFile;

	my $EPOCPath=&main::EPOCPath;

	my $LinkAs=&main::LinkAs;

	my $LibPath=&main::LibPath;

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

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

	my $Plat=&main::Plat;

	my $Trg=&main::Trg;

	my $TrgType=&main::TrgType;

	my @UidList=&main::UidList;	

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

	my $ExportLibrary=&main::ExportLibrary;

	my $NoExportLibrary=&main::NoExportLibrary;

	my $SystemTrg = SystemTarget();

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

	}

#	set up dlltool flag hash

	my %ABIDlltool=(

		X86gcc=>' -m i386' 

	);

#	work out the flags for various platforms

	if ($ABI eq 'X86gcc') {

		$PlatOpt{Gcc}='-c  -masm=intel -B\\epoc32\\gcc_mingw\\_p';

		$PlatOpt{Dlltool}=$ABIDlltool{X86gcc};

	}

	else {

		&main::FatalError("Platform module - ABI \"$ABI\" unrecognised");

	}

#	set up CompatibleABI lib path hash

	my %ABIRTWLibPath=();

	$Dlltool=$ToolPrefix.'dlltool';

	$Archive=$ToolPrefix.'ar';

	$Link=$ToolPrefix.'ld';

	$Objcopy=$ToolPrefix.'objcopy';

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

	&main::Output(

		"\n",

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

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

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

		"\n"

	);

	&main::Output(

		"INCDIR  ="

	);

	foreach (@ChopRTWUserIncPaths) {

		&main::Output(

			" -I \"$_\""

		);

	}

	foreach (@ChopRTWSysIncPaths) {

		&main::Output(

			" -isystem \"$_\""

		);

	}

	&main::Output(

		"\\\n -include \"", $EPOCPath, "include\\gcc.h\"",

		"\n",

		"\n"

	);

	&main::Output(

		"GCCFLAGS=$PlatOpt{Gcc} \\\n",

		"\n"

	);

	&main::Output(

		"GCCDEFS ="

	);

	foreach(@MacroList) {

		&main::Output(

			" -D$_"

		);

	}

	&main::Output(

		" -D PRODUCT_INCLUDE=\"\\\"$VariantFile\\\"\"",

		" \$(USERDEFS)\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"GCC$_ = ${GccPrefix}g++"

		);

		if (/REL$/o) {

			&main::Output(

				      ' ',

				      $PlatOpt{Optimize}

			);

		}

		elsif (/DEB$/o) {

			&main::Output(

				' -g'

			);

			#unless (&main::SrcDbg) {

			#   &main::Output(

			#   	' ', $PlatOpt{Optimize}

			#  );

			#}

		}

		&main::Output(

			' $(GCCFLAGS)'

		);

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

			&main::Output(

				" -D$_"

			);

		}

		&main::Output(

			" \$(GCCDEFS)\n"

		);

	}

	&main::Output(

		"\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"$_ :"

		);

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

			&main::Output (

				#" \\\n\t \"",

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

		);

	}

	# Resource building is done entirely via cl_generic.pm

	foreach (@BldList) {

		&main::Output(

			"\n",

			"RESOURCE$_ : MAKEWORK$_"

		);

	}

	&main::Output(

		"\n",

		"\n",

	);

	if (!-e $DefFile && scalar(&main::Exports)!=0)

	{

		# There are mandatory exports - generate a def file using the mandatory exports.

		$genDefFile = "\$(EPOCBLD)\\$ExportLibrary.gen.def";

	}

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

		#	Establish the entry point symbol

		my $EntrySymbol;

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

			$EntrySymbol = '_E32Dll';

		}

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

			$EntrySymbol = '_E32Startup';

		}

		&main::Output("\n", &Generic_Quote("\$(EPOCBLD)\\$ExportLibrary.prep.def"), " : ");

		my $defFileToUse;

		if (defined($genDefFile))

		{

			# The generated def file is not a dependency of the prep.def - don't add anyting after the ':' char

			&main::Output("\n\tperl -S gendef.pl $genDefFile ", join(' ', &main::Exports), "\n");

			$defFileToUse = $genDefFile;

		}

		else

		{

			&main::Output(&Generic_Quote($DefFile), "\n");

			$defFileToUse = "\$<";

		}

		&main::Output("\tperl -S prepdef.pl $defFileToUse \$@ nodatasizes $EntrySymbol\n\n");

		&main::Output(

			&Generic_Quote("\$(EPOCBLD)\\$ExportLibrary.lib.exp"), " : ", &Generic_Quote("\$(EPOCBLD)\\$ExportLibrary.prep.def"), "\n",

			"\t$Dlltool $PlatOpt{Dlltool} --input-def \"\$<\"  --dllname \"$LinkAs\"  -e \"\$@\"  \n",			

			"\t-\$(ERASE) \"\$(EPOCBLD)\\tmp.txt \"\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(

					" ", &Generic_Quote("\$(EPOCLIB)\\LIB\\$PrimaryExportLibrary.lib")

				);

				&main::Output(

					"\n"

				);

			} else {

				&main::Output(

					"\n",

					"\t\@echo WARNING: Not attempting to create any import libraries.\n",

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

				);

			}

		}

		else {

			&main::Output(

				"\n",

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

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

			);

		}

		&main::Output(

			"\n",

			"\n",

			"# REAL TARGET - LIBRARY\n",

		);

		&main::Output(

			"\n",

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

			&Generic_Quote("\$(EPOCBLD)\\$ExportLibrary.prep.def"), "\n",

			"\t$Dlltool $PlatOpt{Dlltool} --input-def \"\$<\"  --dllname \"$LinkAs\"  --output-lib \"\$@\" \n",

			"\t-\$(ERASE) \"\$(EPOCBLD)\\tmp.txt \"\n"

		);

		if ($ExtraExportLibrary) {

			&main::Output(

				"\n",

				&Generic_Quote("\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.lib"), " : ",

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

				"\tcopy \$< \$@\n"

			);

		}

	}

	&main::Output(

		"\n",

		"CLEANLIBRARY :\n"

	);

	if ($DefFile and !$NoExportLibrary) {

		&main::Output(

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

		);

		if ($ExtraExportLibrary) {

			&main::Output(

				"\t-\$(ERASE) \"\$(EPOCLIB)\\LIB\\$ExtraExportLibrary.lib \"\n"

			);

		}

	}

	&main::Output(

		"\n",

		"\n"

	);

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

	&Generic_Releaseables;

}

sub PMBld {

	my @ASSPLibList=&main::ASSPLibList;

	my @SrcList=&main::SrcList;

	my $BaseTrg=&main::BaseTrg;

	my $Bld=&main::Bld;

	my $ChopBldPath=&main::Path_Chop(&main::BldPath);

	my $DefFile=&main::DefFile;

	my $EPOCIncPath=&main::EPOCIncPath;

	my $FirstLib=&main::FirstLib;

	my $BasicTrgType=&main::BasicTrgType;

	my @LibList;

	my $LibPath=&main::LibPath;

	my $LinkAs=&main::LinkAs;

	my $ChopRelPath=&main::Path_Chop(&main::RelPath);

	my $RelPath=&main::RelPath;

	my @StatLibList=&main::StatLibList;

	my $StatLinkPath=&main::StatLinkPath;

	my $Trg=&main::Trg;

	my $TrgType=&main::TrgType;

	my @UidList=&main::UidList;

	my $ExportLibrary=&main::ExportLibrary;

	my $NoExportLibrary=&main::NoExportLibrary;

	my $SystemTrg = SystemTarget();

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

	my $ExtraExportLibrary;

	unless ($Version{explicit}) {

		$ExtraExportLibrary = $ExportLibrary;

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

	}

	if ($Bld =~ /DEB/) {

		@LibList = &main::DebugLibList;

	} else {

		@LibList = &main::LibList;

	}

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

	}

	# REAL TARGETS

	#-------------

	&main::Output(

		"# REAL TARGET - BUILD VARIANT $Bld\n",

		"\n"

	);

#	releasables

	my @releaseables;

	push @releaseables, "$RelPath$Trg" if ($BasicTrgType!~/^IMPLIB$/io);

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

		push @releaseables, "$RelPath$Trg.MAP";

	}

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

		push @releaseables, "$LibPath$ExportLibrary.lib";

		push @releaseables, "$LibPath$ExtraExportLibrary.lib" if ($ExtraExportLibrary);

	}

	&main::Output(

		"WHAT$Bld : WHATGENERIC\n",

		"\n",

		"CLEAN$Bld : CLEANBUILD$Bld CLEANRELEASE$Bld CLEANLIBRARY\n ",

		"\n",

		"CLEANBUILD$Bld : \n",

		"\t\@perl -S ermdir.pl \"\$(EPOCBLD$Bld)\"\n",

		"\n",

		"CLEANRELEASE$Bld : CLEANGENERIC\n",

		"\n"

	);

	&Generic_WhatCleanTargets($Bld, "WHAT$Bld", "CLEANRELEASE$Bld", @releaseables);