diff -r 000000000000 -r ba25891c3a9e secureswitools/swisistools/source/interpretsislib/stringutils.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/interpretsislib/stringutils.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,464 @@
+/*
+* 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)
+
+#include "stringutils.h"
+
+// System includes
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <sstream>
+
+// User includes
+#include "is_utils.h"
+#include "logger.h"
+#include "utility_interface.h"
+
+// Constants
+const int KInterpretSISExpectedSIDLength = 8;
+const int KInterpretSISCtlIndexLength = 4;
+const std::string KStringUtilsWhiteSpace = "\t  \r\n";
+
+/**
+ * Returns the size of the first occurance of an invalid directory separator.
+ * @param aPath Path to be validated.
+ * @param aIndex index from which the search begin. On function return this 
+ * 				index will point to the illegal directory separator. 
+ * @return 0 if path is valid. Else the number of character to be replaced.
+ * e.g. /sys/bin/ should be replaced with \sys\bin\
+ * and \\sys\\bin\\ should be replaced with \sys\bin\
+ */ 
+int StringUtils::FirstInvalidDirSeparatorSize(std::wstring& aPath, std::wstring::size_type& aIndex)
+	{
+	// If path semantics is correct (as needed by sisx library)
+	// then the function will return 0
+	int ret = 0; 
+	int pos = 0;
+	if((pos = aPath.find(L"/", aIndex)) != std::wstring::npos)
+		{
+		ret = 1;
+		}
+	else if((pos = aPath.find(L"\\\\", aIndex)) != std::wstring::npos)
+		{
+		ret = 2;
+		}
+	aIndex = pos;
+	return ret;
+	}
+
+std::wstring StringUtils::FixPathDelimiters( const std::string& aString )
+    {
+	std::wstring ret = L"";
+    char src[2048];
+    strcpy(src, aString.c_str());
+    //
+	wchar_t* buf = NULL ;
+	int len = ConvertMultiByteToWideChar(src, -1, NULL, 0);
+	buf = new wchar_t[len+1];
+	len = ConvertMultiByteToWideChar(src, -1, buf, len);
+	ret = std::wstring( buf );
+	delete[] buf;
+	//
+    std::wstring::size_type idx = 0;
+	while(len = FirstInvalidDirSeparatorSize(ret, idx))
+        {
+		ret.replace(idx, len, KDirectorySeparator);
+        }
+    //
+    return ret;
+    }
+
+
+std::string StringUtils::TrimWhiteSpace( const std::string& aString )
+	{
+	const int start = aString.find_first_not_of( KStringUtilsWhiteSpace );
+	if (start == std::string::npos)
+        {
+		return "";
+        }
+    //
+	return aString.substr(start, 1 + aString.find_last_not_of( KStringUtilsWhiteSpace ) - start);
+	}
+
+
+bool StringUtils::CheckForMatch( const std::string& aSearchFor, std::string& aLine )
+    {
+    bool found = false;
+    //
+    if ( aLine.size() >= aSearchFor.size() )
+        {
+        std::string prefix = aLine.substr( 0, aSearchFor.size() );
+        if ( prefix == aSearchFor )
+            {
+            found = true;
+            aLine = aLine.substr( aSearchFor.size() );
+            }
+        }
+    //
+    return found;
+    }
+
+
+std::string StringUtils::ToUpper( const std::string& aString )
+    {
+	std::string ret( aString );
+    //
+	std::transform( ret.begin(), ret.end(), ret.begin(), toupper );
+    //
+    return ret;
+    }
+
+std::wstring StringUtils::ToUpper( const std::wstring& aString )
+    {
+	std::wstring ret( aString );
+    //
+	std::transform( ret.begin(), ret.end(), ret.begin(), toupper );
+    //
+    return ret;
+    }
+
+
+std::string StringUtils::ToLower( const std::string& aString )
+    {
+	std::string ret( aString );
+    //
+	std::transform( ret.begin(), ret.end(), ret.begin(), tolower );
+    //
+    return ret;
+    }
+
+bool StringUtils::IsLastCharacter( const std::wstring& aString, wchar_t aChar )
+    {
+    bool isLast = false;
+    //
+    if ( aString.length() )
+        {
+        const wchar_t lastChar = aString[ aString.length() - 1 ];
+        isLast = ( lastChar == aChar );
+        }
+    //
+    return isLast;
+    }
+
+
+bool StringUtils::StartsWithDrive( const std::wstring& aText )
+    {
+    bool startsWithDrive = false;
+    //
+    if ( aText.length() >= 3 )
+        {
+        const std::string prefix = ToUpper( Ucs2ToUtf8( aText.substr( 0, 3 ) ) );
+        //
+        const char drive = prefix[ 0 ];
+        const char colon = prefix[ 1 ];
+        const char backslash = prefix[ 2 ];
+        //
+        if  ( colon == ':' && backslash == '\\' )
+            {
+            startsWithDrive = ( drive >= 'A' && drive <= 'Z' ) || (drive == '!') ;
+            }
+        }
+    //
+    return startsWithDrive;
+    }
+
+
+std::wstring StringUtils::MakePathFromSID( const std::wstring& aBasePath, TUint32 aSID )
+    {
+    // Must make sure that the directory is eight characters long
+    // since other parts of the code assume this (or check for it).
+	std::wstringstream stream;
+	stream << std::hex << aSID;
+    //
+    std::wstring ret = stream.str();
+    //
+    while( ret.length() < KInterpretSISExpectedSIDLength )
+        {
+        ret.insert( 0, L"0" );
+        }
+    // Add trailing slash
+  	ret.append( L"\\" );
+    //
+  	// Convert it to a local path
+	ConvertToLocalPath( ret, aBasePath );
+    return ret;
+    }
+
+
+std::wstring StringUtils::BuildSisRegistryFileName( const int aIndex )
+{
+	std::wstringstream stream;
+	stream << std::hex << aIndex;
+
+	std::wstring ret = stream.str();
+	
+	while( ret.length() < KInterpretSISExpectedSIDLength )
+    {
+        ret.insert( 0, L"0" );
+    }
+
+	ret.append( L".reg" );
+
+	return ret;
+}
+
+
+std::wstring StringUtils::BuildControllerFileName( const int aIndex, const int aCtlIndex)
+{
+	std::wstringstream stream, stream2;
+	stream << std::hex << aIndex;
+	stream2 << std::hex << aCtlIndex;
+
+	std::wstring ret = stream.str();
+	std::wstring ret2 = stream2.str();
+
+	while( ret.length() < KInterpretSISExpectedSIDLength )
+    {
+        ret.insert( 0, L"0" );
+    }
+
+	while( ret2.length() < KInterpretSISCtlIndexLength )
+    {
+        ret2.insert( 0, L"0" );
+    }
+
+	ret.append(L"_");
+	ret += ret2 + (L".ctl");
+
+	return ret;
+}
+
+
+std::wstring StringUtils::EnsureDirectoryTerminated( const std::wstring& aDir )
+    {
+    std::wstring ret = aDir;
+    //
+    if ( ret.length() == 0 )
+        {
+        ret.insert( 0, KDirectorySeparator );
+        }
+    else if ( ret[ ret.length() - 1 ] != KDirectorySeparator[ 0 ] )
+        {
+        ret.append( KDirectorySeparator );
+        }
+    //
+    return ret;
+    }
+
+/**
+ Compares a candidate string to a wildcard string - one containing any number of the wildcard characters '*' and '?'
+ e.g. z:\foo\bar\lang*.txt with z:\foo\bar\lang35.txt.
+
+ The function returns TRUE if a match is found, or FALSE.
+ */
+bool StringUtils::WildcardCompare(const std::wstring& aWildCardFileName, const std::wstring& aFileName)
+{
+	std::wstring::const_iterator wildCurr = aWildCardFileName.begin();
+	std::wstring::const_iterator wildEnd = aWildCardFileName.end();
+
+	std::wstring::const_iterator fileCurr = aFileName.begin();
+	std::wstring::const_iterator fileEnd = aFileName.end();
+
+	std::wstring::const_iterator currentPos = NULL;
+	std::wstring::const_iterator afterPos = NULL;
+
+	// handle the '?' wildcard
+	while ((fileCurr != fileEnd) && (*wildCurr != L'*'))
+		{
+		if ((*wildCurr != *fileCurr) && (*wildCurr != L'?'))
+			{
+			// the current character is different (and not represented by ? or *)
+			return false;
+			}
+
+		if (wildCurr != wildEnd)
+			wildCurr++;
+
+		if (fileCurr != fileEnd)
+			fileCurr++;
+
+		}
+
+	// encountered the '*' wildcard
+	while (fileCurr != fileEnd)
+		{
+		if (*wildCurr == L'*')
+			{
+
+			// get the next char after the '*'
+			if (wildCurr != wildEnd)
+				wildCurr++;
+
+			if (wildCurr == wildEnd)
+				{
+				// abcd* - abcdefg. Matches the remaining characters
+				return true;
+				}
+
+			afterPos = wildCurr;
+
+			if (fileCurr != fileEnd)
+				currentPos = fileCurr++;
+
+			}
+		// keep iterating until we come the character which starts after the '*'
+		else if ((*wildCurr == *fileCurr) || (*wildCurr == L'?')) 
+			{
+			if (wildCurr != wildEnd)
+				wildCurr++;
+
+			if (fileCurr != fileEnd)
+				fileCurr++;
+			} 
+		else
+			{
+			wildCurr = afterPos;
+
+			if (currentPos != fileEnd)
+				fileCurr = currentPos++;
+			}
+		}
+
+	while (*wildCurr == L'*') 
+		{
+		if (wildCurr != wildEnd)
+			wildCurr++;
+		}
+
+	// if we end up with an empty wild card string, we have a match
+	return (*wildCurr == *wildEnd);
+}
+
+/**
+Gets the filename and extension.
+ 
+This is in the form:
+
+filename.ext
+
+@return The filename and extension.
+*/
+std::wstring StringUtils::NameAndExt( const std::wstring& aFile )
+{
+	int pos = aFile.find_last_of(L"\\");
+	if (pos == std::wstring::npos)
+	{
+		return L"";
+	}
+	else 
+    {
+		std::wstring extension(aFile.substr(pos+1));
+		return extension;
+    }
+}
+
+/**
+Gets the drive letter and path.
+ 
+This is in the form
+ 
+drive-letter:\\path\\
+ 
+Note that the drive letter is folded
+
+@return The drive and path.
+*/
+std::wstring StringUtils::DriveAndPath( const std::wstring& aFile )
+{
+	int pos = aFile.find_last_of(L"\\");
+	if (pos == std::wstring::npos)
+	{
+		return L"";
+	}
+	else 
+    {
+		std::wstring extension(aFile.substr(0,pos+1));
+		return extension;
+    }
+}
+
+/**
+Gets the path.
+ 
+The path is in the form:
+ 
+\\path\\
+ 
+@return The path. It always begins and ends in a backslash.
+*/
+std::wstring StringUtils::Path( const std::wstring& aFile )
+{
+	int firstPos = aFile.find_first_of(L"\\");
+	int lastPos = aFile.find_last_of(L"\\");
+	
+	if (lastPos >= firstPos)
+	{
+		std::wstring path(aFile.substr(firstPos,lastPos-1));
+		return path;
+	}
+
+	return L"";
+}
+
+/**
+Gets the filename.
+ 
+This is in the form
+ 
+filename
+ 
+@return The filename.
+*/
+std::wstring StringUtils::Name( const std::wstring& aFile )
+{
+	int startPos = aFile.find_last_of(L"\\");
+	int endPos = aFile.find_last_of(L".");
+
+	if (endPos > startPos)
+    {
+		std::wstring extension(aFile.substr(startPos+1,endPos));
+		return extension;
+    }
+
+	return L"";
+}
+
+/**
+Gets the extension.
+ 
+This is in the form:
+ 
+.extension
+ 
+@return The extension and preceding dot.
+*/
+std::wstring StringUtils::Ext( const std::wstring& aFile )
+{
+	int pos = aFile.find_last_of(L".");
+	if (pos == std::wstring::npos)
+	{
+		return L"";
+	}
+	else 
+    {
+		std::wstring extension(aFile.substr(pos));
+		return extension;
+    }
+}
\ No newline at end of file