#

# 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 contains routines to read the information from the Component Description Files.

package cdfparser;

# Include Module package to use APIs to parse an XML file.

use genericparser;

require Exporter;

@ISA=qw(Exporter);

@EXPORT=qw(

	CreateCDFFileBinaryMapFromDir

	GetBinaries

	GetCDFFileName

	LoadCDF

	GetDynamicDependencies

	GetBinaryInfo

	GetIncludedFeatureList

	GetExcludedFeatureList

);

use strict;

# Map between the CDF File Name and the corresponding list of binaries

# This is required so that one can fetch the list of binaries for a particular CDF file.

my %binaryCDFFileMap=();

# Include Feature List

# The list of features to be included for a given binary.

my @includeFeatureList;

# Exclude Feature List

# The list of features to be excluded for a given binary.

my @excludeFeatureList;

# List that contains the complete information of each binary

my %binaryInfo=();

my $warning_level = 0;

# Absolute path that contains the CDF Files

my @cdfDirectories;

# To extract the cdf files from the directory specified as input. The default directory is chosen if no 

# input is specified.

sub CreateCDFFileBinaryMapFromDir

{

	my @acdfDirList = @_;

	# To store the list of cdf file names specified under the directory

	my @cdfFileList;

	if ((scalar @acdfDirList) != 0)

	{

		foreach my $acdfDir (@acdfDirList)

		{

			opendir DIR, "$acdfDir";

			if(not grep /$acdfDir/i, @cdfDirectories)

			{

				push @cdfDirectories, $acdfDir;

			}

			push (@cdfFileList, (grep /\.cdf/i, readdir DIR));

			foreach my $filename (@cdfFileList)

			{

				&CreateCDFFileBinaryMap(lc($filename), $acdfDir);

				$binaryCDFFileMap{$filename}{path} = $acdfDir;

			}

		}

	}

}

# To create a mapping between the CDF file name and the corresponding list of binaries

sub CreateCDFFileBinaryMap

{

	my ($cdffilename, $aCdfDir) = @_;

	if( defined $binaryCDFFileMap{$cdffilename} )

	{

		return;

	}

	my $path;

	if( defined $aCdfDir)

	{

		$path = "$aCdfDir\/$cdffilename";

	}

	else

	{

		$path = $cdffilename;

	}

	my $rootNode = &genericparser::getRootElement($path);

	$binaryCDFFileMap{$cdffilename}{root} = $rootNode;

	my @binaryList = &genericparser::getChildElements($rootNode);

	my $binaryInfoRef;

	foreach my $binary (@binaryList)

	{

		my $filename = &genericparser::getAttrValue($binary, "id");

		push @{$binaryCDFFileMap{$cdffilename}{binaries}}, $filename;

# This is required so that one can fetch the CDF file name in which the binary is present

		$binaryInfoRef = \%{$binaryInfo{$filename}};

		$binaryInfoRef->{"filename"} = $cdffilename;

	}

}

# To get the complete list of binaries present in a given CDF file

# Input Parameter : CDF filename

# Returns the complete list of binaries

sub GetBinaries

{

	my $cdffilename = shift;

	if (exists $binaryCDFFileMap{$cdffilename})

	{

		return @{$binaryCDFFileMap{$cdffilename}{binaries}};

	}

	else

	{

		return undef;

	}

}

# To get the name of the CDF file that contains the input binary

# Input Parameter : Binary Name

# Returns the CDF file name

sub GetCDFFileName

{

	my $aBinary = lc(shift);

	if (exists $binaryInfo{$aBinary})

	{

		my $binInfo = \%{$binaryInfo{$aBinary}};

		return $binInfo->{filename};

	}

	else

	{

		return undef;

	}

}

#Loads all the specified CDF files.

sub LoadCDF

{

	my @cdfFileList = @_;

	foreach my $afile (@cdfFileList)

	{

		CreateCDFFileBinaryMap($afile);

		my $rootNode = $binaryCDFFileMap{$afile}{root};

		# Get the total list of files present in the cdf file.

		my @binaryList = &genericparser::getChildElements($rootNode);

		# Hash Reference to the hash map binaryInfo

		my $binaryInfoHashRef;

		foreach my $binaryNode (@binaryList)

		{

			my $fileId = &genericparser::getAttrValue($binaryNode, "id");

			$binaryInfoHashRef = \%{$binaryInfo{$fileId}};

			&setBinaryInfo($binaryInfoHashRef, $binaryNode);

		}

	}

}

#Sets the information of the CDF file to a hash map

sub setBinaryInfo

{

	my ($aBinaryInfoRef, $aBinaryNode) = @_;

	# Set the File attributes

	$aBinaryInfoRef->{"id"}		  = &genericparser::getAttrValue($aBinaryNode, "id");

	$aBinaryInfoRef->{"customisable"} = &genericparser::getAttrValue($aBinaryNode, "customisable");

	$aBinaryInfoRef->{"addressable"}  = &genericparser::getAttrValue($aBinaryNode, "addressable");

	$aBinaryInfoRef->{"compress"}	  = &genericparser::getAttrValue($aBinaryNode, "compress");

	$aBinaryInfoRef->{"type"}	  = &genericparser::getAttrValue($aBinaryNode, "type");

  	$aBinaryInfoRef->{"plugin_name"}  = &genericparser::getAttrValue($aBinaryNode, "plugin_name");

  	# Check for the plugin, setting the plugin type as ECOM_PLUGIN

  	if (defined $aBinaryInfoRef->{"plugin_name"})

  	{

  		$aBinaryInfoRef->{"IsFoundInCDF"} = 1;

  		$aBinaryInfoRef->{"source"} = "ABI_DIR\/BUILD_DIR\/$aBinaryInfoRef->{id}";

  		$aBinaryInfoRef->{"plugin_name"} =~ s/$aBinaryInfoRef->{plugin_name}/ECOM/;

  	}

  	else {

		# Get all the nodes of element 'file'

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

		foreach my $childNode (@children)

		{

			$aBinaryInfoRef->{"IsFoundInCDF"} = 1;

			if (&genericparser::getElementName($childNode) eq "source")

			{

				$aBinaryInfoRef->{"source"} = &genericparser::getElementValue($childNode);

			}

			if (&genericparser::getElementName($childNode) eq "destination")

			{

				$aBinaryInfoRef->{"destination"} = &genericparser::getElementValue($childNode);

			}

			if (&genericparser::getElementName($childNode) eq "features")

			{

				# The children nodes will specify the list of features

				my @aFeatureNodes = &genericparser::getChildElements($childNode);

				foreach my $aFeatureChildNode (@aFeatureNodes)

				{

					# A list of features can be listed out either for supported case or for the prevented case.

					if (&genericparser::getElementName($aFeatureChildNode) eq "supports")

					{

						my @aSupportedFeatureNodes = &genericparser::getChildElements($aFeatureChildNode);

						foreach my $aSuppChildNode (@aSupportedFeatureNodes)

						{

							my %feat = ();

							my $featureName = &genericparser::getAttrValue($aSuppChildNode, "name");

							my $featureUID = &genericparser::getAttrValue($aSuppChildNode, "uid");

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

							{

								$feat{name} = $featureName ;

								$feat{uid} = undef;

							}

							elsif(defined ($featureUID) and ($featureUID ne ""))

							{

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

								{

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

									$feat{uid} = $featureUID;

									$feat{name} = undef;

								}

								else

								{

									print "The uid value $featureUID specified for the Include feature list for the Binary, $aBinaryInfoRef->{id}, is not a valid number\n";

								}

							}

							else

							{

								print ("Warning: Feature $featureName has both name and Uid mentioned\n") if ($warning_level < 2);

								next;

							}

							$feat{include} = 1;

							push @includeFeatureList, \%feat;

						}

					}

					if (&genericparser::getElementName($aFeatureChildNode) eq "prevents")

					{

						my @aPreventedFeatureNodes = &genericparser::getChildElements($aFeatureChildNode);

						foreach my $aPreventedChildNode (@aPreventedFeatureNodes)

						{

							my %feat = ();

							my $featureName = &genericparser::getAttrValue($aPreventedChildNode, "name");

							my $featureUID = &genericparser::getAttrValue($aPreventedChildNode, "uid");

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

							{

								$feat{name} = $featureName ;

								$feat{uid} = undef;

							}

							elsif(defined ($featureUID) and ($featureUID ne ""))

							{

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

								{

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

									$feat{uid} = $featureUID;

									$feat{name} = undef;

								}

								else

								{

									print "The uid value $featureUID specified for the Exclude feature list for the Binary, $aBinaryInfoRef->{id}, is not a valid number\n";

								}

							}

							else

							{

								print "Warning: Feature $featureName has both name and Uid mentioned\n" if ($warning_level < 2);

								next;

							}

							$feat{exclude} = 1;

							push @excludeFeatureList, \%feat;

						}

						push @{$aBinaryInfoRef->{"prevents"}}, (&genericparser::getElementValue($aFeatureChildNode));

					}

				}

			}

			if (&genericparser::getElementName($childNode) eq "dynamicdependencies")

			{

				# The children nodes will contain the file name.

				my @aDynDependNodes = &genericparser::getChildElements($childNode);

				foreach my $aDynDependChildNode (@aDynDependNodes)

				{

					# There can be a list of binaries for dynamic dependencies

					if (&genericparser::getElementName($aDynDependChildNode) eq "depend")

					{

						push @{$aBinaryInfoRef->{"depend"}}, (&genericparser::getElementValue($aDynDependChildNode));

					}

				}

			}

			if (&genericparser::getElementName($childNode) eq "localisation")

			{

				# The children nodes will contain the language code

				my @aLocalisationNodes = &genericparser::getChildElements($childNode);

				foreach my $aLocalisationChildNode (@aLocalisationNodes)

				{

					# There can be a list of binaries for dynamic dependencies

					if (&genericparser::getElementName($aLocalisationChildNode) eq "default")

					{

						$aBinaryInfoRef->{"default"} = &genericparser::getElementValue($aLocalisationChildNode);

					}

					if (&genericparser::getElementName($aLocalisationChildNode) eq "language")

					{

						push @{$aBinaryInfoRef->{"language"}}, (&genericparser::getElementValue($aLocalisationChildNode));

					}

				}

			}

			if (&genericparser::getElementName($childNode) eq "options")

			{

				# The children nodes will contain the option details

				my @aOptionNodes = &genericparser::getChildElements($childNode);

				foreach my $aOptionChildNode (@aOptionNodes)

				{

					if (&genericparser::getElementName($aOptionChildNode) eq "multilinguify")

					{

						$aBinaryInfoRef->{"multilinguify"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "stack")

					{

						$aBinaryInfoRef->{"stack"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "heapmin")

					{

						$aBinaryInfoRef->{"heapmin"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "heapmax")

					{

						$aBinaryInfoRef->{"heapmax"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "fixed")

					{

						$aBinaryInfoRef->{"fixed"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "priority")

					{

						$aBinaryInfoRef->{"priority"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "uid1")

					{

						$aBinaryInfoRef->{"uid1"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "uid2")

					{

						$aBinaryInfoRef->{"uid2"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "uid3")

					{

						$aBinaryInfoRef->{"uid3"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "dll")

					{

						$aBinaryInfoRef->{"dll"} = &genericparser::getElementValue($aOptionChildNode);

					}

					if (&genericparser::getElementName($aOptionChildNode) eq "dlldatatop")

					{

						$aBinaryInfoRef->{"dlldatatop"} = &genericparser::getElementValue($aOptionChildNode);

					}

				}

			}

		}

	}

}

# To get the complete list of information for a given binary

# Input Parameter : Binary

# Returns the detailed information for each binary

sub GetBinaryInfo

{

	my $aBinary = shift;

	my $aBinaryInfoHash = \%{$binaryInfo{$aBinary}};

	if ($aBinaryInfoHash->{IsFoundInCDF})

	{

		return $aBinaryInfoHash;

	}

	return undef;

}

# To get the complete list of dynamic dependencies for a given binary

# Input Parameter : Binary

# Returns the complete list of dynamic dependencies

sub GetDynamicDependencies

{

	my $aBinary = shift;

	my $bin = \%{$binaryInfo{$aBinary}};

	return \@{$bin->{"depend"}};

}

#Returns the included feature list

sub GetIncludedFeatureList

{

	return \@includeFeatureList;

}

#Returns the excluded feature list

sub GetExcludedFeatureList

{

	return \@excludeFeatureList;

}

1;