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