@rem

@rem Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

@rem All rights reserved.

@rem This component and the accompanying materials are made available

@rem under the terms of "Eclipse Public License v1.0"

@rem which accompanies this distribution, and is available

@rem at the URL "http://www.eclipse.org/legal/epl-v10.html".

@rem

@rem Initial Contributors:

@rem Nokia Corporation - initial contribution.

@rem

@rem Contributors:

@rem

@rem Description:

@rem

@rem = '--*-Perl-*--

@echo off

if "%OS%" == "Windows_NT" goto WinNT

perl -x -S "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9

goto endofperl

:WinNT

perl -x -S "%0" %*

if NOT "%COMSPEC%" == "%SystemRoot%\system32\cmd.exe" goto endofperl

if %errorlevel% == 9009 echo You do not have Perl in your PATH.

goto endofperl

@rem ';

#!perl

#line 14

use strict;

use Getopt::Long;

use File::Spec;

use File::Copy;

use File::Path;

use File::Basename;

my $toolVersion = "2.1";

# Example warnings:

#

# Incorrect slash

#	\src\common\generic\comms-infras\commsfw\group\bld.inf:10: Incorrect slash in PRJ_EXPORTS - '..\inc\commschan.h'.

#	\src\cedar\generic\base\f32\group\ecomp.mmp:14: Incorrect slash in SYSTEMINCLUDE - '..\inc'.

#	\src\common\generic\syncml\framework\TransportProvision\HttpWsp\SmlHttpBase.cpp:13: Incorrect slash in #include - 'http\rhttpheaders.h'.

#

# Incorrect case for epoc32 tree

#	\src\common\generic\syslibs\pwrcli\group\bld.inf:23: Incorrect case for epoc32 tree in PRJ_EXPORTS - '\epoc32\rom\include\PwrCli.IBY'.

#	\src\common\generic\security\crypto\group\hash.mmp:8: Incorrect case for epoc32 tree in TARGET - 'hash.DLL'.

#	\src\common\generic\syslibs\ecom\ongoing\Framework\frame\Discoverer.cpp:20: Incorrect case for epoc32 tree in #include - 'BaSPI.h'.

#

# Incorrect case versus filesystem

#	\src\common\generic\comms-infras\commdb\commdbshim\group\BLD.INF:20: Incorrect case versus filesystem in PRJ_EXPORTS - '..\inc\cdblen.h' vs. \src\common\generic\comms-infras\commdb\commdbshim\INC\CDBLEN.H.

#	\src\common\generic\syslibs\ecom\ongoing\Framework\MMPFiles\EComServer.mmp:45: Incorrect case versus filesystem in USERINCLUDE - '..\..\framework\inc' vs. \src\common\generic\syslibs\ecom\ongoing\Framework\inc.

#	\src\common\generic\comms-infras\commdb\commdbshim\INC\CDBOVER.H:16: Incorrect case versus filesystem in #include - 'cdbpreftable.h' vs. \src\common\generic\comms-infras\commdb\commdbshim\INC\CDBPREFTABLE.H.

#

# Incorrect case for epoc32 tree from default export (i.e. source export case will replicated under \epoc32)

#	\src\common\generic\application-protocols\http\group\bld.inf:22: Incorrect case for epoc32 tree from default export in PRJ_EXPORTS - '..\inc\HTTPSocketConstants.h'.

#	\src\common\generic\messaging\email\smtpservermtm\group\bld.inf:11: Incorrect case for epoc32 tree from default export in PRJ_EXPORTS - '..\inc\smts.h' vs. \src\common\generic\messaging\email\smtpservermtm\inc\SMTS.H.

#

# Incorrect case versus exclusion list

#	\src\common\generic\Multimedia\openmax\group\bld.inf:14: Incorrect case versus exclusion list in PRJ_EXPORTS - '\epoc32\include\openmax\il\OMX_Types.h' vs. OMX_TYPES.H.

#	\src\common\generic\Multimedia\openmax\inc\openmax\il\OMX_Audio.h:41: Incorrect case versus exclusion list in #include - 'OMX_Types.h' vs. OMX_TYPES.H.

#

# Can't find physical file match for

#	\src\common\generic\app-framework\conarc\group\BLD.INF:48: Can't find physical file match for PRJ_TESTMMPFILES MMP - '..\tsrc\tcon3_V2.mpp' on filesystem.

#

# 1. Check arguments, output help etc.

my $analyse = 0;

my $list = 0;

my $update = 0;

my $warnings = "";

my $verbose = 0;

my $debug = 0;

my $debugUpdate = 0;

GetOptions ('analyse|a' => \$analyse, 'list|l' => \$list, 'update|u' => \$update, 'warnings|w=s' => \$warnings,

			'verbose|v' => \$verbose, 'debug|d' => \$debug, 'debugupdate|du' => \$debugUpdate);

if (@ARGV == 0)

	{

	print (STDERR "\nFIXSOURCE.BAT - Version $toolVersion\n");

	print STDERR << 'END_OF_HELP';

Usage: fixsource.bat -analyse|-list|-update|-warnings buildlog_1.log [buildlog_n.log] 

Parses the output from the specified build logs to locate warnings produced via

"abld -checksource".  Provides the option to update source automatically to comply

with Symbian's Filename Policy.

-analyse | -a	             List and describe all warnings that cannot be addressed

                             by this tool.

-list    | -l	             List all source files that can be updated by this tool

                             using "-update".

-update  | -u	             Update source files, as output by "-list", to comply with

                             Symbian's Filename Policy.

-warnings| -w [all|fixable]  Output all unique "-checksource" warnings present in the

                             specified logs:

                                all     - every warning, regardless of whether this

                                          tool can fix them.

                                fixable - only warnings that this tool can fix.

-verbose | -v                Additional verbose output for the "-update" option.

NOTES:

* The tool assumes that the original build source and layout is present on the drive

  where it is being executed.

* With the exception of the "-warnings all" output, any warnings for files under the

  known release and build locations of %EPOCROOT%epoc32\include and

  %EPOCROOT%epoc32\build are discarded by default.

END_OF_HELP

	}

# 2. Parse the logs storing all GNU format warnings and errors

my %ActionableFilenamePolicyWarnings;	# Hash Key (filename)

										#	Hash Key (line number)

										#		Hash Key (problematic text)

										#			Hash Key ORIGINAL_WARNINGS

										#				Hash Key (original warning)

										#					1

										#			Hash Key ITEM

										#				item type that has generated the warning

										#			Hash Key SEARCH_TEXT

										#				quotemeta version of problematic text

										#			Hash Key UNIX_SLASH

										#				1

										#			Hash Key LOWERCASE

										#				1

										#			Hash Key PHYSICAL

										#				1

										#			Hash Key EXCLUSION

										#				1

										#			Hash Key PHYSICAL_REALITY

										#				Hash Key (physical reality)

										#					1

										#				fully pathed filesystem reality used in physical checking

										#			Hash Key EXCLUSION_LISTING

										#				required format of reference as dictated from an exclusion list

										#			Hash Key ACTUAL_TEST

										#				test used for check when this differed from that in actual source

										#			Hash Key DEFAULT_EXPORT

										#				special case - a PRJ_EXPORTS line without a destination will break

										#				the filename policy if the source line is not lowercase

my %NonActionableFilenamePolicyWarnings;

my %AllFilenamePolicyWarnings;

my %OtherWarningsAndErrors;

foreach my $BUILD_LOG (@ARGV)

	{

	open BUILD_LOG, "< $BUILD_LOG" or die "\nCannot read \"$BUILD_LOG\"!\n\n";

	while (<BUILD_LOG>)

		{

		chomp;

		if (/^\\\S+:.*: .+$/)

			{

			if (!/:\d+: (Incorrect case|Incorrect slash|Can\'t find) /)

				{

				$OtherWarningsAndErrors{$_} = 1 if (!/(unresolved api-item|unknown base class|unresolved xref|no image file|xm-replace_text)/);	# Ignore the noise of doc stuff...

				next;					

				}

			$AllFilenamePolicyWarnings{$_} = 1;

			if (/: Can\'t find /)

				{

				$NonActionableFilenamePolicyWarnings{$_} = 1;

				next;

				}

			my $originalWarning = $_;

			/(^.*):(\d+): Incorrect (case for epoc32 tree|case versus filesystem|case versus exclusion list|slash|case for epoc32 tree from default export) in (.+) - \'(.+?)\'/;

			my $filename = $1;

			my $lineNumber = $2;

			my $type = $3;

			my $item = $4;

			my $problematicText = $5;

			$type =~ s/case for epoc32 tree from default export/defaultexport/;

			$type =~ s/case for epoc32 tree/lowercase/;

			$type =~ s/case versus filesystem/physical/;

			$type =~ s/case versus exclusion list/exclusion/;

			my $actualTest = "";

			my $physicalReality = "";

			my $exclusionListing = "";

			$actualTest = $1 if (/\(actual test \'(.*)\'\)/);

			if (/ vs\. (.*)\./)

				{

				$physicalReality = $1 if ($type eq "physical");

				$exclusionListing = $1 if ($type eq "exclusion");

				}

			if ($debug)

				{

				print ("ORIGINAL WARNING   : $originalWarning\n");

				print ("FILENAME           : $filename\n");

				print ("LINENUMBER         : $lineNumber\n");

				print ("TYPE               : $type\n");

				print ("ITEM               : $item\n");

				print ("PROBLEMATIC TEXT   : $problematicText\n");

				print ("ACTUAL TEST        : $actualTest\n") if ($actualTest);

				print ("PHYSICAL REALITY   : $physicalReality\n") if ($physicalReality);

				print ("EXCLUSION LISTING  : $exclusionListing\n") if ($exclusionListing); 

				print ("\n");

				}

			next if ($warnings =~ /all/i);

	# Line Number

			my $lineNumberHashRef;

			if ($ActionableFilenamePolicyWarnings{$filename})

				{

				$lineNumberHashRef = $ActionableFilenamePolicyWarnings{$filename};

				}

			else

				{

				my %newHash;

				$lineNumberHashRef = \%newHash;

				$ActionableFilenamePolicyWarnings{$filename} = $lineNumberHashRef;

				}

	# Problematic Text

			my $problematicTextHashRef;

			if ($lineNumberHashRef->{$lineNumber})

				{

				$problematicTextHashRef = $lineNumberHashRef->{$lineNumber};

				}

			else

				{

				my %newHash;

				$problematicTextHashRef = \%newHash;

				$lineNumberHashRef->{$lineNumber} = $problematicTextHashRef;

				}

	# Attributes

			my $attributesHashRef;

			if ($problematicTextHashRef->{$problematicText})

				{

				$attributesHashRef = $problematicTextHashRef->{$problematicText};

				}

			else

				{

				my %newHash;

				$attributesHashRef = \%newHash;

				$problematicTextHashRef->{$problematicText} = $attributesHashRef;

				}

	# Attributes : Original Warnings

			my $originalWarningsHashRef;

			if ($attributesHashRef->{ORIGINAL_WARNINGS})

				{

				$originalWarningsHashRef = $attributesHashRef->{ORIGINAL_WARNINGS};

				}

			else

				{

				my %newHash;

				$originalWarningsHashRef = \%newHash;			

				$attributesHashRef->{ORIGINAL_WARNINGS} = $originalWarningsHashRef;

				}

			$originalWarningsHashRef->{$originalWarning} = 1;

	# Attributes : Item

			$attributesHashRef->{ITEM} = $item;

	# Attributes : Search Text

			$attributesHashRef->{SEARCH_TEXT} = quotemeta ($problematicText);

	# Attributes : Unix Slash

			$attributesHashRef->{UNIX_SLASH} = 1 if ($type eq "slash");

	# Attributes : Lowercase

			$attributesHashRef->{LOWERCASE} = 1 if ($type eq "lowercase");

	# Attributes : Physical

			$attributesHashRef->{PHYSICAL} = 1 if ($type eq "physical");

	# Attributes : Exclusion

			$attributesHashRef->{EXCLUSION} = 1 if ($type eq "exclusion");

	# Attributes : Physical Reality

			my $physicalRealityHashRef;

			if ($physicalReality)

				{

				if ($attributesHashRef->{PHYSICAL_REALITY})

					{

					$physicalRealityHashRef = $attributesHashRef->{PHYSICAL_REALITY};

					}

				else

					{

					my %newHash;

					$physicalRealityHashRef = \%newHash;			

					$attributesHashRef->{PHYSICAL_REALITY} = $physicalRealityHashRef;

					}

				$physicalRealityHashRef->{$physicalReality} = 1;

				}

	# Attributes : Actual Test

			$attributesHashRef->{ACTUAL_TEST} = $actualTest if ($actualTest);

	# Attributes : Exclusion Listing

			$attributesHashRef->{EXCLUSION_LISTING} = $exclusionListing if ($exclusionListing);

	# Attributes : Default Export

			$attributesHashRef->{DEFAULT_EXPORT} = 1 if ($type eq "defaultexport");

			}

		}

	close BUILD_LOG;

	}

# 3. Examine source and warnings and compile lists of files and warnings that we can/can't do anything about

my %WarningsNotMatchingSource;

my %WarningsWithMissingFiles;

my %WarningsForBothLowercaseAndPhysicalOnSameReference;

my %WarningsForMultiplePhysicalUpdates;

if ($analyse || $list || $update || $debugUpdate || $warnings =~ /^fixable$/i)

	{

	foreach my $SOURCE_FILE (sort keys %ActionableFilenamePolicyWarnings)

		{

	# Discard anything in known release locations

		if ($SOURCE_FILE =~ /\\epoc32\\(include|build)\\/i)

			{

			delete ($ActionableFilenamePolicyWarnings{$SOURCE_FILE});

			next;

			}

		my $lineNumbersHashRef = $ActionableFilenamePolicyWarnings{$SOURCE_FILE};

	# Discard warnings where source files cannot be found

		if (!(open SOURCE_FILE, "< $SOURCE_FILE"))

			{

			foreach my $lineNumber (sort keys (%$lineNumbersHashRef))

				{

				my $problematicTextHashRef = $lineNumbersHashRef->{$lineNumber};

				foreach my $problematicText (sort keys (%$problematicTextHashRef))

					{

					my $attributesHashRef = $problematicTextHashRef->{$problematicText};

					my $originalWarningsHashRef = $attributesHashRef->{ORIGINAL_WARNINGS};

					foreach my $originalWarning (keys (%$originalWarningsHashRef))

						{

						$WarningsWithMissingFiles{$originalWarning} = 1;

						}					

					}

				}

			delete ($ActionableFilenamePolicyWarnings{$SOURCE_FILE});

			next;

			}

	# Identify and discard warnings where, for the same reference:

	# (a) both lowercase and physical warnings are flagged and

	# (b) multiple, different, filesystem matches have been found

	# These will need to be resolved manually

		foreach my $lineNumber (sort keys (%$lineNumbersHashRef))

			{

			my $problematicTextHashRef = $lineNumbersHashRef->{$lineNumber};

			foreach my $problematicText (sort keys (%$problematicTextHashRef))

				{

				my $attributesHashRef = $problematicTextHashRef->{$problematicText};

				my $originalWarningsHashRef = $attributesHashRef->{ORIGINAL_WARNINGS};

				my $skipPhysicalUpdate = 0;

				my $skipLowercaseUpdate = 0;

				if ($attributesHashRef->{LOWERCASE} && $attributesHashRef->{PHYSICAL})

					{

					$skipPhysicalUpdate = 1;

					$skipLowercaseUpdate = 1;

					foreach my $originalWarning (keys %{$originalWarningsHashRef})

						{

						next if ($originalWarning !~ /Incorrect case/);

						$originalWarning =~ /\:(.*$)/;

						my $lowercaseAndPhysicalWarningsHashRef;	

						if ($WarningsForBothLowercaseAndPhysicalOnSameReference{$SOURCE_FILE})

							{

							$lowercaseAndPhysicalWarningsHashRef = $WarningsForBothLowercaseAndPhysicalOnSameReference{$SOURCE_FILE};

							}

						else

							{

							my %newHash;

							$lowercaseAndPhysicalWarningsHashRef = \%newHash;			

							$WarningsForBothLowercaseAndPhysicalOnSameReference{$SOURCE_FILE} = $lowercaseAndPhysicalWarningsHashRef;

							}

						$lowercaseAndPhysicalWarningsHashRef->{$1} = 1;						

						}

					}

				my $physicalRealityHashRef = $attributesHashRef->{PHYSICAL_REALITY};

				if ($physicalRealityHashRef && ((keys %{$physicalRealityHashRef}) > 1))

					{						

					my $physicalMatchCheck;

					if ($attributesHashRef->{ACTUAL_TEST})

						{

						$physicalMatchCheck = $attributesHashRef->{ACTUAL_TEST};

						}

					else

						{

						$physicalMatchCheck = $problematicText;

						$physicalMatchCheck =~ s/\.\.[\\|\/]//g;

						$physicalMatchCheck =~ s/\.[\\|\/]//g;

						}

					$physicalMatchCheck =~ s/\\\\/\\/g;		

					$physicalMatchCheck =~ s/\/\//\//g;

					$physicalMatchCheck =~ s/\//\\/g;

					$physicalMatchCheck = quotemeta($physicalMatchCheck);

					$physicalMatchCheck =~ s/\\\*/\\w\+/g;			# * -> \w+

					$physicalMatchCheck =~ s/\\\?/\\w\{1\}/g;		# ? -> \w{1}

					my %normalisedPhysicalReferences;

					foreach my $physicalReality (keys %{$physicalRealityHashRef})

						{

						$physicalReality =~ /($physicalMatchCheck)$/i;

						$normalisedPhysicalReferences{$1} = 1;

						}

					if ((keys (%normalisedPhysicalReferences)) > 1)

						{

						foreach my $originalWarning (keys %{$originalWarningsHashRef})

							{

							next if ($originalWarning !~ /Incorrect case versus/);

							$originalWarning =~ /\:(.*$)/;

							my $multiplePhysicalWarningsHashRef;	

							if ($WarningsForMultiplePhysicalUpdates{$SOURCE_FILE})

								{

								$multiplePhysicalWarningsHashRef = $WarningsForMultiplePhysicalUpdates{$SOURCE_FILE};

								}

							else

								{

								my %newHash;

								$multiplePhysicalWarningsHashRef = \%newHash;			

								$WarningsForMultiplePhysicalUpdates{$SOURCE_FILE} = $multiplePhysicalWarningsHashRef;

								}

							$multiplePhysicalWarningsHashRef->{$1} = 1;

							}

						$skipPhysicalUpdate = 1;

						}

					}

				$attributesHashRef->{LOWERCASE} = 0 if ($skipLowercaseUpdate);

				$attributesHashRef->{PHYSICAL} = 0 if ($skipPhysicalUpdate);

				if (!$attributesHashRef->{LOWERCASE} && !$attributesHashRef->{PHYSICAL} &&

					!$attributesHashRef->{UNIX_SLASH} && !$attributesHashRef->{DEFAULT_EXPORT} &&

					!$attributesHashRef->{EXCLUSION})

					{

					delete ($problematicTextHashRef->{$problematicText});

					}

				}

			delete ($lineNumbersHashRef->{$lineNumber}) if (!scalar (keys %{$problematicTextHashRef}));

			}

		my $lineNumber = 0;

		while (my $line = <SOURCE_FILE>)

			{

			$lineNumber++;

			next if (!($lineNumbersHashRef->{$lineNumber}));

			my $problematicTextHashRef = $lineNumbersHashRef->{$lineNumber};

			foreach my $text (keys %{$problematicTextHashRef})

				{

				my $attributesHashRef = $problematicTextHashRef->{$text};				

				chomp ($line);

				if ($line !~ /(\"|\<|^|\s){1}$attributesHashRef->{SEARCH_TEXT}/)

					{

					# Put warning(s) onto the failed list, as we can't find the required text

					# in the source present on the machine

					my $originalWarningsHashRef = $attributesHashRef->{ORIGINAL_WARNINGS};

					foreach my $originalWarning (keys %{$originalWarningsHashRef})

						{

						$WarningsNotMatchingSource{$originalWarning} = $line;

						}

					delete ($problematicTextHashRef->{$text});

					}

				}