diff -r 000000000000 -r ba25891c3a9e secureswitools/swisistools/source/interpretsislib/configmanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/interpretsislib/configmanager.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,703 @@
+/*
+* Copyright (c) 2007-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: 
+*
+*/
+
+
+#pragma warning (disable: 4786)
+
+// System includes
+#include <iostream>
+#include <fstream>
+#include <hal_data.h>
+#include <algorithm>
+ 
+
+// User includes
+#include "stringutils.h"
+#include "is_utils.h"
+#include "configmanager.h"
+
+// Enumerations
+enum TConfigAttributeFlag
+    {
+    EConfigFlagTypeNotSupported = 1,
+    EConfigFlagTypeNumeric      = 2,
+    EConfigFlagTypeBoolean      = 4,
+    EConfigFlagTypeYesNo        = 8,
+	EConfigFlagTypeString		= 16
+    };
+
+// Structures
+struct ConfigAttribute
+	{
+	const wchar_t* iName;
+	TUint32 iId;
+    TUint32 iFlags;
+	};
+
+// Constants
+const std::string KConfigAttributeHexPrefix = "0x";
+const std::string KConfigAttributeValueTrue = "TRUE";
+const std::string KConfigAttributeValueFalse = "FALSE";
+const std::string KConfigAttributeValueYes = "YES";
+const std::string KConfigAttributeValueNo = "NO";
+
+const ConfigAttribute KConfigAttributes[] =
+	{
+    // HAL entries
+	{L"MANUFACTURER",				HALData::EManufacturer,                 EConfigFlagTypeNumeric },
+	{L"MANUFACTURERHARDWAREREV",	HALData::EManufacturerHardwareRev,      EConfigFlagTypeNumeric },
+	{L"MANUFACTURERSOFTWAREREV",	HALData::EManufacturerSoftwareRev,      EConfigFlagTypeNumeric },
+	{L"MANUFACTURERSOFTWAREBUILD",	HALData::EManufacturerSoftwareBuild,    EConfigFlagTypeNumeric },
+	{L"MODEL",						HALData::EModel,                        EConfigFlagTypeNumeric },
+	{L"MACHINEUID",					HALData::EMachineUid,                   EConfigFlagTypeNumeric },
+	{L"DEVICEFAMILY",				HALData::EDeviceFamily,                 EConfigFlagTypeNumeric },
+	{L"DEVICEFAMILYREV",			HALData::EDeviceFamilyRev,              EConfigFlagTypeNumeric },
+	{L"CPU",						HALData::ECPU,                          EConfigFlagTypeNumeric },
+	{L"CPUARCH",					HALData::ECPUArch,                      EConfigFlagTypeNumeric },
+	{L"CPUABI",						HALData::ECPUABI,                       EConfigFlagTypeNumeric },
+	{L"CPUSPEED",					HALData::ECPUSpeed,                     EConfigFlagTypeNumeric },
+	{L"SYSTEMTICKPERIOD",			HALData::ESystemTickPeriod,             EConfigFlagTypeNumeric },
+	{L"MEMORYRAM",					HALData::EMemoryRAM,                    EConfigFlagTypeNumeric },
+	{L"MEMORYRAMFREE",				HALData::EMemoryRAMFree,                EConfigFlagTypeNumeric },
+	{L"MEMORYROM",					HALData::EMemoryROM,                    EConfigFlagTypeNumeric },
+	{L"MEMORYPAGESIZE",				HALData::EMemoryPageSize,               EConfigFlagTypeNumeric },
+	{L"POWERBACKUP",				HALData::EPowerBackup,                  EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"KEYBOARD",					HALData::EKeyboard,                     EConfigFlagTypeNumeric },
+	{L"KEYBOARDDEVICEKEYS",			HALData::EKeyboardDeviceKeys,           EConfigFlagTypeNumeric },
+	{L"KEYBOARDAPPKEYS",			HALData::EKeyboardAppKeys,              EConfigFlagTypeNumeric },
+	{L"KEYBOARDCLICK",				HALData::EKeyboardClick,                EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"KEYBOARDCLICKVOLUMEMAX",		HALData::EKeyboardClickVolumeMax,       EConfigFlagTypeNumeric },
+	{L"DISPLAYXPIXELS",				HALData::EDisplayXPixels,               EConfigFlagTypeNumeric },
+	{L"DISPLAYYPIXELS",				HALData::EDisplayYPixels,               EConfigFlagTypeNumeric },
+	{L"DISPLAYXTWIPS",				HALData::EDisplayXTwips,                EConfigFlagTypeNumeric },
+	{L"DISPLAYYTWIPS",				HALData::EDisplayYTwips,                EConfigFlagTypeNumeric },
+	{L"DISPLAYCOLORS",				HALData::EDisplayColors,                EConfigFlagTypeNumeric },
+	{L"DISPLAYCONTRASTMAX",			HALData::EDisplayContrastMax,           EConfigFlagTypeNumeric },
+	{L"BACKLIGHT",					HALData::EBacklight,                    EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"PEN",						HALData::EPen,                          EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"PENX",						HALData::EPenX,                         EConfigFlagTypeNumeric },
+	{L"PENY",						HALData::EPenY,                         EConfigFlagTypeNumeric },
+	{L"PENDISPLAYON",				HALData::EPenDisplayOn,                 EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"PENCLICK",					HALData::EPenClick,                     EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"PENCLICKVOLUMEMAX",			HALData::EPenClickVolumeMax,            EConfigFlagTypeNumeric },
+	{L"MOUSE",						HALData::EMouse,                        EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"MOUSEX",						HALData::EMouseX,                       EConfigFlagTypeNumeric },
+	{L"MOUSEY",						HALData::EMouseY,                       EConfigFlagTypeNumeric },
+	{L"MOUSEBUTTONS",				HALData::EMouseButtons,                 EConfigFlagTypeNumeric },
+	{L"CASESWITCH",					HALData::ECaseSwitch,                   EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"LEDS",						HALData::ELEDs,                         EConfigFlagTypeNumeric },
+	{L"INTEGRATEDPHONE",			HALData::EIntegratedPhone,              EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"DISPLAYBRIGHTNESS",			HALData::EDisplayBrightness,            EConfigFlagTypeNumeric },
+	{L"DISPLAYBRIGHTNESSMAX",		HALData::EDisplayBrightnessMax,         EConfigFlagTypeNumeric },
+	{L"KEYBOARDBACKLIGHTSTATE",		HALData::EKeyboardBacklightState,       EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"ACCESSORYPOWER",				HALData::EAccessoryPower,               EConfigFlagTypeNumeric | EConfigFlagTypeBoolean | EConfigFlagTypeYesNo },
+	{L"SYSTEMDRIVE",				HALData::ESystemDrive,                  EConfigFlagTypeNumeric },
+	{L"FPHARDWARE",					HALData::EHardwareFloatingPoint,        EConfigFlagTypeNumeric },
+	{L"NUMHALATTRIBUTES",			HALData::ENumHalAttributes,             EConfigFlagTypeNumeric },
+
+    // Custom entries for Interpretsis only
+	{L"LANGUAGE",					KVariableLanguage,                      EConfigFlagTypeNumeric },
+	{L"DRIVE",						KVariableDrive,							EConfigFlagTypeString },
+	{L"DEVICE_SUPPORTED_LANGUAGE",	KVariableDevSupLng,						EConfigFlagTypeNumeric }
+	};
+
+
+ConfigManager::ConfigManager(const CParameterList& aParamList)
+    {
+	const std::wstring& fileName = aParamList.ConfigFileName();
+
+    if ( FileExists( fileName ) )
+        {
+    	std::string fName;
+        fName = Ucs2ToUtf8( fileName );
+        //
+        std::ifstream stream;
+	    stream.open( fName.c_str(), std::ios::binary );
+        //
+        try
+            {
+            ReadFile( stream );
+            stream.close();
+            }
+        catch( const ConfigManagerException& e )
+            {
+            stream.close();
+            throw e;
+            }
+        }
+
+	// Add the Rom drive and System drive definition to the DriveMap
+	// So all the drives info. will be available from ConfigManager
+	AddRomAndSystemDrives(aParamList);
+    }
+
+
+ConfigManager::~ConfigManager()
+    {
+	// Clean up iDrives
+	for( DrivesMap::iterator it=iDrives.begin(); it != iDrives.end(); it++ )
+        {
+        DriveAttributes* entry = it->second;
+		delete entry;
+        }
+	iDeviceSupportedLanguages.clear();
+	iMatchingSupportedLanguages.clear();
+    }
+
+
+void ConfigManager::AddRomAndSystemDrives(const CParameterList& aParamList)
+	{
+	if ( aParamList.IsFlagSet(CParameterList::EFlagsZDriveSet)) 
+		{
+		CheckAndAddDrive('z', aParamList.RomDrivePath());
+		}
+
+	if ( IsTargetDrivePresent('z') )
+		{
+		if (aParamList.IsFlagSet(CParameterList::EFlagsRomRofsLogFilesSet) &&
+			aParamList.IsFlagSet(CParameterList::EFlagsDisableZDriveChecksSet) == 0 )
+			{
+			// z drive is set via ROM/ROFS logs, otherwise, command parser would have throw an exception
+			std::stringstream err;
+			err << "Cannot specify both -r option in command line and define the directory "
+				<< "representing the ROM drive in config file";
+			throw ConfigManagerException( ConfigManagerException::ETypeDriveError, err.str());
+			}
+		}
+	else
+		{
+		if (!aParamList.IsFlagSet(CParameterList::EFlagsDisableZDriveChecksSet))
+			{
+			// z drive defiend by ROM/ROFS logs
+			if (aParamList.IsFlagSet(CParameterList::EFlagsRomRofsLogFilesSet))
+				{
+				CheckAndAddDrive('z', L"");
+				}
+			else
+				{
+				// z drive is not set via config.ini or by -z option
+				std::stringstream err;
+				err << "Missing -r option and the ROM drive representing directory is not defined; "
+					<< "Must specify one of them (BUT not both)";
+				throw ConfigManagerException( ConfigManagerException::ETypeDriveError, err.str());
+				}
+			}
+		}
+	
+	if (aParamList.IsFlagSet(CParameterList::EFlagsCDriveSet)) 
+		{
+		CheckAndAddDrive(aParamList.SystemDriveLetter(), aParamList.SystemDrivePath());
+		}
+
+	if ( !IsTargetDrivePresent(aParamList.SystemDriveLetter()) )
+		{
+		std::stringstream err;
+		err << "The directory representing the system drive is not defined";
+		throw ConfigManagerException( ConfigManagerException::ETypeDriveError, err.str());
+		}
+	}
+
+
+void ConfigManager::SetValue( TUint32 aKey, TUint32 aValue )
+    {
+    iValues[ aKey ] = aValue;
+    }
+
+
+bool ConfigManager::ValueExists( TUint32 aKey ) const
+    {
+    ConfigurationMap::const_iterator it = iValues.find( aKey );
+    bool found = ( it != iValues.end() );
+    return found;
+    }
+
+
+TUint32 ConfigManager::ValueById( TUint32 aKey ) const
+    {
+    assert( ValueExists( aKey ) );
+    ConfigurationMap::const_iterator it = iValues.find( aKey );
+    const TUint32 ret = it->second;
+    return ret;
+    }
+
+
+void ConfigManager::ReadFile( std::ifstream& aStream )
+    {
+    int lineNumber = 1;
+    std::string line;
+    //
+    while( std::getline( aStream, line ) )
+        {
+        ProcessLine( line, lineNumber++ );
+        }
+    }
+
+
+void ConfigManager::ProcessLine( const std::string& aLine, int aLineNumber )
+    {
+	std::string line = aLine;
+
+    // Strip comments
+	std::string::size_type commentPos = line.find( "//" );
+    if ( commentPos != std::string::npos )
+        {
+        line = line.substr( 0, commentPos );
+        }
+
+    if  ( line.length() )
+        {
+    	std::string::size_type breakPos = line.find( "=" );
+        if ( breakPos != std::string::npos )
+            {
+        	std::string value = line.substr( breakPos + 1 );
+            line = line.substr( 0, breakPos );
+
+            // Trim & tidy up before the conversion phase
+            line = StringUtils::TrimWhiteSpace( line );
+            value = StringUtils::TrimWhiteSpace( value );
+
+            if ( line.length() && value.length() )
+                {
+                ConvertLineData( line, value, aLineNumber );
+                }
+            }
+        }
+    }
+
+std::vector<TInt>& ConfigManager::GetDeviceSupportedLanguages()
+	{
+		return iDeviceSupportedLanguages;
+	}
+
+void ConfigManager::ConvertLineData( const std::string& aKey, std::string& aValue, int aLineNumber )
+    {
+    const ConfigAttribute* attrib = AttributeByName( aKey );
+    if ( attrib )
+        {
+        // Now try to convert the value string according to the attribute's
+        // conversion specification.
+        if ( attrib->iFlags & EConfigFlagTypeNotSupported )
+            {
+            throw ConfigManagerException( ConfigManagerException::ETypeKeywordNotSupported, 
+                                          aKey,
+                                          aValue,
+                                          aLineNumber );
+            }
+        else
+            {
+            TUint32 num = 0;
+
+            // First try numeric conversion, since this satsifies most of
+            // the entries. Then try bool / yes / no
+            if ( ( attrib->iFlags & EConfigFlagTypeNumeric ) && TryStringToNumeric( aValue, num ) )
+                {
+            	if ( attrib->iId == KVariableDevSupLng )
+            		{
+            		if ( !AddDeviceSupportedLanguage(num))
+            			{
+    					throw ConfigManagerException( ConfigManagerException::ETypeDuplicateDefinition, 
+    													aKey, aValue, aLineNumber );
+    					}
+                	return;
+            		}
+
+                }
+            else if ( ( attrib->iFlags & EConfigFlagTypeBoolean ) && TryStringToBool( aValue, num ) )
+                {
+                }
+            else if ( ( attrib->iFlags & EConfigFlagTypeYesNo ) && TryStringToYesNo( aValue, num ) )
+                {
+                }
+			else if ( ( attrib->iFlags & EConfigFlagTypeString ) && (attrib->iId == KVariableDrive) )
+				{
+	            DriveAttributes* newDrive = new DriveAttributes();
+				int driveLetter = ConvertToDriveAttributes(StringUtils::ToLower(aValue), newDrive);
+				
+				if (driveLetter == 0)
+					{
+					delete newDrive;
+					throw ConfigManagerException( ConfigManagerException::ETypeInvalidValueForKey, 
+													aKey, aValue, aLineNumber );
+					}
+				
+				if ( !IsDirectory(newDrive->iDir) )
+					{
+					delete newDrive;
+					throw ConfigManagerException( ConfigManagerException::ETypeInvalidDirectory, 
+													aKey, aValue, aLineNumber );
+					}
+
+				if (!AddDrive(newDrive, driveLetter))
+					{
+					delete newDrive;
+					throw ConfigManagerException( ConfigManagerException::ETypeDuplicateDefinition, 
+													aKey, aValue, aLineNumber );
+					}
+
+				return;
+				}
+            else
+                {
+                throw ConfigManagerException( ConfigManagerException::ETypeInvalidValueForKey, 
+                                              aKey,
+                                              aValue,
+                                              aLineNumber );
+                }
+
+            // Assume okay if got here.
+            if ( !ValueExists( attrib->iId ) )
+                {
+                SetValue( attrib->iId, num );
+                }
+            else
+                {
+                throw ConfigManagerException( ConfigManagerException::ETypeDuplicateDefinition, 
+                                              aKey,
+                                              aValue,
+                                              aLineNumber );
+                }
+            }
+        }
+	else
+		{ 
+	 	// DEF117196
+	 	// Config files can be created by the licensee from HAL HDA files. It is cumbersome if they 
+	 	// produce an error and halt if there is an attribute defined in the config file which is not 
+	 	// relevant to interpretsis.
+	 	// Instead a warning is produced.
+		std::ostringstream stream;
+    	stream << "Unsupported keyword at line " << aLineNumber << " of ini file [" << aKey << " = " << aValue << "] ";
+    	stream << std::endl;
+    	std::wstring finalMessage = Utf8ToUcs2( stream.str() );
+		LWARN( finalMessage );
+		}
+    }
+
+
+std::string ConfigManager::AttributeNameById( TUint32 aId )
+    {
+	std::string ret = "Unknown/Unsupported attribute";
+    //
+    const int attributeCount = sizeof( KConfigAttributes ) / sizeof( ConfigAttribute );
+	for( int i=0; i<attributeCount; i++ )
+		{
+		if  ( KConfigAttributes[i].iId == aId )
+			{
+			std::wstring entry( KConfigAttributes[i].iName );
+            ret = Ucs2ToUtf8( entry );
+			}
+		}
+    //
+    return ret;
+    }
+
+
+const ConfigAttribute* ConfigManager::AttributeByName( const std::string& aName )
+    {
+	std::string upperCased( aName );
+    upperCased = StringUtils::ToUpper( upperCased );
+    std::wstring searchFor;
+    searchFor = Utf8ToUcs2( upperCased );
+    //
+    const int attributeCount = sizeof( KConfigAttributes ) / sizeof( ConfigAttribute );
+    const ConfigAttribute* ret = NULL;
+    //
+	for( int i=0; i<attributeCount; i++ )
+		{
+		if  ( KConfigAttributes[i].iName == searchFor )
+			{
+			ret = &KConfigAttributes[i];
+			break;
+			}
+		}
+    //
+    return ret;
+    }
+
+
+bool ConfigManager::TryStringToNumeric( const std::string& aText, TUint32& aNumber )
+    {
+    bool convertedOk = false;
+    //
+    std::istringstream stringStream( aText );
+
+    // Check for hex prefix
+    if ( aText.length() > 2 && aText.substr( 0, 2 ) == KConfigAttributeHexPrefix )
+        {
+        // Skip 0x prefix
+        stringStream.ignore( 2 );
+        stringStream >> std::hex >> aNumber;
+        convertedOk = ( !stringStream.fail() );
+        }
+    else
+        {
+        stringStream >> aNumber;
+        convertedOk = ( !stringStream.fail() );
+        }
+    //
+    return convertedOk;
+    }
+
+
+bool ConfigManager::TryStringToBool( const std::string& aText, TUint32& aNumber )
+    {
+    bool convertedOk = false;
+    //
+    std::string text = StringUtils::ToUpper( aText );
+    if ( text == KConfigAttributeValueTrue )
+        {
+        aNumber = true;
+        convertedOk = true;
+        }
+    else if ( text == KConfigAttributeValueFalse )
+        {
+        aNumber = false;
+        convertedOk = true;
+        }
+    //
+    return convertedOk;
+    }
+
+
+bool ConfigManager::TryStringToYesNo( const std::string& aText, TUint32& aNumber )
+    {
+    bool convertedOk = false;
+    //
+    std::string text = StringUtils::ToUpper( aText );
+    if ( text == KConfigAttributeValueYes )
+        {
+        aNumber = true;
+        convertedOk = true;
+        }
+    else if ( text == KConfigAttributeValueNo )
+        {
+        aNumber = false;
+        convertedOk = true;
+        }
+    //
+    return convertedOk;
+    }
+
+
+int ConfigManager::ConvertToDriveAttributes( const std::string& aString, DriveAttributes* aDrive)
+    {
+	std::string::const_iterator it = aString.begin();
+	std::string::const_iterator end = aString.end();
+	std::string::const_iterator currentPos = it;
+	int driveLetter = 0;
+
+	if (currentPos != end)
+        {
+		std::string temp;
+
+        currentPos = std::find(it, end, ' ');
+
+		if (currentPos == end)
+			{
+			return 0;
+			}
+
+		// Set the drive representation location
+		Utf8ToUcs2(std::string(it, (currentPos-it)), aDrive->iDir);
+			
+		temp =  StringUtils::TrimWhiteSpace( std::string(currentPos, end) );
+
+		it = temp.begin();
+		end = temp.end();
+
+		// Look for the next 'space' if found
+		currentPos = std::find(it, end, ' ');
+
+		if (currentPos - it != 1)
+			{
+			// The drive letter is more than one character
+			return 0;
+			}
+		
+		// Set the target drive letter
+		driveLetter = tolower(*it);
+
+		if (currentPos == end)
+			{
+			// The external attribute is not set, i.e. leave it as the default value.
+			return driveLetter;
+			}
+
+		temp =  StringUtils::TrimWhiteSpace( std::string(currentPos, end) );
+
+		// Set the external attribute to true
+		if (StringUtils::ToLower(temp) == "ext")
+			aDrive->iExternal = true;
+      
+		return driveLetter;
+		}
+
+	return 0;
+	}
+
+
+std::wstring ConfigManager::GetLocalDrivePath(int aDrive)
+{
+	DrivesMap::const_iterator it = iDrives.find( aDrive );
+
+	if (it == iDrives.end())
+	{
+		std::stringstream err;
+		err << "Drive: " << aDrive << " not defined";
+		throw ConfigManagerException( ConfigManagerException::ETypeDriveError, err.str());
+	}
+
+    return it->second->iDir;
+}
+
+
+bool ConfigManager::IsTargetDrivePresent(int aDrive) const
+{
+	DrivesMap::const_iterator it = iDrives.find( aDrive );
+
+	return (it != iDrives.end());
+}
+
+
+bool ConfigManager::IsTargetDriveExt(int aDrive) const
+{
+	DrivesMap::const_iterator it = iDrives.find( aDrive );
+
+	if (it == iDrives.end())
+	{
+		std::stringstream err;
+		err << "Drive: " << aDrive << " not defined";
+		throw ConfigManagerException( ConfigManagerException::ETypeDriveError, err.str());
+	}
+
+
+    return it->second->iExternal;
+}
+
+
+bool ConfigManager::AddDrive(DriveAttributes* aDrive, const int aDriveLetter)
+{
+	DrivesMap::const_iterator it = iDrives.find( aDriveLetter );
+
+	if( it != iDrives.end())
+	{
+		// Drive already present
+		return false;
+	}
+
+	// Set the map value
+	iDrives[aDriveLetter] = aDrive;
+	return true;
+}
+
+
+void ConfigManager::CheckAndAddDrive(const int aDrive, const std::wstring& aDir,const bool aExternal)
+{
+	DrivesMap::iterator it = iDrives.find( aDrive );
+
+	if (it != iDrives.end())
+	{
+		char drive = aDrive;
+	 	std::stringstream warn;
+		warn << "Redefining drive: " << drive;
+		std::wstring finalMessage = Utf8ToUcs2( warn.str() );
+		LWARN( finalMessage + L" to " + aDir);
+
+		delete it->second;
+		iDrives.erase(it);
+	}
+
+	DriveAttributes* newDrive = new DriveAttributes();
+
+	newDrive->iDir = aDir;
+	newDrive->iExternal = aExternal;
+	
+	// Set the map value
+	iDrives[aDrive] = newDrive;
+}
+
+
+bool ConfigManager::AddDeviceSupportedLanguage(TInt langId)
+	{
+ 	std::vector<int>::const_iterator end = iDeviceSupportedLanguages.end();
+	for (std::vector<int>::const_iterator curr = iDeviceSupportedLanguages.begin(); curr != end; ++curr)
+		{
+			 if ( *curr == langId)
+			 {
+				 return false;
+			 }
+		}
+	iDeviceSupportedLanguages.push_back(langId);
+	return true;
+	}
+void ConfigManager::AddMatchingSupportedLanguages(TInt aMatchingSupportedLangauges)
+	{
+ 	std::vector<int>::const_iterator end = iMatchingSupportedLanguages.end();
+	for (std::vector<int>::const_iterator curr = iMatchingSupportedLanguages.begin(); curr != end; ++curr)
+		{
+			 if ( *curr == aMatchingSupportedLangauges)
+			 {
+				 return;
+			 }
+		}
+	iMatchingSupportedLanguages.push_back(aMatchingSupportedLangauges);
+	return;
+	}
+
+std::vector<TInt>& ConfigManager::GetMatchingSupportedLanguages() 
+	{
+		return iMatchingSupportedLanguages;
+	}
+ConfigManagerException::~ConfigManagerException()
+    {
+    }
+
+
+void ConfigManagerException::Display() const
+    {
+	std::ostringstream stream;
+    stream << "Configuration problem at line " << iLineNumber << " [" << iKey << " = " << iValue << "]: ";
+    //
+	switch( iType )
+		{
+		case ETypeKeywordNotSupported:
+			stream << "KEY is not supported";
+			break;
+		case ETypeInvalidValueForKey:
+			stream << "\'" << iValue << "\'" << " is an invalid type or out of range";
+			break;
+		case ETypeDuplicateDefinition:
+			stream << "\'" << iKey << "\'" << "has already been defined previously in this configuration";
+			break;
+		case ETypeInvalidDirectory:
+			stream << "\'" << iValue << "\'" << " directory is not found";
+			break;
+		case ETypeDriveError:
+			LERROR( Utf8ToUcs2( iValue ) );
+			return;
+
+		default:
+			stream << "Unknown error";
+			break;
+		}
+    //
+    stream << std::endl;
+    std::wstring finalMessage = Utf8ToUcs2( stream.str() );
+    //
+	LERROR( finalMessage );
+    }
+