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

my $GccPrefix='';

my $ToolPrefix='';

my $HelperLib='';

my %PlatOpt=(

	'Dlltool'=>'',

	'Entry'=>'-e',

	'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

);

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 {

	print "// No additional keywords for this platform\n";

}

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;

}

my %CompatibleABIs=(

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

	ARM4=>['ARMI'],

	THUMB=>['ARMI']

);

my @CompatibleABIs;

sub PMUnderlyingABI($) {

	my ($ABI) = @_;

	if ($ABI eq 'ARM4T') {

		if (&main::BuildAsARM) {

			return 'ARMI';

		}

		elsif (SystemTarget()) {

			return 'ARM4';

		}

		else {

			return 'THUMB';

		}

	}

	return $ABI;

}

my $Makecmd;

my %ABILibPath=();

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::Path_RltToWork(&main::SysIncPaths));

	my @ChopRTWUserIncPaths=&main::Path_Chop(&main::Path_RltToWork(&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=(

		ARMI=>'-m arm_interwork',

		ARM4=>'-m arm',

		THUMB=>'-m thumb'

	);

#	work out the flags for various platforms

	if ($ABI eq 'ARMI') {

		$PlatOpt{Gcc}='-march=armv4t -mthumb-interwork';

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

	}

	elsif ($ABI eq 'ARM4T') {

		if (&main::BuildAsARM) {

			$PlatOpt{Gcc}='-march=armv4t -mthumb-interwork';

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

		}

		elsif ($SystemTrg) {

			$PlatOpt{Gcc}='-march=armv4';

#			allow thumb for ARM4 ABI where necessary

			unless (&main::PlatABI eq 'ARM4') {

				$PlatOpt{Gcc}.='t';

			}

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

		}

		else {

			$GccPrefix='thumb-epoc-pe-';

			$PlatOpt{Gcc}='-mthumb-interwork -D__MARM_THUMB__';

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

		}

	}

	elsif ($ABI eq 'ARM4') {

		$PlatOpt{Gcc}='-march=armv4';

#		allow thumb for ARM4 ABI where necessary

		unless (&main::PlatABI eq 'ARM4') {

			$PlatOpt{Gcc}.='t';

		}

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

	}

	elsif ($ABI eq 'THUMB') {

		$GccPrefix='thumb-epoc-pe-';

		$PlatOpt{Gcc}='-mthumb-interwork';

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

	}

	else {

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

	}

	@CompatibleABIs=@{$CompatibleABIs{$UnderlyingABI}};

#	set up CompatibleABI lib path hash

	foreach (@CompatibleABIs) {

		$ABILibPath{$_}=&main::Path_Strip("$LibPath..\\$_\\");

	}

	my %ABIRTWLibPath=();

	foreach (@CompatibleABIs) {

		$ABIRTWLibPath{$_}=&main::Path_RltToWork($ABILibPath{$_});

	}

	$Dlltool=$ToolPrefix.'dlltool';

	$Archive=$ToolPrefix.'ar';

	$Link=$ToolPrefix.'ld';

	$Objcopy=$ToolPrefix.'objcopy';

	&Generic_Header(1,$Makecmd);	# define standard things using relative paths

#	GCC needs a fully-qualified path

	if ($ENV{'PATH'} !~ m/[a-zA-z]{1}:{1}.[^;]*epoc32\\gcc\\bin/i) {

		if ($Makecmd eq "nmake") {

			&main::Output(

				"\n",

				"PATH=",&main::Path_Drive,$EPOCPath,"gcc\\bin;\$(PATH)\n",

				"\n"

			);

		}

		else {

			&main::Output(

				"\n",

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

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

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

				"\n"

			);

		}

	}

	&main::Output(

		"INCDIR  ="

	);

	foreach (@ChopRTWUserIncPaths) {

		&main::Output(

			" -I \"$_\""

		);

	}

	foreach (@ChopRTWSysIncPaths) {

		&main::Output(

			" -I \"$_\""

		);

	}

	if($VariantFile){

	    # gcc needs a relativ path

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

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

	}

	&main::Output(

		"\n",

		"\n"

	);

	&main::Output(

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

		"\t\t-pipe -c -nostdinc -Wall -Wno-ctor-dtor-privacy -Wno-unknown-pragmas $WarningLevel\n",

		"\n"

	);

	&main::Output(

		"GCCDEFS ="

	);

	foreach(@MacroList) {

		&main::Output(

			" -D$_"

		);

	}

	&main::Output(

		" \$(USERDEFS)\n",

		"\n"

	);

	foreach (@BldList) {

		&main::Output(

			"GCC$_ = ${GccPrefix}gcc"

		);

		if (/REL$/o) {

			&main::Output(

				      ' -s -fomit-frame-pointer ',

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

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

	);

	&main::Output(

		"LIBRARY : MAKEWORK"

	);

	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)\\UREL\\$PrimaryExportLibrary.lib")

				);

				foreach (@CompatibleABIs) {

					&main::Output(

						" ", &Generic_Quote("$ABILibPath{$_}UREL\\$PrimaryExportLibrary.lib")

					);

					&Generic_MakeWorkDir('MAKEWORKLIBRARY',"$ABILibPath{$_}UREL");

				}

				&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)\\UREL\\$PrimaryExportLibrary.lib\"\n",

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

			);

		}

		&main::Output(

			"\n",

			"\n",

			"# REAL TARGET - LIBRARY\n",

			"# EPOCBLDP = ", &Generic_Definition('EPOCBLDP'), "\n",

			"# EPOCLIB = ", &Generic_Definition('EPOCLIB'), "\n",

		);

		&main::Output(

			"\n",

			&Generic_Quote("\$(EPOCBLDP)\\$ExportLibrary.prep.def"), " : ",

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

			"\tperl -S prepdef.pl \$< \$@\n",

			"\n",

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

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

			"\tpushd ".&Generic_Quote("\$(EPOCBLDP)")." && \\\n",

			"\t$Dlltool $PlatOpt{Dlltool} --output-lib \"$ExportLibrary.tmp.lib\" --def \"$ExportLibrary.prep.def\" --dllname \"$LinkAs\" && popd && move ", &Generic_Quote("\$(EPOCBLDP)\\$ExportLibrary.tmp.lib"), " \$@\n"

		);

		if ($ExtraExportLibrary) {

			&main::Output(

				"\n",

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

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

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

			);

		}

		foreach (@CompatibleABIs) {

			&main::Output(

				"\n",

				&Generic_Quote("$ABILibPath{$_}UREL\\$ExportLibrary.lib"), " : ",

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

				"\tpushd ".&Generic_Quote("\$(EPOCBLDP)")." && \\\n",

				"\t$Dlltool $ABIDlltool{$_} --output-lib \"$ExportLibrary.tmp.lib\" \\\n",

				"\t\t--def \"$ExportLibrary.prep.def\" \\\n",

				"\t\t--dllname \"$LinkAs\" && popd && move ", &Generic_Quote("\$(EPOCBLDP)\\$ExportLibrary.tmp.lib"), " \$@\n"

			);

			if ($ExtraExportLibrary) {

				&main::Output(

					"\n",

					&Generic_Quote("$ABILibPath{$_}UREL\\$ExtraExportLibrary.lib"), " : ",

					&Generic_Quote("$ABILibPath{$_}UREL\\$ExportLibrary.lib"), "\n",

					"\tcopy \$< \$@\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 -S efreeze.pl \$(EFREEZE_ALLOW_REMOVE) \"$DefFile\" \"\$(EPOCBLDP)\\$ExportLibrary.def\" \n"

		);

	}

	&main::Output(

		"\n",

		"CLEANLIBRARY :\n"

	);

	if ($DefFile and !$NoExportLibrary) {

		&main::Output(

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

			"\t-\$(ERASE) \"\$(EPOCBLDP)\\$ExportLibrary.prep.def\"\n"

		);

		if ($ExtraExportLibrary) {

			&main::Output(

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

			);

		}

		foreach (@CompatibleABIs) {

			&main::Output(

				"\t-\$(ERASE) \"$ABILibPath{$_}UREL\\$ExportLibrary.lib\"\n"

			);

			if ($ExtraExportLibrary) {

				&main::Output(

					"\t-\$(ERASE) \"$ABILibPath{$_}UREL\\$ExtraExportLibrary.lib\"\n"

				);

			}

		}

	}

	&main::Output(

		"\n",

		"\n"

	);

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

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