#

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

#

# This package processes the Image Content XML, and creates an OBY file to create a Rom image.

package ImageContentHandler;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	ParseImageContentXML

	ProcessImageContent

	AddBinary

	GetBldRomOpts

	SetBldRomOpts

	GenObyFile

	GetObyFiles

	AddBinaryFromOby

	UpdateObyBinaryStaticDep

	PrintMsg

	DumpBinaries

);

use strict;

use genericparser;

use cdfparser;

use Dep_Lister;

#Error list

my @errors;

my %ImageContent=();		#Image details are stored in this tree

my $RootNode;				#The root node of the XML root document element

my @TargetImageList;		#The list of target element nodes in the XML. These are ordered based on their 

							#  imageid (if it is a number, else, based on the availibility of Rom locations within 0..7).

my @binarySelectionArray;	#This array stores the ABI directories to be looked up to select binaries.

my @ImageContentBinaries;	#This list is for the biaries mentioned in Image content XML for 

							#  keywords like, 'primary', 'secondary', 'device', 'extension', 'variant'.

# List that contains information of binary from OBY file. This list is maintained to check if their static dependencies

#	have been included already in Rom.

my %obyFileInfo=();

my $ImageIndex=-1;

my @Includes;		#List of included features. The included feature in this list is a hash table giving the 

					#Uid or the name. These features are collected either from the Image content or the CDF XMLs.

my @Excludes;		#List of excluded features.The excluded feature in this list is a hash table giving the 

					#Uid or the name. These features are collected either from the Image content or the CDF XMLs.

my %DefaultDirs =();#This hash table records the default ABI and the BUILD directories. These are updated in case

					#  the overriding buildrom options are provided e.g., -D_FULL_DEBUG or -D_PLAT=GCCE etc.

my @BPABIPlats = &BPABIutl::BPABIutl_Plat_List; # Add the BPABI Platforms to be added

my $isEcomPlugin=0; # This flag will be set when PLUGINs are provided in the CDF file.

sub ParseImageContentXML

{

	my $XMLFile = shift;

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

	$RootNode = &getRootElement($XMLFile);

	&SetImageDetails(\%ImageContent, $RootNode);

}

my @padding;

#This subroutine traverses the XML tree and stores the fields in the hast table %ImageContent. The keys

#	are the branch names. For target nodes., it stores the nodes themselves in the hash table and doesn't

#	go deeper. These nodes are processed laster. For the other nodes, it keeps traversing recursively.

# There are some special keys used to store the nodes and values in the tree. While storing an XML::DOM

#  node, it sores with the keys 'nodes', while, for storing a value, it is stored with the key 'vals'.

# These are the keys used to retrieve the contents of the tree while generating the final OBY.

sub SetImageDetails

{

	my ($ImageDetailRef, $ImageNode) = @_;

	my @children = &genericparser::getChildElements($ImageNode);

	my $child;

	my $TreeRef;

	my $branch;

	my $parentName = &genericparser::getElementName($ImageNode);

	my $childCnt = scalar @children;

	my ($indent) = join('', @padding);

	my $val = &genericparser::getElementValue($ImageNode);

	$val = Trim($val);

	if($val ne "")

	{

		push @{$ImageDetailRef->{vals}}, $val;

	}

	my $NodeRef;

	foreach $child (@children)

	{

		$branch = &genericparser::getElementName($child);

		$NodeRef = \%{$ImageDetailRef->{$branch}};

		if($branch eq "cdf" and $parentName eq "romscope")

		{

#			Record the romscope node. This node indicates the oby files or cdf files/directories

#			that may be used.

			push @{$NodeRef->{nodes}}, $child;

			next;

		}

		if($branch eq "target" and $parentName eq "romtarget")

		{

			push @{$NodeRef->{nodes}}, $child;

			next;

		}

		if( ($branch =~ /primary/i  ) ||

			($branch =~ /secondary/i) ||

			($branch =~ /extension/i) ||

			($branch =~ /variant/i  ) ||

			($branch =~ /device/i   ) )

		{

			next;

		}

		if( $child->hasChildNodes() )

		{

			$NodeRef->{hasChildren} = 1;

			push @padding, ".";

			SetImageDetails($NodeRef, $child);

		}

		else

		{

			$NodeRef->{hasChildren} = 0;

		}

#		Get all attributes...

		my $attribs = &genericparser::getNodeAttributes($child);

		my $attrib;

		my $nodeName;

		my $nodeVal;

		my %attr=();

		my $attrLen = $attribs->getLength;

		for (my $pos = 0; $pos < $attrLen;$pos++)

		{

			$attrib = $attribs->item($pos);

			if(!$attrib)

			{

				next;

			}

			$nodeName = lc ($attrib->getName);

			$nodeVal = lc  ($attrib->getValue);

			$attr{$nodeName}=$nodeVal;

		}

		push @{$NodeRef->{vals}}, \%attr;

	}

	pop @padding;

}

my @romGeometry;			#Array to store all Roms mentioned in RomGeometry

my %romGeometryHash = ();	#This Hash table records the indices in @romGeometry array, keying on their Ids.

my $curRomImageIndex;		#This scalar records the current Rom image being processed. An binary encountered

							#  becomes part of the Rom image corresponding to this partition.

# This subroutine associates the RomGeometry and the RomTarget sub-trees to set indices for the Rom-target

#   nodes.It stores the Image content XML entries for primary/secondary/device/extension/variant keywords.

#   It also stores the features that are included/excluded in Image content XML.

sub ProcessImageContent

{

	my $TotalImages = &ProcessRomGeometry();

	my @trgList;

	if( defined @{$ImageContent{romtarget}{target}{nodes}})

	{

		@trgList = @{$ImageContent{romtarget}{target}{nodes}};

	}

#	Go through the romgeometry to find the location of each image. The valid IDs are 0 through 7.

	foreach my $trg (@trgList)

	{

#		The ID field in romgeometry can be an integer in the range 0 through 7.

#		If it is not a number, its location is assumed as its sequence number

		my $imageid = &genericparser::getAttrValue($trg, "imageid");

		if($imageid =~ /Any/i)

		{

			next;

		}

		elsif(exists $romGeometryHash{$imageid})

		{

			$ImageIndex = $romGeometryHash{$imageid};

			push @{$TargetImageList[$ImageIndex]} , $trg;

		}

	}

#	Romscope - update the maps if the files and directories are mentioned.

	my @romScopeNodes;

	if(defined @{$ImageContent{romscope}{cdf}{nodes}})

	{

		@romScopeNodes = @{$ImageContent{romscope}{cdf}{nodes}};

	}

	my $type;

	my $file;

	my $dir;

	foreach my $aNode (@romScopeNodes)

	{

		$type = &genericparser::getAttrValue($aNode, "type");

		if( $type =~ /dir/i)

		{

			$dir = &genericparser::getElementValue($aNode);

			&cdfparser::CreateCDFFileBinaryMapFromDir($dir);

		}

		elsif($type =~ /file/i)

		{

			$file = &genericparser::getElementValue($aNode);

			&cdfparser::CreateCDFFileBinaryMap($file);

		}

	}

	my $availablePos = 0;

	foreach my $trg (@trgList)

	{

		if(&genericparser::getAttrValue($trg, "imageid") =~ /Any/i)

		{

			while($availablePos < $TotalImages)

			{

				if( !defined($TargetImageList[$availablePos][0]) )

				{

					push @{$TargetImageList[$availablePos]}, $trg;

					last;

				}

				$availablePos++;

			}

		}

	}

	my $pos = 0;

	while( $pos < 8)

	{

		if( defined $TargetImageList[$pos][0] )

		{

#			Record the current Rom image index so that the binaries are included in the corresponding

#			Rom image.

#			The romGeometry and TargetImageList arrays are associated both being indexed on

#			the Rom-image index.

			$curRomImageIndex = $pos;

			&ProcessTarget($pos, \@{$TargetImageList[$pos]});

		}

		$pos++;

	}

#	Pick the primary/secondary/device binaries

	my @nodes = &genericparser::getNodeFromTree($RootNode, "options", "primary", "file");

	if( defined @nodes)

	{

		&SaveImageContentBinaries(\@nodes, "primary");

	}

	@nodes = &genericparser::getNodeFromTree($RootNode, "options", "secondary", "file");

	if( defined @nodes)

	{

		&SaveImageContentBinaries(\@nodes, "secondary");

	}

	@nodes = &genericparser::getNodeFromTree($RootNode, "options", "extension", "file");

	if( defined @nodes)

	{

		&SaveImageContentBinaries(\@nodes, "extension");

	}

	@nodes = &genericparser::getNodeFromTree($RootNode, "options", "variant", "file");

	if( defined @nodes)

	{

		&SaveImageContentBinaries(\@nodes, "variant");

	}

	@nodes = &genericparser::getNodeFromTree($RootNode, "options", "device", "file");

	if( defined @nodes)

	{

		&SaveImageContentBinaries(\@nodes, "device");

	}

	foreach my $imgBin (@ImageContentBinaries)

	{

		&ProcessStaticDep($imgBin->{source});

	}

#	Pick the binary selection order

	if (exists($ImageContent{options}{binaryselectionorder}{vals}))

	{

	    my ($abiDirs) = @{$ImageContent{options}{binaryselectionorder}{vals}};

	    @binarySelectionArray = split(',', $abiDirs);

	    @binarySelectionArray = Trim(@binarySelectionArray);

	}

	my $featureList = &cdfparser::GetIncludedFeatureList();

	foreach my $feature (@$featureList)

	{

		push @Includes, $feature;

	}

	$featureList = &cdfparser::GetExcludedFeatureList();

	foreach my $feature (@$featureList)

	{

		push @Excludes, $feature;

	}

}

#Arrange the Rom-geometry according to their Id when they are numbers. The named images

#are arranged starting from the empty slots in Rom geometry array.

sub ProcessRomGeometry

{

	my $RomImageCount = 0;

	my $pos = 0;

	while($pos < 8)

	{

		$romGeometry[$pos++] = undef;

	}

	my @roms = @{$ImageContent{romgeometry}{image}{vals}};

	$RomImageCount = scalar (@roms);

	my @namedImages;

#	Visit all images and allocate them the indices they mention.

	foreach my $img (@roms)

	{

		if($img->{id} =~ /(\d+)/)

		{

			$pos = $1;

			if( defined($romGeometry[$pos]) )

			{

				print "Error: $romGeometry[$pos]->{id} and $img->{id} cant be allocated the same position\n";

				exit;

			}

			$romGeometry[$pos] = $img;

#			Record the index of this Rom

			$romGeometryHash{$img->{id}} = $pos;

		}

		else

		{

#			These are the named images that are allocated there positions sequentially starting from

#			the first available empty position

			push @namedImages, $img;

		}

	}

#	Revisit the images and allocate the remaining (unallocated) positions.

	$pos = 0;

	my $namedImageCount = scalar (@namedImages);

	my $firstNamedImgIdx = 0;

	my $img;

	while(	($pos < 8) and ($namedImageCount > 0) )

	{

		if( $romGeometry[$pos] )

		{

#			skip the positions already allocated.

			$pos++;

			next;

		}

		$img = $namedImages[$firstNamedImgIdx];

		$romGeometry[$pos] = $img;

#		Record the index of this Rom

		$romGeometryHash{$img->{id}} = $pos;

		$pos++;$firstNamedImgIdx++;

		$namedImageCount--;

	}

	return $RomImageCount;

}

my @ObyFileList;

#This subrouting processes the target nodes that may include OBYs/CDFs or features. For CDFs, the satic/dynamic

#  dependencies are evaluated.

sub ProcessTarget

{

	my ($ImgPos , $trgNodesRef) = @_;

	my @cdfFileList;

#	For all the 'target' nodes associated with an image in romgeometry at the given index...

#	The link between a target and an image in romGeometry is the image id. If the imageid

#	of a target is 'Any', then the first available image in romGeometry is allocated to

#	that target.

	foreach my $target (@$trgNodesRef)

	{

#		Fetch any cdfs included within the Image Content file

		my @cdfs = &getNodeFromTree($target, "include","cdf");

		my $type;

		my $file;

		my $dir;

		foreach my $cdfNode (@cdfs)

		{

			$type = &genericparser::getAttrValue($cdfNode, "type");

			if( !($type) || ($type eq "file") )

			{

				$file = &genericparser::getElementValue($cdfNode);

				push @cdfFileList, $file;

			}

			elsif($type eq "dir")

			{

				$dir = &genericparser::getElementValue($cdfNode);

				&cdfparser::CreateCDFFileBinaryMapFromDir($dir);

			}

		}

#		Collect all the obey files mentioned in this 'target' node.

		my @obys = &getNodeFromTree($target, "include","obyFile");

		foreach my $obyNode (@obys)

		{

			$file = &genericparser::getElementValue($obyNode);

			push @ObyFileList, $file;

		}

		&CollectFeatures($target, 1, \@Includes);

		&CollectFeatures($target, 0, \@Excludes);

	}

	ProcessCDFList(\@cdfFileList);

}

# This subroutine updates the include or exclude feature list collected from Image content XML.

sub CollectFeatures

{

#	Collect all the features included/excluded in this 'target' node.

	my ($target, $Inc, $IncludeExcludeListRef) = @_;

	my $IncExcStr;

	if($Inc == 1)

	{

		$IncExcStr = "include";

	}

	else

	{

		$IncExcStr = "exclude";

	}

	my @nodes = &getNodeFromTree($target, $IncExcStr,"feature");

	foreach my $node (@nodes)

	{

		my %aFeatureInfo = ();

		my $isValidFeature = 0;

		my $feature = &genericparser::getAttrValue($node, "name");

		if($Inc)

		{

#			Mark the feature included.

			$aFeatureInfo{include} = 1;

		}

		else

		{

#			Mark the feature excluded.

			$aFeatureInfo{exclude} = 1;

		}

		if(defined $feature and $feature ne "")

		{

			$aFeatureInfo{name}= $feature;

			$aFeatureInfo{uid} = undef;

			$isValidFeature = 1;

		}

		else

		{

			$feature = &genericparser::getAttrValue($node, "uid");

			if(!defined $feature or $feature eq "")

			{

				print "Warning: Neither feature name nor uid is defined \n";

			}

			else

			{

				if(&featureparser::ValidateUIDValue($feature))

				{

					$feature = &featureparser::ConvertHexToDecimal($feature);

					$aFeatureInfo{uid}= $feature;

					$aFeatureInfo{name}= undef;

					$isValidFeature = 1;

				}

				else

				{

					print "The uid value $feature specified in the Image Content Description is not a valid number\n";

				}

			}

		}

		if($isValidFeature)

		{

			push @$IncludeExcludeListRef, \%aFeatureInfo;

		}

	}

}

sub DumpImageDetails

{

	my ($HRef) = @_;

	my %hash = %$HRef;

	my $ChildHRef;

	foreach my $Key (keys %hash)

	{

		if($Key eq "hasChildren" || $Key eq "vals")

		{