FCL/sf/mw/appinstall: comparison secureswitools/swisistools/source/xmlparser/xmlparser.cpp

equal deleted inserted replaced

-:ae54820ef82c
+:245df5276b97
 */
 #include "xmlparser.h"
 #include "logs.h"
 #include "exception.h"
+#include "utf8_wrapper.h"
 #include "util.h"
 #include <xercesc/sax2/XMLReaderFactory.hpp>
 #include <xercesc/sax2/DefaultHandler.hpp>
 #include <xercesc/util/XMLString.hpp>
 #include <vector>
 #include <memory>
 #include <cstdio>
+#ifndef _WIN32
+#include <ctype.h>
+//__ctype_b was removed from glibc. This is a workaround to fix the linking problem
+extern "C"
+{
+const unsigned short int** __ctype_b()
+{
+return __ctype_b_loc();
+}
+}
+#endif // _WIN32
 XERCES_CPP_NAMESPACE_USE
+//------------------------------------------------------------------------------------------------------------------------------
+//											UTILITY FUNCTIONS
+//------------------------------------------------------------------------------------------------------------------------------
+int XercesStringToInteger(const XercesString& aWideStr)
+	{
+	int strLen = aWideStr.length();
+	const XMLCh* source = aWideStr.c_str();
+char* buffer = new char[strLen << 2];
+	// Using a temp variable in place of buffer as ConvertUTF16toUTF8 modifies the source pointer passed.
+	char* temp = buffer;
+	ConvertUTF16toUTF8(&source, aWideStr.c_str() + strLen, &temp,  temp + (strLen << 2));
+	// Appending NUL to the converted buffer.
+	*temp = 0;
+	int value = 0;
+	sscanf(buffer, "%d", &value);
+	delete[] buffer;
+	return value;
+	}
 // these function pointers are used to call appropriate release methods of XMLString
 // present in the xerces library.
 typedef void (*releaseXmlChPtr) (XMLCh** buf);
 typedef void (*releaseChPtr) (char** buf);
+#ifdef _WIN32
+// We need not do anything for WINDOWS, since XMLCh string(XercesString)
+// and WString both are same and will be in UTF-16 encoding format.
+#define XMLChToWString(aParameter) (aParameter)
+#else
+inline std::wstring XMLChToWString(const XercesString& aXercesString)
+	{
+	return XercesStringToWString (aXercesString);
+	}
+#endif // _WIN32
 DllExport CScrXmlParser::CScrXmlParser()
 	{}
 	DOMNode* swTypeNamesRoot	= swTypeNames->item(0);
 	DOMElement* swTypeNamesNode = static_cast< xercesc::DOMElement* >( swTypeNamesRoot );
 	DOMNodeList* uniqueSwTypeName = swTypeNamesNode->getElementsByTagName(tagUniqueSoftwareTypeName.get());
 	const XMLCh* textContent = uniqueSwTypeName->item(0)->getTextContent();
-	scrEnvDetails.iUniqueSoftwareTypeName = std::wstring(textContent);
+	scrEnvDetails.iUniqueSoftwareTypeName = XMLChToWString(textContent);
 	DOMNodeList* localizableSwTypeNames = swTypeNamesNode->getElementsByTagName(tagLocalizableSwTypeName.get());
 	const  XMLSize_t localizableSwTypeNamesCount = localizableSwTypeNames->getLength();
 	for( XMLSize_t count=0 ; count<localizableSwTypeNamesCount ; ++count )
 		{
 if(0 != launcherExecutable->getLength())
 {
 		textContent = launcherExecutable->item(0)->getTextContent();
 		fn_auto_ptr<releaseXmlChPtr, XMLCh> launcherExecutableText( &XMLString::release,textContent );
 		const XMLCh* launcherExecutableValue = launcherExecutableText.get();
-		scrEnvDetails.iLauncherExecutable = launcherExecutableValue;
+		scrEnvDetails.iLauncherExecutable = XMLChToWString(launcherExecutableValue);
 		}
 DOMNodeList* customAcessList = aEnvironment->getElementsByTagName(tagCustomAcess.get());
 	const  XMLSize_t customAcessDataCount = customAcessList->getLength();
 	for( XMLSize_t count=0 ; count<customAcessDataCount ; ++count )
 		{
 	DOMNodeList* mimes = mimeDetailNode->getElementsByTagName(tagMIMEType.get());
 	const  XMLSize_t mimeCount = mimes->getLength();
 	for( XMLSize_t count=0 ; count<mimeCount ; ++count )
 		{
 		const XMLCh* textContent = mimes->item(count)->getTextContent();
-		scrEnvDetails.iMIMEDetails.push_back(textContent);
+		std::wstring textString = XMLChToWString(textContent);
+		scrEnvDetails.iMIMEDetails.push_back(textString);
 		}
 	LOGEXIT("CScrXmlParser::GetEnvironmentData()");
 	return scrEnvDetails;
 		fn_auto_ptr<releaseXmlChPtr, XMLCh> tagSoftwareTypeName( &XMLString::release, XMLString::transcode("SoftwareTypeName") );
 		DOMNodeList* softwaretype = elementRoot->getElementsByTagName(tagSoftwareTypeName.get());
 		const XMLCh* textContent = softwaretype->item(0)->getTextContent();
-		preProvisionDetail.iSoftwareTypeName = std::wstring(textContent);
+		preProvisionDetail.iSoftwareTypeName = XMLChToWString(textContent);
 		// Retrieve the nodes for Component.
 		DOMNodeList* componentNodes = elementRoot->getElementsByTagName(tagComponent.get());
 		const  XMLSize_t nodeCount = componentNodes->getLength();
 	XmlDetails::TScrPreProvisionDetail::TComponentLocalizable componentLocalizable;
 	if(locale->getLength() != 0)
 		{
 		const XMLCh* textLocale = locale->item(0)->getTextContent();
-		componentLocalizable.iLocale = Util::WideCharToInteger(textLocale);
+		componentLocalizable.iLocale = XercesStringToInteger(textLocale);
 		}
 	const XMLCh* textName = name->item(0)->getTextContent();
-	componentLocalizable.iName = textName;
+	componentLocalizable.iName = XMLChToWString(textName);
 	if(vendor->getLength() != 0)
 		{
 		const XMLCh* textVendor = vendor->item(0)->getTextContent();
-		componentLocalizable.iVendor = textVendor;
+		componentLocalizable.iVendor = XMLChToWString(textVendor);
 		}
 	LOGEXIT("CScrXmlParser::GetComponentLocalizable()");
 	return componentLocalizable;
 	}
 	DOMNodeList* isBinary = aEnvironment->getElementsByTagName(tagComponentPropertyIsBinary.get());
 	XmlDetails::TScrPreProvisionDetail::TComponentProperty componentProperty;
 	const XMLCh* textName = name->getTextContent();
-	componentProperty.iName	= textName;
+	componentProperty.iName	= XMLChToWString(textName);
 	if(locale->getLength() != 0)
 		{
 		const XMLCh* textLocale = locale->item(0)->getTextContent();
-		componentProperty.iLocale = Util::WideCharToInteger(textLocale);
+		componentProperty.iLocale = XercesStringToInteger(textLocale);
 		}
 	DOMNodeList* childNodes = value->item(0)->getChildNodes();
 	const XMLSize_t nodeCount = childNodes->getLength();
 		{
 		DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) );
 		if( XMLString::equals(currentElement->getTagName(), tagComponentPropertyIntValue.get()))
 			{
 			componentProperty.iIsIntValue = true;
-			componentProperty.iValue = currentElement->getTextContent();
+			componentProperty.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		else if( XMLString::equals(currentElement->getTagName(), tagComponentPropertyStrValue.get()))
 			{
 			componentProperty.iIsIntValue = false;
-			componentProperty.iValue = currentElement->getTextContent();
+			componentProperty.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		}
 	if(isBinary->getLength() != 0)
 		{
 		const XMLCh* textIsBinary = isBinary->item(0)->getTextContent();
-		componentProperty.iIsStr8Bit = Util::WideCharToInteger(textIsBinary);
+		componentProperty.iIsStr8Bit = XercesStringToInteger(textIsBinary);
 		}
 	LOGEXIT("CScrXmlParser::GetComponentProperty()");
 	return componentProperty;
 	}
 		}
 	// attribute - location
 	DOMNamedNodeMap* attributes = aDOMElement->getAttributes();
 	DOMNode* location = attributes->getNamedItem(tagLocation.get());
-	componentFile.iLocation = location->getTextContent();
+	componentFile.iLocation = XMLChToWString(location->getTextContent());
 	LOGEXIT("CScrXmlParser::GetComponentFile()");
 	return componentFile;
 	}
 XmlDetails::TScrPreProvisionDetail::TComponentDependency CScrXmlParser::GetComponentDependency( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement)
 		XmlDetails::TScrPreProvisionDetail::TComponentDependency::TComponentDependencyDetail componentDependencyDetail;
 		DOMElement* currentDepDetail = static_cast< xercesc::DOMElement* >( depList->item(index) );
 		DOMNodeList* supplierId = currentDepDetail->getElementsByTagName(tagSupplierId.get());
 		const XMLCh* textSupplierId = supplierId->item(0)->getTextContent();
-		componentDependencyDetail.iSupplierId = std::wstring(textSupplierId);
+		componentDependencyDetail.iSupplierId = XMLChToWString(textSupplierId);
 		DOMNodeList* fromVersion = currentDepDetail->getElementsByTagName(tagFromVersion.get());
 		const XMLCh* textFromVersion = fromVersion->item(0)->getTextContent();
-		componentDependencyDetail.iFromVersion = std::wstring(textFromVersion);
+		componentDependencyDetail.iFromVersion = XMLChToWString(textFromVersion);
 		DOMNodeList* toVersion = currentDepDetail->getElementsByTagName(tagToVersion.get());
 		const XMLCh* textToVersion = toVersion->item(0)->getTextContent();
-		componentDependencyDetail.iToVersion = std::wstring(textToVersion);
+		componentDependencyDetail.iToVersion = XMLChToWString(textToVersion);
 		componentDependency.iComponentDependencyList.push_back(componentDependencyDetail);
 		}
 	// attribute - location
 	DOMNamedNodeMap* attributes = aDOMElement->getAttributes();
 	DOMNode* dependentId = attributes->getNamedItem(tagDependentId.get());
-	componentDependency.iDependentId = dependentId->getTextContent();
+	componentDependency.iDependentId = XMLChToWString(dependentId->getTextContent());
 	LOGEXIT("CScrXmlParser::GetComponentDependency()");
 	return componentDependency;
 	}
 XmlDetails::TScrPreProvisionDetail::TComponentFile::TFileProperty
 	DOMNodeList* value = aDOMElement->getElementsByTagName(tagFilePropertyValue.get());
 	DOMNodeList* isBinary = aDOMElement->getElementsByTagName(tagFilePropertyIsBinary.get());
 	const XMLCh* textName = name->getTextContent();
-	fileProperty.iName	= textName;
+	fileProperty.iName	= XMLChToWString(textName);
 	int valueLength = value->getLength();
 	if(valueLength != 0)
 		{
 		for(int valIndex = 0; valIndex< valueLength; ++valIndex)
 				{
 				DOMElement* valueElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) );
 				if( XMLString::equals(valueElement->getTagName(), tagFilePropertyIntValue.get()))
 					{
 					fileProperty.iIsIntValue = true;
-					fileProperty.iValue = currentElement->getTextContent();
+					fileProperty.iValue = XMLChToWString(currentElement->getTextContent());
 					}
 				else if( XMLString::equals(valueElement->getTagName(), tagFilePropertyStrValue.get()))
 					{
 					fileProperty.iIsIntValue = false;
-					fileProperty.iValue = currentElement->getTextContent();
+					fileProperty.iValue = XMLChToWString(currentElement->getTextContent());
 					}
 				}
 			}
 		}
 	LOGEXIT("CScrXmlParser::GetFileProperty()");
 	if( romApplication->getLength() != 0)
 		{
 		LOGINFO("CScrXmlParser::GetComponentDetails()- rom app");
 		const XMLCh* textRomApplication = romApplication->item(0)->getTextContent();
-		componentDetails.iIsRomApplication = Util::WideCharToInteger(textRomApplication);
+		componentDetails.iIsRomApplication = XercesStringToInteger(textRomApplication);
 		}
 	if( removable->getLength() != 0)
 		{
 		const XMLCh* textRemovable = removable->item(0)->getTextContent();
-		componentDetails.iIsRemovable = Util::WideCharToInteger(textRemovable);
+		componentDetails.iIsRemovable = XercesStringToInteger(textRemovable);
 		}
 	if( size->getLength() != 0)
 		{
 		const XMLCh* textSize = size->item(0)->getTextContent();
-		componentDetails.iSize = Util::WideCharToInteger(textSize);
+		componentDetails.iSize = XercesStringToInteger(textSize);
 		}
 	if( scomoState->getLength() != 0)
 		{
 		const XMLCh* textScomoState = scomoState->item(0)->getTextContent();
-		componentDetails.iScomoState = Util::WideCharToInteger(textScomoState);
+		componentDetails.iScomoState = XercesStringToInteger(textScomoState);
 		}
 	if( globalId->getLength() != 0)
 		{
 		const XMLCh* textGlobalId = globalId->item(0)->getTextContent();
-		componentDetails.iGlobalId = textGlobalId;
+		componentDetails.iGlobalId = XMLChToWString(textGlobalId);
 		}
 	if( versionDetail->getLength() != 0)
 		{
 		// tags for Version
 		DOMNamedNodeMap* attributes = versionElement->getAttributes();
 		DOMNode* major = attributes->getNamedItem(tagMajor.get());
 		DOMNode* minor = attributes->getNamedItem(tagMinor.get());
 		DOMNode* build = attributes->getNamedItem(tagBuild.get());
-		componentDetails.iVersion.iMajor = major->getTextContent();
+		componentDetails.iVersion.iMajor = XMLChToWString(major->getTextContent());
-		componentDetails.iVersion.iMinor = minor->getTextContent();
+		componentDetails.iVersion.iMinor = XMLChToWString(minor->getTextContent());
-		componentDetails.iVersion.iBuild = build->getTextContent();
+		componentDetails.iVersion.iBuild = XMLChToWString(build->getTextContent());
 		}
 	if( originVerified->getLength() != 0)
 		{
 		const XMLCh* textOriginVerified = originVerified->item(0)->getTextContent();
-		componentDetails.iOriginVerified = Util::WideCharToInteger(textOriginVerified);
+		componentDetails.iOriginVerified = XercesStringToInteger(textOriginVerified);
 		}
 	if( hidden->getLength() != 0)
 		{
 		const XMLCh* textHidden = hidden->item(0)->getTextContent();
-		componentDetails.iIsHidden = Util::WideCharToInteger(textHidden);
+		componentDetails.iIsHidden = XercesStringToInteger(textHidden);
 		}
 	LOGEXIT("CScrXmlParser::GetComponentDetails()");
 	return componentDetails;
 	}
 	DOMNode* name = attributes->getNamedItem(tagSwTypeNameValue.get());
 	XmlDetails::TScrEnvironmentDetails::TLocalizedSoftwareTypeName localizedSwTypeName;
 	const XMLCh* textLocale = locale->getTextContent();
-	localizedSwTypeName.iLocale = Util::WideCharToInteger(textLocale);
+	localizedSwTypeName.iLocale = XercesStringToInteger(textLocale);
 	const XMLCh* textName = name->getTextContent();
-	localizedSwTypeName.iName = textName;
+	localizedSwTypeName.iName =  XMLChToWString(textName);
 	LOGEXIT("CScrXmlParser::GetLocalizedSoftwareTypeName()");
 	return localizedSwTypeName;
 	}
 XmlDetails::TScrEnvironmentDetails::TCustomAcessList
 	int secureIdVal=0;
 	sscanf(textSecureId.get(),"%x",&secureIdVal);
 	customAcessList.iSecureId = secureIdVal;
 	const XMLCh* textAccessMode = accessMode->getTextContent();
-	customAcessList.iAccessMode = Util::WideCharToInteger(textAccessMode);
+	customAcessList.iAccessMode = XercesStringToInteger(textAccessMode);
 	LOGEXIT("CScrXmlParser::GetCustomAcessList()");
 	return customAcessList;
 	}
 XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo CScrXmlParser::GetApplicationRegistrationInfo(const DOMElement* aDOMElement)
 		XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType opaqueDataType = GetOpaqueDataType(currentOpaqueData);
 		appProperty.iLocale = opaqueDataType.iLocale;
 		appProperty.iName = L"OpaqueData";
 		appProperty.iIntValue = 0;
-		appProperty.iIsStr8Bit = true;
+		appProperty.iIsStr8Bit = opaqueDataType.iIsBinary;
 		appProperty.iServiceUid = 0;
 		appProperty.iStrValue = opaqueDataType.iOpaqueData;
 		appRegistrationInfo.iApplicationProperty.push_back(appProperty);
 		}
 	DOMNodeList* isBinary = aDOMElement->getElementsByTagName(tagAppAttributeIsBinary.get());
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppAttribute appAttribute;
 	const XMLCh* textName = name->getTextContent();
-	appAttribute.iName	= textName;
+	appAttribute.iName	= XMLChToWString(textName);
 	DOMNodeList* childNodes = value->item(0)->getChildNodes();
 	const XMLSize_t nodeCount = childNodes->getLength();
 	for(int index = 0; index< nodeCount; ++index)
 		{
 		DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) );
 		if( XMLString::equals(currentElement->getTagName(), tagApplicationAttributeIntValue.get()))
 			{
 			appAttribute.iIsIntValue = true;
-			appAttribute.iValue = currentElement->getTextContent();
+			appAttribute.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		else if( XMLString::equals(currentElement->getTagName(), tagApplicationAttributeStrValue.get()))
 			{
 			appAttribute.iIsIntValue = false;
-			appAttribute.iValue = currentElement->getTextContent();
+			appAttribute.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		}
 	if(isBinary->getLength() != 0)
 		{
 		const XMLCh* textIsBinary = isBinary->item(0)->getTextContent();
-		appAttribute.iIsStr8Bit = Util::WideCharToInteger(textIsBinary);
+		appAttribute.iIsStr8Bit = XercesStringToInteger(textIsBinary);
 		}
 	LOGEXIT("CScrXmlParser::GetAppAttribute()");
 	return appAttribute;
 	}
 	std::wstring file;
 	if( fileName->getLength() != 0)
 		{
 		const XMLCh* fil = fileName->item(0)->getTextContent();
-		file = fil;
+		file = XMLChToWString(fil);
 		}
 	LOGEXIT("CScrXmlParser::GetFileOwnershipInfo()");
 	return file;
 	}
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TDataType dataType;
 	if( priority->getLength() != 0)
 		{
 		const XMLCh* pri = priority->item(0)->getTextContent();
-		dataType.iPriority = Util::WideCharToInteger(pri);
+		dataType.iPriority = XercesStringToInteger(pri);
 		}
 	if( type->getLength() != 0)
 		{
 		const XMLCh* typ = type->item(0)->getTextContent();
-		dataType.iType = typ;
+		dataType.iType = XMLChToWString(typ);
 		}
 	LOGEXIT("CScrXmlParser::GetDataType()");
 	return dataType;
 	}
 	{
 	LOGENTER("CScrXmlParser::GetOpaqueDataType()");
 	// tags in OpaqueDataType
 	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagData( &XMLString::release, XMLString::transcode("Data") );
 	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagOpaqueLocale( &XMLString::release, XMLString::transcode("OpaqueLocale") );
+	fn_auto_ptr<releaseXmlChPtr, XMLCh> tagIsBinary( &XMLString::release, XMLString::transcode("IsBinary") );
 	DOMNodeList* Data = aDOMElement->getElementsByTagName(tagData.get());
 	DOMNodeList* OpaqueLocale = aDOMElement->getElementsByTagName(tagOpaqueLocale.get());
+	DOMNodeList* isBinary = aDOMElement->getElementsByTagName(tagIsBinary.get());
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType opaqueDataType;
 	if( OpaqueLocale->getLength() != 0)
 		{
 		const XMLCh* pri = OpaqueLocale->item(0)->getTextContent();
-		opaqueDataType.iLocale = Util::WideCharToInteger(pri);
+		opaqueDataType.iLocale = XercesStringToInteger(pri);
 		}
 	if( Data->getLength() != 0)
 		{
 		const XMLCh* typ = Data->item(0)->getTextContent();
-		opaqueDataType.iOpaqueData = typ;
+		opaqueDataType.iOpaqueData = XMLChToWString(typ);
 		}
+	if(isBinary->getLength() != 0)
+		{
+		const XMLCh* textIsBinary = isBinary->item(0)->getTextContent();
+		opaqueDataType.iIsBinary = XercesStringToInteger(textIsBinary);
+		}
 	LOGEXIT("CScrXmlParser::GetOpaqueDataType()");
 	return opaqueDataType;
 	}
 XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType opaqueDataType;
 	if( ServiceOpaqueLocale->getLength() != 0)
 		{
 		const XMLCh* pri = ServiceOpaqueLocale->item(0)->getTextContent();
-		opaqueDataType.iLocale = Util::WideCharToInteger(pri);
+		opaqueDataType.iLocale = XercesStringToInteger(pri);
 		}
 	if( ServiceData->getLength() != 0)
 		{
 		const XMLCh* typ = ServiceData->item(0)->getTextContent();
-		opaqueDataType.iOpaqueData = typ;
+		opaqueDataType.iOpaqueData = XMLChToWString(typ);
 		}
 	LOGEXIT("CScrXmlParser::GetServiceOpaqueDataType()");
 	return opaqueDataType;
 	}
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppServiceInfo appServiceInfo;
 	if( uid->getLength() != 0)
 		{
 		const XMLCh* priority = uid->item(0)->getTextContent();
-		appServiceInfo.iUid = Util::WideCharToInteger(priority);
+		appServiceInfo.iUid = XercesStringToInteger(priority);
 		}
 	// for each OpaqueData retrieve all tags
 	for( XMLSize_t index = 0; index < ServiceOpaqueDataCount; ++index )
 		{
 		XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType opaqueDataType = GetServiceOpaqueDataType(currentOpaqueData);
 		appProperty.iLocale = opaqueDataType.iLocale;
 		appProperty.iName = L"OpaqueData";
 		appProperty.iIntValue = 0;
-		appProperty.iIsStr8Bit = true;
+		appProperty.iIsStr8Bit = opaqueDataType.iIsBinary;
 		appProperty.iServiceUid = appServiceInfo.iUid;
 		appProperty.iStrValue = opaqueDataType.iOpaqueData;
 		aAppRegistrationInfo.iApplicationProperty.push_back(appProperty);
 		}
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppLocalizableInfo::TLocalizableAttribute appLocalizableAttribute;
 	LOGINFO("name->getTextContent");
 	const XMLCh* textName = name->getTextContent();
-	appLocalizableAttribute.iName = textName;
+	appLocalizableAttribute.iName = XMLChToWString(textName);
 	DOMNodeList* childNodes = value->item(0)->getChildNodes();
 	const XMLSize_t nodeCount = childNodes->getLength();
 	for(int index = 0; index< nodeCount; ++index)
 		{
 		DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) );
 		if( XMLString::equals(currentElement->getTagName(), tagAppLocalizableInfoAttributeIntValue.get()))
 			{
 			appLocalizableAttribute.iIsIntValue = true;
-			appLocalizableAttribute.iValue = currentElement->getTextContent();
+			appLocalizableAttribute.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		else if( XMLString::equals(currentElement->getTagName(), tagAppLocalizableInfoAttributeStrValue.get()))
 			{
 			appLocalizableAttribute.iIsIntValue = false;
-			appLocalizableAttribute.iValue = currentElement->getTextContent();
+			appLocalizableAttribute.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		}
 	if(isBinary->getLength() != 0)
 		{
 		const XMLCh* textIsBinary = isBinary->item(0)->getTextContent();
-		appLocalizableAttribute.iIsStr8Bit = Util::WideCharToInteger(textIsBinary);
+		appLocalizableAttribute.iIsStr8Bit = XercesStringToInteger(textIsBinary);
 		}
 	LOGEXIT("CScrXmlParser::GetAppLocalizableAttribute()");
 	return appLocalizableAttribute;
 	}
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppLocalizableInfo::TViewData::TViewDataAttributes appLocalizableViewDataAttribute;
 	LOGINFO("name->getTextContent");
 	const XMLCh* textName = name->getTextContent();
 	LOGINFO("assign name");
-	appLocalizableViewDataAttribute.iName = textName;
+	appLocalizableViewDataAttribute.iName = XMLChToWString(textName);
 	LOGINFO("getChildNodes()");
 	DOMNodeList* childNodes = value->item(0)->getChildNodes();
 	LOGINFO("childNodes->getLength()");
 	const XMLSize_t nodeCount = childNodes->getLength();
 		DOMElement* currentElement = static_cast< xercesc::DOMElement* >( childNodes->item(index) );
 		if( XMLString::equals(currentElement->getTagName(), tagAppLocalizableViewDataIntValue.get()))
 			{
 			LOGINFO("int value");
 			appLocalizableViewDataAttribute.iIsIntValue = true;
-			appLocalizableViewDataAttribute.iValue = currentElement->getTextContent();
+			appLocalizableViewDataAttribute.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		else if( XMLString::equals(currentElement->getTagName(), tagAppLocalizableViewDataStrValue.get()))
 			{
 			LOGINFO("str value");
 			appLocalizableViewDataAttribute.iIsIntValue = false;
-			appLocalizableViewDataAttribute.iValue = currentElement->getTextContent();
+			appLocalizableViewDataAttribute.iValue = XMLChToWString(currentElement->getTextContent());
 			break;
 			}
 		}
 	if(isBinary->getLength() != 0)
 		{
 		LOGINFO("bin value");
 		const XMLCh* textIsBinary = isBinary->item(0)->getTextContent();
-		appLocalizableViewDataAttribute.iIsStr8Bit = Util::WideCharToInteger(textIsBinary);
+		appLocalizableViewDataAttribute.iIsStr8Bit = XercesStringToInteger(textIsBinary);
 		}
 	LOGEXIT("CScrXmlParser::GetAppLocalizableViewDataAttributes()");
 	return appLocalizableViewDataAttribute;
 	}
 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppProperty appProperty;
 	if( locale->getLength() != 0)
 		{
 		const XMLCh* loc = locale->item(0)->getTextContent();
-		appProperty.iLocale = Util::WideCharToInteger(loc);
+		appProperty.iLocale = XercesStringToInteger(loc);
 		}
 	if( name->getLength() != 0)
 		{
 		const XMLCh* nam = name->item(0)->getTextContent();
-		appProperty.iName = nam;
+		appProperty.iName = XMLChToWString(nam);
 		}
 	if( intvalue->getLength() != 0)
 		{
 		const XMLCh* intval = intvalue->item(0)->getTextContent();
-		appProperty.iIntValue = Util::WideCharToInteger(intval);
+		appProperty.iIntValue = XercesStringToInteger(intval);
 		}
 	if( strvalue->getLength() != 0)
 		{
 		const XMLCh* strval = strvalue->item(0)->getTextContent();
-		appProperty.iStrValue = strval;
+		appProperty.iStrValue = XMLChToWString(strval);
 		}
 	LOGEXIT("CScrXmlParser::GetAppProperty()");
 	return appProperty;
 	}
 void SchemaErrorHandler::resetErrors ()
 	{
 	std::string msg( "Resetting error handler object" );
 	LOGINFO(msg);
 	}

changeset 60	245df5276b97
parent 25	98b66e4fb0be
child 67	3a625661d1ce