# Copyright (c) 2001-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:

# Wrapper to support the EPOC AIF Compiler

# 

#

use FindBin;		# for FindBin::Bin

use File::Copy;		# for copy()

use Cwd;		# for cwd

use File::Basename;	# for basename()

my $PerlBinPath;	# fully qualified pathname of the directory containing this script

my $curdrive="x";	    	# will be initialised when first needed

# establish the path to the Perl binaries

BEGIN {

	require 5.005_03;		# check user has a version of perl that will cope

	$PerlBinPath = $FindBin::Bin;	# X:/epoc32/tools

	$PerlBinPath =~ s/\//\\/g;	# X:\epoc32\tools

}

use lib $PerlBinPath;

use E32Variant;         # for variant specific macros

use Pathutl;

use Preprocessor;

sub print_usage

	{

#........1.........2.........3.........4.........5.........6.........7.....

	print <<USAGE_EOF;

Usage:

  epocaif [options] srcfile [-o outputfile] [-t tmpdir] [-b "bmps" | -m mbm] [-l "TargetPath:CWD"]

The available options are

   -Ixxx  -- C++ preprocessor arguments

   -o	  -- output AIF file name including path

   -t	  -- tempory directory for intermediate files

   -b	  -- list of bitmaps Eg., "-b/c8\\location\\bmp1 /c8\\location\\bmp2.."

   -m	  -- compiled MBM file (alternative to -b)

   -l	  -- if specified, captures all source to \\epoc32\\localisation\\...

The aif resource file is then passed through the C++ preprocessor, using any 

specified preprocessor arguments, and then compiled with RCOMP.EXE to 

generate a compiled resource.

The -m or -b option is used to generate a suitable MBM file, if required.

The MBM and the compiled resource are then combined to produce an AIF file.

USAGE_EOF

	}

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

# Process commandline arguments

#

# Can't use the Getopt package because it doesn't like the -D and -I style options

#

my $sourcefile="";

my $opt_o="";

my $opt_h="";	

my $tmpdir="";

my $opt_v=1;

my $opt_b="";

my $opt_l="";

my $opt_m="";

my $TrgPath;

my $xipaif=1;

my $exe = &PreprocessorToUseExe();

my $cpp_spec= "$exe -undef -C ";	    # preserve comments

my $errors = 0;

while (@ARGV)

	{

	my $arg = shift @ARGV;

	if ($arg =~ /^-I-$/)

		{

		$cpp_spec .= "-I- ";

		next;

		}

	if ($arg =~ /^-I(.*)$/)

		{

		$cpp_spec .= "-I ";

		if ($1 eq "")

		    {

		    $arg = shift @ARGV;

		    }

		else

		    {

		    $arg = $1;

		    }

		$cpp_spec .= quoted_path($arg)." ";

		next;

		}

	if ($arg =~ /^-v$/)

		{

		$opt_v =1;

		next;

		}

	if ($arg =~ /^-o(.*)$/)

		{

		$opt_o =$1;

		$TrgPath = $opt_o;

		next;

		}

	if ($arg =~ /^-t(.*)\\?$/)

		{

		$tmpdir =$1;

		next;

		}

	if ($arg =~ /^-b(.*)$/)

		{

		$opt_b =$1;

		next;

		}	

	if ($arg =~ /^-m(.*)$/)

		{

		$opt_m =$1;

		next;

		}	

	if ($arg =~ /^-l(.*)$/)

		{

		$opt_l =$1;

		next;

		}	

	if ($arg =~ /^-/)

		{

		print "Unknown arg: $arg\n";

		$errors++;

		next;

		}

	$sourcefile=$arg;

	}

if ($opt_m ne "" && $opt_b ne "")

	{

	print "Can't specify both -m and -b\n";

	$errors++;

	}

if ($errors || $sourcefile eq "")

	{

	print_usage();

	exit 1;

	}

my $rss_base = basename($sourcefile);

my ($rssfile) = split(/\./, $rss_base);	    # remove extension

my $rpp_name = "$tmpdir\\$rssfile.rpp";

my $outputfile="$tmpdir\\AIF.RSC";	

my $headerfile=$opt_h;

if ($opt_v)

	{

	print "* Source file:   $sourcefile\n";

	print "* Resource file: $outputfile\n" if ($outputfile ne "");

	}

$opt_o = "-o\"$outputfile\"" if ($outputfile ne "");

$opt_h = "-h\"$headerfile\"" if ($headerfile ne "");

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

# Run the preprocessor

#

my $variantMacroHRHFile = Variant_GetMacroHRHFile();

if($variantMacroHRHFile){

    my $variantFilePath = Path_Split('Path',$variantMacroHRHFile);

    chop ( $variantFilePath );

    $cpp_spec .= " -I \"" . &Path_RltToWork($variantFilePath) . "\" -include " . &Path_RltToWork($variantMacroHRHFile) . " "; 

}

$cpp_spec .= "-I $PerlBinPath\\..\\include ";	# extra path to support shared tools

$cpp_spec .= "-D_UNICODE ";

$cpp_spec .= quoted_path($sourcefile) ." -o ". quoted_path($rpp_name);

print "* $cpp_spec\n" if ($opt_v);

system($cpp_spec);

my $cpp_status = $?;

die "* cpp failed\n" if ($cpp_status != 0);

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

# Copy source to epoc32\localisation

#

if ($opt_l ne "")

{

use lockit_info;

	my ($rssfile, $FileType) = split(/\./, basename($TrgPath));

	&Lockit_SrcFile($rssfile, $rpp_name, $opt_l, $FileType, $opt_b);

}

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

# Merge rls strings to rpp

#

&Merge_rls_string($rpp_name);

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

# Run the resource compiler

#

my $rcomp_spec = "rcomp -u ";

$rcomp_spec .= "-:$tmpdir\\_dump_of_resource_ "; # causes Rcomp to dump each resource (uncompressed and unpadded) in $tmpdir\\_dump_of_resource_1, $tmpdir\\_dump_of_resource_2, etc

$rcomp_spec .= "$opt_o $opt_h -s\"$rpp_name\" -i\"$sourcefile\"";

print "* $rcomp_spec\n" if ($opt_v);

system($rcomp_spec);

if ($? != 0)

	{

	print "* RCOMP failed - deleting output files\n";

	unlink $outputfile if ($outputfile ne "");

	unlink $headerfile if ($headerfile ne "");

	exit 1;

	}

print "* deleting $rpp_name\n" if ($opt_v);

unlink $rpp_name;

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

# Run bmconv, if needed

#

if ($opt_b ne "")

	{

	print "* bmconv /q $tmpdir\\AIF.MBM $opt_b\n" if ($opt_v);

	system("bmconv /q $tmpdir\\AIF.MBM $opt_b");

	if ($? != 0)

		{

		print "* BMCONV failed\n";

		exit 1;

		}

	print "* bmconv /q /s $tmpdir\\AIF_XIP.MBM $opt_b\n" if ($opt_v);

	system("bmconv /q /s $tmpdir\\AIF_xip.MBM $opt_b");

	if ($? != 0)

		{

		print "* BMCONV failed\n";

		exit 1;

		}

	}

elsif ($opt_m ne "")

	{

	print "* copy $opt_m $tmpdir\\AIF.MBM\n" if ($opt_v); 

	copy($opt_m, "$tmpdir\\AIF.MBM");

	# no xip file genarated 

	$xipaif=0;

	}

else

	{

	# no bitmap specified - this is legitimate

	unlink("$tmpdir\\AIF.MBM");

	unlink("$tmpdir\\AIF_xip.MBM");

	}

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

# Get the from UID from the first four bytes of "$tmpdir\\_dump_of_resource_1"

#

open(DUMP_OF_RESOURCE_1, "< $tmpdir\\_dump_of_resource_1") or die("* Can't open dump file\n");

binmode(DUMP_OF_RESOURCE_1);

my $data;

my $numberOfBytesRead=read(DUMP_OF_RESOURCE_1, $data, 4);

defined($numberOfBytesRead) or die("* Can't read from dump file\n");

($numberOfBytesRead>=4) or die("* Dump file too short\n");

my $uid=(unpack('V', $data))[0];

undef($data);

undef($numberOfBytesRead);

close(DUMP_OF_RESOURCE_1) or die("* Can't close dump file\n");

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

# Produce the AIF file from the RSC and MBM files

#

my $uidcrc = "uidcrc.exe 0x101fb032 0 ".sprintf('0x%08x', $uid)." $tmpdir\\out.aif";

my $uidcrc_xip = "uidcrc.exe 0x101fb032 0 ".sprintf('0x%08x', $uid)." $tmpdir\\out_xip.aif";

print "* $uidcrc\n" if ($opt_v);

system($uidcrc);

if ($? != 0)

	{

	print "* UIDCRC failed\n";

	exit 1;

	}

if ($xipaif ne 0)

	{	

	print "* $uidcrc\n" if ($opt_v);

	system($uidcrc_xip);

	if ($? != 0)

		{

		print "* UIDCRC failed\n";

		exit 1;

		}

	}

open(OUT_AIF, ">> $tmpdir\\out.aif") or die("* Can't open temporary file\n");

binmode(OUT_AIF);

if ($xipaif ne 0)

	{

	open(OUTXIP_AIF, ">> $tmpdir\\out_xip.aif") or die("* Can't open temporary file\n");

	binmode(OUTXIP_AIF);

	}

print "* Writing length of the RSC-block\n" if ($opt_v);

my $lengthOfRscBlock=-s("$tmpdir\\aif.rsc");

my $numberOfPaddingBytes=(4-($lengthOfRscBlock%4))%4;

print(OUT_AIF pack('V', $lengthOfRscBlock));

if ($xipaif ne 0)

	{

	print(OUTXIP_AIF pack('V', $lengthOfRscBlock));

	}

print "* Appending the RSC-block\n" if ($opt_v);

&appendFile(\*OUT_AIF, "$tmpdir\\aif.rsc");

if ($xipaif ne 0)

	{

	&appendFile(\*OUTXIP_AIF, "$tmpdir\\aif.rsc");

	}

# append any necessary padding bytes so that the file-offset of the start of the MBM-block is a multiple of 4-bytes

print(OUT_AIF ('_' x $numberOfPaddingBytes));

if ($xipaif ne 0)

	{

	print(OUTXIP_AIF ('_' x $numberOfPaddingBytes));

	}

if (-e("$tmpdir\\aif.mbm"))

	{

	print "* Appending the MBM-block\n" if ($opt_v);

	&appendFile(\*OUT_AIF, "$tmpdir\\aif.mbm");

	}

if (-e("$tmpdir\\aif_xip.mbm"))

	{

	print "* Appending the XIPMBM-block\n" if ($opt_v);

	&appendFile(\*OUTXIP_AIF, "$tmpdir\\aif_xip.mbm");

	}

close(OUT_AIF) or die("* Can't close temporary file\n");

if ($xipaif ne 0)

	{

	close(OUTXIP_AIF) or die("* Can't close temporary file\n");

	}

print "* copy $tmpdir\\out.aif $TrgPath\n" if ($opt_v);

copy("$tmpdir\\out.aif", "$TrgPath");

if ($xipaif ne 0)

	{

	my $basepath = &Path_Split('Path', $TrgPath);

	my $ext=&Path_Split('Ext',  $TrgPath);

	my $basename = basename($TrgPath, $ext);

	my $xip="_xip";

	print "* copy $tmpdir\\out_xip.aif $basepath$basename$xip$ext\n" if ($opt_v);

	copy("$tmpdir\\out_xip.aif", "$basepath$basename$xip$ext");

	}

unlink("$tmpdir\\_dump_of_resource_*");

unlink("$tmpdir\\aif.rsc");

unlink("$tmpdir\\aif.mbm");

unlink("$tmpdir\\out.aif");

unlink("$tmpdir\\aif_xip.mbm");

unlink("$tmpdir\\out_xip.aif");

exit 0;

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

# Subroutine: convert path into something acceptable to CPP.EXE

#

sub quoted_path

    {

    my ($arg) = @_;

    return "\"$arg\"" if ($arg !~ /^\\[^\\]/);	# not an absolute path

    if ($curdrive eq "x")

		{

		$curdrive="";

		$curdrive=$1 if (cwd =~ /^(.:)/);	

		}

    return "\"$curdrive$arg\"";

    }

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

# Subroutine: Merge the rls strings in the rpp file specified

#

sub Merge_rls_string

	{

	my ($rppfile) = @_;

	my $line;

	my $StringId;

	my $key;

	my $value;

	my $StringToSubstitute;

	my %ResourceString;

	print "* merging text strings to $rppfile\n" if ($opt_v);

	open NEWRPP, ">$rppfile.new" or die "* Can't write to $rppfile.new";

	open RPP, "$rppfile" or die "* Can't open $rppfile";

	while ($line = <RPP>) 	{

		while (($StringId, $StringToSubstitute)=each %ResourceString)

		{

			$line=~s/\b$StringId\b/$StringToSubstitute/g if ($line !~ /^rls_string/);

		}

		# find quoted "" strings

		if($line =~ /^rls_string\s+(\S+)\s+(.*$)/)

		{

			my $text = $2;

			$key = $1;

			$line=~s/(.*)/\/\/$1/;

			my $substr_count = 0;

			if(!exists $ResourceString{$key})

			{

			SUBSTR:	while (1)

			{

				# find quoted "" strings e.g. "hello"

				if($text =~ /^(\s*\"(.*?\\.)*.*?\")/)		

				{

					$value = $1;

					$text = $';

					++$substr_count;

				}

				# find quoted '' strings. e.g. 'world'

				elsif($text =~ /^(\s*\'(.*?\\.)*.*?\')/)			

				{

					$value = $1;

					$text = $';

					++$substr_count;

				}

				# find hex strings e.g. <0x34><0x45><0x65>

				elsif($text =~ /^(\s*(<.*?>)+)/)		

				{

					$value = $1;

					$text = $';

					++$substr_count;

				}

				# find c comment e.g. /*hello world*/ (may exist between strings)

				elsif($text =~ /^(\s*\/\*.*?\*\/)/)		

				{

					$text = $';

					next SUBSTR; # ignore embedded comment

				}

				# find c++ comment e.g. //hello world (may exist after strings)

				elsif($text =~ /^(\s*\/\/.*$)/)		

				{

					$text = $';

					next SUBSTR; # ignore trailing comment

				}

				# exit search

				else

				{

					if ($substr_count == 0)

					{

						warn("WARNING: rls_string $key either has incorrect syntax or no value\n");

					}

					last SUBSTR;

				}

			$ResourceString{$key} .= $value;

			}

		  	}

		}

		print NEWRPP $line;

	}

	close RPP;

	close NEWRPP;

	copy ("$rppfile.new", "$rppfile");

	unlink ("$rppfile.new");

	}

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

# Subroutine: Append a file into the open (binary) file already opened

#

sub appendFile

	{

	my $fileHandleOfTarget=shift;

	my $fileNameOfSource=shift;

	open(SOURCE, "< $fileNameOfSource") or die("* Can't open $fileNameOfSource\n");

	binmode(SOURCE);

	for (;;)

		{

		my $data;

		my $numberOfBytesRead=read(SOURCE, $data, 1024);

		defined($numberOfBytesRead) or die("* Can't read from $fileNameOfSource\n");

		if ($numberOfBytesRead==0)

			{

			last;

			}

		print($fileHandleOfTarget $data);

		}

	close(SOURCE) or die("* Can't close $fileNameOfSource\n");

	}