# Copyright (c) 2007-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:

#

# modified start: makefile improvement 

use Cwd;

# modified end: makefile improvement 

use Digest::MD5;

use File::Basename;

package featurevariantmap;

our $verbose = 0;

my $featureListDir = "$ENV{EPOCROOT}epoc32\\include\\variant\\featurelists";

sub LoadFeatureList

	{

	my %featurehash;

	# Try and find the feature master list folder

	if (!opendir DIR, $featureListDir)

		{

		print "\nERROR: Failed to open feature list directory $featureListDir: $!";

		return \%featurehash;

		}

	# Load the list of features from each file

	foreach my $file ( grep(/\.txt$/i, readdir DIR) )

		{

		$file = "$featureListDir\\$file";

		print "Reading feature list from $file\n" if ($verbose);

		if (!open IN, $file)

			{

			print "\nERROR: Failed to read feature list $file: $!";

			}

		else

			{

			while(my $line = <IN>)

				{

				$line =~ s/\/\/.+$//; # Get rid of c++ style comments

				if ($line =~ /(\S+)/)

					{

					$featurehash{$1} = $file;

					}

				}

			close IN;

			}

		}

	closedir DIR;

	return \%featurehash;

	}

sub ValidFeature

{

	our $featurelist;

	my $name = shift;

	$featurelist = LoadFeatureList() if !$featurelist;

	return exists $featurelist->{$name};

# modified start: makefile improvement 

}

sub GetVariantListFromVmap

{

	my $obj = shift;

	my $vmapfile = shift;

	if(open(VMAP, "<$vmapfile"))

	{

		my @varlist;

		while(<VMAP>)

		{

			if(/^\w{32}\s+(\w+)/)

			{

				push @varlist, $1;

			}

		}

		close(VMAP);

		return @varlist;

	}

	close(VMAP);

	return;

}

sub CheckOldVmapFile

{

	my $thisObj = shift;

	my $vmapfile = shift;

	my $varRef = shift;

	my $buildincludes = $$varRef{BUILD_INCLUDES};

	my $parents = $$varRef{PARENTS};

	my $children = $$varRef{CHILDREN};

	my $varianthrh = $$varRef{VARIANT_HRH};

	my %variantMacrolist;

	my $Options = "-dM -undef -nostdinc -+";

	my $Drive = $1 if (Cwd->cwd =~ /^(.:)/);

	if($buildincludes)

	{

		foreach (@$buildincludes)

		{

			$Options .= " -I \"".$Drive.$_."\"";

		}

	}

	if($varianthrh)

	{

		$Options .= " \"".$Drive.$varianthrh."\"";

	}

	if(open(CPP, "cpp $Options 2>&1 |"))

	{

		while(<CPP>)

		{

			my ( $key, $value );

			if (/^#define (\w+(?:\([^\)]*\))?)(?:\s(\S.*?))?\s*$/)

			{

				my $tmpKey = $1;

				my $tmpValue = $2;

				$tmpValue =~ s/,/\\,/g;

				($key, $value ) = ( $tmpKey, $tmpValue ? "\'$tmpValue\'" : 'defined' );

			}

			if ($key && ValidFeature($key))

			{

				$variantMacrolist{$key} = $value;

			}

		}

		if(!close(CPP))

		{

			print "Incomplete pre-precess of $varianthrh \n";

		}

	}

	my $findReusedKey = 1;

	my %vmapfeatureinfo;

	my $keyhash;

	my $macroList;

	if(open(VMAP, "<$vmapfile"))

	{

		while(<VMAP>)

		{

			if(/^\w{32}\s+(\w+)/)

			{

				$findReusedKey = 1;

				s/(^\w{32})\s+\w+\s+//;

				$keyhash = $1;

				my @feature = split(/(?<=[^\\]),/, $_);

				foreach my $value (@feature)

				{

					if($value =~ /([^\s]*)\s*=\s*(.*)/)

					{

						$vmapfeatureinfo{$1} = $2;

					}

				}

				foreach my $key (sort keys %vmapfeatureinfo)

				{

					if(($vmapfeatureinfo{$key} eq "undefined") && (not(exists($variantMacrolist{$key}))))

					{

						$findReusedKey = 1;

					}

					elsif($vmapfeatureinfo{$key} eq $variantMacrolist{$key})

					{

						$findReusedKey = 1;

					}else

					{

						$findReusedKey = 0;

						last;

					}

				}

				if( $findReusedKey == 1)

				{

					$macroList = $_;

					last;

				}

				undef(%vmapfeatureinfor);

				undef($keyhash);

			}

		}

	}

	if($findReusedKey == 1)

	{

    	return ($keyhash, $macroList);

	}

	else

	{

		return;

	}

}

# modified end: makefile improvement 

# Usage:	featurevariantmap->Hash(\@sources, \%var)

#

# Generate a hash value from the source files for a target using the

# given feature variant data.

#

# \@sources	- list of source files (full path)

# \%var		- variant data (from featurevariantparser->GetVariant)

#

# returns the hash value, or "" if an error occurs.

sub Hash

{

	my $thisObj = shift;

	my @result = $thisObj->HashAndFeatures(@_);

	return $result[0];

}

# Usage:	featurevariantmap->HashAndFeatures(\@sources, \%var)

#

# Generate a hash value from the source files for a target using the

# given feature variant data.

#

# \@sources	- list of source files (full path)

# \%var		- variant data (from featurevariantparser->GetVariant)

#

# returns a list of two entries [0] the hash value, or "" if an error occurs [1] A string of macros tested or affecting the code

sub HashAndFeatures

{

	my $thisObj = shift;

	my $srcRef = shift;

	my $varRef = shift;

	return "" if (!$srcRef || !$varRef);

	return "" if (!$$varRef{'VALID'});

	# get the pre-processing options

	my $pre = $$varRef{'PREINCLUDE'};

	my $inc = $$varRef{'BUILD_INCLUDES'};

	my $mac = $$varRef{'MACROS'};

	# Pass -dU option to get list of macros affecting the code

	my $options = "-dU -undef -nostdinc -+";

	if ($pre)	# pre-include file

	{

		$options .= " -include \"$pre\"";

	}

	if ($inc)	# include directories

	{

		foreach (@$inc)

		{

			$options .= " -I \"$_\"";

		}

	}

	if ($mac)	# macro definitions

	{

		foreach (@$mac)

		{

			$options .= " -D$_";

		}

	}

	my %testedMacrosHash;

	# Macros that affect the mmp file also affect the variant - so add them to the list

	foreach my $key ( keys %{ $$varRef{MMPTESTED} } )

		{

		$testedMacrosHash{$key} = $$varRef{MMPTESTED}->{$key} if (ValidFeature($key));

		}

	foreach my $src (@$srcRef)

	{

		my $options = "-I " . File::Basename::dirname($src) . " $options";

		print "cpp $options $src\n" if ($verbose);

		if (open(CPP, "cpp $options $src 2>&1 |"))

		{

			while (<CPP>)

			{

				print $_ if ($verbose && /No such file/);

				# Scan for #define or #undef generated for -dU

				my ( $key, $value );

				if (/^#define (\w+(?:\([^\)]*\))?)(?:\s(\S.*?))?\s*$/)

				{

# modified start: makefile improvement 

					my $tmpKey = $1;

					my $tmpValue = $2;

					$tmpValue =~ s/,/\\,/g;

					( $key, $value ) = ( $tmpKey, $tmpValue ? "\'$tmpValue\'" : 'defined' );

# modified end: makefile improvement 

				}

				elsif (/^#undef (.+)$/)

				{

					( $key, $value ) = ( $1, 'undefined' );

				}

				if ($key && ValidFeature($key))

				{

					# Warn the user if a macro appears to have changed value - shouldn't really happen

					# Feature macros should only be set in platform HRH files and not in the code

					if (exists $testedMacrosHash{$key} && $testedMacrosHash{$key} ne $value)

					{

						print "WARNING: Feature macro $key redefined from $testedMacrosHash{$key} to $value\n";

					}

					# Store the macro details

					$testedMacrosHash{$key} = $value;

				}

			}

			if (!close(CPP))

			{

				# this probably means that a rsg file was included

				# that hasn't been generated yet.

				print "Incomplete pre-process of $src\n" if ($verbose);

			}

		}

		else

		{

			print "ERROR: Could not pre-process $src\n";

			return "";

		}

	}

	# Now generate the tested macros string

	my $testedMacros = '';

	foreach my $key ( sort keys %testedMacrosHash )

	{

		$testedMacros .= ',' if $testedMacros;

		$testedMacros .= "$key=$testedMacrosHash{$key}";

	}

	print "Tested feature list: $testedMacros\n" if $verbose;

	return ( Digest::MD5::md5_hex($testedMacros), $testedMacros );

}

# Usage:	featurevariantmap->Save("my.dll", "1234", "myvar", \@hints)

#

# Write a hash value for a target into the target.vmap file along

# with some optional hints data.

#

# "my.dll"	- the target (full path)

# "1234"	- the hash value (32 character hex number)

# "myvar"	- the feature variant name

# \@hints	- optional list of extra strings (eg. "FEATUREVARIANT")

#

# returns 0 if OK and non-zero if an error occurs.

sub Save

{

	my $thisObj = shift;

	my $binName = shift;

	my $keyValue = shift;

	my $varName = shift;

	my $features = shift;

	my $hintRef = shift;

	# read the current data first if the .vmap file already exists

# modified by SV start: makefile improvement 

	my $vmapFile = "$binName.$varName.vmap";

	my @lines;

	my $tmpinfo = "$keyValue $varName";

	$tmpinfo .= " $features" if $features;

	if (open(VMAP, $vmapFile))

	{

		my @tmp=<VMAP>;

		if (grep (/$tmpinfo/, @tmp)){

			close(VMAP);

			return 0;

		}

		else {

			foreach  (@tmp)

			{

				if (/^\w{32}\s+(\w+)/)

				{

					push(@lines, $_) unless (uc($1) eq uc($varName));

				}

			}

			close(VMAP);

		}

	}

# modified by SV end: makefile improvement 

	# write the new data to the .vmap file

	if (!open(VMAP, ">$vmapFile"))

	{

		print "ERROR: Could not write VMAP to $vmapFile\n";

		return 1;

	}

	# put the hints at the beginning

	if ($hintRef)

	{

		foreach (@$hintRef)

		{

			print VMAP "$_\n";

		}

	}

	# then the "key var" pairs

	foreach (@lines)

	{

		print VMAP $_;

	}

	print VMAP "$keyValue $varName";

	print VMAP " $features" if $features;

	print VMAP "\n";

	close(VMAP);

	return 0;

}

# Usage:    featurevariantmap->Find("my.dll", "myvar")

#

# Look for a binary using its "final" name. We will use the feature

# variant map and the feature variant name to deduce the "variant"

# binary name and test for its existence.

#

# "my.dll"	- the final target (full path)

# "myvar"	- the feature variant name

#

# returns the file name if found, or "" otherwise.

sub Find

{

	my $thisObj = shift;

	my $binName = shift;

	my $varName = shift;

	# look for the vmap file

# modified by SV start: makefile improvement 

	my $vmapFile = "$binName.$varName.vmap";

# modified by SV end: makefile improvement 

	if (-e $vmapFile)

	{

		my $key = $thisObj->GetKeyFromVMAP($varName, $vmapFile);

		if ($key)

		{

			$binName =~ /^(.*)\.([^\.]*)$/;

			$binName = "$1.$key.$2";

		}

		else

		{

			print "ERROR: No \'$varName\' variant for $binName in $vmapFile\n";

			return "";	# file not found

		}

	}

	# check that the actual binary exists

	if (-e $binName)

	{

		return $binName;

	}

	return "";	# file not found

}

# internal functions

sub GetKeyFromVMAP

	{

	my $thisObj = shift;

	my @res = $thisObj->GetDataFromVMAP(@_);

	return $res[0];

	}

# Usage:    featurevariantmap->GetDataFromVMAP("myvar", "mydll.vmap")

#

# Opens the vmap file indicated and returns the data for the requested variant

#

# "myvar"	- the feature variant name

# "my.vmap"	- the final target vmap file (full path)

#

# Returns a list ( hash, features ) for the variant in the vmap or undef if not found

sub GetDataFromVMAP

{

	my $thisObj = shift;

	my $varName = shift;

	my $fileName = shift;

	if (!open(VMAP, $fileName))

	{

		print "ERROR: Could not read VMAP from $fileName\n";

		return "";

	}

	while (<VMAP>)

	{

		chomp;

		if (/(\w{32})\s+$varName\s+(.*)$/i or /(\w{32})\s+$varName$/i)

		{

			my ( $hash, $features ) = ( $1, $2 ? $2 : '' );

			close(VMAP);

			return ( $hash, $features );

		}

	}

	close(VMAP);

	return;

}

1;