#

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

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "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: 

#

#------------------------------------------------------------------------------

# Name   : Localiser.pm

# Use    : Implementation of a new localisation process.

#

# Version History :

#

# v1.1.2 (30/01/2008) : Valliappan Ramanathan - ISIS

#  - Updated to build with EC build

#

# v1.1.1 (04/08/2006) :

#  - Update include management, now it uses cpp.

#

# v1.1.0 (12/05/2006) :

#  - Corrected include parsing, remove that fact that file must start with \

#  - Added locales_xx.iby creation

#

# v1.0.1 (12/05/2006) :

#  - Corrected __MakeRlt function

#

# v1.0 (19/04/2006) :

#  - First version of the script.

#------------------------------------------------------------------------------

## @ file

#

#------------------------------------------------------------------------------

# Package __OUT

#------------------------------------------------------------------------------

package __OUT;

use strict;

my $outputer = "__OUT";

sub SetLoggerPackage

{

	my ($p) = shift;

	return unless($p);

	$outputer = $p;

}

sub AUTOLOAD

{

	my ($method) = (our $AUTOLOAD);	

	if ( $outputer eq "__OUT" )

	{

		$method =~ s/^__OUT:://;

		if ($method =~ /print/i)

		{

			print ("@_");

		}

		elsif ($method =~ /die/i)

		{

			die (@_);

		}

		else

		{

			print (uc($method).": @_");

		}

	}

	elsif ( defined ($outputer) and defined($method) )

	{

		print "@_\n" if ($method =~ /die/i);		

		$method =~ s/^__OUT::/$outputer\::/;

		no strict 'refs';

		&$method( @_ );

	}

}

1;

## @class ZipUp

#

#

#

package ZipUp;

use strict;

use Archive::Zip;

use File::Copy;

sub new

{

	my ( $class, $filename ) = @_;

	return undef unless ($filename);

	my $self = {

		__filename => $filename,

	};

	return bless $self, $class;

}

sub AddFile

{

	my ( $self, $filename ) = (shift,shift);

	&__OUT::Print ("Adding '\\$filename'\n");	

	my $cmd = "zip ".$self->{ __filename }." $filename\n";

	&__OUT::Print (scalar(`$cmd`));

}

sub AddFilesFromList

{

	my ( $self, $listfilename ) = (shift,shift);

	if ( -e $listfilename )

	{

		&__OUT::Print ("Adding files using '$listfilename'\n");		

			my $cmd = "more $listfilename | zip -9 ".$self->{ __filename }." -@";

		&__OUT::Print ( $cmd."\n" );

		&__OUT::Print ( scalar( `$cmd` ) );

	}		

}

1;

## @class Finder

#

#

#

package Finder;

sub new

{

	my ( $class, $regexp, $rootdir ) = @_;

	my $self = {

		__rootdir => $rootdir,

		__regexp => $regexp,

	};

	return bless $self, $class;

}

sub Find

{

	my ($self, $dir, $list) = @_;

	my @fake;

	$list = \@fake unless (defined ($list));

	$dir = $self->{__rootdir} unless (defined($dir));

	opendir (DIR, $dir);

	my @l = readdir(DIR);

	closedir(DIR);

	foreach my $name (@l)

	{

		next if ($name =~ /^\.+$/);

		my $filename = "$dir/$name";

		if ( -d $filename )

		{

			$self->Find($filename, $list);

		}

		elsif ( $filename =~ /$self->{__regexp}/i )

		{			

			push @$list, $filename;

		}		

	}

	return $list;

}

1;

## @class Localiser

#

#

package Localiser;

use strict;

use File::Path;

#use ISIS::GenBuildTools;

use IPC::Open3;

use File::Spec;  

use File::Basename;

my $DEFAULT_LOC_PATH = "\\s60\\S60LocFiles";

use constant DEFAULT_XML_PATH => ".xml";

use constant DEFAULT_WHATXML_PATH => "_what.xml";

use constant DEFAULT_CHECKXML_PATH => "_check.xml";

use constant DEFAULT_TPATH => "\\zips";

use constant DEFAULT_MAKE_PATH => ".make";

use constant DEFAULT_WHATMAKE_PATH => "whatMakefile";

use constant DEFAULT_CHECKMAKE_PATH => "checkMakefile";

sub new

{

	my $class = shift;

	my $configfiles = shift;

	my $languagelist = shift;

	my $includepath = shift;

	my $bldfile = shift;

	my $tpath = shift || DEFAULT_TPATH;

	my @configuration;

	my %platform;# = ("armv5");

	my $self = {

		__configfiles => $configfiles,

		__includepath => $includepath,

		__languagelist => $languagelist,

		__configuration => \@configuration,

		__platform	=> \%platform,

		__tpath => $tpath,

		__bldfile => $bldfile

	};

	return bless $self, $class;	

}

sub DefaultLocPath

{

	my ($k) = @_;

	$DEFAULT_LOC_PATH = $k if (defined ($k));

	return $DEFAULT_LOC_PATH;

}

sub Keepgoing

{

	my ($self, $k) = @_;

	$self->{__keepgoing} = $k if (defined ($k));

	return $self->{__keepgoing};

}

sub SetLoggerPackage

{

	my ($self, $outputer) = @_;

	return unless($outputer);

	&__OUT::SetLoggerPackage($outputer);

}

sub Initialise()

{

	my $self = shift;

	my ($drive) = File::Spec->splitpath(File::Spec->rel2abs(File::Spec->curdir()));

	foreach my $filename ( @{ $self->{__configfiles} } )

	{

		# adding path of the input file into the include path list

		my $includepath = "";

		$includepath .= "-I ".File::Spec->rel2abs(dirname($filename));

		foreach my $path ( @{ $self->{__includepath} } )

		{

			$path = File::Spec->rel2abs($path);

			$path = "$drive$path" if ($path =~ /^\\/);			

			$includepath .= " -I $path";

		}

		# command line to execute

		my $cmd = "cpp -nostdinc -u $includepath ".File::Spec->rel2abs($filename);

		__OUT::Print( "$cmd\n");

		# parsing using cpp...

		my $childpid = open3(\*WTRFH, \*RDRFH, \*ERRFH, $cmd);

		close(WTRFH);

		while (<RDRFH>)

		{

				if ( /^\s*<option (\w+)>/ )

				{

					my $option = lc($1);

					$self->{ __platform }->{ $option } = $option; # if ($option =~ /^(armv5|winscw)$/i);

				}

				else

				{

					my $c = &__LocInfoData::CreateFromLine( $_ );

					push ( @{ $self->{__configuration} }, $c ) if ($c);

				}

		}

		close(RDRFH);	

		# Manage cpp errors

		my $err = "";

		while(<ERRFH>) { $err .= "$_\n";}

		if (not ($err eq "")){ __OUT::Error ("$err"); }

		# Closing cleanly....

		close(ERRFH);

		waitpid($childpid, 0);

	}

	# if not platform add default one: armv5

	unless (scalar (keys (%{$self->{ __platform }}) ))

	{

		__OUT::Warning("No platform specified, using default (ARMV5)");

		$self->{ __platform }->{ 'armv5' } = 'armv5';

	}

}

sub CheckConfig

{

	my $self = shift;

	my $result = 1;

	foreach my $c ( @{ $self->{__configuration} } )

	{

		$result &&= $c->CheckBldInf();

		$result &&= $c->CheckLocFiles();

	}	

	return $result;

}

sub PrepareLocalisation

{

	my $self = shift;

	my $filename = shift;

	my $zip = new ZipUp($filename);

	__OUT::Print ("Preparing each component\n");

	foreach my $c ( @{ $self->{__configuration} } )

	{

		$c->ZipUpLocFiles( $zip );

	}

	HandleEpoc32LocFiles( $self-> { __languagelist }, $zip );

	my $time1;

	my $time2;

	$time1 = time();

	foreach my $c ( @{ $self->{__configuration} } )

	{

		$c->GenerateStubLocFiles( $self-> { __languagelist } );

		$c->ChangeMMPsAndMKs( $self-> { __languagelist }, $zip );

		$c->TouchRSS();

	}

	$time2 = time();

	my $time = $time2 - $time1;

__OUT::Print ("time for loc file / mmp changes: $time\n");

}

sub GenerateMakefiles

{

	my $self = shift;

	my $time1;

	my $time2;

	$time1 = time();

	__OUT::Print ("Generating Makefiles for EC\n");

	$self->__GenerateECMakefile();

	#$self->__GenerateWhatECMakefile();

	#$self->__GenerateCheckECMakefile();

	$time2 = time();

	my $time = $time2 - $time1;

__OUT::Print ("time for GenerateMakefiles: $time\n");

}

sub GenerateXMLFiles

{

	my $self = shift;

	__OUT::Print ("Generating XML for TBS\n");

	$self->__GenerateTBSXML();

	$self->__GenerateWhatTBSXML();

	$self->__GenerateCheckTBSXML();

}

sub __GenerateTBSXML

{

	my $self = shift;

	my $xmlfile = $self->{ __bldfile }."".DEFAULT_XML_PATH;

	open (XML, ">$xmlfile") or __OUT::Die ("Cannot open '$xmlfile':$!");

	print 	XML "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";

	print 	XML "<Product Name=\"$xmlfile\">\n";

	print 	XML "\t<Commands>\n";

	my $id = 1;

	my $stage = 1;

	print XML "\t\t<SetEnv Order = \"1\" Name = \"EPOCROOT\" Value = \"\\\"/>\n";

	print XML "\t\t<SetEnv Order = \"2\" Name = \"PATH\" Value = \"\\epoc32\\gcc\\bin;\\epoc32\\tools;%PATH%\"/>\n";

	# bldmake bldfiles

	foreach my $c ( @{ $self->{__configuration} } )

	{

		#<Execute CommandLine="call bldmake bldfiles -k" Component="\s60\icons" Cwd="\s60\icons\group" ID="2" Stage="1" />

		print XML "		<Execute CommandLine=\"call bldmake bldfiles -k\" Component=\"".$c->GetPath()."\" Cwd=\"".$c->GetPath()."\\".$c->GetGroup()."\" ID=\"".$id++."\" Stage=\"$stage\" />\n";

	}

	$stage++;

	# abld makefile

	foreach my $p ( keys (%{ $self->{ __platform } }) )

	{

		foreach my $c ( @{ $self->{__configuration} } )

		{

			foreach my $mmp ( @{$c->GetMMPs()} )

			{

					print XML "		<Execute CommandLine=\"call abld makefile $p ".$mmp." -k\" Component=\"".$c->GetPath()."\" Cwd=\"".$c->GetPath()."\\".$c->GetGroup()."\" ID=\"".$id++."\" Stage=\"$stage\" />\n";

			}

		}

		# Next platform

		$stage++;

	}

	# abld resource

	foreach my $p ( keys (%{ $self->{ __platform } }) )

	{  			

		foreach my $c ( @{ $self->{__configuration} } )

		{

			foreach my $mmp ( @{ $c->GetMMPs() } )

			{ 		

				if ( $c->GetMMPType($mmp) eq 'mmp')

				{

						print XML "		<Execute CommandLine=\"call abld resource $p ".$mmp." -k\" Component=\"".$c->GetPath()."\" Cwd=\"".$c->GetPath()."\\".$c->GetGroup()."\" ID=\"".$id++."\" Stage=\"$stage\" />\n";

				}

			}

		}

		# Next platform

		$stage++;

	}

	#

	# Mk are treated by languages

	#

	foreach my $lang ( @{ $self-> { __languagelist } } )

	{  			

		foreach my $p ( keys (%{ $self->{ __platform } }) )

		{  			

			foreach my $c ( @{ $self->{__configuration} } )

			{

				foreach my $mmp ( @{ $c->GetMMPs() } )

				{

					if ( $c->GetMMPType($mmp) eq 'mk')

					{

							print XML "		<Execute CommandLine=\"set LANGUAGE=$lang &amp;&amp; call abld resource $p ".$mmp." -k\" Component=\"".$c->GetPath()."\" Cwd=\"".$c->GetPath()."\\".$c->GetGroup()."\" ID=\"".$id++."\" Stage=\"$stage\" />\n";

					}

				}

			}

			# Next platform...

			$stage++;

		}

	}

	print 	XML "	</Commands>\n";

	print 	XML "</Product>\n";	

	close(XML);

}

sub __GenerateWhatTBSXML

{

	my $self = shift;

		my $xmlfile = $self->{ __bldfile }."".DEFAULT_WHATXML_PATH;

	open (XML, ">$xmlfile") or __OUT::Die ("Cannot open '$xmlfile':$!");

	print 	XML "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";

	print 	XML "<Product Name=\"$xmlfile\">\n";

	print 	XML "\t<Commands>\n";

	my $id = 1;

	my $stage = 1;

	print XML "\t\t<SetEnv Order = \"1\" Name = \"EPOCROOT\" Value = \"\\\"/>\n";

	print XML "\t\t<SetEnv Order = \"2\" Name = \"PATH\" Value = \"\\epoc32\\gcc\\bin;\\epoc32\\tools;%PATH%\"/>\n";

	# abld resource

	foreach my $c ( @{ $self->{__configuration} } )

	{

		foreach my $mmp ( @{$c->GetMMPs()} )

		{

			if ( $c->GetMMPType($mmp) eq 'mk')

			{

				foreach my $lang ( @{ $self-> { __languagelist } } )

				{  			

					foreach my $p ( keys (%{ $self->{ __platform } }) )

					{  			

						print XML "		<Execute CommandLine=\"set LANGUAGE=$lang &amp;&amp; call abld build $p ".$mmp." -w\" Component=\"".$c->GetPath()."\" Cwd=\"".$c->GetPath()."\\".$c->GetGroup()."\" ID=\"".$id++."\" Stage=\"$stage\" />\n";

					}

				}

			}

			else

			{

				foreach my $p ( keys (%{ $self->{ __platform } }) )

				{

					print XML "		<Execute CommandLine=\"call abld build $p ".$mmp." -w\" Component=\"".$c->GetPath()."\" Cwd=\"".$c->GetPath()."\\".$c->GetGroup()."\" ID=\"".$id++."\" Stage=\"$stage\" />\n";

				}

			}

		}

	}

	$stage++;

	print 	XML "	</Commands>\n";

	print 	XML "</Product>\n";	

	close(XML);

}

sub __GenerateCheckTBSXML

{

	my $self = shift;

	my $xmlfile = $self->{ __bldfile }."".DEFAULT_CHECKXML_PATH;

	open (XML, ">$xmlfile") or __OUT::Die ("Cannot open '$xmlfile':$!");

	print 	XML "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";

	print 	XML "<Product Name=\"$xmlfile\">\n";

	print 	XML "\t<Commands>\n";

	my $id = 1;

	my $stage = 1;

	print XML "\t\t<SetEnv Order = \"1\" Name = \"EPOCROOT\" Value = \"\\\"/>\n";

	print XML "\t\t<SetEnv Order = \"2\" Name = \"PATH\" Value = \"\\epoc32\\gcc\\bin;\\epoc32\\tools;%PATH%\"/>\n";

	# abld resource

	foreach my $c ( @{ $self->{__configuration} } )

	{

		foreach my $mmp ( @{$c->GetMMPs()} )

		{

			if ( $c->GetMMPType($mmp) eq 'mk')

			{

				foreach my $lang ( @{ $self-> { __languagelist } } )

				{  			

					foreach my $p ( keys (%{ $self->{ __platform } }) )

					{