--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/inc/bacline.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,72 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __BACLINE_H
+#define __BACLINE_H
+
+#ifndef __E32BASE_H
+#include <e32base.h>
+#endif
+
+/**
+Not available until Platform 003
+@internalComponent
+*/
+typedef TBuf<0x100> TBaCommand;
+
+class CCommandLineArguments : public CBase
+/** Parses command line arguments.
+
+The class provides functions to access the arguments that are supplied when 
+a program is launched as a new process. 
+
+The program name is returned as argument 0. Other arguments are returned as 
+arguments 1, 2 etc. 
+
+The Count() function indicates how many arguments there are, including the 
+program name. Arguments may be quoted to contain blanks and quotes.
+
+The command line arguments and process name occupy 256 characters each. In 
+order to minimise the space used throughout the lifetime of a program, it 
+is recommended that the program parse the arguments shortly after initialisation, 
+save the argument values appropriately, and then destroy the CCommandLineArguments 
+object.
+
+The main use of this class is in parsing the arguments of WINC command-line 
+utilities.
+
+This class is not intended for user derivation 
+@publishedAll
+@released
+*/
+	{
+public:
+	// construct/destruct
+	IMPORT_C static CCommandLineArguments* NewLC();
+	IMPORT_C static CCommandLineArguments* NewL();
+	IMPORT_C ~CCommandLineArguments();
+	// extract
+	IMPORT_C TPtrC Arg(TInt aArg) const;
+	IMPORT_C TInt Count() const;
+private:
+	CCommandLineArguments();
+	void ConstructL();
+private:
+	CArrayFixFlat<TPtrC>* iArgs;
+	HBufC* iCommandLine;
+	TFileName iFileName;
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/inc/stringpool.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,291 @@
+// Copyright (c) 2001-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __STRINGPOOL_H__
+#define __STRINGPOOL_H__ 
+
+#include <e32base.h>
+#include <stringtablesupport.h>
+#include <stringpoolerr.h>
+
+class RStringF;
+class RString;
+class RStringToken;
+class RStringTokenF;
+class MStringPoolCloseCallBack;
+class RStringBase;
+class CStringPoolImplementation;
+
+
+class MStringPoolCloseCallBack
+/** 
+Abstract callback interface that alerts implementors to when a string pool 
+closes.
+@publishedAll
+@released
+*/
+	{
+	///Implement this function to perform some operation when the string pool is being closed
+	public:
+	/** Called when the string pool is about to close. */
+		virtual void StringPoolClosing()=0;
+	};
+
+/** The string pool handle object.  A string pool can have several
+	distinct handles associated with it, each associated with a
+	different pre-loaded table. The difference between them is that
+	creating a string from an enum will interpret the enum as an
+	offset into the relevant pre-loaded table */
+class RStringPool
+/** 
+String pool handle.
+
+A string pool can have several distinct handles associated with it, each associated 
+with a different pre-loaded table. Creating a string from an enum value interprets 
+the value as an offset into the relevant pre-loaded table. 
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline RStringPool();
+
+	IMPORT_C void OpenL();
+
+	IMPORT_C void OpenL(const TStringTable& aTable);
+
+	IMPORT_C void OpenL(const TStringTable& aTable,MStringPoolCloseCallBack& aCallBack);
+
+	IMPORT_C void Close();
+
+	IMPORT_C RStringF OpenFStringL(const TDesC8& aString) const;
+
+	IMPORT_C RString OpenStringL(const TDesC8& aString) const;
+
+	IMPORT_C RString String(RStringToken aString) const;
+
+	IMPORT_C RString String(TInt aIndex,const TStringTable& aTable) const;	
+
+	IMPORT_C RStringF StringF(RStringTokenF aString) const;
+
+	IMPORT_C RStringF StringF(TInt aIndex,const TStringTable& aTable) const;	
+
+ private:
+	friend class RStringBase;
+	friend class RString;
+	friend class RStringF;
+	friend class CStringPoolImplementation;
+
+	CStringPoolImplementation* iImplementation;
+	};
+
+/** A compact (4 byte) representation of a string in the string pool. This
+	class must be turned into a RStringBase (or one of its derived classes) before you can do anything
+	useful with it. It is only intended to be used when storing strings 
+	in situations where space matters; normaly use RStringBase.
+	@see RStringBase
+*/
+class RStringTokenBase
+/** 
+Base class for the RStringToken and RStringTokenF string representations.
+A compact (4 byte) representation of a string in the string pool. This
+class must be turned into a RStringBase (or one of its derived classes) before you can do anything
+useful with it. It is only intended to be used when storing strings 
+in situations where space matters; normaly use RStringBase.
+@see RStringBase
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline RStringTokenBase();
+
+	inline RStringTokenBase operator=(RStringBase aVal);
+
+	inline TBool IsNull() const;
+
+ protected:
+	friend class RStringPool;
+	friend class RStringBase;
+	friend class RStringTokenEither;
+	friend class CStringPoolImplementation;
+
+	TUint32 iVal;
+	};
+
+
+class RStringToken : public RStringTokenBase
+/** 
+A compact (4 byte) representation of a string in the string pool. 
+
+This class must be turned into a RString before you can do anything useful 
+with it. It is only intended to be used when storing strings in situations 
+where space matters. You should normally use RString. 
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline TBool operator==(RStringToken aVal) const;
+
+	inline TBool operator!=(RStringToken aVal) const;
+
+	inline RStringToken operator=(RString aVal);
+
+	friend class RStringPool;
+	friend class RString;
+	friend class CStringPoolImplementation;
+	};
+
+class RStringTokenF  : public RStringTokenBase
+/** 
+A compact (4 byte) representation of a RStringF string in the string pool. 
+
+This class must be turned into a RStringF before you can do anything useful 
+with it. It is only intended to be used when storing strings in situations 
+where space matters. You should normally use RStringF. 
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline TBool operator==(RStringTokenF aVal) const;
+
+	inline TBool operator!=(RStringTokenF aVal) const;
+
+	inline RStringTokenF operator=(RStringF aVal);
+
+	friend class RStringPool;
+	friend class RStringF;
+	friend class CStringPoolImplementation;
+	};
+
+class RStringBase
+/** 
+Base class for classes that represent a string in a string pool. 
+
+There are sub-classes for folded and non-folded strings. Use this class when 
+you want to receive a string, but have no intention of comparing it with anything. 
+
+
+@see RStringPool 
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline RStringBase();
+
+	IMPORT_C void Close();
+
+	IMPORT_C RStringBase Copy();
+
+	IMPORT_C const TDesC8& DesC() const;
+
+	inline operator RStringTokenBase() const;
+
+	IMPORT_C TInt Index(const TStringTable& aTable) const;
+
+	IMPORT_C const TStringTable*  OriginalTableRef() const;
+
+	inline RStringPool Pool() const;
+
+ protected:
+	friend class RStringPool;
+	friend class RStringTokenBase;
+
+	RStringPool iPool;
+	TUint32 iVal;
+	};
+
+class RString : public RStringBase
+/** 
+A string that is stored in a string pool, with case-sensitive comparisons. 
+
+To initialise values of this class, you need to use the operator() functions 
+on the RStringPool. 
+
+This class performs comparisons in a non-folded (case sensitive) manner. 
+
+@see RStringPool
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline RString Copy();
+
+	inline operator RStringToken() const;
+
+	inline TBool operator==(const RString& aVal) const;
+
+	inline TBool operator!=(const RString& aVal) const;
+
+	friend class RStringPool;
+	friend class RStringToken;
+	};
+
+class RStringF : public RStringBase
+/** 
+A string that is stored in a string pool, with case-insensitive comparisons.
+
+To initialise values of this class, you need to use the operator() functions 
+on the RStringPool. 
+
+Comparisons with this class use folded (case insensitive) comparisons. 
+@publishedAll
+@released
+*/
+	{
+ public:
+	inline RStringF Copy();
+
+	inline operator RStringTokenF() const;
+
+	inline TBool operator==(const RStringF& aVal) const;
+
+	inline TBool operator!=(const RStringF& aVal) const;
+
+	friend class RStringPool;
+	friend class RStringTokenF;
+	};
+
+/**
+A pointer to a string table.
+@publishedAll
+@released
+*/
+
+struct TStringTable
+	{
+	/// The number of elements in the table
+	/** The number of elements in the table. */
+	TUint iCount;
+	/// A pointer to an array of pointers to the strings
+	/** A pointer to an array of pointers to the strings. */
+	const void* const * iTable;	
+
+	/// ETrue if the table should be considered case-sensitive.
+	/** Flag that is ETrue if the table should be considered case-sensitive, otherwise 
+	EFalse. */
+	TBool iCaseSensitive;
+	};
+
+// Include the inline functions
+#include <stringpool.inl>
+
+#endif // __STRINGPOOL_H__
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/inc/stringpool.inl	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,222 @@
+// Copyright (c) 2001-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __STRINGPOOL_INL__
+#define __STRINGPOOL_INL__
+
+
+
+inline RStringTokenBase::RStringTokenBase()
+		: iVal(0)
+/** Default constructor. */
+	{
+	}
+
+
+inline RStringTokenBase RStringTokenBase::operator=(RStringBase aVal)
+/** Assignment operator, which makes a string token from a string. 
+
+@param aVal The value of the string to copy.
+@return The string token base. */
+	{
+	iVal = aVal.iVal;
+	return *this;
+	}
+
+
+inline TBool RStringTokenBase::IsNull() const
+/** Tests if the string is null or not.
+
+@return ETrue if the string is null, otherwise EFalse. */
+	{
+	return (iVal == 0);
+	}
+
+
+inline TBool RStringToken::operator==(RStringToken aVal) const
+/** Equality operator. 
+
+@param aVal The string to compare.
+@return ETrue if the strings are the same, otherwise EFalse. */
+	{
+	return iVal == aVal.iVal;
+	}
+
+
+inline TBool RStringToken::operator!=(RStringToken aVal) const
+/** Inequality operator. 
+
+@param aVal The string to compare.
+@return ETrue if the strings are different, else EFalse */
+	{
+	return iVal != aVal.iVal;
+	}
+
+
+inline RStringToken RStringToken::operator=(RString aVal)
+/** Assignment operator, which makes a string token from a string. 
+
+@param aVal The string to copy.
+@return The string token. */
+	{
+	iVal = aVal.iVal;
+	return *this;
+	}
+
+
+inline TBool RStringTokenF::operator==(RStringTokenF aVal) const
+/** Equality operator.
+
+@param aVal The string to compare.
+@return ETrue if the strings are the same, otherwise EFalse. */
+	{
+	return iVal == aVal.iVal;
+	}
+
+
+inline TBool RStringTokenF::operator!=(RStringTokenF aVal) const
+/** Inequality operator. 
+
+@param aVal The string to compare.
+@return ETrue if any strings are different, else EFalse */
+	{
+	return iVal != aVal.iVal;
+	}
+
+
+inline RStringTokenF RStringTokenF::operator=(RStringF aVal)
+/** Assignment operator that makes a string token from a string. 
+
+@param aVal The string to compare.
+@return The string token. */
+	{
+	iVal = aVal.iVal;
+	return *this;
+	}
+
+
+inline RStringBase::RStringBase()
+		: iVal(0)
+/** Default constructor. */
+	{
+	}
+
+/** Returns a compact string equivalent to the string  */
+inline RStringBase::operator RStringTokenBase() const
+	{
+	RStringTokenBase s;
+	s.iVal = iVal;
+	return s;
+	}
+
+inline RString RString::Copy()
+/** Copies a string. 
+
+Both the original and the copy must be separately closed.
+
+@return The string to copy. */
+	{
+	RStringBase::Copy();
+	return *this;
+	}
+
+/** Returns a compact string equivalent to the string (for case-sensitive strings)  */
+inline RString::operator RStringToken() const
+	{
+	RStringToken s;
+	s.iVal = iVal;
+	return s;
+	}
+
+inline RStringF RStringF::Copy()
+/** Copies a string. 
+
+Both the original and the copy must be separately closed.
+
+@return The string to copy. */
+	{
+	RStringBase::Copy();
+	return *this;
+	}
+
+
+inline TBool RStringF::operator==(const RStringF& aVal) const
+/** Equality operator.
+
+@param aVal The string to compare.
+@return ETrue if the strings are equal, else EFalse */
+	{
+	__ASSERT_DEBUG(iPool.iImplementation==aVal.iPool.iImplementation || aVal.iVal==0 || iVal==0, StringPoolPanic::Panic(StringPoolPanic::EComparisonBetweenTwoStringPoolsNotAllowed));
+	return (iVal == aVal.iVal);
+	}
+
+
+inline TBool RStringF::operator!=(const RStringF& aVal) const
+/** Inequality operator.
+
+@param aVal The string to compare.
+@return ETrue if the strings are not equal, else EFalse */
+	{
+	__ASSERT_DEBUG(iPool.iImplementation==aVal.iPool.iImplementation || aVal.iVal==0 || iVal==0, StringPoolPanic::Panic(StringPoolPanic::EComparisonBetweenTwoStringPoolsNotAllowed));
+	return (iVal != aVal.iVal);
+	}
+
+
+inline RStringF::operator RStringTokenF() const
+	{
+	RStringTokenF s;
+	s.iVal = iVal;
+	return s;
+	}
+
+
+inline RStringPool RStringBase::Pool() const 
+/** Gets the string pool.
+
+@return The string pool. */
+	{
+	return iPool;
+	}
+
+
+inline TBool RString::operator==(const RString& aVal) const
+/** Equality operator.
+
+@param aVal The string to compare.
+@return ETrue if the strings are equal, else EFalse */
+	{
+	__ASSERT_DEBUG(iPool.iImplementation==aVal.iPool.iImplementation || aVal.iVal==0 || iVal==0, StringPoolPanic::Panic(StringPoolPanic::EComparisonBetweenTwoStringPoolsNotAllowed));
+	return (iVal == aVal.iVal);
+	}
+
+
+inline TBool RString::operator!=(const RString& aVal) const
+/** Inequality operator.
+
+@param aVal The string to compare.
+@return ETrue if the strings are not equal, else EFalse */
+	{
+	__ASSERT_DEBUG(iPool.iImplementation==aVal.iPool.iImplementation || aVal.iVal==0 || iVal==0, StringPoolPanic::Panic(StringPoolPanic::EComparisonBetweenTwoStringPoolsNotAllowed));
+	return (iVal != aVal.iVal);
+	}
+
+inline RStringPool::RStringPool()
+		: iImplementation(0)
+/** Default constructor. */
+	{
+	}
+
+
+#endif // __STRINGPOOL_INL__

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/inc/stringpoolerr.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,46 @@
+// Copyright (c) 2001-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __STRINGPOOLERR_H
+#define __STRINGPOOLERR_H
+
+#include <e32std.h>
+#include <e32base.h>
+
+class StringPoolPanic
+/**
+@internalComponent
+*/
+	{
+public:
+	enum TStringPoolPanic
+		{
+		EComparisonBetweenTwoStringPoolsNotAllowed=0,// We are trying to compare a string from one string pool to a string from another string pool
+		EIllegalUseOfNullString,
+		ECreatingStringWithWrongCase,
+        EStringNotTableEntry,
+        EStringTableNotFound
+		};
+	static void Panic(TStringPoolPanic aPanic);
+	};
+
+inline void StringPoolPanic::Panic(StringPoolPanic::TStringPoolPanic aPanic)
+	{
+	_LIT(KStringPoolPanic,"StringPool");
+	User::Panic(KStringPoolPanic,aPanic);
+	}
+
+#endif // __STRINGPOOLERR_H
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/inc/stringtablesupport.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,69 @@
+// Copyright (c) 2001-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// StringTableSupport.h
+// 
+// This file contains defines needed by the auto-generated string table files.
+// There is no reason why a manualy written cpp file outsinde the string pool
+// implementation should include it.
+//
+
+#ifndef __STRINGTABLESUPPORT_H__
+#define __STRINGTABLESUPPORT_H__
+
+/**
+@internalComponent
+*/
+#define _STLIT8(name,s) const static TStLitC8<sizeof(s)> name={sizeof(s)-1,s}
+
+// A class that differs from TLitC only in that it does not have a
+// dereference operator defined
+//##ModelId=3B1E52AB0100
+template <TInt S>
+class TStLitC8
+/**
+@internalComponent
+*/
+	{
+public:
+	inline operator const TDesC8&() const;
+	inline const TDesC8& operator()() const;
+	inline operator const __TRefDesC8() const;
+public:
+	//##ModelId=3B1E52AB0120
+	TUint iTypeLength;
+	//##ModelId=3B1E52AB0117
+	TText8 iBuf[__Align8(S)];
+	};
+
+template <TInt S>
+inline const TDesC8& TStLitC8<S>::operator()() const
+	{
+	return *REINTERPRET_CAST(const TDesC8*,this);
+	}
+
+template <TInt S>
+inline TStLitC8<S>::operator const TDesC8&() const
+	{
+	return *REINTERPRET_CAST(const TDesC8*,this);
+	}
+
+template <TInt S>
+inline TStLitC8<S>::operator const __TRefDesC8() const
+	{
+	return *REINTERPRET_CAST(const TDesC8*,this);
+	}
+
+struct TStringTable;
+
+#endif // __STRINGTABLESUPPORT_H__

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/src/bacline.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,150 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifdef __TOOLS2__
+#ifndef _WIN32
+#define __TOOLS__
+#endif
+#endif
+
+#include <bacline.h>
+
+#ifdef __TOOLS2__
+#include <cstring>
+extern char **gArgv;
+#endif
+
+EXPORT_C CCommandLineArguments* CCommandLineArguments::NewLC()
+/** Allocates and constructs a command line arguments parser, putting the returned 
+pointer onto the cleanup stack. The function leaves if there is insufficient 
+memory.
+
+@return The command line arguments parser. */
+	{
+	CCommandLineArguments* self=new (ELeave) CCommandLineArguments;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+EXPORT_C CCommandLineArguments* CCommandLineArguments::NewL()
+/** Allocates and constructs a command line arguments parser. The function leaves 
+if there is insufficient memory.
+
+@return The command line arguments parser. */
+	{
+	CCommandLineArguments* self=CCommandLineArguments::NewLC();
+	CleanupStack::Pop();
+	return self;
+	}
+
+EXPORT_C CCommandLineArguments::~CCommandLineArguments()
+/** Frees resources prior to destruction. */
+	{
+	delete iArgs;
+	delete iCommandLine;
+	}
+
+CCommandLineArguments::CCommandLineArguments()
+	{
+	}
+
+void CCommandLineArguments::ConstructL()
+	{
+	// allocate args array
+	iArgs=new (ELeave) CArrayFixFlat<TPtrC> (10);
+	// get raw command line
+
+#ifndef __TOOLS2__
+	RProcess me;
+#endif
+	iCommandLine=HBufC::NewL(User::CommandLineLength());
+	TPtr commandLine(iCommandLine->Des());
+	User::CommandLine(commandLine);
+#ifndef __TOOLS2__
+	iFileName=me.FileName();
+#else
+	iFileName.Copy(TPtrC8((TUint8*)gArgv[0], strlen(gArgv[0])));
+#endif
+
+	// scan for each argument
+	TText* out=CONST_CAST(TText*,iCommandLine->Ptr());
+	const TText* scan=out;
+	const TText* end=scan+iCommandLine->Length();
+	while (scan < end) // scan one argument
+		{
+		while (scan < end && *scan==' ') // skip leading space
+			scan++;
+		if (scan == end) // ignore if blank
+			break;
+		TBool quoted=*scan=='\"'; // note leading quote
+		if (quoted)
+			scan++;
+		TText* start=out; // note start in output
+		if (!quoted) // if not quoted, scan for blank
+			{
+			while (scan < end && *scan!=' ')
+				*out++ = *scan++;
+			}
+		else // quoted, scan for quote
+			{
+			for (;;) // one quote-or-double sequence
+				{
+				while (scan < end && *scan!='\"') // all up to quote
+					*out++ = *scan++;
+				if (scan < end) // skip quote
+					scan++;
+				if (scan < end && *scan=='\"') // transfer if quote is doubled
+					*out++ = *scan++;
+				else // finished this arg
+					break;
+				}
+			}
+		TPtrC arg(start, out-start);
+		iArgs->AppendL(arg);
+		}
+	}
+
+
+EXPORT_C TPtrC CCommandLineArguments::Arg(TInt aArg) const
+/** Returns a non-modifiable pointer descriptor representing the specified command-line 
+argument.
+
+Arg(0) is the file name as specified on the command line. Arg(1), Arg(2) etc. 
+are the arguments specified to the command.
+
+The pointer descriptor is valid throughout the lifetime of the CCommandLineArguments 
+object. If you wish to retain argument values after the CCommandLineArguments 
+object is destroyed, you should copy the argument data into a different object.
+
+@param aArg The index of the desired argument. This number must be less than 
+Count(). Specify 0 for the name used to invoke the process. Specify 1, 2 etc. 
+for the arguments.
+@return Non-modifiable pointer descriptor to the specified argument text. */
+	{
+	if (aArg > 0 ) // a normal argument
+		return iArgs->operator[](aArg-1);
+	else // process name
+		return TPtrC(iFileName);
+	}
+
+EXPORT_C TInt CCommandLineArguments::Count() const
+/** Returns the number of command line arguments, including the program name.
+
+@return The number of command line arguments, plus one for the program name. 
+Returns 1, if no arguments are specified. */
+	{
+	return iArgs->Count()+1;
+	}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/src/stringpoolapi.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,292 @@
+// Copyright (c) 2003-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32std.h>
+#include "stringpoolimplementation.h"
+
+
+
+EXPORT_C void RStringBase::Close()
+/** Closes a string.
+
+You must close every string you open. In other words, every call to RStringBase::Copy(),
+RStringPool::OpenStringL() and RStringPool::OpenFStringL() must be matched
+by a close.
+
+Strings created through RStringPool::String() or RStringPool::StringF() with
+an integer argument need not be closed (but closing is harmless).
+
+Strings created through RStringPool::String() or RStringPool::StringF() with
+a StringToken or StringTokenF argument must not be closed, as they're just
+changing the external representation. */
+	{
+	if (iVal)
+		//harmless for empty strings
+		iPool.iImplementation->Close(RStringTokenEither(iVal));
+	// invalidate the string if it's a dinamic one	otherwise do nothing
+	if(!StringUtils::IsTableEntry(this->iVal))
+		iVal=0U;
+	}
+
+
+EXPORT_C RStringBase RStringBase::Copy()
+/** Copies a string.
+
+Both the original and the copy string must be separately closed.
+
+@return The string base. */
+	{
+	if (iVal)
+		iPool.iImplementation->IncrementCount(RStringTokenEither(iVal));
+	return *this;
+	}
+
+
+/** Returns the content of the string
+ */
+EXPORT_C const TDesC8& RStringBase::DesC() const
+/** Gets the content of the string.
+
+@return Descriptor containing the content of the string. */
+	{
+	// check for empty string
+	if (iVal == 0)
+		return KNullDesC8();
+	if (StringUtils::IsTableEntry(iVal))
+		{
+		TInt index = StringUtils::TableIndex(iVal);
+		TInt tableUid= StringUtils::TableUid(iVal);
+		return iPool.iImplementation->TableLookup(index, tableUid);
+		}
+	else
+		return *StringUtils::NodePtr(iVal)->iDes;
+	}
+
+
+EXPORT_C TInt RStringBase::Index(const TStringTable& aTable) const
+/** Gets the enumeration value corresponding to this string.
+
+@param	aTable String table to look in
+@return	The string's enumeration value, or -1 if there is no such value
+@panic	EStringTableNotFound If the table supplied is not found. This panic is raised in debug builds only, in release mode the behaviour is undefined*/
+	{
+	//return an error for empty strings(i.e. with iVal=0 )
+	if(!this->iVal)
+	   return KErrNotFound;
+	TInt tableId=iPool.iImplementation->TableUid(aTable);
+	__ASSERT_DEBUG(tableId!=KErrNotFound,StringPoolPanic::Panic(StringPoolPanic::EStringTableNotFound));
+	// First check the iVal is part of the same table
+	if (StringUtils::IsTableEntry(iVal))
+	   {
+	   if (tableId==StringUtils::TableUid(iVal))
+		   return StringUtils::TableIndex(iVal);
+	   }
+	// Then check if the iVal is in the reverse duplicate list
+	TInt index=iPool.iImplementation->FindTableIndexFromFirstVal(iVal, tableId);
+	return index;
+	}
+
+
+EXPORT_C const TStringTable* RStringBase::OriginalTableRef() const
+/** Gets the table (if any) that first added the current string to the pool.
+
+Note there multiple tables can contain the same string.
+
+@return The table or NULL if the string was created dynamically (not from
+a table) */
+	{
+	if(StringUtils::IsTableEntry(iVal))
+		return &iPool.iImplementation->TableRef(iVal);
+	else
+		return NULL;
+	}
+
+/** Implementation of RStringPool class*/
+
+EXPORT_C void RStringPool::OpenL()
+/** Creates an initialised string pool with no pre-loaded string tables.
+
+@leave KErrNoMemory Not enough memory to open the pool */
+	{
+	iImplementation = new (ELeave) CStringPoolImplementation;
+	}
+
+EXPORT_C void RStringPool::OpenL(const TStringTable& aTable,MStringPoolCloseCallBack& aCallBack)
+/** Creates an initialised string pool with a pre-loaded string table, and a string-pool-closing
+callback.
+
+@param aTable The pre-loaded string table.
+@param aCallBack Callback interface that is called when the string pool closes
+@leave KErrNoMemory Not enough memory to open the pool */
+	{
+	if (!iImplementation)
+		{
+		iImplementation = new (ELeave) CStringPoolImplementation;
+		CleanupClosePushL(*this);
+		iImplementation->AddTableL(aTable);
+		iImplementation->AddCallBackL(aCallBack);
+		CleanupStack::Pop(); //this
+		}
+	else
+		{
+		iImplementation->AddTableL(aTable);
+		iImplementation->AddCallBackL(aCallBack);
+		}
+	}
+
+EXPORT_C void RStringPool::OpenL(const TStringTable& aTable)
+/** Creates an initialised string pool with a pre-loaded string table.
+
+@param aTable The pre-loaded string table.
+@leave KErrNoMemory Not enough memory to open the pool */
+	{
+	if (!iImplementation)
+		{
+		iImplementation = new (ELeave) CStringPoolImplementation;
+		CleanupClosePushL(*this);
+		iImplementation->AddTableL(aTable);
+		CleanupStack::Pop(); //this
+		}
+	else
+		{
+		iImplementation->AddTableL(aTable);
+		}
+	}
+
+
+EXPORT_C void RStringPool::Close()
+/** Closes the string pool table.
+
+This invalidates all other handles to the table. */
+	{
+	delete iImplementation;
+	iImplementation = NULL;
+	}
+
+EXPORT_C RStringF RStringPool::OpenFStringL(const TDesC8& aString) const
+/** Creates an RStringF using the current string pool.
+
+The string is opened as case-insensitive.
+
+@param aString The value of the string.
+@leave KErrNoMemory Not enough memory to open the string
+@return Initialised RStringF object */
+	{
+	RStringTokenEither newString = iImplementation->OpenL(aString, ETrue);
+	RStringF r;
+	r.iPool = *this;
+	r.iVal = newString.iVal;
+	return r;
+	}
+
+EXPORT_C RString RStringPool::OpenStringL(const TDesC8& aString) const
+/** Creates an RString using the current string pool.
+
+The string is opened as case-sensitive.
+
+@param aString The value of the string.
+@leave KErrNoMemory Not enough memory to open the string
+@return Initialised RString object */
+	{
+	RStringTokenEither newString = iImplementation->OpenL(aString, EFalse);
+	RString r;
+	r.iPool = *this;
+	r.iVal = newString.iVal;
+	return r;
+	}
+
+EXPORT_C RString RStringPool::String(RStringToken aString) const
+/** Creates an RString from the supplied RStringToken.
+
+@param aString The string token
+@return Initialised RString object */
+	{
+	RString r;
+	r.iPool = *this;
+	r.iVal = aString.iVal;
+	return r;
+	}
+
+EXPORT_C RString RStringPool::String(TInt aIndex,const TStringTable& aTable) const
+/** Gets a case-sensitive string specified by a string table enumeration value.
+
+aIndex is interpreted as an offset into the handle's pre-loaded string table.
+
+@param	aIndex The string table enumeration value
+@param	aTable The string table from which to read the string
+@return	Initialised RString object
+@panic	EStringTableNotFound If the table supplied is not found. This panic is raised in debug builds only, in release mode the behaviour is undefined*/
+	{
+	__ASSERT_DEBUG(aTable.iCaseSensitive==1,StringPoolPanic::Panic(StringPoolPanic::ECreatingStringWithWrongCase));
+	if(aIndex <(TInt)aTable.iCount)
+		{//the index is in valid range the index
+		RString r;
+		r.iPool = *this;
+		TInt16 tableUid = iImplementation->TableUid(aTable);
+		__ASSERT_DEBUG(tableUid!=KErrNotFound,StringPoolPanic::Panic(StringPoolPanic::EStringTableNotFound));
+		r.iVal = StringUtils::ValFromIndex(aIndex, tableUid);
+		TInt originalVal;
+		if (KErrNotFound!=(originalVal=iImplementation->FindFirstValFromDuplicate(r.iVal)))
+			{
+			r.iVal=originalVal;
+			}
+		return r;
+		}
+	else // the index is out of range
+	return RString();
+	}
+
+EXPORT_C RStringF RStringPool::StringF(RStringTokenF aString) const
+/** Creates a RStringF from the supplied RStringToken.
+
+@param aString The value of the string
+@return Initialised RStringF object */
+	{
+	RStringF r;
+	r.iPool = *this;
+	r.iVal = aString.iVal;
+	return r;
+	}
+
+EXPORT_C RStringF RStringPool::StringF(TInt aIndex,const TStringTable& aTable) const
+/** Gets a case-insensitive string specified by a string table enumeration value.
+
+Creates an RStringF from a string table enumeration value.
+
+aIndex is interpreted as an offset into the handle's pre-loaded string table.
+
+@param	aIndex The string table enumeration value
+@param	aTable The string table from which to read the string
+@return	Initialised RStringF object
+@panic	EStringTableNotFound If the table supplied is not found. This panic is raised in debug builds only, in release mode the behaviour is undefined*/
+	{
+	__ASSERT_DEBUG(aTable.iCaseSensitive==0,StringPoolPanic::Panic(StringPoolPanic::ECreatingStringWithWrongCase));
+	if(aIndex <(TInt)aTable.iCount)
+		{//the index is in valid range the index
+		RStringF r;
+		r.iPool = *this;
+		TInt16 tableUid = iImplementation->TableUid(aTable);
+		__ASSERT_DEBUG(tableUid!=KErrNotFound,StringPoolPanic::Panic(StringPoolPanic::EStringTableNotFound));
+		r.iVal = StringUtils::ValFromIndexF(aIndex, tableUid);
+		TInt originalVal;
+		if (KErrNotFound!=(originalVal=iImplementation->FindFirstValFromDuplicate(r.iVal)))
+			{
+			r.iVal=originalVal;
+			}
+		return r;
+		}
+	else // the index is out of range so return an empty string
+	return RStringF();
+	}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/src/stringpoolimplementation.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,566 @@
+// Copyright (c) 2001-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32base.h>
+#include "stringpoolimplementation.h"
+
+const TInt KMapGranularity=20;
+
+CStringPoolNode::~CStringPoolNode()
+	{
+	delete iDes;
+	}
+
+CStringPoolImplementation::CStringPoolImplementation() : iStringMapList(KMapGranularity, _FOFF(TStringIdMap, iSourceTableVal)), iStringMapListReverse(KMapGranularity, _FOFF(TStringIdMap, iTargetTableVal))
+	{
+	}
+
+CStringPoolImplementation::~CStringPoolImplementation()
+	{
+	// Look for non-expirable strings
+	TInt i;
+	for (i = 0; i < KHashModulo; i++ )
+		{
+		DeleteUndeletableStrings(iCIHashTable, i);
+		DeleteUndeletableStrings(iCSHashTable, i);
+		}
+#ifdef _DEBUG
+
+	__LOG(_L8(":Closing String Pool.\n"))
+		TBool leaksFound = EFalse;
+	// Check that the string pool is empty, or more accurately that
+	// everything in it is a pre-loaded string
+	for (i = 0; i < KHashModulo; i++ )
+		{
+		if (iCIHashTable[i])
+			{
+			for (TInt j = 0; j < iCIHashTable[i]->Count(); j++)
+				{
+				if (!StringUtils::IsTableEntry(iCIHashTable[i]->At(j).iVal))
+					{
+					if (!leaksFound)
+						{
+						__LOG(_L8("The following strings were leaked through not being Closed:\n"))
+						leaksFound = ETrue;
+						}
+
+					// Get the problem string
+					__LOG((reinterpret_cast<CStringPoolNode*>
+							(iCIHashTable[i]->At(j).iVal & KTokenToNode))->iDes->Des());
+					}
+				}
+			}
+		if (iCSHashTable[i])
+			{
+			for (TInt j = 0; j < iCSHashTable[i]->Count(); j++)
+				{
+				if (!StringUtils::IsTableEntry(iCSHashTable[i]->At(j).iVal))
+					{
+					if (!leaksFound)
+						{
+						__LOG(_L8("The following strings were leaked through not being Closed:\n"))
+						leaksFound = ETrue;
+						}
+
+					// Get the problem string
+					__LOG((reinterpret_cast<CStringPoolNode*>(
+							iCSHashTable[i]->At(j).iVal & KTokenToNode))->iDes->Des());
+					}
+				}
+			}
+		if (leaksFound)
+			__DEBUGGER();
+		}
+
+	if (!leaksFound)
+		__LOG(_L8("No leakages were detected\n"));
+
+#endif //_DEBUG
+	for (TInt ii = 0; ii < KHashModulo; ii++)
+		{
+		delete iCIHashTable[ii];
+		delete iCSHashTable[ii];
+		}
+
+	iTablePtrs.Close();
+	iStringMapList.Close();
+	iStringMapListReverse.Close();
+	iRollbackMapList.Close();
+	iRollbackHashListCS.Close();
+	iRollbackHashListCI.Close();
+	// Notify the external users of the StringPool that the object is getting closed
+	TInt cBCounter = iCallBacks.Count();
+	if(cBCounter>0)
+		{
+		while (--cBCounter>=0)
+			{
+			iCallBacks[cBCounter]->StringPoolClosing();
+			}
+		}
+	iCallBacks.Close();
+	}
+
+// Check for any undeletable string and delete them now
+void CStringPoolImplementation::DeleteUndeletableStrings(CArrayFixSeg<RStringTokenEither>* aArray[KHashModulo], TInt i)
+	{
+	if (aArray[i])
+		{
+		for (TInt j = 0; j < aArray[i]->Count(); ++j)
+			{
+			if (!StringUtils::IsTableEntry(aArray[i]->At(j).iVal))
+				{
+				CStringPoolNode* node= reinterpret_cast<CStringPoolNode*>(aArray[i]->At(j).iVal & KTokenToNode);
+				if (KMarkedForNoDeleted==node->iRefcount)
+					{
+					delete node;
+					aArray[i]->Delete(j);
+					j--;
+					}
+				}
+			}
+		}
+	}
+
+CStringPoolImplementation* CStringPoolImplementation::NewL()
+	{
+	CStringPoolImplementation* table = new (ELeave) CStringPoolImplementation();
+	return table;
+	}
+
+void CStringPoolImplementation::CleanupHashCS(TAny* aImplementation)
+	{
+	CStringPoolImplementation* imp=reinterpret_cast<CStringPoolImplementation*>(aImplementation);
+	CleanUpHash(&imp->iRollbackHashListCS, imp->iCSHashTable);
+	}
+
+void CStringPoolImplementation::CleanupHashCI(TAny* aImplementation)
+	{
+	CStringPoolImplementation* imp=reinterpret_cast<CStringPoolImplementation*>(aImplementation);
+	CleanUpHash(&imp->iRollbackHashListCI, imp->iCIHashTable);
+	}
+
+void CStringPoolImplementation::CleanUpHash(RPointerArray <RStringTokenEither>* aHashCleanup, CArrayFixSeg<RStringTokenEither>* aHash[KHashModulo])
+	{
+	if (aHashCleanup->Count()>0)
+		{
+		RStringTokenEither* token=(*aHashCleanup)[0];	// Get first entry
+		for (TInt i = 0; i < KHashModulo; i++ )
+			{
+			if (aHash[i])
+				{
+				for (TInt j = 0; j < aHash[i]->Count(); j++)
+					{
+					if (!StringUtils::IsTableEntry(aHash[i]->At(j).iVal))
+						{
+						if (aHash[i]->At(j).iVal==token->iVal)
+							{
+							CStringPoolNode* node= reinterpret_cast<CStringPoolNode*>(aHash[i]->At(j).iVal & KTokenToNode);
+							delete node;
+							aHash[i]->Delete(j);
+							aHashCleanup->Remove(0);
+							break;
+							}
+						}
+					}
+				}
+
+			}
+		}
+	}
+
+void CStringPoolImplementation::CleanupIdMap(TAny* aImplementation)
+	{
+	CStringPoolImplementation* imp=reinterpret_cast<CStringPoolImplementation*>(aImplementation);
+	if (imp->iRollbackMapList.Count()>0)
+		{
+		TStringIdMap* map=imp->iRollbackMapList[0];
+		TInt index=imp->iStringMapList.FindInUnsignedKeyOrder(*map);
+		imp->iRollbackMapList.Remove(0);
+		if (index!=KErrNotFound)
+			{
+			imp->iStringMapList.Remove(index);
+			}
+		index=imp->iStringMapListReverse.FindInUnsignedKeyOrder(*map);
+		if (index!=KErrNotFound)
+			{
+			for (TInt count=index;count<imp->iStringMapListReverse.Count();++count)
+				{
+				if (imp->iStringMapListReverse[count].iTargetTableVal==map->iTargetTableVal && imp->iStringMapListReverse[count].iSourceTableVal==map->iSourceTableVal)
+					{
+					imp->iStringMapListReverse.Remove(index);
+					}
+				}
+			}
+		}
+	}
+
+void CStringPoolImplementation::AddTableL(const TStringTable& aTable)
+	{
+	for (TInt count=0;count<iTablePtrs.Count();++count)	// check for adding the same table twice
+		{
+		if (iTablePtrs[count]==&aTable)
+			{
+			return;
+			}
+		}
+	User::LeaveIfError(iTablePtrs.Append(&aTable));	// Add the pointer to this table so we can keep track of the Table IDs. The table ID is the index in this array
+	//Is the table Case Sensitive or not?
+	TBool (*genericValFromIndex)(TInt, TUint16);
+	if (aTable.iCaseSensitive==1)
+		genericValFromIndex = StringUtils::ValFromIndex;
+	else
+		genericValFromIndex = StringUtils::ValFromIndexF;
+
+	CArrayFixSeg<RStringTokenEither>** hashTableToUse =
+	aTable.iCaseSensitive ? iCSHashTable :iCIHashTable ;
+	TInt cleanupCounter=0;
+	for (TUint i = 0; i < aTable.iCount; ++i)
+		{
+		const TStLitC8<1>* string=reinterpret_cast<const TStLitC8<1>* >(aTable.iTable[i]);
+
+		// Try to find the string in memory, maybe as a dynamic string or as a member of an another table
+		RStringTokenEither token=FindDes(*string, !aTable.iCaseSensitive);
+		if (!token.IsNull())
+			{
+			TStringIdMap map;
+			map.iSourceTableVal=StringUtils::ValFromIndex(i, (TInt16)(iTablePtrs.Count()-1),aTable.iCaseSensitive);
+			map.iTargetTableVal=token.iVal;
+
+			// Put on cleanup stack
+			User::LeaveIfError(iRollbackMapList.Append(&map));
+			TCleanupItem cleanup(CleanupIdMap, this);
+			CleanupStack::PushL(cleanup);
+			++cleanupCounter;
+
+			User::LeaveIfError(iStringMapList.InsertInUnsignedKeyOrder(map));
+
+			// Check if this is a link to a dynamic string
+			if (!StringUtils::IsTableEntry(token.iVal))
+				{
+				CStringPoolNode* node = StringUtils::NodePtr(token.iVal);
+				node->iRefcount=KMarkedForNoDeleted; // Make sure this string never gets deleted
+				}
+
+			// Now store the reverse array
+			User::LeaveIfError(iStringMapListReverse.InsertInUnsignedKeyOrderAllowRepeats(map));
+			}
+		else
+			{
+			TUint8 hash = static_cast<TUint8>(Hash(*string));
+			CArrayFixSeg<RStringTokenEither>* collisionList = hashTableToUse[hash];
+			if ( !collisionList )
+				//HashTableToUse now is used as list of all entry with the same hash
+				collisionList = hashTableToUse[hash] =
+				new (ELeave) CArrayFixSeg<RStringTokenEither>( 2 );
+			RStringTokenEither s;
+			s.iVal = genericValFromIndex(i, (TInt16)(iTablePtrs.Count()-1));
+
+			__LOG2(_L8("Table entry being added with hash %d, val %d"), hash, s.iVal);
+			__LOG(*reinterpret_cast<const TStLitC8<1>* >(aTable.iTable[i]));
+			// Put on cleanup stack
+			if (aTable.iCaseSensitive==1)
+				{
+				User::LeaveIfError(iRollbackHashListCS.Append(&s));
+				TCleanupItem cleanup(CleanupHashCS, this);
+				CleanupStack::PushL(cleanup);
+				}
+			else
+				{
+				User::LeaveIfError(iRollbackHashListCI.Append(&s));
+				TCleanupItem cleanup(CleanupHashCI, this);
+				CleanupStack::PushL(cleanup);
+				}
+
+			++cleanupCounter;
+			collisionList->AppendL(s);
+			}
+		}
+	CleanupStack::Pop(cleanupCounter);
+	iRollbackMapList.Reset();
+	iRollbackHashListCS.Reset();
+	iRollbackHashListCI.Reset();
+	}
+
+// Find FirstVal given duplicate val
+TInt32 CStringPoolImplementation::FindFirstValFromDuplicate(TInt32 aDuplicateVal) const
+	{
+	TStringIdMap map;
+	map.iSourceTableVal=aDuplicateVal;
+	TInt index=iStringMapList.FindInUnsignedKeyOrder(map);
+	if (index!=KErrNotFound)
+		return iStringMapList[index].iTargetTableVal;
+	else
+		return KErrNotFound;
+	}
+
+
+
+// Find table index Val given first val & table UID
+TInt CStringPoolImplementation::FindTableIndexFromFirstVal(TInt32 aFirstVal, TInt aTableUid) const
+	{
+	TStringIdMap map;
+	map.iTargetTableVal=aFirstVal;
+	TInt index=iStringMapListReverse.FindInUnsignedKeyOrder(map);
+	if (KErrNotFound==index)
+		return KErrNotFound;
+
+	for (TInt count=index;count<iStringMapListReverse.Count();++count)
+		{
+		if (iStringMapListReverse[count].iTargetTableVal==aFirstVal && StringUtils::TableUid(iStringMapListReverse[count].iSourceTableVal)==aTableUid)
+			{
+			return StringUtils::TableIndex(iStringMapListReverse[count].iSourceTableVal);
+			}
+		}
+		return KErrNotFound;
+	}
+
+
+// Find the UId for a given table
+TInt16 CStringPoolImplementation::TableUid(const TStringTable& aTable) const
+	{
+	for (TInt count=0; count<iTablePtrs.Count(); ++count)
+		{
+		if (iTablePtrs[count]==&aTable)
+			return (TInt16)count;
+		}
+	return KErrNotFound;
+	}
+
+// Find a reference to the table that first added the  string represented by aVal to the pool
+const TStringTable& CStringPoolImplementation::TableRef(TInt32 aVal) const
+	{
+	__ASSERT_DEBUG(aVal!=0, StringPoolPanic::Panic(StringPoolPanic::EIllegalUseOfNullString));
+	TInt16 tableUid=(TInt16)(aVal>>20);
+	const TStringTable* theTableRef=(iTablePtrs[tableUid]);
+	return  *theTableRef;
+	}
+
+// Find the descriptor for a given table and index
+const TDesC8& CStringPoolImplementation::TableLookup(TInt aIndex, TInt aTableUid) const
+	{
+	return *reinterpret_cast<const TStLitC8<1>*>(iTablePtrs[aTableUid]->iTable[aIndex]);
+	}
+
+
+// Lookup with allocating
+//
+RStringTokenEither
+CStringPoolImplementation::OpenL( const TDesC8& aAttributeName,
+								  TBool aCaseInsensitive)
+	{
+	// lookup the attribute
+	RStringTokenEither s(FindDes( aAttributeName , aCaseInsensitive));
+	if (!s.IsNull())
+		{
+		if (!StringUtils::IsTableEntry(s.iVal))
+			{
+
+			CStringPoolNode* node = StringUtils::NodePtr(s.iVal);
+			if (KMarkedForNoDeleted!=node->iRefcount)
+				node->iRefcount++;
+			__LOG1(_L8("String copied (during open). Count is now %d"), node->iRefcount);
+			__LOG(*node->iDes);
+			}
+		return s;
+		}
+
+	// create a new node at the end of the appropriate array
+	CStringPoolNode* newnode = new (ELeave) CStringPoolNode();
+	CleanupStack::PushL( newnode );
+	newnode->iDes = aAttributeName.AllocL();
+	newnode->iRefcount = 1;
+
+	TInt hash = Hash( aAttributeName );
+	CArrayFixSeg<RStringTokenEither>** hashTableToUse =
+		aCaseInsensitive ? iCIHashTable : iCSHashTable;
+	__LOG2(_L8("Newly added with hash value %d, node val 0x%x\n"), hash, newnode)
+	__LOG(aAttributeName);
+
+	newnode->iHash = static_cast<TUint8>(hash);
+	CArrayFixSeg<RStringTokenEither>* collisionList = hashTableToUse[hash];
+	if ( !collisionList )
+		collisionList = hashTableToUse[hash] = new (ELeave) CArrayFixSeg<RStringTokenEither>( 2 );
+
+	s.iVal = reinterpret_cast<TUint32>(newnode);
+	if (aCaseInsensitive)
+		s.iVal += 2;
+	collisionList->AppendL(s);
+
+	CleanupStack::Pop(); // newnode
+
+	return s;
+	}
+
+void CStringPoolImplementation::Close(RStringTokenEither aString)
+	{
+	if (StringUtils::IsTableEntry(aString.iVal))
+		return;
+
+	CStringPoolNode* node = StringUtils::NodePtr(aString.iVal);
+	if (KMarkedForNoDeleted == node->iRefcount)	// -1 means a non-expirable string
+		return;
+	if (--node->iRefcount == 0)
+		{
+		//this is  the last reference of this string
+		CArrayFixSeg<RStringTokenEither>** hashTableToUse =
+		aString.iVal & 2 ? iCIHashTable : iCSHashTable;
+
+		// Delete the node and delete the entry in the relevant collision list
+		CArrayFixSeg<RStringTokenEither>* collisionList = hashTableToUse[node->iHash];
+		TInt count = collisionList->Count();
+		for (TInt i = 0; i < count; i++)
+			{
+			if (collisionList->At(i) == aString)
+				{
+				// Log the fact that a string reference is about to die...
+				__LOG1(_L8("Removing string with hash value %d\n"), node->iHash)
+				__LOG(node->iDes->Des());
+				collisionList->Delete(i);
+				break;
+				}
+			}
+		delete node;
+		}
+	else
+		{
+		__LOG1(_L8("String closed. Count is now %d"),
+			   node->iRefcount);
+		__LOG(node->iDes->Des());
+		}
+	}
+
+void CStringPoolImplementation::IncrementCount(RStringTokenEither aString)
+	{
+	if (StringUtils::IsTableEntry(aString.iVal))
+		return;
+	CStringPoolNode* node = StringUtils::NodePtr(aString.iVal);
+	if (KMarkedForNoDeleted!=node->iRefcount)
+		node->iRefcount++;
+	__LOG1(_L8("String copied. Count is now %d"), node->iRefcount);
+	__LOG(*node->iDes);
+	}
+
+// Very simple case-sensitive comparison. We can assume that the
+// strings are the same length, and we only care if the strings are
+// the same. (Unlike normal comparison functions that also tell you
+// which one is 'smaller')
+TBool CStringPoolImplementation::CompareCS(const TDesC8& s1, const TDesC8& s2)
+	{
+	const TUint8* ptr1 = s1.Ptr();
+	const TUint8* ptr2 = s2.Ptr();
+	const TUint8* stop = &ptr1[s1.Length()];
+	for (; ptr1 < stop; ptr1++,ptr2++)
+		{
+		if (*ptr1 != *ptr2)
+			return EFalse;
+		}
+	return ETrue;
+	}
+
+// Note that the hash function must generate the same hash values for
+// strings that differ by case. If changing the algorithm here make
+// sure this is still true.
+TBool CStringPoolImplementation::CompareCI(const TDesC8& s1, const TDesC8& s2)
+	{
+	const TUint8* ptr1 = s1.Ptr();
+	const TUint8* ptr2 = s2.Ptr();
+	const TUint8* stop = &ptr1[s1.Length()];
+	for (; ptr1 < stop; ptr1++,ptr2++)
+		{
+		if (*ptr1 != *ptr2)
+			{
+			// They're not exactly the same; see if they differ only
+			// by case. If one character is a letter, we can do a
+			// comparison ignoring bit 5 in both cases. If that
+			// matches, they are the same.
+			if (!((*ptr1 & KCaseInsensitive) == (*ptr2 & KCaseInsensitive) &&
+				  (*ptr1 >= 'A' && *ptr1 <= 'Z' ||
+				   *ptr1 >= 'a' && *ptr1 <= 'z')))
+				return EFalse;
+			}
+		}
+	return ETrue;
+	}
+
+// Find the given descriptor in the hash table
+//
+RStringTokenEither
+CStringPoolImplementation::FindDes( const TDesC8& aAttributeName, TBool aCaseInsensitive)
+	{
+	CArrayFixSeg<RStringTokenEither>** hashTableToUse =
+		aCaseInsensitive ? iCIHashTable : iCSHashTable;
+	CArrayFixSeg<RStringTokenEither>* collisionList =hashTableToUse[Hash(aAttributeName)];
+	RStringPool pool;
+	TBool (*compareFunction)(const TDesC8&, const TDesC8&);
+	if (aCaseInsensitive)
+		compareFunction = CompareCI;
+	else
+		compareFunction = CompareCS;
+	pool.iImplementation = this;
+	if ( collisionList )
+		{
+		TInt length=aAttributeName.Length();
+		TInt count = collisionList->Count();
+		for ( TInt i = 0; i < count; i++ )
+			{
+			RStringTokenEither token = collisionList->At(i);
+			RStringEither s(this, token);
+			const TDesC8& string = s.DesC();
+			if ( string.Length()==length &&
+				 (*compareFunction)(aAttributeName, string))
+				return token;
+			}
+		}
+	return RStringTokenEither();
+	}
+
+
+// Generate a hash value
+//
+TUint CStringPoolImplementation::Hash( const TDesC8& aDes ) const
+	{
+	// We ignore bit 5, which is a crude way of making the hash case
+	// insensitive. This means that things that might differ only by
+	// case end up in the same bucket, and we can then worry about
+	// whether they're really the same later.
+	TInt len=aDes.Length();
+	TUint hash = 0;
+	const TUint8* ptr=aDes.Ptr();
+	for ( TInt i = 0; i < len; i++ )
+		hash = 131*hash + (*ptr++ & KCaseInsensitive);
+	return hash % KHashModulo;
+	}
+
+TInt StringUtils::ValFromIndex(TInt aIndex, TUint16 aTableId)
+	{
+	return (aTableId << 20) + (aIndex << 2) + 1;
+	}
+
+TInt StringUtils::ValFromIndexF(TInt aIndex, TUint16 aTableId)
+	{
+	return (aTableId << 20) + (aIndex << 2) + 3;
+	}
+
+TInt StringUtils::ValFromIndex(TInt aIndex, TUint16 aTableId, TBool aCaseSensitive)
+	{
+	if (aCaseSensitive)
+		return ValFromIndex(aIndex, aTableId);
+	else
+		return ValFromIndexF(aIndex, aTableId);
+	}
+void  CStringPoolImplementation::AddCallBackL( MStringPoolCloseCallBack& aCallBack)
+	{
+	User::LeaveIfError(iCallBacks.Append(&aCallBack));
+	}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bafl/src/stringpoolimplementation.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,334 @@
+// Copyright (c) 2001-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __STRINGPOOLIMPLEMENTATION_H__
+#define __STRINGPOOLIMPLEMENTATION_H__
+
+#include <e32base.h>
+#include <stringpool.h>
+#include <stringtablesupport.h>
+
+/**
+This is an 8 bit value with every bit set except bit 5 (value
+32). The ASCII codes of upper and lower case characters differ by
+32.
+@internalComponent 
+*/
+const TUint KCaseInsensitive = 223;
+
+/**
+@internalComponent 
+*/
+const TInt KHashModulo = 32;
+
+/**
+Bit 0 represents if it is a table (set) or not (unset).
+Bit 1 represents case sensitivity (set) or not (unset)
+
+For non-static table values (dynamic strings), the remaining bits 
+are interpreted as a pointer to a CStringPoolNode (which is assumed 
+to be word aligned). 
+
+Bits 2-20 represent the table index.
+Bits 21-31 represent the table uid (that is the address of the table).
+*/
+
+/**
+Bit 1 is used in tokens to indicate case sensitivity. So mask it
+out to get the node.
+@internalComponent 
+*/
+const TUint KTokenToNode = 0xfffffffd;
+
+/**
+Determine if this id corresponds to a table.
+@internalComponent
+*/
+#define IS_TABLE_ENTRY(tableId)(tableId & 0x01)
+
+/**
+Obtain the Table Index.
+@internalComponent
+*/
+#define TABLE_INDEX(val)((val & 0xffffc)>>2)
+
+/**
+Obtain the Table UID.
+@internalComponent
+*/
+#define TABLE_UID(val)(val>>20)
+
+/**
+This is used to mark the reference count of a node so that is will not be deleted when closed
+@internalComponent
+*/
+const TUint KMarkedForNoDeleted = 0xffff;
+
+
+
+class RStringTokenEither;
+
+/**
+@internalComponent
+*/
+struct TStringIdMap
+	{
+	TInt32 iSourceTableVal;
+	TInt32 iTargetTableVal;
+	};
+
+
+/**
+Internal node class
+@internalComponent
+*/
+NONSHARABLE_CLASS(CStringPoolNode) : public CBase
+	{
+public:
+	~CStringPoolNode();
+
+ public:
+	HBufC8* iDes;
+	TUint16 iRefcount;
+	TUint8  iHash;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CStringPoolImplementation) : public CBase
+	{
+public:
+	CStringPoolImplementation();
+	/// Destructor
+	~CStringPoolImplementation();
+
+	/// Constructs a string pool
+	static CStringPoolImplementation* NewL();
+
+	// USed for cleaning up when a OpenTableL leaves
+	static void CleanupHashCS(TAny* aImplementation);
+	static void CleanupHashCI(TAny* aImplementation);
+	static void CleanupIdMap(TAny* aImplementation);
+	static void CleanUpHash(RPointerArray <RStringTokenEither>* aHashCleanup, CArrayFixSeg<RStringTokenEither>* hash[KHashModulo]);
+
+	/// Adds a table to the pool. (Note this currently only works once)
+	void AddTableL(const TStringTable& aTable);
+	void AddCallBackL( MStringPoolCloseCallBack& aCallBack);
+
+
+	// Find FirstVal given duplicate val
+	TInt32 FindFirstValFromDuplicate(TInt32 aDuplicateVal) const;
+
+	// Find table index Val given first val & table UID
+	TInt FindTableIndexFromFirstVal(TInt32 aDuplicateVal, TInt aTableUid) const;
+
+
+	TInt16 TableUid(const TStringTable& aTable) const;
+
+	const TStringTable& TableRef(TInt32 aVal) const;
+
+	/// Looks up a particular index in the pre-loaded tables
+	const TDesC8& TableLookup(TInt aIndex, TInt aTableUid) const;
+
+	/// Finds or creates a string. Increments the reference count if needed.
+	RStringTokenEither OpenL( const TDesC8& aString, TBool aCaseInsensitive); 
+
+	/// Closes a string (decrements the reference count and deletes if 0
+	void Close(RStringTokenEither aString);
+
+	/// Increments the reference count on a string
+	void IncrementCount(RStringTokenEither aString);
+
+	inline RStringPool Handle();
+
+private:	
+
+	// Check for any undeletable string and delete them now
+	void DeleteUndeletableStrings(CArrayFixSeg<RStringTokenEither>* aArray[KHashModulo], TInt i);
+
+private:
+
+	/// Finds a string in the pool.
+	RStringTokenEither FindDes( const TDesC8& aString, TBool aCaseInsensitive);
+
+	/// Calculates a hash for a descriptor
+	TUint Hash( const TDesC8& ) const;
+
+	static TBool CompareCS(const TDesC8& s1, const TDesC8& s2);
+	static TBool CompareCI(const TDesC8& s1, const TDesC8& s2);
+
+ private:
+	/// The table.
+	CArrayFixSeg<RStringTokenEither>* iCSHashTable[KHashModulo];
+	CArrayFixSeg<RStringTokenEither>* iCIHashTable[KHashModulo];	
+	RPointerArray<TStringTable> iTablePtrs;	// Stores array of tables, where the index is the table UID
+	RArray <TStringIdMap> iStringMapList;
+	RArray <TStringIdMap> iStringMapListReverse;
+
+	// For rolling back when a leave occurs during CreateTableL
+	RPointerArray <TStringIdMap> iRollbackMapList;	
+	RPointerArray <RStringTokenEither> iRollbackHashListCS;
+	RPointerArray <RStringTokenEither> iRollbackHashListCI;
+	RPointerArray<MStringPoolCloseCallBack> iCallBacks;
+	};
+
+/** 
+An internal version of the string token class. This class can hold
+either folding or non-folding versions, and it is up to the user
+to get it right.
+@internalComponent
+*/
+class RStringTokenEither : public RStringTokenBase
+	{
+ public:
+	inline RStringTokenEither();
+
+	inline RStringTokenEither(TUint32 aVal);
+
+	/** Comparison operator
+		@param aVal The string to compare. */
+	inline TBool operator==(RStringTokenEither aVal) const;
+
+	/** Comparison operator
+		@param aVal The string to compare. */
+	inline TBool operator!=(RStringTokenEither aVal) const;
+
+	/** Assignment operator; makes a string token from a string.
+		@param aVal The string to copy */
+	inline RStringTokenEither operator=(RStringBase aVal);
+
+	friend class RStringPool;
+	friend class RStringEither;
+	friend class CStringPoolImplementation;
+	};
+
+class RStringEither : public RStringBase
+/**
+@internalComponent
+*/
+	{
+	public:
+	RStringEither(CStringPoolImplementation* aPool, RStringTokenEither aVal);
+	};
+
+class StringUtils
+/**
+@internalComponent
+*/
+	{
+ public:
+	static inline TBool IsTableEntry(TInt aVal);
+	static inline TInt TableIndex(TInt aVal);
+	static inline TInt16 TableUid(TInt aVal);
+	static inline CStringPoolNode* NodePtr(TInt aVal);
+	static TInt ValFromIndex(TInt aIndex, TUint16 aTableId);
+	static TInt ValFromIndexF(TInt aIndex, TUint16 aTableId);
+	static TInt ValFromIndex(TInt aIndex, TUint16 aTableId, TBool aCaseSensitive);
+	
+	static void LogIt(TRefByValue<const TDesC8> aFmt, ...);
+	static void LogIt1(TRefByValue<const TDesC8> aFmt);
+	};
+
+#ifndef __TOOLS2__
+#define _LOGGING
+#endif
+
+#if defined (_DEBUG) && defined (_LOGGING)
+
+/**
+HTTP Logging macros
+@internalComponent
+*/
+#define __LOG(C)			StringUtils::LogIt1(C);
+#define __LOG1(C, X)		StringUtils::LogIt(C, X);
+#define __LOG2(C, X, Y)		StringUtils::LogIt(C, X, Y);
+#define __LOG3(C, X, Y, Z)	StringUtils::LogIt(C, X, Y, Z);
+
+#else
+
+/**
+NULL macros
+@internalComponent
+*/
+#define __LOG(C)			
+#define __LOG1(C, X)		
+#define __LOG2(C, X, Y)		
+#define __LOG3(C, X, Y, Z)	
+#endif // !_DEBUG
+
+
+inline TBool StringUtils::IsTableEntry(TInt aVal)
+	{
+	return IS_TABLE_ENTRY(aVal);
+	}
+
+inline TInt StringUtils::TableIndex(TInt aVal)
+	{
+	return TABLE_INDEX(aVal);
+	}
+
+inline TInt16 StringUtils::TableUid(TInt aVal)
+	{
+	return (TInt16) TABLE_UID(aVal);
+	}
+
+inline CStringPoolNode* StringUtils::NodePtr(TInt aVal)
+	{
+	return reinterpret_cast<CStringPoolNode*>(aVal & KTokenToNode);
+	}
+
+inline RStringEither::RStringEither(CStringPoolImplementation* aPool, 
+							 RStringTokenEither aVal)
+	{
+	iPool = aPool->Handle();
+	iVal = aVal.iVal;
+	}
+
+inline RStringPool CStringPoolImplementation::Handle()
+	{
+	RStringPool p;
+	p.iImplementation = this;
+	return p;
+	}
+
+inline RStringTokenEither::RStringTokenEither()
+	{
+	}
+
+inline RStringTokenEither::RStringTokenEither(TUint32 aVal)
+	{
+	iVal = aVal;
+	}
+
+inline TBool RStringTokenEither::operator==(RStringTokenEither aVal) const
+	{
+	return iVal == aVal.iVal;
+	}
+
+inline TBool RStringTokenEither::operator!=(RStringTokenEither aVal) const
+	{
+	return iVal != aVal.iVal;
+	}
+
+inline RStringTokenEither RStringTokenEither::operator=(RStringBase aVal)
+	{
+	RStringTokenBase b = aVal;
+	iVal = b.iVal;
+	return *this;
+	}
+
+
+#endif // __STRINGPOOLIMPLEMENTATION_H__

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/bld.inf	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,57 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+PRJ_PLATFORMS
+TOOLS2
+
+PRJ_TESTEXTENSIONS
+
+#ifdef TOOLS2
+start extension tools/x86tool
+
+	option TARGET_NAME teststatic
+	option TARGET_TYPE lib
+	option SOURCE teststatic.cpp
+end
+
+start extension tools/x86tool
+
+	option TARGET_NAME testdll
+	option TARGET_TYPE dll
+	option SOURCE testdll.cpp
+
+	option LIBS teststatic
+	option SHARED_LIBS symport
+end
+
+start extension tools/x86tool
+
+	option TARGET_NAME testexe
+	option TARGET_TYPE exe
+	option SOURCE testexe.cpp
+
+	option LIBS teststatic
+	option SHARED_LIBS symport testdll
+end
+
+start extension tools/x86tool
+
+	option TARGET_NAME testexe_main.test
+	option TARGET_TYPE exe
+	option SOURCE testexe_main.cpp
+
+	option LIBS teststatic symuser
+end
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/test.pl	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,315 @@
+#!/usr/bin/perl
+
+# Copyright (c) 2008-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 "Symbian Foundation License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+#
+
+use strict;
+use warnings;
+use Test;
+use Getopt::Long qw(:config auto_version auto_help);
+use File::Spec::Functions;
+use File::Basename;
+use Cwd;
+
+# The following are the tests to run
+BEGIN { plan tests => 96 }
+
+# Make sure we're in the correct folder
+chdir('../bldtest') or die "Failed to set folder: $!";
+
+# Version of the script - just use the date
+$main::VERSION = '09-Oct-08';
+
+# Get command line arguments
+print "\n";
+my ( $verbose, $ignore );
+GetOptions("verbose" => \$verbose, "ignore" => \$ignore) or pod2usage(2);
+
+my $win32 = 1 if $^O =~ /MSWin32/;
+print "Running on Win32\n" if $win32 && $verbose;
+print "Running on Linux\n" if !$win32 && $verbose;
+
+# Test new build system
+my $flm = catfile($ENV{SBS_HOME}, 'lib', 'flm', 'x86tool.xml');
+my $tem = catfile($ENV{EPOCROOT}, 'epoc32', 'tools', 'makefile_templates', 'tools', 'x86tool.mk');
+
+warn "FLM $flm doesn't exist?" if !-e $flm;
+print "Testing SBSv2 with FLM\n";
+rename $tem, "$tem.disabled";
+$ENV{SBS_VERSION} = 2 if $win32;
+doCheck('deb');
+doCheck('rel');
+rename "$tem.disabled", $tem;
+
+# Disable the FLM if it exists and run test with the TEM
+print "Testing SBSv2 with TEM\n";
+rename $flm, "$flm.disabled";
+doCheck('deb');
+doCheck('rel');
+rename "$flm.disabled", $flm;
+
+# Test old build system
+print "Testing SBSv1 with TEM\n";
+if ($win32)
+	{
+	$ENV{SBS_VERSION} = 1;
+	doCheck('deb');
+	doCheck('rel');
+	}
+else
+	{
+	# No such thing on Linux - just keep Test happy
+	for(my $i = 1; $i <= 32; $i++)
+		{
+		ok(1);
+		}
+	}
+
+# ***
+# Check everything works
+#
+sub doCheck
+	{
+	my $variant = shift;
+
+	# Have to set library path for Linux
+	if (!$win32)
+		{
+		$ENV{LD_LIBRARY_PATH} =~ s[/epoc32[^:]+:/][];
+		$ENV{LD_LIBRARY_PATH} = "$ENV{EPOCROOT}epoc32/release/tools2/linux-i386/$variant:$ENV{LD_LIBRARY_PATH}";
+		}
+
+	# Build the code
+	my $sbs_ver = doBuild($variant);
+
+	# File extensions differ on Windows and Linux
+	my ( $ext_exe, $ext_dll ) = $win32 ? ( '.exe', '.dll' ) : ( '', '.so' );
+
+	# Generate string for the location of built file in epoc tree
+	my $release = catfile($ENV{EPOCROOT}, 'epoc32', 'release', 'tools2');
+	$release = catfile($release, 'linux-i386') if !$win32;
+	$release = catfile($release, '%s', '%s%s');
+
+	# The simple test should pass
+	doTest(sprintf($release, $variant, 'testexe', $ext_exe));
+	doTest(sprintf($release, $variant, 'testexe_main.test', ''));
+
+	# Check that the exe and lib have been built
+	checkExist(sprintf($release, $variant, 'testexe', $ext_exe));
+	checkExist(sprintf($release, $variant, 'testexe_main.test', ''));
+	checkExist(sprintf($release, $variant, 'libteststatic', '.a'));
+	checkExist(sprintf($release, $variant, 'libtestdll', $ext_dll));
+
+	# Check all the files exist
+	if ($sbs_ver == 1)
+		{
+		my $build = catfile($ENV{EPOCROOT}, 'epoc32', 'build', cwd(), 'wrappermakefiles', '%s', cwd(), '%s');
+		$build =~ s/\w:\\//g;
+
+		# Check the object files exist
+		checkExist(sprintf($build, $variant, 'testexe.cpp.o'));
+		checkExist(sprintf($build, $variant, 'teststatic.cpp.o'));
+		checkExist(sprintf($build, $variant, 'testdll.cpp.o'));
+
+		# Clean should delete everything
+		doClean($sbs_ver, $variant);
+	
+		# Object files should be gone now
+		checkMissing(sprintf($build, $variant, 'testexe.cpp.o'));
+		checkMissing(sprintf($build, $variant, 'teststatic.cpp.o'));
+		checkMissing(sprintf($build, $variant, 'testdll.cpp.o'));
+		}
+	else
+		{
+		my $build;
+
+		# Build location differs between the TEM and FLM
+		my $flm = catfile($ENV{SBS_HOME}, 'lib', 'flm', 'x86tool.xml');
+		if (-e $flm)
+			{
+			my $cwd = cwd();
+			$cwd =~ s/$ENV{HOME}// if $ENV{HOME};
+			$build = catfile($ENV{EPOCROOT}, 'epoc32', 'build', 'x86tools', '%s', '%s', $cwd, '%s');
+			$build =~ s/\w:\\//g;
+
+			# Check the object files exist
+			checkExist(sprintf($build, $variant, 'testexe', 'testexe.cpp.o'));
+			checkExist(sprintf($build, $variant, 'teststatic', 'teststatic.cpp.o'));
+			checkExist(sprintf($build, $variant, 'testdll', 'testdll.cpp.o'));
+	
+			# Clean should delete everything
+			doClean($sbs_ver, $variant);
+	
+			# Object files should be gone now
+			checkMissing(sprintf($build, $variant, 'testexe', 'testexe.cpp.o'));
+			checkMissing(sprintf($build, $variant, 'teststatic', 'teststatic.cpp.o'));
+			checkMissing(sprintf($build, $variant, 'testdll', 'testdll.cpp.o'));
+			}
+		else
+			{
+			$build = catfile($ENV{EPOCROOT}, 'epoc32', 'build', '%s', cwd(), '%s');
+			$build =~ s/\w:\\//g;
+
+			# Check the object files exist
+			checkExist(sprintf($build, $variant, 'testexe.cpp.o'));
+			checkExist(sprintf($build, $variant, 'teststatic.cpp.o'));
+			checkExist(sprintf($build, $variant, 'testdll.cpp.o'));
+	
+			# Clean should delete everything
+			doClean($sbs_ver, $variant);
+	
+			# Object files should be gone now
+			checkMissing(sprintf($build, $variant, 'testexe.cpp.o'));
+			checkMissing(sprintf($build, $variant, 'teststatic.cpp.o'));
+			checkMissing(sprintf($build, $variant, 'testdll.cpp.o'));
+			}
+		}
+
+	# Releaseables should be gone
+	checkMissing(sprintf($release, $variant, 'testexe', $ext_exe));
+	checkMissing(sprintf($release, $variant, 'testexe_main.test', ''));
+	checkMissing(sprintf($release, $variant, 'libteststatic', '.a'));
+	checkMissing(sprintf($release, $variant, 'libtestdll', $ext_dll));
+	}
+
+sub checkExist
+	{
+	my $file = shift;
+	print "Checking file exists: $file\n" if $verbose;
+	ok(-e $file);
+	}
+
+sub checkMissing
+	{
+	my $file = shift;
+	print "Checking file missing: $file\n" if $verbose;
+	ok(!-e $file);
+	}
+
+# ***
+# Runs test code
+#
+sub doTest
+	{
+	my $test = shift;
+	warn "Can't find test exe: $test" if (!-e $test);
+
+	my $pass;
+	if (-e $test)
+		{
+		print "Running test: $test\n" if $verbose;
+		open TEST, "$test|" or die "Failed to start test $test: $!";
+		while(<TEST>)
+			{
+			$pass = 1 if /^RTEST: SUCCESS/ or /TEST Successfully Completed/;
+			}
+		close TEST;
+		}
+	ok($pass);	
+	}
+
+# ***
+# Cleans the test code
+# *
+sub doClean
+	{
+	my $sbs_ver = shift;
+	my $variant = shift;
+
+	my $redir = $verbose?'':' >nul 2>&1';
+	print "Cleaning component for $variant\n" if $verbose;
+	if ($sbs_ver == 1)
+		{
+		# Use the old build system
+		system("bldmake bldfiles$redir");
+		system("abld test makefile tools2$redir");
+		system("abld test clean tools2 $variant$redir");
+		}
+	else
+		{
+		# Use the new build system
+		system("sbs -c tools2_$variant.test CLEAN$redir");
+		}
+	}
+
+# ***
+# Builds the test code
+# *
+sub doBuild
+	{
+	my $variant = shift;
+
+	# First of all see if SBSv2 is installed
+	my $sbs_ver = 1;
+	open SBS, 'sbs -v 2>&1|' or die "Failed to execute command: $!";
+	while(<SBS>)
+		{
+		if (/^sbs version/)
+			{
+			$sbs_ver = 2;
+			last;
+			}
+		}
+	close SBS;
+	die "This test requires SBSv2. Run with -ignore to run this test anyway" if $sbs_ver == 1 && !$ignore;
+
+	# Override the result using environment variable
+	$sbs_ver = 1 if $ENV{SBS_VERSION} && $ENV{SBS_VERSION} == 1;
+
+	# Now build the test code - assumes current working directory is correct!
+	my $redir = $verbose?'':' >nul 2>&1';
+	print "Building test code using SBSv$sbs_ver for $variant\n" if $verbose;
+	if ($sbs_ver == 1)
+		{
+		print "Building using sbsv1\n" if $verbose;
+
+		# Use the old build system
+		system("bldmake bldfiles$redir");
+		system("abld test makefile tools2$redir");
+		system("abld test clean tools2$redir");
+		system("abld test library tools2$redir");
+		system("abld test target tools2 $variant$redir");
+		}
+	else
+		{
+		print "Building using sbsv2\n" if $verbose;
+
+		# TEM can't handle parallel builds due to dependencies between extension makefiles
+		my $flm = catfile($ENV{SBS_HOME}, 'lib', 'flm', 'x86tool.xml');
+		my $jopt = (!-e $flm) ? '-j 1' : '';
+
+		# Use the new build system
+		system("sbs $jopt -c tools2_$variant.test CLEAN$redir");
+		system("sbs $jopt -c tools2_$variant.test$redir");
+		}
+
+	# Return the sbs version for later
+	return $sbs_ver;
+	}
+
+=head1 NAME
+
+test.pl - A script for running tests
+
+=head1 SYNOPSIS
+
+test.pl [-help] [-version] [-verbose] [-ignore]
+
+ Options:
+   -help      brief help message
+   -version   version of the script
+   -verbose   print what the scripts does
+   -ignore    ignore lack of SBSv2 and run tests anyway
+=cut

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/testdll.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,77 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32base.h>
+#include <e32std.h>
+#include <e32debug.h>
+
+#include "testdll.h"
+
+EXPORT_C CTestDll::CTestDll()
+	{
+	}
+
+EXPORT_C CTestDll::~CTestDll()
+	{
+	}
+
+void LeavingFuncL()
+	{
+	User::Leave(-777);
+	}
+
+EXPORT_C void CTestDll::LeaveL()
+	{
+	TRAPD(err, LeavingFuncL());
+	User::Leave(err);
+	}
+
+EXPORT_C TInt CTestDll::ArrayL()
+	{
+	RArray<TInt> array;
+	array.Append(1);
+	array.Append(2);
+	array.Append(3);
+
+	TInt count = array.Count();
+	array.Close();
+	return count;
+	}
+
+EXPORT_C void CTestDll::DescriptorL()
+	{
+	TBuf<256> des1;
+	TBuf<256> des2(_L("... TBuf descriptors are okay\n"));
+	des1.Format(_L("%S"), &des2);	
+	RDebug::Print(des1);
+	
+	HBufC8* hbuf1 = HBufC8::NewLC(76);
+	hbuf1->Des().Copy(_L8("... Heap descriptors are okay\n"));
+	des1.Copy(*hbuf1);
+	RDebug::Print(des1);
+
+	des1.Zero();
+	des1.AppendNum(TReal(3.14), TRealFormat());
+	RDebug::Print(_L("... The value of PI=%S\n"), &des1);
+	
+	des1.Zero();
+	des1.AppendFormat(_L("... More accurate value of PI=%e\n"), TReal(3.14159));
+	RDebug::Print(des1);
+
+	// DEF132478: libsymport.a is out of date
+	RThread().Id();
+
+	CleanupStack::PopAndDestroy(hbuf1);
+	}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/testdll.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,30 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef _TESTDLL_H__
+#define _TESTDLL_H__
+
+class CTestDll : public CBase
+	{
+public:
+	IMPORT_C CTestDll();
+	IMPORT_C ~CTestDll();
+public:
+	IMPORT_C void LeaveL();
+	IMPORT_C TInt ArrayL();
+	IMPORT_C void DescriptorL();
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/testexe.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,80 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32debug.h>
+#include <e32base.h>
+#include <e32hashtab.h>
+#include <e32test.h>
+
+#include "teststatic.h"
+#include "testdll.h"
+
+RTest test(_L("Simple tests"));
+
+EXPORT_C void HashL()
+	{
+	TInt in = 0x12345678;
+	TInt out = 0;
+	out = DefaultHash::Integer(in);
+	test(in != out);
+	}
+
+void DefectsL()
+	{
+	// DEF132826: symport User:Alloc family error checking
+	test(User::Alloc(-10) == NULL);
+	}
+
+void doMainL()
+	{
+	CTestDll dll;
+
+	test.Start(_L("Leaving"));
+	TRAPD(err, TestStatic::LeaveL());
+	RDebug::Print(_L("... Leave code from lib: %d\n"), err);
+	TRAP(err, dll.LeaveL());
+	RDebug::Print(_L("... Leave code from dll: %d\n"), err);
+	test(err != KErrNone);
+
+	test.Next(_L("Arrays"));
+	test(TestStatic::ArrayL() == 3);
+	test(dll.ArrayL() == 3);
+
+	test.Next(_L("Descriptors"));
+	TestStatic::DescriptorL();
+	dll.DescriptorL();
+
+	test.Next(_L("Hash"));
+	HashL();
+
+	test.Next(_L("Defects"));
+	DefectsL();
+
+	test.End();
+	}
+
+int E32Main()
+	{
+	RDebug::Print(_L("Called from E32Main\n"));
+
+	__UHEAP_MARK;
+	CTrapCleanup* theCleanup = CTrapCleanup::New();
+	TRAPD(ret, doMainL());
+	test(ret == KErrNone);
+	test.Close();
+	delete theCleanup;
+	__UHEAP_MARKEND;
+	return ret;
+	}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/testexe_main.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,66 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32debug.h>
+#include <e32base.h>
+#include <e32hashtab.h>
+#include <e32test.h>
+
+#include "teststatic.h"
+
+RTest test(_L("Simple tests"));
+
+EXPORT_C void HashL()
+	{
+	TInt in = 0x12345678;
+	TInt out = 0;
+	out = DefaultHash::Integer(in);
+	test(in != out);
+	}
+
+void doMainL()
+	{
+	test.Start(_L("Leaving"));
+	TRAPD(err, TestStatic::LeaveL());
+	RDebug::Print(_L("... Leave code: %d\n"), err);
+	test(err != KErrNone);
+
+	test.Next(_L("Arrays"));
+	test(TestStatic::ArrayL() == 3);
+
+	test.Next(_L("Descriptors"));
+	TestStatic::DescriptorL();
+
+	test.Next(_L("Hash"));
+	HashL();
+
+	test.End();
+	}
+
+// Note - no E32Main!
+int main(int argc, char *argv[])
+	{
+	RDebug::Print(_L("Called from main\n"));
+
+	__UHEAP_MARK;
+	CTrapCleanup* theCleanup = CTrapCleanup::New();
+	TRAPD(ret, doMainL());
+	test(ret == KErrNone);
+	test.Close();
+	delete theCleanup;
+	__UHEAP_MARKEND;
+	return ret;
+	}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/teststatic.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,60 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32base.h>
+#include <e32std.h>
+#include <e32debug.h>
+
+#include "teststatic.h"
+
+EXPORT_C void TestStatic::LeaveL()
+	{
+	User::Leave(-666);
+	}
+
+EXPORT_C TInt TestStatic::ArrayL()
+	{
+	RArray<TInt> array;
+	array.Append(1);
+	array.Append(2);
+	array.Append(3);
+
+	TInt count = array.Count();
+	array.Close();
+	return count;
+	}
+
+EXPORT_C void TestStatic::DescriptorL()
+	{
+	TBuf<256> des1;
+	TBuf<256> des2(_L("... TBuf descriptors are okay\n"));
+	des1.Format(_L("%S"), &des2);	
+	RDebug::Print(des1);
+	
+	HBufC8* hbuf1 = HBufC8::NewLC(76);
+	hbuf1->Des().Copy(_L8("... Heap descriptors are okay\n"));
+	des1.Copy(*hbuf1);
+	RDebug::Print(des1);
+
+	des1.Zero();
+	des1.AppendNum(TReal(3.14), TRealFormat());
+	RDebug::Print(_L("... The value of PI=%S\n"), &des1);
+	
+	des1.Zero();
+	des1.AppendFormat(_L("... More accurate value of PI=%e\n"), TReal(3.14159));
+	RDebug::Print(des1);
+
+	CleanupStack::PopAndDestroy(hbuf1);
+	}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/bldtest/teststatic.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,27 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef _TESTSTATIC_H__
+#define _TESTSTATIC_H__
+
+class TestStatic
+	{
+public:
+	IMPORT_C static void LeaveL();
+	IMPORT_C static TInt ArrayL();
+	IMPORT_C static void DescriptorL();
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/charconv/framework/inc/utf.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,86 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#if !defined(__UTF_H__)
+#define __UTF_H__
+
+#if !defined(__E32STD_H__)
+#include <e32std.h>
+#endif
+
+
+class CnvUtfConverter
+/** 
+Converts text between Unicode (UCS-2) and the two Unicode transformation 
+formats UTF-7 and UTF-8. There are no functions to convert directly between 
+UTF-7 and UTF-8.
+
+Objects of this class do not need to be created because all the member functions 
+are static. The four functions are passed text in the second argument and 
+output the resulting text in the first argument. Sixteen-bit descriptors are 
+used to hold text encoded in UCS-2 (i.e. normal 16 bit Unicode), and eight-bit 
+descriptors are used to hold text encoded in either of the transformation 
+formats.
+
+The conversion functions return the number of characters which were not converted 
+because the output descriptor was not long enough to hold all of the converted 
+text. This allows users of this class to perform partial conversions on an 
+input descriptor, handling the case when the input descriptor is truncated 
+mid way through a multi-byte character. The caller does not have to guess 
+how big to make the output descriptor for a given input descriptor- they 
+can simply do the conversion in a loop using a small output descriptor. The 
+ability to handle truncated descriptors is particularly useful if the caller 
+is receiving information in chunks from an external source. 
+@publishedAll
+@released
+*/
+	{
+public:
+	/** Conversion error flags. At this stage there is only one error flag 
+	- others may be added in the future. */
+	enum TError
+		{
+ 		/** The input descriptor contains a single corrupt character. This 
+ 		might occur when the input descriptor only contains some of the bytes 
+ 		of a single multi-byte character. */
+		EErrorIllFormedInput=KErrCorrupt
+		};
+	 
+	 /** Initial value for the state argument in a set of related calls to
+	ConvertToUnicode(). */
+	enum {KStateDefault=0}; 
+public:
+	// the conversion functions return either one of the TError values above, or the number of unconverted elements left at the end of the input descriptor
+	IMPORT_C static TInt ConvertFromUnicodeToUtf7(TDes8& aUtf7, const TDesC16& aUnicode, TBool aEncodeOptionalDirectCharactersInBase64);
+	static TInt ConvertFromUnicodeToUtf7(TDes8& aUtf7, const TDesC16& aUnicode, TBool aIsImapUtf7, TBool aEncodeOptionalDirectCharactersInBase64);
+	IMPORT_C static TInt ConvertFromUnicodeToUtf8(TDes8& aUtf8, const TDesC16& aUnicode);
+	static TInt ConvertFromUnicodeToUtf8(TDes8& aUtf8, const TDesC16& aUnicode, TBool aGenerateJavaConformantUtf8);
+	IMPORT_C static TInt ConvertToUnicodeFromUtf7(TDes16& aUnicode, const TDesC8& aUtf7, TInt& aState);
+	static TInt ConvertToUnicodeFromUtf7(TDes16& aUnicode, const TDesC8& aUtf7, TBool aIsImapUtf7, TInt& aState);
+	IMPORT_C static TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8);
+	static TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8, TBool aGenerateJavaConformantUtf8);
+	static TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8, TBool aGenerateJavaConformantUtf8,
+			TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter);
+
+	IMPORT_C static HBufC8* ConvertFromUnicodeToUtf7L(const TDesC16& aUnicode,TBool aEncodeOptionalDirectCharactersInBase64);
+	IMPORT_C static HBufC8* ConvertFromUnicodeToUtf8L(const TDesC16& aUnicode);
+	IMPORT_C static HBufC16* ConvertToUnicodeFromUtf7L(const TDesC8& aUtf7); 
+	IMPORT_C static HBufC16* ConvertToUnicodeFromUtf8L(const TDesC8& aUtf8);
+
+
+	};
+
+#endif
+