Moving feature configuration out of the buildrom scope.
# Copyright (c) 2005-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:
# Routines involved in checking that source matches various filename policy constraints
#
#
package CheckSource;
require Exporter;
@ISA=qw(Exporter);
# Exported for clarity in calling scripts and modules
our $CheckSource_PhysicalCheck = 1;
our $CheckSource_NoUserSystemDistinction = 1;
@EXPORT=qw(
CheckSource_MetaData
CheckSource_Includes
CheckSource_ExportedIncludes
CheckSource_MakefileOutput
CheckSource_UnixSlash
CheckSource_Lowercase
CheckSource_Physical
$CheckSource_PhysicalCheck
$CheckSource_NoUserSystemDistinction
);
use Cwd;
use Pathutl;
use Win32;
my $exclusionsFile = $ENV{EPOCROOT}."epoc32\\tools\\filenamepolicyexclusions.txt";
my $makefileWarningPrefix = "\@echo ";
my $checksourcePrefix = "\@perl -S checksource.pl";
my $releaseLocationRoot = quotemeta ($ENV{EPOCROOT}."epoc32");
sub CheckSource_MetaData (\%$$$$;$;$)
{
my ($actionHash, $sourceFile, $item, $reference, $lineNumber, $physical, $offset) = @_;
return if ($reference =~ /^(\.|\.\.)$/);
my $checksourceCall = "$checksourcePrefix --metadata \"$sourceFile\" \"$item\" \"$reference\" $lineNumber";
$checksourceCall .= " $physical" if ($physical);
$checksourceCall .= " \"$offset\"" if ($offset);
$$actionHash{$checksourceCall} = 1;
}
sub CheckSource_UnixSlash (\%$$$$;$)
{
my ($actionHash, $sourceFile, $item, $reference, $lineNumber, $verbose) = @_;
$sourceFile =~ s/^[a-zA-Z]{1}://;
$item =~ s/PRJ_EXPORTS \(NO DESTINATION\)/PRJ_EXPORTS/;
print "Checking - Unix slash : $sourceFile ($lineNumber) - $item:$reference\n" if ($verbose);
if ($reference =~/\\/)
{
$$actionHash{constructWarning ($sourceFile, $lineNumber, $item, "Incorrect slash in", $reference)} = 1;
}
}
sub CheckSource_Lowercase (\%$$$;$;$)
{
my ($actionHash, $sourceFile, $item, $reference, $lineNumber, $verbose) = @_;
return if ($reference =~ /^[\/|\\]epoc32[\/|\\]tools[\/|\\].*$/);
$sourceFile =~ s/^[a-zA-Z]{1}://;
print "Checking - lowercase : $sourceFile ($lineNumber) - $item:$reference\n" if ($verbose);
my $exclusion = lowercaseExclusionCheck ($reference);
if ($exclusion eq "UNLISTED")
{
if ($reference =~ /[A-Z]/)
{
$$actionHash{constructWarning ($sourceFile, $lineNumber, $item, "Incorrect case for epoc32 tree in", $reference)} = 1;
}
}
elsif ($exclusion !~ /(OK|ERROR)/)
{
$$actionHash{constructWarning($sourceFile, $lineNumber, $item, "Incorrect case versus exclusion list in", $reference, " vs. $exclusion")} = 1;
}
}
sub CheckSource_Physical (\%$$$$;$;$)
{
my ($actionHash, $sourceFile, $item, $reference, $lineNumber, $path, $verbose) = @_;
print "Checking - physical : $sourceFile ($lineNumber) - $item:$reference:$path\n" if ($verbose);
my $physicalCheck;
my $searchText;
my $examineDefaultExportDestination = ($item =~ s/PRJ_EXPORTS \(NO DESTINATION\)/PRJ_EXPORTS/) ? 1 : 0;
if ($item eq "#include")
{
# In the case of #includes, the path passed in is already the fully pathed physical file
# that needs to be checked (as obtained from the parsed output of CPP)
$searchText = $reference;
$physicalCheck = $path;
}
else
{
my $physicalReference;
if (($item =~ /^PRJ_(TEST)?MMPFILES MMP/) && ($reference !~ /\.\w+$/i))
{
$physicalReference = $reference."\.mmp";
$searchText = $reference."\.*";
}
elsif ($item =~ /^DEFFILE/)
{
# The full path for DEFFILE entries is always passed in, so we just
# need to concentrate on sorting out the oddities for the search
# text and then just take the final file bit as the physical
# reference
$searchText = $reference;
$searchText .= "?\.*" if ($reference !~ /(\.def|[\\|\/])$/i);
$searchText =~ s/(\.def)/\?$1/i if ($item !~ /NOSTRICTDEF/);
$searchText =~ s/\~/\*/;
$physicalReference = $searchText;
$physicalReference =~ s/\//\\/g;
$physicalReference =~ s/\?/u/;
$physicalReference =~ s/\.\w+$/\.def/;
$physicalReference = &Path_Split ('File', $physicalReference);
}
else
{
$searchText = $reference;
$physicalReference = $searchText;
}
my $physicalLocation;
if ($path)
{
$physicalLocation = $path;
}
elsif ($reference =~ /^(\\|\/)/)
{
$physicalLocation = $ENV{EPOCROOT};
}
elsif ($reference =~ /^\+/)
{
$physicalLocation = $ENV{EPOCROOT}."epoc32\\";
}
elsif ($item =~ /EXTENSIONS/)
{
$physicalLocation = $ENV{EPOCROOT}."epoc32\\tools\\makefile_templates\\";
}
else
{
$physicalLocation = &Path_Split ('Path', $sourceFile);
}
$physicalReference =~ s/^[\\|\/]//;
$physicalCheck = $physicalLocation.$physicalReference;
}
$physicalCheck =~ s/\//\\/g;
$physicalCheck = &Path_Strip ($physicalCheck);
# If a file reference is actually under \epoc32, we just need to confirm that it's lowercase
if ($physicalCheck =~ /^$releaseLocationRoot/i)
{
CheckSource_Lowercase (%$actionHash, $sourceFile, $item, $reference, $lineNumber, $verbose);
return;
}
# Massage search text to provide something we can compare with a physical check on the filesystem
$searchText =~ s/\//\\/g;
$searchText =~ s/\.\.\\//g;
$searchText =~ s/\.\\//g;
$searchText =~ s/\\\\/\\/g;
my $warningSearchText = $searchText; # Record a more intelligible version of the search text for warning purposes
$searchText = quotemeta ($searchText);
$searchText =~ s/\\\*/\\w\+/g; # * -> \w+
$searchText =~ s/\\\?/\\w\{1\}/g; # ? -> \w{1}
my $physicalReality = getPhysical ($physicalCheck);
my $warningSuffix = "";
if (!$physicalReality)
{
$$actionHash{constructWarning($sourceFile, $lineNumber, $item, "Can\'t find physical file match for", $reference, " on filesystem")} = 1;
}
elsif ($physicalReality !~ /^.*$searchText$/)
{
if ($physicalReality !~ /^.*$searchText$/i)
{
# Doesn't just differ in case...something's gone wrong
$$actionHash{constructWarning($sourceFile, $lineNumber, $item, "Can\'t find physical file match for", $reference, " - match was attempted against $physicalReality")} = 1;
}
else
{
if (($item =~ /^DEFFILE/ || $item =~ /^PRJ_(TEST)?MMPFILES MMP/) && ($reference !~ /$searchText$/))
{
$warningSuffix .= " (actual test \'$warningSearchText\')"
}
$warningSuffix .= " vs. $physicalReality";
$$actionHash{constructWarning($sourceFile, $lineNumber, $item, "Incorrect case versus filesystem in", $reference, $warningSuffix)} = 1;
}
}
# Special case - PRJ_EXPORTS source lines with no destination must be normalised via a new destination compliant
# with the filename policy. FIXSOURCE will do this, but it needs a warning to work on
if ($examineDefaultExportDestination)
{
$physicalReality =~ /^.*($searchText)$/i;
my $defaultExportReference = $1;
my $exclusion = lowercaseExclusionCheck ($defaultExportReference);
if ($defaultExportReference =~ /[A-Z]/)
{
$$actionHash{constructWarning ($sourceFile, $lineNumber, $item, "Incorrect case for epoc32 tree from default export in", $reference, $warningSuffix)} = 1;
}
}
}
sub CheckSource_Includes ($\%$\@;\@;\@;$)
{
# References are used for array arguments only so that they can be distinguished within the subroutine
my ($sourceFile, $actionHash, $preInclude, $macros, $userIncludesRef, $systemIncludesRef, $noUserSystemDistinction) = @_;
my (@userIncludes, @systemIncludes);
@userIncludes = @$userIncludesRef if ($userIncludesRef);
@systemIncludes = @$systemIncludesRef if ($systemIncludesRef);
my $call = "$checksourcePrefix --preprocess -- ";
if (($sourceFile !~ /\.inf$/i) && ($sourceFile !~ /\.mmp/i))
{
push @$macros, "__SUPPORT_CPP_EXCEPTIONS__";
}
my $platformPreInclude = "";
foreach my $macro (@$macros)
{
$call .= "-D$macro ";
if ($macro =~ /__ARMCC_2_2__/)
{
$platformPreInclude = $ENV{EPOCROOT}."epoc32\\include\\rvct2_2\\rvct2_2.h";
if (($sourceFile =~ /BASE\\E32\\compsupp\\/i) && $ENV{RVCT22INC})
{
# Need some way to deal with ARMINC from the front-end...
my $rvctIncDir = $ENV{RVCT22INC};
push @systemIncludes, $rvctIncDir;
}
}
elsif ($macro =~ /__GCCE__/)
{
$platformPreInclude = $ENV{EPOCROOT}."epoc32\\include\\GCCE\\GCCE.h";
my $GCCEinstall = Cl_bpabi::getConfigVariable('COMPILER_INSTALL_PATH');
push @systemIncludes, "\"\\\"$GCCEinstall\\..\\lib\\gcc\\arm-none-symbianelf\\3.4.3\\include\\\"\"";
}
}
if ($preInclude ne "")
{
$call .= "-include ".getDrive().$preInclude." ";
push @systemIncludes, &Path_Split ('Path', getDrive().$preInclude);
}
if ($platformPreInclude ne "")
{
$call .= "-include ".getDrive().$platformPreInclude." ";
push @systemIncludes, &Path_Split ('Path', getDrive().$platformPreInclude);
}
# Enforce user and system includes in checksource processing.
foreach my $include (@userIncludes)
{
$include =~ s/\\$//;
$include = getDrive().$include if (($include !~ /^[a-zA-Z]:/) && ($include !~ /^[\"|\.]/));
$call .= "-I $include ";
}
$call .= "-I- " unless $noUserSystemDistinction;
foreach my $include (@systemIncludes)
{
$include =~ s/\\$//;
$include = getDrive().$include if (($include !~ /^[a-zA-Z]:/) && ($include !~ /^[\"|\.]/));
$call .= "-I $include ";
}
$sourceFile =~ s/\//\\/g;
$sourceFile = &Path_Strip ($sourceFile);
$sourceFile = getDrive().$sourceFile;
$call .= $sourceFile;
$$actionHash{$call} = 1;
return $call;
}
sub CheckSource_ExportedIncludes ($$\%)
{
my ($sourceFile, $destinationFile, $actionHash) = @_;
# Exclude exported files as appropriate
if ($destinationFile)
{
my $epoc32Include = quotemeta ($ENV{EPOCROOT})."epoc32\\\\include";
return if ($destinationFile !~ /^$epoc32Include/i);
return if ($destinationFile =~ /\.def$/i);
}
$$actionHash{"$checksourcePrefix --parsefile -- $sourceFile"} = 1;
}
sub CheckSource_MakefileOutput(%)
{
my (%actionHash) = @_;
return "\t\@rem\n" if !(keys (%actionHash));
my $output = "";
foreach (keys (%actionHash))
{
$output .= "\t$_\n";
}
return $output;
}
sub getDrive
{
if(cwd =~ /^([a-zA-Z]:)/)
{
return $1;
}
return "";
}
sub getPhysical ($)
{
my ($physicalReference) = @_;
my $physicalReality = Win32::GetLongPathName($physicalReference);
if ($physicalReality)
{
$physicalReality =~ s/^.*://;
$physicalReality = &Path_Strip ($physicalReality);
}
return $physicalReality;
}
sub constructWarning ($$$$$;$)
{
my ($sourceFile, $lineNumber, $item, $warningText, $reference, $suffix) = @_;
$sourceFile =~ s/\//\\/g;
$sourceFile = Win32::GetLongPathName($sourceFile);
$sourceFile =~ s/^[a-zA-Z]{1}://;
$sourceFile = &Path_Strip ($sourceFile);
my $warning = "";
$warning .= $sourceFile.":".$lineNumber.": ".$warningText." $item - \'".$reference."\'";
$warning .= $suffix if ($suffix);
$warning .= ".";
return $warning;
}
sub lowercaseExclusionCheck ($)
{
my ($reference) = @_;
# An exclusions file isn't mandatory
return "UNLISTED" if (! -e $exclusionsFile);
my $EXCLUSIONS;
if (!(open EXCLUSIONS, "< $exclusionsFile"))
{
print ("ERROR: Can't open $exclusionsFile in checksource processing.\n");
return "ERROR";
}
my $referenceDOSSlash = $reference;
$referenceDOSSlash =~ s/\//\\/g;
my $exclusionCheck = "UNLISTED";
while (my $exclusion = <EXCLUSIONS>)
{
next if ($exclusion =~ /^\s*$/);
$exclusion =~ s/^\s+//;
$exclusion =~ s/\s+$//;
$exclusion =~ s/\//\\/g;
my $quotemetaExclusion = quotemeta ($exclusion);
if ($referenceDOSSlash =~ /^$quotemetaExclusion$/i)
{
if ($referenceDOSSlash !~ /^$quotemetaExclusion$/)
{
$exclusionCheck = $exclusion;
}
else
{
$exclusionCheck = "OK";
}
last;
}
elsif($referenceDOSSlash =~ /\\$quotemetaExclusion$/i)
{
if ($referenceDOSSlash !~ /\\$quotemetaExclusion$/)
{
$exclusionCheck = $exclusion;
}
else
{
$exclusionCheck = "OK";
}
last;
}
}
close EXCLUSIONS;
return $exclusionCheck;
}
1;