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

# this package contains generic routines to handle bits of makefiles which are

# common to all of the platforms. Currently it deals with AIF, MBM amd RSC files.

# 

#

package cl_generic;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	Generic_Define

	Generic_Definition

	Generic_MakeWorkDir

	Generic_MakeWorkFile

	Generic_Quote

	Generic_Header

	Generic_Releaseables

	Generic_BitMapBld

	Generic_ResrcBld

	Generic_AifBld

	Generic_End

	Generic_CopyAction

	Generic_WhatCleanTargets

	Generic_WhatTargets

	Generic_CleanTargets

);

use strict;

use File::Basename;

use lockit_info;

use CheckSource;

use E32Variant;

my $SavedBldPath;

my $MakefileType=0;	# 0=NMAKE, 1=MAKE

my %CheckSourceResourceIncludes;

sub Generic_Header ($$;$) {

	my ($UseRltPaths, $makefileType, $supportAbsPathConversion) = @_;

	$MakefileType=($makefileType eq "nmake")? 0:1;

	my $LibSubDir="UDEB";

	if (&main::PlatOS eq 'EPOC32') {

		$LibSubDir="UREL";

	}

	elsif (&main::PlatOS eq 'TOOLS2') {

		$LibSubDir="LIB";

	}

	my $BldPath=&main::BldPath;

	if ( LocalBuildPathExists() ) {

		$BldPath = ConvertToLocalBuild($BldPath);

	}

	# Get the information regarding supporting Compiler Wrapper option

	my $IsCompilerWrapperOption=&main::CompilerWrapperOption();

	my $RelPath=&main::RelPath;

	my $LibPath=&main::LibPath;

	my $LinkPath=&main::LinkPath;

	my $StatLinkPath=&main::StatLinkPath;

	my $ASSPLinkPath=&main::ASSPLinkPath;

	$SavedBldPath=&main::Path_Chop($BldPath);

	if ($UseRltPaths) {

		if ( ! LocalBuildPathExists() ) {

			# Local build does not exists so keep relative path.

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

		}

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

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

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

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

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

	}

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

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

	$LibPath=&main::Path_Chop($LibPath);

	$LinkPath=&main::Path_Chop($LinkPath);

	$StatLinkPath=&main::Path_Chop($StatLinkPath);

	$ASSPLinkPath=&main::Path_Chop($ASSPLinkPath);

	my $EPOCDataPath=&main::Path_Chop(&main::EPOCDataPath);

	my $EPOCIncPath=&main::Path_Chop(&main::EPOCIncPath);

	my $DataPath=&main::Path_Chop(&main::DataPath);

	my $TrgPath=&main::Path_Chop(&main::TrgPath);

	my $erasedefn = "\@erase";

	$erasedefn = "\@erase 2>>nul" if ($ENV{OS} eq "Windows_NT");

	&main::Output(

		"\n",

		'# CWD ',             &main::Path_WorkPath, "\n",

		'# MMPFile ',         &main::MmpFile,       "\n",

		'# Target ',          &main::Trg,           "\n",

		'# TargetType ',      &main::TrgType,       "\n",

		'# BasicTargetType ', &main::BasicTrgType,  "\n",

		'# MakefileType ', ($MakefileType==1)? "GNU":"NMAKE", "\n"

	);

	my @BldList=&main::BldList;

	my %featureVariantInfo = &main::FeatureVariantInfo;

	if (%featureVariantInfo)

		{

		&main::Output("# FeatureVariantName ", $featureVariantInfo{NAME}, "\n");

		foreach (@BldList)

			{

			&main::Output("# FeatureVariant".$_."Label ", $featureVariantInfo{$_."_LABEL"}, "\n");

			}

		}

	&main::Output(

		"\n",

		"ERASE = $erasedefn\n",

		"\n"

	);

	# Include function to perform optional DOS to Unix slash conversion

	# on absolute paths if requested from backend.

	if ($supportAbsPathConversion) {

		&main::Output(

			"ifeq \"\$(UNIX_SLASH_FOR_CC_ABS_PATHS)\" \"1\"\n",

			"define absolutePaths\n",

			"\$(subst \\,\/,\$1)\n",

			"endef\n",

			"else\n",

			"define absolutePaths\n",

			"\$1\n",

			"endef\n",

			"endif\n",

			"\n"

		);

	}

	&main::Output(

		"# EPOC DEFINITIONS\n",

		"\n"

	);

	Generic_Define("EPOCBLD",  $BldPath);

	if (defined $ENV{PBUILDPID}) {

		my $BldPathP = $BldPath . '$(PBUILDPID)';

		Generic_Define("EPOCBLDP", $BldPathP);

	} else {

		Generic_Define("EPOCBLDP", $BldPath);

	}

	Generic_Define("EPOCTRG",  $RelPath);

	Generic_Define("EPOCLIB",  $LibPath);

	Generic_Define("EPOCLINK", $LinkPath);

	Generic_Define("EPOCSTATLINK", $StatLinkPath);

	Generic_Define("EPOCBSFSTATLINK", $RelPath);

	Generic_Define("EPOCASSPLINK", $ASSPLinkPath);

	Generic_Define("EPOCDATA", $EPOCDataPath);

	Generic_Define("EPOCINC",  $EPOCIncPath);

	Generic_Define("TRGDIR",   $TrgPath);

	Generic_Define("DATADIR",  $DataPath);

	foreach (@BldList) {

		&main::Output("\n");

		my $bldOffset = "";

		$bldOffset .= $featureVariantInfo{$_."_LABEL"}."\\" if (%featureVariantInfo && !$featureVariantInfo{INVARIANT});

		Generic_Define("EPOCBLD$_", "\$(EPOCBLD)\\".$bldOffset.lc($_));

		if (defined $ENV{PBUILDPID}) {

			Generic_Define("EPOCBLDP$_", "\$(EPOCBLDP)\\".$bldOffset.lc($_));

		} else {

			Generic_Define("EPOCBLDP$_", "\$(EPOCBLD)\\".$bldOffset.lc($_));

		}

		Generic_Define("EPOCTRG$_", "\$(EPOCTRG)\\".lc($_));

		Generic_Define("EPOCLIB$_", "\$(EPOCLIB)\\".lc($LibSubDir));

		Generic_Define("EPOCLINK$_", "\$(EPOCLINK)\\".lc($LibSubDir));

		Generic_Define("EPOCSTATLINK$_", "\$(EPOCSTATLINK)\\".lc($_));

		Generic_Define("EPOCBSFSTATLINK$_","\$(EPOCBSFSTATLINK)\\".lc($_));

		Generic_Define("EPOCASSPLINK$_", "\$(EPOCASSPLINK)\\".lc($LibSubDir));

	}

	# Compiler Wrapper option support 

	# Generate the information Compiler Wrapper options in second level make file.

	if($IsCompilerWrapperOption)

	{

		&main::Output(

			"\n\n",

			"#COMPILER WRAPPER OPTION DEFINITIONS\n",

			"COMPWRAP = ",

			"$ENV{ABLD_COMPWRAP}", # Extract the tool name from environment variable

			"\n\n"

		);

	}

	# Compiler Wrapper option

	my $gccxml;

	if (&main::Plat =~ /gccxml/i){

		$gccxml = &main::Plat;

	}

	my $edg;

	if (&main::Plat =~ /edg/i){

		$edg = &main::Plat;

	}

	&main::Output(

		"\n",

		"# EPOC PSEUDOTARGETS\n",

		"\n"

	);

	foreach (@BldList) {

		if(!$edg){

			&main::Output(

				"$_ : MAKEWORK$_ RESOURCE$_\n\n"

			);

		}

		else {

			&main::Output(

				"$_ : MAKEWORK$_ \n\n"

			);

		}

	}

	&main::Output(	# ALL comes after DEB: because first target in makefile is the default

		"ALL :"

	);

	foreach (@BldList) {

		&main::Output(

			" $_"

		);

	}

	# # Compiler Wrapper option support 

	if($IsCompilerWrapperOption)

	{

		&main::Output(	# ALL comes after DEB: because first target in makefile is the default

			"\n\nCOMPWRAPALL : COMPWRAPUREL COMPWRAPUDEB"

		);

	}

	&main::Output(

		"\n",

		"\n",

		"CLEAN CLEANALL : CLEANBUILD CLEANRELEASE CLEANLIBRARY\n",

		"\n"

	);

	my $pseudoTarget;

	foreach $pseudoTarget ("WHAT", "RESOURCE", "CLEANBUILD", "CLEANRELEASE", 

				"MAKEWORK", "LISTING")

		{

		if(($gccxml && $pseudoTarget eq "RESOURCE") ||

		!($gccxml || $edg)){

			&main::Output(

				"\n",

				"\n",

				"$pseudoTarget $pseudoTarget","ALL :"

			);

			foreach (@BldList) {

				&main::Output(

					" $pseudoTarget$_"

				);

			}

		}	

	}

	if($gccxml){

		&main::Output(

		"\n",

		"\n",

		);

	}

	if(!($gccxml || $edg)){

		&main::Output(

			"\n",

			"\n",

			"MAKEWORK : MAKEWORKLIBRARY\n",

			"\n"

		);

	}

	if(!$edg){

		foreach (@BldList) {

			&main::Output(

				"RESOURCE$_ "

			);

		}

		&main::Output(

			": GENERIC_RESOURCE\n",

			"\n"

		);

	}

}

# Quote name if necessary, according to the type of Makefile

sub Generic_Quote ($) {

	my ($name)=@_;

	if ($MakefileType==1) {

		# GNU make wants backslash before each space

		$name =~ s/ /\\ /go;

	} else {

		# NMAKE prefers quotes around all filenames

		$name = "\"$name\"";

	}

	return $name;

}

# Generic file copying action, which uses built-in variables quoted appropriately

#

# GNU make variables may contain spaces, but perl.exe will be executed directly

# and so doesn't need any quotes.

sub Generic_CopyAction($) {

	my ($target) = @_;

	my $source = '$?';

	$target = '$@' if (!defined $target);

	return "perl -w -S ecopyfile.pl $source $target\n";

}

# Record necessary directories, for eventual emkdir.pl rules

# Also need to record related defines, to eliminate duplicates

my %DirDefines;

sub expandDefines ($) {

	my ($value)=@_;

	while ($value =~ /^(.*?)\$\((\w+)\)(.*)$/) {

		last if ($2 eq 'PBUILDPID');

		$value="$1$DirDefines{$2}$3";

	}

	return $value;

}

sub Generic_Define ($$;$) {

	my ($name, $value, $trailer)=@_;

	$trailer="" if (! defined $trailer);

	&main::Output(

		"$name = $value$trailer\n"

	);

	$DirDefines{$name}=expandDefines($value);

}

sub Generic_Definition ($) {

	return $DirDefines{$_[0]};

}

my %MkDirs;

sub Generic_MkDir ($) {

	my $dir=&main::Path_Chop(&expandDefines($_[0]));

	$dir = lc $dir;

	$dir =~ s/\$\(pbuildpid\)/\$\(PBUILDPID\)/g;

	$MkDirs{$dir}=1;

	return $dir;

}

# Accumulate MAKEWORK targets and lists of directories,

# automatically filling in the rest of the details.

#

my %MakeWork;

sub Generic_MakeWorkDir($$) {

	my ($work, $dir) = @_;

	if ( LocalBuildPathExists() ) {

		$dir = ConvertToLocalBuild($dir);

	}

	my $workhash;

	if (defined $MakeWork{$work}) {

		$workhash=$MakeWork{$work};

	} else {

		my %newhash;

		$workhash=\%newhash;

		$MakeWork{$work}=$workhash;

	}

	my $normdir=lc &main::Path_Chop(&expandDefines($dir));

	$normdir =~ s/\$\(pbuildpid\)/\$\(PBUILDPID\)/g;

	$$workhash{$normdir} ||= &Generic_MkDir($dir);

}

sub Generic_MakeWorkFile($$) {

	my ($work, $file) = @_;

	my $dir=&main::Path_Split('Path',&expandDefines($file));

	&Generic_MakeWorkDir($work,$dir);

}

sub Generic_WhatTargets($$@)

{

	my ($prefix, $whattarget, @files)=@_;

	if ((scalar @files) == 0) {

		&main::Output(

			"\n",

			"\n$whattarget :\n",

			"\t\@rem none\n"

		);

	} else {

# emit list of releasables in batches to avoid overflowing the 2048 character 

# batch file line limit doing echo or erase...

		my $count=1;

		my $length=0;

		&main::Output(

			"\n",

			"${prefix}_RELEASEABLES$count="

		);

		my $File;

		foreach $File (sort @files) {

			my $name = &Generic_Quote($File);

			my $namelen = length($name)+3;	# for space, newline and tab

			if ($length+$namelen > 1700) {	# very conservative limit

				$count++;

				$length=0;

				&main::Output(

					"\n",

					"${prefix}_RELEASEABLES$count="

				);

			}

			&main::Output(

				" \\\n\t", $name

			);

			$length += $namelen;

		}

		&main::Output(

			"\n",

			"\n",

			"$whattarget:\n"

		);

		my $filecount=1;

		while ($filecount<=$count) {

			&main::Output(

				"\t\@echo \$(${prefix}_RELEASEABLES$filecount)\n"

			);

			$filecount++;

		}

	}

	&main::Output(

		"\n",

	);

}

sub Generic_CleanTargets($$@) {

	my ($prefix, $cleantarget, @files)=@_;

	if ((scalar @files) == 0) {

		&main::Output(

			"\n",

			"\n$cleantarget :\n",

			"\t\@rem none\n"

		);

	} else {

# emit list of releasables in batches to avoid overflowing the 2048 character 

# batch file line limit doing echo or erase...

		my $count=1;

		my $length=0;

		&main::Output(

			"\n",

			"${prefix}_CLEANTARGETS$count="

		);

		my $File;

		foreach $File (sort @files) {

			my $name = &Generic_Quote($File);

			my $namelen = length($name)+3;	# for space, newline and tab

			if ($length+$namelen > 1700) {	# very conservative limit

				$count++;

				$length=0;

				&main::Output(

					"\n",

					"${prefix}_CLEANTARGETS$count="

				);

			}

			if (!main::NoExportLibrary || ($name !~ /.dso$/i && $name !~ /.lib$/i))

			{

				&main::Output(

					" \\\n\t", $name

				);

				$length += $namelen;

			}

		}

		&main::Output(

			"\n",

			"\n",

			"$cleantarget:\n",

		);

		my $filecount=1;

		while ($filecount<=$count) {

			&main::Output(

				"\t-\$(ERASE) \$(${prefix}_CLEANTARGETS$filecount)\n"

			);

			$filecount++;

		}

	}

	&main::Output(

		"\n",

	);

}

sub Generic_WhatCleanTargets($$$@) {

	my ($prefix, $whattarget, $cleantarget, @files)=@_;

	if ((scalar @files) == 0) {

		&main::Output(

			"\n",

			"\n$whattarget $cleantarget :\n",

			"\t\@rem none\n"