#

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

# This package is to build rom image

#

package buildrom;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	image_content_processing_phase

	process_cmdline_arguments

	preprocessing_phase

	substitution_phase

	reorganize_phase

	plugin_phase

	multlinguify_phase

	spi_creation_phase

	suppress_phase

	bitmap_aif_converison_phase

	cleaning_phase

	create_dumpfile

	create_dirlisting

	suppress_image_generation

	invoke_rombuild

	getOBYDataRef

	isobystatement

	isdatastatement

	isspidatastatement

	isexecutablefile

	isdirectorymetadata

	isbitmap

	isaif

	isresource

	hardwarevariant

	executableextension

	executabletype

	getSourceFile

	getDestFile

	getOBYAttributes

	getHardwareVariant

	getObyCommand

	process_dlldata

	featurefile_creation_phase

	processData

	create_smrimage

);

my $useinterpretsis = 1;

if ($^O !~ /^MSWin32$/i){

	$useinterpretsis = 0;

}

my $enforceFeatureManager = 0; # Flag to make Feature Manager mandatory if SYMBIAN_FEATURE_MANAGER macro is defined. 

my $BuildromMajorVersion = 3 ;

my $BuildromMinorVersion = 26;

my $BuildromPatchVersion = 0;

sub print_usage

{

	# Option "-fm" will be supported instead of option "-f|fr" if SYMBIAN_FEATURE_MANAGER macro is defined.

	my $featuresOptionUsage = "-ffeatureuids or -fr=featureuids -- feature registry database XML file name";

	if ($enforceFeatureManager) 

	{

		$featuresOptionUsage = "-fm=featuredatabasefile          -- feature manager/feature registry database XML file name.\n".

							   "\t\t\t\t    Multiple XML files can be passed seperated by commas.\n".

							   "   -nofm=featuresdatafile           -- don't generate features data file.".

							   " Instead use pre-built features data file.";

	}

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

	print <<USAGE_EOF;

BUILDROM - ROM configuration tool V$BuildromMajorVersion.$BuildromMinorVersion.$BuildromPatchVersion

Usage:

  buildrom [options] obyfile [obyfile2 ...]   

Build a ROM according to the specification defined by concatenating the

specified obyfiles.

The initial specification is modified by C++ preprocessor directives,

and subsequently adjusted by statements in the ROM specification language.

The final specification is in the subset of the specification language

which is understood directly by ROMBUILD.

Each obyfile parameter specifies a file via a search path: if the

filename is not matched then buildrom will look in \/epoc32\/rom\/include.

Buildrom invokes ROMBUILD to generate the ROM image, and produces a

number of related files such as the ROM symbol file. The name of the

image file is specified directly by the -o option, or determined by 

scanning the final specification for the "romname" keyword. If there is 

more than one "romname" statement, the last one takes precedence.

The available options are

   -Dxxx                            -- C++ preprocessor arguments

   -oimagename                      -- ROM image name, overriding any ROMNAME statement

   -s                               -- strict option, any missing files will stop buildrom 

   -p                               -- preserves the intermediate files pertaining to data drive, Z drive and BMCONV

   -spi                             -- enable producing SPI files

   -spiplacement                    -- enable positioning of spi file

   -w                               -- warn if file has been selected from a different directory 

   $featuresOptionUsage

   -etool                           -- external tool specification (xx is tool's perl module)

   -compress                        -- compression type of ROM image:

                                       -compress compress whole ROM image.

                                       -compress=paged compress paged section in the ROM image only.

                                       -compress=unpaged compress unpaged section in the ROM image only. 

   -ccomprmethod                    -- compression method: none|inflate|bytepair

   -geninc                          -- generate INC file

   -gendep                          -- generate dependence graph for rom image

   -nosymbols                       -- disable creation of symbol file

   -noimage                         -- disable creation of ROM/ROFS/DataDrive Image

   -j<digit>                        -- do the main job with <digit> threads

   -cache                           -- allow the ROFSBUILD to reuse/generate cached executable files

   -nocache                         -- force the ROFSBUILD not to reuse/generate cached executable files

   -cleancache                      -- permanently remove all cached executable files

   -loglevel<level>                 -- Level of information logging where loglevel is 0,1,2

                                       0 default level of information

                                       1 host/ROM filenames, file size and the hidden attribute along with level0 log

                                       2 E32 file header attributes along with level1 log

   -z=xxx or -zdrivepath=xxx        -- specify a location to create Z drive directory. 

   -d=xxx or -datadrivepath=xxx     -- specify a location to create data drive directory.

   -k or -keepgoing                 -- enable keepgoing,continue to create the data drive image even

                                    if the non-sis, sis or zdrive image file(s) are missing or corrupt; create rom/rofs

									image even some oby files missing and/or duplicated definitions in oby files .

   -r or -retainfolder              -- enable retainfolder,would retain pre-existence of z & data drive folder. 

   -zdriveimage=xxx                 -- specify Z drive image (ROM, CORE, ROFS or Ext-ROFS image).

   -pfile=xxx                       -- specify a parameter file for interpretsis to take additional parameters.

   -argforinterpretsis=xxx          -- specify command line argument(s) for interpretsis which will override the 

                                    parameter file contents.

   -l=xxx or -logimagecontents=xxx  -- extract all stub-sis and SWI certificate store file(s) only 

                                    and log all the file(s) that are part of the Z drive image on to a log file.  

   -I<directory>                    -- Use <directory> for the referenced IBY/OBY files

   -argfile=xxx                     -- specify argument-file name containing list of command-line arguments to buildrom   

   -lowmem                          -- use memory-mapped file for image build to reduce physical memory consumption   

   -checkcase                       -- check character case of path/name in oby/iby files, 

                                    the result will be checkcase.log, this option is only valid on windows.

Popular -D defines to use include

   -D_DEBUG         -- select debug versions of some files

   -D_FULL_DEBUG    -- select debug versions of all files

   -D_ARM4          -- specify the target platform

   -D_EABI=xxxx     -- specify target for all files (e.g. armv5)

   -D_KABI=xxxx     -- specify the target platform for the Kernel (e.g. armv5)

Other defines may be useful for particular OBY files.

USAGE_EOF

}

use strict;

use romutl;

use romosvariant;

my $PerlEPOCPath = &get_epocroot()."epoc32\/tools\/";   # fully qualified pathname of the directory containing EPOC Perl modules

sub ExportDirs ($);

my $xmlrequired = 0; # assume xml required is false. Used to determine if xml

                     # modules should be loaded.

use flexmodload;	     # To load modules dynamically

# Work out the relative path to the epoc32 directory

use spitool qw(&createSpi);

use Cwd;

use externaltools; 	#To invoke External Tools

use File::Basename;

my @tempfiles;  	

my $preserve = 0; 	#flag to indicate if temporary files should be preserved

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

my $epocroot = &get_epocroot;

my @obyfiles;

my $cppargs = "-nostdinc -undef";

my $opt_v = 0;

my $opt_o = "";

my $strict = 0;

my $warnSelection = 0; # default is not warn about selecting files from 

		       # different directories when the file is missing from

		       # the specified directory

my $createspi = 0; # don't create SPI files by default

my $spiset=0;

my $spiplacement = 0; # enable the placement of spi file

my %spipositionflag = (); # map of Image index at which the keyword SPI_POSITION is used.

use constant NONE => 0;

use constant INFLATE => 1;

use constant BYTEPAIR => 2;

my $opt_compression;  # Default compression method parameter undefined

use constant UNCOMPRESSED   => 0;        # Indicates the ROM image will not be compressed.

use constant ALLSECTIONS    => 1;        # Indicates both paged section and unpaged section will be compressed.

use constant PAGEDSECTION   => 2;        # Indicates only paged section will be compressed.

use constant UNPAGEDSECTION => 3;        # Indicates only unpaged section will be compressed.

my $opt_compression_type = UNCOMPRESSED; # Leave the ROM image uncompressed by default.

#Variables to store cache command line options

my $opt_cache      = 0;

my $opt_nocache    = 0;

my $opt_cleancache = 0;

my $thisdir=cwd;

$thisdir=~s-\\-\/-go;		    # separator from Perl 5.005_02+ is forward slash

$thisdir.= "\/" unless $thisdir =~ /\/$/;

$thisdir =~ s-\/-\\-g if (&is_windows);

my $rominclude = $epocroot."epoc32\/rom\/include\/";

$rominclude = &get_epocdrive().$rominclude unless $rominclude =~ /^.:/;

$rominclude =~s-\\-\/-g;

my %plugintypes; #hash of plugin types and their SPI files' destinations in ROM

$plugintypes{"ECOM"} = "\/private\/10009d8f\/"; #ECOM SPI files' destination in ROM image

my @obydata;

my @newobydata;

my %substitutionData;

my @substitutionOrder;

my %languageCodes;

my $defaultLanguageCode;

my %multiLinguifyAlias;  # to by-pass the 'mustbesysbin' option for multilinguify 'alias'es. 

my $abiDowngrade = "";

my @binarySelectionOrder;

my $fromDIR;

my %rombuildOptions = ("-type-safe-link" => 1 );

my $enforceSysBin = 0;

my $line;

my $errors = 0;

my @romimage;

my $rombasename;

my $sourcefile;

my $sourceline;

#my $line;

my %romfiles;

# To handle BINARY_SELECTION_ORDER macro.

my $firstDIR;

my $binarySelectionOrderFlag = 0;

my %DllDataMap = ();	#Map to keep track of DLL Data patch statements.

my $patchDataStmtFlag = 0;

my $featuremanager = 0; #Flag to enable support for feature manager database XML file and to generate  

			# features data file.

my $noFeatureManager = 0; # Flag to stop the generation of features.dat file and use pre-built features.dat if provided.

my $preBuiltFeaturesDataFile  = ''; # To store the name of pre-built features.dat file provided with "-nofm" option.

#Image Content XML file that supports specific feature to be added

my $image_content = undef;

#Feature list XML file that acts as database containing all features details

my $featureXml = undef;

my $geninc = "";

my $gendep = "";

my $nosymbols = "";

my $noimage = "";

my $customizedPlat = undef;

my $opt_jobs= "";

#Summary of files(both executables and data files) currently includes 

#	host and ROM file names, 

#	size of the file in ROM

#	whether the file is hidden

# This option is added so that the above additional information is emitted by rombuild/rofsbuild tools

# only when supplied with this option so that the existing tools don't get affected.

my $logLevel="";

# This option is used to pass -lowmem argument to rombuild/rofsbuild tools

my $lowMem="";

# Feature Variation modules and data

my %featureVariant;

# global variables specific to data drive image generation. 

use File::Path;					# Module to provide functions to remove or create directories in a convenient way.

use File::Copy;					# Module to provide functions to copy file(s) from source to destination.

use File::Find;

use datadriveimage;				# module which provides all necessary functions to create data drive image.

my $ZDirloc = "";				# location of Z drive directory.

my $DataDriveDirloc = "";		# location of data drive directory.

my @sisfilelist;				# an array to hold sis file(s).

my @zDriveImageList;			# an array to hold z drive image name.

my @datadiveobydata;			# an array to hold data drive oby data.

my @datadriveimage;				# array which holds data drive image attribute.

my $rootdir = "";				# which holds root directory information.

my @datadrivedata;				# array to maintain list of lines taken from processed data drive oby file.

my @nonsisFilelist;				# array to maintain list of nonsis file(s). 

my @sisobydata;					# array to maintain all list of files(s) got by installing sis files. 

my @renameList;					# array to maintain list of file(s) that has to be renamed.

my @aliaslist;					# array to maintain list of file(s) that has to be made alias.

my @hideList;					# array to maintain list of file(s) that has to be made hidden.

my $sisfilepresent = 0;			# enable if sis file(s) are present.

my $stubsisfilepresent = 0;		# enable if stub-sis file(s) are present.

my $opt_k = 0;					# enable if keepgoing option is specified by the user.

my $opt_r = 0;					# enable if retain pre-existence of folder is specified by the user.

my $dataImageCount = 0;			# no of data drive image that has to generated.

my @zdriveImageName;			# list of Z drive image name(s) specified using zdriveimagename in oby/iby file.

my $opt_zimage = 0;				# enable if z drive image is found.

my $zDrivePresent = 0;			# flag to check whether Z drive needs to be created.

my @dataDriveFileList;			# list of processed data drive related files.

my $paraFile = undef;			# parameter file for interpretsis.

my @romImages;					# list of generated z drive image(s)(rom/rofs). 

my $imageEntryLogFile = undef;	# a log file to log all the z drive image contents.

my $opt_logFile = 0;			# enable if z drive entries has to be logged on to a log file.

my %dataIndexHash = ();			# a hash which holds key-value pair between datadrive index and datadrive image count.

my $interpretsisOpt = undef;	# enable if command line arguments are specified by the user to INTERPRETSIS.

my @interpretsisOptList;		# an array which holds all the list of option(s) that needs to passed to INTERPRETSIS. 

my @Global_BPABIPlats;

my @Global_PlatList;

my @smrImageFileList;

my $needSmrImage = 0;

my %smrPartitions;

my %smrNameInfo;

my @obeyFileList;

my $smrNoImageName = 0;

my $onlysmrimage = 1;

my $checkcase = 0;

my $checkcase_platform = "";

my $checkcase_test = 0;

my $opt_workdir = 0;

sub match_obyfile

{

	my ($obyfile) = @_;

	if (-f $obyfile)

	{

		push @obyfiles, $obyfile;

		return 1;

	}

	# search for the oby file in the list of include directories

	my @otherDirs = ($rominclude);

	if ($featureVariant{'VALID'})

	{

		my $dirRef = $featureVariant{'ROM_INCLUDES'};

		@otherDirs = @$dirRef if ($dirRef);

	}

	foreach my $dir (@otherDirs)

	{

		print "$dir/$obyfile\n" if ($opt_v);

		if (-f "$dir/$obyfile")

		{

		    push @obyfiles, "$dir/$obyfile";

		    return 1;

		}

	}

	return 0;

}

# This function invokes ROFSBUILD tool with appropriate parameters to generate data drive image.

# It also deletes zdrive and datadrive folder after all the image has been processed and generated

# if and only if preserve(-p) option is disabled.

sub create_datadriveImage

{

	for (my $dataidx=0; $dataidx < $dataImageCount; $dataidx++)

	{

		my $driveIndex = $dataIndexHash{$dataidx};

		if(defined($driveIndex))

		{

			my $obeyfile=$datadriveimage[$driveIndex]{obeyfile};

			my $compress=$datadriveimage[$driveIndex]{compress};

			my $uncompress=$datadriveimage[$driveIndex]{uncompress};

			if ($obeyfile)

			{

				if(!defined $opt_compression)

				{

					if ($compress ne 0)

					{

						$compress=" -compress";

					}

					elsif($uncompress ne 0)

					{

						$compress=" -uncompress";

					}

					elsif($compress eq 0)

					{

						$compress=" ";

					}

				}

				else

				{

					$compress = $opt_compression;

					$compress =~m/\s-(compression)(method)\s(none|inflate|bytepair)/;

					print "* ".$1." ".$2.": ".$3;

				}

				my $command = "rofsbuild -slog".$compress." -datadrive=$obeyfile.oby";

				print "* Executing $command\n" if ($opt_v);

				system($command);

				if ($? != 0)

				{

					&datadriveimage::reportError("* ROFSBUILD failed to generate data drive image",$opt_k);

				}

				else

				{

					push(@dataDriveFileList,$obeyfile.".img");

				}

			}

		}

	}

	# after processing all the data drive image(s) delete zdrive and datadrive directory 

	# if and only if preserve(-p) option is disabled.

	if($dataImageCount)

	{

		# delete Z drive directory if and only if preserve(-p) option is disabled.

		my $retVal = &deleteDirectory($ZDirloc,$opt_v)if(!($preserve));

		if($retVal)

		{

			&datadriveimage::reportError("* Warning could not delete $ZDirloc",$opt_k);

		}

		# delete data drive directory if and only if preserve(-p) option is disabled.

		$retVal = &deleteDirectory($DataDriveDirloc,$opt_v)if(!($preserve));

		if($retVal)

		{

			&datadriveimage::reportError("* Warning could not delete $DataDriveDirloc",$opt_k);

		}

		# reset image count to zero.

		$dataImageCount = 0;

		# reset z drive present to zero.

		$zDrivePresent = 0;

	}

}

sub tidy_exit

{

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

	# Tidy and exit

	if (!$preserve)

	{

	    foreach my $tempfiles (@tempfiles)

	    {

	    print "remove $tempfiles\n" if ($opt_v);

			unlink "$tempfiles";

	    }

	}

	if($rombasename)

	{

		system("dir $rombasename.*");

	}

	if(@dataDriveFileList)

	{

		print "\n";

		print " ----------------------------------------------------------\n";

		print "| List of file(s) generated pertaining to data drive image |\n";

		print " ----------------------------------------------------------\n";

		my $arraySize = scalar(@dataDriveFileList);

		for( my $i=0; $i < $arraySize; $i++ )

		{

			# remove the first element from an array and return it 

			my $element = shift(@dataDriveFileList);

			# get the size of the file.

			my $size = -s $element;

			print "Size = ".$size." bytes"."\t"."File = ".$element."\n";

		}

	}

	exit(0);

}

# This is the main function which is responsible for processing data drive image.

# This function internally calls other functions to create datadrive folder,zdrive folder

# and external tools such as INTERPRETSIS, READIMAGE and finally ROFSBUILD to generate 

# appropriate data drive image.

sub processData		

{