diff -r 000000000000 -r 044383f39525 imgtools/buildrom/tools/ImageContentHandler.pm
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imgtools/buildrom/tools/ImageContentHandler.pm	Tue Oct 27 16:36:35 2009 +0000
@@ -0,0 +1,1550 @@
+#
+# 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")
+		{
+			next;
+		}
+		my $indent = join('', @padding);
+		&PrintMsg ($indent. $Key);
+		if($hash{$Key}{hasChildren} == 1)
+		{
+			push @padding, ".";
+			&PrintMsg ("\n");
+			$ChildHRef = \%{$hash{$Key}};
+			&DumpImageDetails($ChildHRef);
+		}
+		elsif( defined ($hash{$Key}{vals}) )
+		{
+			&PrintMsg ("\nVals $hash{$Key}{vals}\n");
+			push @padding, ".";
+			$indent = join('', @padding);
+			my @array = @{$hash{$Key}{vals}};
+			&PrintMsg ("array len = " . scalar(@array) . "\n");
+			foreach my $attrib ( @array )
+			{
+				foreach my $key1 (keys %$attrib)
+				{
+					&PrintMsg ($indent . $Key. " ". "$key1=$$attrib{$key1}\n");
+				}
+				&PrintMsg ("\n");
+			}
+		}
+		elsif( defined (@{$hash{$Key}{nodes}}) )
+		{
+			my $node = $hash{$Key}{nodes}[0];
+			&PrintMsg ("{". scalar(@{$hash{$Key}{nodes}})."}\n");
+		}
+	}
+	pop @padding;
+}
+
+sub CheckErrors
+{
+	if($#errors > -1)
+	{
+		&PrintMsg ("errors..........$#errors \n");
+		foreach (@errors)
+		{
+			&PrintMsg ($_ ."\n");
+		}
+		exit;
+	}
+}
+
+my @ImageBinaryList;#2d array storing the list of binaries per rom image
+sub AddBinary
+{
+	my ($binaryName) = @_;
+	{
+		push @{$ImageBinaryList[$curRomImageIndex]}, $binaryName;
+	}
+}
+
+sub SetBldRomOpts
+{
+	my ($key, $value) = @_;
+	if( $key eq undef )
+	{
+#		The default ABI directory is armv5 unless specified otherwise in the buildrom command-line.
+#		The default build directory is urel unless specified otherwise in the buildrom command-line.
+		$DefaultDirs{ABI_DIR} = 'ARMV5';
+		$DefaultDirs{BUILD_DIR}='urel';
+
+		$DefaultDirs{DEST_DIR}= "\\sys\\bin";
+
+	}
+	else
+	{
+#		trim the value for leading/trailing whitespace
+		$value = Trim($value);
+		$DefaultDirs{$key} = $value;
+	}
+}
+
+sub Trim()
+{
+	my @out = @_;
+	for (@out) {
+		s/^\s+//;
+		s/\s+$//;
+	}
+	return wantarray ? @out : $out[0];
+}
+
+sub GetBldRomOpts
+{
+	my ($key) = @_;
+	return $DefaultDirs{$key};
+}
+
+sub DumpBinaries
+{
+	&PrintMsg ("***********Binaries in ROM***********\n");
+	my $img_idx = 0;
+	while ($img_idx < 8 and defined ($ImageBinaryList[$img_idx]))
+	{
+		my @list = @{$ImageBinaryList[$img_idx]};
+		&PrintMsg ("Image $img_idx has ". scalar (@list ) . " binaries\n");
+		foreach my $bin (@list)
+		{
+			&PrintMsg ("file[$img_idx]=$bin\n");
+		}
+		$img_idx++;
+	}
+
+	&PrintMsg ("***********END***********\n");
+}
+
+sub PrintMsg
+{
+	my ($msg) = @_;
+	print "$msg";
+}
+
+# This subroutine is used to generate OBY-contents based on contents of the Image content XML. The image content XML 
+#   may have, in turn, included other OBYs/CDFs. These contents are appended to the Phase-I OBY file (where, the 
+#   Phase-I OBY file is generated by the preprocessor which is the conglomeration of all the buildrom supplied OBY files).
+sub GenObyFile
+{
+	my ($ObyFileName) = @_;
+	open (OBYFH, ">>$ObyFileName") or die("* Can't open $ObyFileName\n");
+	my $binRef;
+	my $line;
+	my $index;
+	my $new_src_path;
+	my $exec_src_path = $ENV{EPOCROOT};#This is the Executable source path
+	$exec_src_path .= "epoc32\\release\\";
+	my $abidir = $DefaultDirs{ABI_DIR};
+	my $blddir = $DefaultDirs{BUILD_DIR};
+
+	GenObyHeader(*OBYFH);
+
+	for($index = 0;$index < 8;$index++)
+	{
+		if( !defined $romGeometry[$index] )
+		{
+			next;
+		}
+
+		$line = "rom_image $index ";
+		$line .= $romGeometry[$index]{name} . " ";
+		$line .= "size=" . $romGeometry[$index]{size} . " ";
+		if( $romGeometry[$index]{type} =~ /nonxip/)
+		{
+			$line .= " non-xip ";
+		}
+		else
+		{
+			$line .= " xip ";
+		}
+
+		$line .= $romGeometry[$index]{compression} . " ";
+		if($romGeometry[$index]{extension} eq "yes")
+		{
+			$line .= " extension ";
+		}
+
+		$line .= "\n";
+
+		print OBYFH $line;
+
+		$line = "ROM_IMAGE[$index] {\n";	#Start of contents of this image
+		print OBYFH $line;
+
+		foreach my $binary (@{$ImageBinaryList[$index]}) {
+			$binRef = &cdfparser::GetBinaryInfo($binary);
+			if( defined ($binRef) and $binRef->{IsFoundInCDF})
+			{
+				if(exists $binRef->{default})
+				{
+					$line = "DEFAULT_LANGUAGE $binRef->{default} \n";
+					print OBYFH "$line";
+				}
+				
+				if(exists $binRef->{language})
+				{
+					my $langCodes = $binRef->{language};
+ 					foreach my $lang (@$langCodes)
+					{
+						$line = "LANGUAGE_CODE $lang \n";
+						print OBYFH "$line";
+					}
+				}
+
+#				Replace the BUILD_DIR with udeb or urel
+#				Default BUILD_DIR is urel and can be overridden by using cmd line option '_FULL_DEBUG'
+#				If a binary is to be picked always from udeb, then the src path in CDF must be mentioned
+#				as udeb e.g. <source>abi_dir\udeb\drtaeabi.dll</source>, in which case, the mentioned dir
+#				is picked as it is.
+
+				$new_src_path = $binRef->{source};
+
+				$new_src_path =~ s/ABI_DIR/$abidir/i;
+				$new_src_path =~ s/BUILD_DIR/$blddir/i;
+				$new_src_path =~ s/DEBUG_DIR/udeb/i;
+
+				$new_src_path =~ s/epocroot/EPOCROOT/;
+				$new_src_path =~ s/zresource/ZRESOURCE/;
+				$new_src_path =~ s/zprivate/ZPRIVATE/;
+				$new_src_path =~ s/zsystem/ZSYSTEM/;
+
+				
+				my $FileFound = 0;
+				
+				if($binRef->{IsExecutable})
+				{
+					$new_src_path = $exec_src_path . $new_src_path;
+					if(!-f $new_src_path)
+					{
+						foreach my $newAbiDir (@binarySelectionArray)
+						{
+							$new_src_path =~ s/$abidir/$newAbiDir/i;
+							if(-f $new_src_path)
+							{
+								$FileFound = 1;
+								last;
+							}
+							$abidir = $newAbiDir;
+						}
+
+						if( !$FileFound )
+						{
+							$FileFound = fallback($abidir, \$new_src_path);
+  							if( !$FileFound )
+							{
+								print "Missing file $binRef->{source} \n";
+								$new_src_path = $binRef->{source};
+							}
+
+						}
+					}
+#					compress options
+					if(exists $binRef->{compress} and ($binRef->{compress} eq "uncompress") )
+					{
+						$line = "fileuncompress=";
+					}
+					elsif($binRef->{compress} eq "compress")
+					{
+						$line = "filecompress=";
+					}
+					elsif( exists $binRef->{dll})
+					{
+						$line = "dll=";
+					}
+#					Checks the plugin type
+					elsif( exists $binRef->{type} and $binRef->{type} eq "plugin")
+					{
+						if (exists $binRef->{plugin_name})
+						{
+							$isEcomPlugin=1;
+							$line = "__$binRef->{plugin_name}_PLUGIN(ABI_DIR\\BUILD_DIR,ECOM_BIN_DIR,DATAZ_,ECOM_RSC_DIR,$binRef->{id},$binRef->{id})\n";
+						}
+					}
+					else
+					{
+						$isEcomPlugin=0;
+						$line = "file=";
+					}
+
+					if (!$isEcomPlugin)
+					{
+						$line .= $new_src_path . " ";
+						$line .= $binRef->{destination};
+					}
+
+
+#					stack,heap,fixed,priority,uid,dll,dlldatatop
+					if( exists $binRef->{stack})
+					{
+						$line .= " stack " . $binRef->{stack};
+					}
+					if( exists $binRef->{heapmin})
+					{
+						$line .= " heapmin " . $binRef->{heapmin};
+					}
+					if( exists $binRef->{heapmax})
+					{
+						$line .= " heapmax " . $binRef->{heapmax};
+					}
+					if( exists $binRef->{fixed})
+					{
+						$line .= " fixed";
+					}
+					if( exists $binRef->{priority})
+					{
+						$line .= " priority " . $binRef->{priority};
+					}
+					if( exists $binRef->{uid1})
+					{
+						$line .= " uid1 " . $binRef->{uid1};
+					}
+					if( exists $binRef->{uid2})
+					{
+						$line .= " uid2 " . $binRef->{uid2};
+					}
+					if( exists $binRef->{uid3})
+					{
+						$line .= " uid3 " . $binRef->{uid3};
+					}
+					if( exists $binRef->{dlldatatop})
+					{
+						$line .= " dlldatatop ". $binRef->{dlldatatop}; 
+					}
+					if( exists $binRef->{customisable} and $binRef->{customisable} eq "true")
+					{
+						$line .= " patched ";
+					}
+				}
+				else
+				{
+					my $type = $binRef->{type};
+					if($type =~ /normal/i)
+					{
+						$line = "data=";
+					}
+					if($type =~ /aif/i)
+					{
+						$line = "aif=";
+					}
+					elsif($type =~ /compressedbitmap/i)
+					{
+						$line = "compressed-bitmap=";
+					}
+					elsif($type =~ /autobitmap/i)
+					{
+						$line = "auto-bitmap=";
+					}
+					elsif($type =~ /bitmap/i)
+					{
+						$line = "bitmap=";
+					}
+
+					if(exists $binRef->{multilinguify})
+					{
+						my $extension;
+						my $srcNameWithoutExt;
+						my $dstNameWithoutExt;
+
+						if($new_src_path =~ /(.*)\.(.*)/)
+						{
+							$srcNameWithoutExt = $1;
+							$extension = $2;
+						}
+						if($binRef->{destination} =~ /(.*)\.(.*)/)
+						{
+							$dstNameWithoutExt = $1;
+						}
+
+						$line .= "MULTI_LINGUIFY(";
+						$line .= $extension . " ";
+						$line .= $srcNameWithoutExt . " ";
+						$line .= $dstNameWithoutExt;
+						$line .= ") ";
+					}
+					else
+					{
+						$line .= $new_src_path . " ";
+						$line .= $binRef->{destination};
+					}
+				}
+
+				$line .= "\n";
+				print OBYFH $line;
+			}
+			else
+			{
+				#Check if the binary is from ImageContent XML file.
+				my $imagecontentbin = 0;
+				foreach my $bin (@ImageContentBinaries) {
+					my $source;
+					if( $bin->{source} =~ /.*\\(\S+)/)
+					{
+						$source = $1;
+					}
+					if (grep /$binary/i, $source) {#Skip the binary that is already included in the OBY Header
+						$imagecontentbin = 1;
+						next;
+					}
+				}
+
+				if ($imagecontentbin) {
+					next;
+				}
+				my $obyInfo = &ImageContentHandler::GetObyBinaryInfo($binary);
+				if(!defined $obyInfo)
+				{
+					$line = "file=" . $exec_src_path. $DefaultDirs{ABI_DIR}. "\\" . $DefaultDirs{BUILD_DIR}. "\\". $binary. " ";
+					$line .= $DefaultDirs{DEST_DIR}. "\\". $binary;
+					$line .= "\n";
+					print OBYFH $line;
+				}
+			}
+		}
+		$line = "\n}\n";
+		print OBYFH $line;
+	}
+	close OBYFH;
+}
+
+#Sets default target to ARMV5 directory if the requested binary is not found
+sub fallback{
+	
+	my ($abidir, $abiFileRef) = @_;
+	my $foundFile=0;
+	foreach my $BpabiPlat (@BPABIPlats)
+	{
+		if ($$abiFileRef =~ /^(.*)\\$BpabiPlat\\(.*)$/)
+		{
+			$$abiFileRef =~ s/$abidir/ARMV5/i;
+			if(-f $$abiFileRef)
+			{
+				$foundFile = 1;
+				last;
+			}
+		}
+	}
+	return $foundFile;
+}
+
+# This subroutine generates the Rom configuration details like, 'bootbinary', 'romlinearbase', romalign,
+#   'kerneldataaddress', 'kernelheapmin' etc.
+sub GenObyHeader
+{
+	my ($fh) = @_;
+	my $line;
+
+#	version
+	if( defined @{$ImageContent{version}{vals}})
+	{
+		my $ver = @{$ImageContent{version}{vals}}[0];
+		if(defined $ver)
+		{
+			$line = "version=$ver\n";
+			print $fh $line;
+		}
+	}
+
+#	romchecksum
+	if( defined @{$ImageContent{romchecksum}{vals}})
+	{
+		my $cksum = @{$ImageContent{romchecksum}{vals}}[0];
+		if(defined $cksum)
+		{
+			$line = "romchecksum=$cksum\n";
+			print $fh $line;
+		}
+	}
+
+#	time
+	if( defined @{$ImageContent{time}{vals}})
+	{
+		my $time = @{$ImageContent{time}{vals}}[0];
+		if(defined $time)
+		{
+			$line = "time=ROMDATE $time\n";
+			print $fh $line;
+		}
+	}
+
+
+#	The Binary selection order
+	if(scalar @binarySelectionArray )
+	{
+		my $abilist = join (',', @binarySelectionArray);
+		$line = "\nBINARY_SELECTION_ORDER $abilist\n";
+		print $fh $line;
+	}
+
+#	trace
+	if( defined @{$ImageContent{options}{trace}{vals}})
+	{
+		my @traceFlags = @{$ImageContent{options}{trace}{vals}};
+		if(scalar @traceFlags)
+		{
+			$line = "trace $traceFlags[0]\n";
+			print $fh $line;
+		}
+	}
+
+#	The bootbinary
+	if( defined @{$ImageContent{options}{bootbinary}{vals}})
+	{
+		my $binary;
+		my @bootbin = @{$ImageContent{options}{bootbinary}{vals}};
+		if(scalar @bootbin)
+		{
+			$binary = $bootbin[0];
+			$binary =~ s/abi_dir/ABI_DIR/;
+ 			$line = "bootbinary=$binary\n";
+			print $fh $line;
+		}
+	}
+
+
+#	dataaddress
+	if( defined @{$ImageContent{options}{dataaddress}{vals}})
+	{
+		my @dataAddr = @{$ImageContent{options}{dataaddress}{vals}};
+		if(scalar @dataAddr)
+		{
+			$line = "dataaddress=$dataAddr[0]\n";
+			print $fh $line;
+		}
+	}
+
+#	debugport
+	if( defined @{$ImageContent{options}{debugport}{vals}})
+	{
+		my @dgbPort = @{$ImageContent{options}{debugport}{vals}};
+		if(scalar @dgbPort)
+		{
+			$line = "debugport=$dgbPort[0]\n";
+			print $fh $line;
+		}
+	}
+
+#	defaultstackreserve
+	if( defined @{$ImageContent{options}{defaultstackreserve}{vals}})
+	{
+		my @defStackRes = @{$ImageContent{options}{defaultstackreserve}{vals}};
+		if(scalar @defStackRes)
+		{
+			$line = "defaultstackreserve=$defStackRes[0]\n";
+			print $fh $line;
+		}
+	}
+
+#	wrapper
+	if( defined @{$ImageContent{options}{wrapper}{vals}})
+	{
+		my %tbl = @{$ImageContent{options}{wrapper}{vals}}[0];
+		if(exists $tbl{epoc})
+		{
+			$line = "epocwrapper\n";
+			print $fh $line;
+		}
+		elsif(exists $tbl{coff})
+		{
+			$line = "coffwrapper\n";
+			print $fh $line;
+		}
+		elsif(exists $tbl{none})
+		{
+			$line = "nowrapper\n";
+			print $fh $line;
+		}
+	}
+
+#	kernel options
+	my $val;
+	if( defined @{$ImageContent{options}{kernel}{name}{vals}})
+	{
+		$val = @{$ImageContent{options}{kernel}{name}{vals}}[0];
+		$line = "kernelromname=$val\n";
+		print $fh $line;
+	}
+	if( defined @{$ImageContent{options}{kernel}{dataaddress}{vals}})
+	{
+		$val = @{$ImageContent{options}{kernel}{dataaddress}{vals}}[0];
+		$line = "kerneldataaddress=$val\n";
+		print $fh $line;
+	}
+	if( defined @{$ImageContent{options}{kernel}{trace}{vals}})
+	{
+		$val = @{$ImageContent{options}{kernel}{trace}{vals}}[0];
+		$line = "kerneltrace $val\n";
+		print $fh $line;
+	}
+	if( defined @{$ImageContent{options}{kernel}{heapmin}{vals}})
+	{
+		$val = @{$ImageContent{options}{kernel}{heapmin}{vals}}[0];
+		$line = "kernelheapmin=$val\n";
+		print $fh $line;
+	}
+	if( defined @{$ImageContent{options}{kernel}{heapmax}{vals}})
+	{
+		$val = @{$ImageContent{options}{kernel}{heapmax}{vals}}[0];
+		$line = "kernelheapmax=$val\n";
+		print $fh $line;
+	}
+#	romlinearbase
+	if( defined @{$ImageContent{options}{romlinearbase}{vals}})
+	{
+		my @romLinBase = @{$ImageContent{options}{romlinearbase}{vals}};
+		if(scalar @romLinBase)
+		{
+			$line = "romlinearbase=$romLinBase[0]\n";
+			print $fh $line;
+		}
+	}
+
+#   romalign
+	if( defined @{$ImageContent{options}{romalign}{vals}})
+	{
+		my @romAlign = @{$ImageContent{options}{romalign}{vals}};
+		if(scalar @romAlign )
+		{
+			$line = "romalign=$romAlign[0]\n";
+			print $fh $line;
+		}
+	}
+
+
+
+
+#	autosize keyword with the block size
+	if( defined @{$ImageContent{options}{autosize}{vals}})
+	{
+		my @autoSz = @{$ImageContent{options}{autosize}{vals}};
+		if(scalar @autoSz )
+		{
+			$line = "autosize=$autoSz[0]\n";
+			print $fh $line;
+		}
+	}
+
+#	coreimage keyword with the coreimage name.
+	if( defined @{$ImageContent{options}{coreimage}{vals}})
+	{
+		my @coreImg = @{$ImageContent{options}{coreimage}{vals}};
+		if(scalar @coreImg)
+		{
+			$line = "coreimage=$coreImg[0]\n";
+			print $fh $line;
+		}
+	}
+
+
+
+	foreach my $imgBin (@ImageContentBinaries)
+	{
+		$line = $imgBin->{keyword};
+		my $srcPath = $imgBin->{source};
+		$srcPath =~ s/abi_dir/ABI_DIR/;
+		$srcPath =~ s/kernel_dir/KERNEL_DIR/;
+		$srcPath =~ s/debug_dir/DEBUG_DIR/;
+		$srcPath =~ s/build_dir/BUILD_DIR/;
+		if(! ($imgBin->{keyword} =~ /secondary/i) )
+		{
+#			VARID mentioned for primary, device, extension and variant keywords.
+			$line .= "[VARID]" ;
+		}
+		$line .= "=" . $srcPath . "\t\t" .  $imgBin->{destination};
+		for my $key (keys %$imgBin)
+		{
+			if( ($key =~ /keyword/i) ||
+				($key =~ /source/i) ||
+				($key =~ /destination/i))
+			{
+#				These keys are already taken care.
+				next;
+			}
+
+#			Write the rest of the keywords if any, (e.g., 'fixed' or HEAPMAX(0x40000) ) to the oby line.
+			$line .= " ".($key);
+			if( defined $imgBin->{$key})
+			{
+				$line .= "(". $imgBin->{$key}. ") ";
+			}
+		}
+		print $fh "$line\n";
+	}
+}
+
+sub GetObyFiles
+{
+	return \@ObyFileList;
+}
+
+sub GetBinarySelectionOrder
+{
+	return \@binarySelectionArray;
+}
+
+sub GetFeatures()
+{
+	my %FeatureMap = ();
+	my @FeatList;
+	my $featRef;
+	my $uid;
+	foreach my $feat (@Includes)
+	{
+		if($feat->{name})
+		{
+			$uid = &featureparser::getFeatureUID($feat->{name});
+			if(!defined $uid)
+			{
+				print "Error: Feature $feat->{name} not found in feature list XML\n";
+				next;
+			}
+			$feat->{uid} = $uid;
+		}
+		else
+		{
+			$uid = $feat->{uid};
+			if(!&featureparser::getFeatureInfo($uid))
+			{
+				print "Error: Feature Uid $uid not found in feature list XML\n";
+				next;
+			}
+		}
+
+		$featRef = $FeatureMap{$uid};
+		if( $featRef->{include} == 1 )
+		{
+#			Already added to the final feature list
+		}
+		else
+		{
+			$FeatureMap{$uid} = $feat;
+			push @FeatList, $feat;
+		}
+	}
+
+	foreach my $feat (@Excludes)
+	{
+		if($feat->{name})
+		{
+			$uid = &featureparser::getFeatureUID($feat->{name});
+			if(!defined $uid)
+			{
+				print "Error: Feature $feat->{name} not found in feature list XML\n";
+				next;
+			}
+			$feat->{uid} = $uid;
+		}
+		else
+		{
+			$uid = $feat->{uid};
+			if(!&featureparser::getFeatureInfo($uid))
+			{
+				print "Error: Feature Uid $uid not found in feature list XML\n";
+				next;
+			}
+		}
+
+		$featRef = $FeatureMap{$uid};
+		if( $featRef->{include} == 1 )
+		{
+			print "Error:The feature Uid $uid was added into the include as well as exclude list\n";
+			next;
+		}
+		elsif($featRef->{exclude} == 1)
+		{
+#			Already added to the final feature list
+			next;
+		}
+		else
+		{
+			$FeatureMap{$uid} = $feat;
+			push @FeatList, $feat;
+		}
+	}
+	return \@FeatList;
+}
+
+sub AddBinaryFromOby
+{
+		my $aBinary = lc shift;
+	my $aFullPath = lc shift;
+
+	my $bin = \%{$obyFileInfo{$aBinary}};
+	$bin->{IsFoundInOby}  = 1;
+	$bin->{fullpath} = $aFullPath;
+}
+
+sub GetObyBinaryInfo
+{
+	my $aBinary = lc shift;
+
+	my $aBinaryInfoHash = \%{$obyFileInfo{$aBinary}};
+
+	if( $aBinaryInfoHash->{IsFoundInOby} == 1)
+	{
+		return $aBinaryInfoHash;
+	}
+	return undef;
+}
+
+sub UpdateObyBinaryStaticDep
+{
+#	Go through the files added from Oby to see if any of their static
+#	dependencies need to be resolved.
+
+	foreach my $obyBin (keys %obyFileInfo)
+	{
+		if(!defined (&VisitedBinaryInfo($obyBin)) )
+		{
+			&ProcessStaticDep($obyFileInfo{$obyBin}{fullpath});
+		}
+	} 
+}
+
+sub SaveImageContentBinaries
+{
+	my ($binaryListRef, $aKeyword) = @_;
+	
+	foreach my $node (@$binaryListRef)
+	{
+		my %binInfo = ();
+
+#		The keywords being primary, secondary, extension, variant and device
+		$binInfo{keyword} = $aKeyword;
+
+		my @children = &genericparser::getChildElements($node);
+
+		foreach my $child (@children)
+		{
+			my $name = &genericparser::getElementName($child);
+			my $val = &genericparser::getElementValue($child);
+			$binInfo{$name} = $val;
+		}
+		push @ImageContentBinaries, \%binInfo;
+	}
+}
+
+my %VisitedBinaries = ();
+my @RomIncludeList;
+
+sub ProcessCDFList {
+
+	my ($CDFListRef) = @_;
+
+	foreach my $cdf (@$CDFListRef)
+	{
+		&LoadFromCDF($cdf);
+	}
+
+}
+
+my @padding ;
+sub LoadFromCDF
+{
+	my $cdf;
+	my $binFile;
+
+	my @BinList;
+	($cdf, $binFile) = @_;
+
+#Load the XML and get its contents
+	cdfparser::LoadCDF($cdf);
+
+#Get all binaries from the mdf
+	(@BinList) = &cdfparser::GetBinaries($cdf);
+
+	my $DynBinListRef;
+	my $aBinary;
+	my $aFile;
+
+	my $VisitedBinaryInfoHash;
+	my $indent = join('', @padding);
+	my $binInfo;
+	foreach $aBinary (@BinList)
+	{
+		$VisitedBinaryInfoHash = &VisitedBinaryInfo($aBinary);
+		if($VisitedBinaryInfoHash)
+		{
+			next;
+		}
+		else
+		{
+			$VisitedBinaryInfoHash = \%{$VisitedBinaries{$aBinary}};
+		}
+
+		&ImageContentHandler::AddBinary($aBinary);
+
+		$VisitedBinaryInfoHash->{Marked} = 1;
+		push @RomIncludeList, $aBinary;
+
+#		Include the dynamic dependencies.
+		($DynBinListRef) = cdfparser::GetDynamicDependencies($aBinary);
+		foreach $aFile (@$DynBinListRef)
+		{
+			if(grep $aFile, @BinList)
+			{
+#				the dynamic dependency is found in the same cdf file which
+#				is already loaded.
+				next;
+			}
+
+			my $new_cdf = cdfparser::GetCDFFileName($aFile);
+#			In case there is no cdf describing this binary, ignore it.
+			if( defined $new_cdf )
+			{
+				push @padding, ".";
+				LoadFromCDF($new_cdf, $aFile);
+			}
+		}
+		$binInfo = cdfparser::GetBinaryInfo($aBinary);
+		&ProcessStaticDep($binInfo->{source}, $aBinary);
+	}
+}
+
+sub ProcessStaticDep
+{
+	my ($aBinary) = @_;
+
+	my $aAbsFile;
+#	Include the static dependencies.
+
+	my $dir = "$ENV{EPOCROOT}epoc32\\release\\";
+	my $abidir = &ImageContentHandler::GetBldRomOpts("ABI_DIR");
+	my $blddir = &ImageContentHandler::GetBldRomOpts("BUILD_DIR"); 
+
+	if($aBinary =~ /(.*)\\.*/)
+	{
+		$aBinary =~ s/ABI_DIR/$abidir/i;
+		$aBinary =~ s/BUILD_DIR/$blddir/i;
+		$aBinary =~ s/DEBUG_DIR/udeb/i;
+	}
+	else
+	{
+		$dir .= $abidir . "\\";
+		$dir .= $blddir. "\\";
+	}
+	$aAbsFile = $dir. $aBinary;
+
+	if(!-f $aAbsFile)
+	{
+#		While evaluating the static dependency, check if the file is found in the 
+#		default abi directory. Otherwise, look into the binary selection order.
+		my $binSelOrderRef = &ImageContentHandler::GetBinarySelectionOrder();
+		my $foundFile = 0;
+		foreach my $newAbiDir (@$binSelOrderRef)
+		{
+			$aAbsFile =~ s/$abidir/$newAbiDir/i;
+			if(-f $aAbsFile)
+			{
+				$foundFile = 1;
+				last;
+			}
+			$abidir = $newAbiDir;
+		}
+		if($foundFile == 0)
+		{
+#While evaluating the static dependency, check if the file is found in the 
+#default abi directory. Otherwise, fallback to the default ARMV5 directory.
+			$foundFile = fallback($abidir, \$aAbsFile);
+			if($foundFile == 0)
+			{
+				return;
+			}
+
+		}
+	}
+
+#	Collect the static dependencies of this binary.
+	my (@StatDepsList) = &Dep_Lister::StaticDeps($aAbsFile);
+
+#	Remove the path portion from the file name if found to get the filename.
+#	This is the key into the BinaryInfo map maintained by cdfparser.
+	my $filename;
+
+	if( $aBinary =~ /.*\\(\S+)/)
+	{
+		$filename = $1;
+	}
+	else
+	{
+		$filename = $aBinary;
+	}
+
+	my $binaryInfoRef = cdfparser::GetBinaryInfo($filename);
+
+	if( defined $binaryInfoRef)
+	{
+#		Mark the binary it it is a valid E32 executable.
+		if(defined @StatDepsList)
+		{
+			$binaryInfoRef->{IsExecutable} = 1;
+		}
+		else
+		{
+			$binaryInfoRef->{IsExecutable} = 0;
+		}
+	}
+
+	my $VisitedBinaryInfoHash;
+	foreach my $aFile (@StatDepsList)
+	{
+		my $new_cdf = cdfparser::GetCDFFileName($aFile);
+
+		if(defined($new_cdf))
+		{
+			LoadFromCDF($new_cdf, $aFile);
+		}
+		else
+		{
+#			Include the static dependencies even if there is no mdf describing this binary
+
+			$VisitedBinaryInfoHash = &VisitedBinaryInfo($aFile);
+			if( !defined ($VisitedBinaryInfoHash) )
+			{
+				$VisitedBinaryInfoHash = \%{$VisitedBinaries{$aFile}};
+				$VisitedBinaryInfoHash->{Marked} = 1;
+				&ImageContentHandler::AddBinary($aFile);
+				&ProcessStaticDep($aFile);
+			}
+			else
+			{
+			}
+		}
+	}
+}
+
+sub VisitedBinaryInfo
+{
+	my ($aBinary) = @_;
+	my $VisitedBinaryInfoHash = \%{$VisitedBinaries{$aBinary}};
+	if($VisitedBinaryInfoHash->{Marked} == 1)
+	{
+		return $VisitedBinaryInfoHash;
+	}
+	return undef;
+}
+
+1;