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