diff -r 675a964f4eb5 -r 35751d3474b7 cryptomgmtlibs/securitytestfw/test/testhandler2/T_input.cpp
--- a/cryptomgmtlibs/securitytestfw/test/testhandler2/T_input.cpp	Tue Jul 21 01:04:32 2009 +0100
+++ b/cryptomgmtlibs/securitytestfw/test/testhandler2/T_input.cpp	Thu Sep 10 14:01:51 2009 +0300
@@ -1,556 +1,556 @@
-/*
-* Copyright (c) 1998-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: 
-*
-*/
-
-
-#include <s32file.h>
-#include "t_input.h"
-#include "t_errorconverter.h"
-
-const TUint KMaxTagLength = 80;
-
-EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, const TDesC8& aStart, const TDesC8& aEnd)
-	{
-	TInt pos  = 0;
-	return Input::ParseElement(aBuf, aStart, aEnd, pos);
-	}
-
-EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, const TDesC8& aStart)
-	{
-	TInt pos = 0;
-	TBuf8<KMaxTagLength> end;
-	end.Copy(aStart);
-	end.Insert(1, _L8("/"));
-	return Input::ParseElement(aBuf, aStart, end, pos);	
-	}
-
-EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, 
-										const TDesC8& aStart, 
-										const TDesC8& aEnd, 
-										TInt& aPos)
-	{
-	TInt err = KErrNone;
-	return Input::ParseElement(aBuf, aStart, aEnd, aPos, err);
-	}
-
-
-// Find the portion of aBuf between aStart and aEnd, allowing for nesting
-EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, 
-									const TDesC8& aStart,
-									const TDesC8& aEnd, 
-									TInt& aPos,
-									TInt& aError)
-	{
-	aError = KErrNone;
-	TInt startPos = KErrNotFound;
-	TInt level = 0;
-	do
-		{
-		TPtrC8 data = aBuf.Mid(aPos);
-
-		// Find the first start or end tag
-		TInt nextStart = data.Find(aStart);
-		TInt nextEnd = data.Find(aEnd);
-
-		if (nextStart == KErrNotFound && nextEnd == KErrNotFound)
-			{
-			// None found
-			aError = KErrNotFound;
-			return TPtrC8();
-			}
-		else if (nextEnd == KErrNotFound || (nextStart != KErrNotFound && nextStart < nextEnd))
-			{
-			// Start tag found first
-			++level;
-			aPos += nextStart + aStart.Length();
-
-			if (startPos == KErrNotFound)
-				{
-				// Record position of first start tag
-				startPos = aPos;
-				}
-			}
-		else
-			{
-			// End tag found first
-			--level;
-			aPos += nextEnd + aEnd.Length();
-			}
-		}
-	while (level > 0);
-
-	if (level == -1)
-		{
-		// End tag found before start tag
-		aError = KErrArgument;
-		return TPtrC8();
-		}
-
-	ASSERT(startPos != KErrNotFound);
-	return aBuf.Mid(startPos, aPos - startPos - aEnd.Length());
-	}
-
-EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, const TDesC16& aStart, const TDesC16& aEnd)
-	{
-	TInt pos  = 0;
-	return Input::ParseElement(aBuf, aStart, aEnd, pos);
-	}
-
-
-EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, 
-										const TDesC16& aStart, 
-										const TDesC16& aEnd, 
-										TInt& aPos)
-	{
-	TInt err = KErrNone;
-	return Input::ParseElement(aBuf, aStart, aEnd, aPos, err);
-	}
-
-
-EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, 
-									const TDesC16& aStart,
-									const TDesC16& aEnd, 
-									TInt& aPos,
-									TInt& aError)
-	{
-	aError = KErrNone;
-	const TInt length = aBuf.Length();
-	TPtrC16 temp1 = aBuf.Right(length - aPos);
-	TInt elementStart = temp1.Find(aStart);
-	if (elementStart < 0)
-		{
-		aError = elementStart;
-		TPtrC16 res(KNullDesC16);
-		return res;
-		}
-	elementStart+= aStart.Length();
-	aPos+=elementStart;
-
-	TPtrC16 temp2 = temp1.Right(temp1.Length() - elementStart);
-	TInt elementEnd = temp2.Find(aEnd);
-	if (elementEnd < 0)
-		{
-		TPtrC16 res(KNullDesC16);
-		return res;
-		}
-
-	aPos+=elementEnd;
-	aPos+=aEnd.Length();
-
-	TPtrC16 element = temp2.Left(elementEnd);
-	return element;
-	}
-
-EXPORT_C HBufC8* Input::ParseElementHexL(const TDesC8& aBuf, const TDesC8& aStart)
-	{
-	TPtrC8 data = Input::ParseElement(aBuf, aStart);
-	__ASSERT_ALWAYS(data.Size() % 2 == 0, User::Panic(_L("ParseElementHexL"), 1));
-	TInt bytes = data.Size()/2;
-	HBufC8* buf = HBufC8::NewLC(bytes);
-	TPtr8 ptr = buf->Des();
-	ptr.SetLength(bytes);
-
-	if(bytes)
-		{
-		for (TInt i = 0 ; i < data.Length() ; i += 2)
-			{
-			TUint8 tmp;
-			tmp=(TUint8)(data[i]-(data[i]>'9'?('A'-10):'0'));
-			tmp*=16;
-			tmp|=(TUint8)(data[i+1]-(data[i+1]>'9'?('A'-10):'0'));
-			ptr[i/2] = tmp;
-			}
-		}
-	CleanupStack::Pop(buf);
-	return buf;
-	}
-
-EXPORT_C TBool Input::ParseElementBoolL(const TDesC8& aBuf, const TDesC8& aStart)	
-	{
-	TPtrC8 value = Input::ParseElement(aBuf, aStart);
-	if( value.CompareF(_L8("ETrue")) == 0 || value.CompareF(_L8("True")) == 0 )
-		{
-		return ETrue;
-		}
-	else if( value.CompareF(_L8("EFalse")) == 0 || value.CompareF(_L8("False")) == 0 )
-		{
-		return EFalse;
-		}
-	//if it's neither false nor true, leave
-	User::Leave(KErrArgument);
-	return EFalse;
-	}
-
-
-EXPORT_C TBool Input::GetExpectedResultL(const TDesC& aResult /* in */, TInt &aError /* out */)
-	{
-	TBool result;
-	CErrorConverter *errorConverter = CErrorConverter::NewLC();
-
-	result = errorConverter->GetExpectedResultL(aResult, aError);
-	CleanupStack::PopAndDestroy(errorConverter);
-	
-	return(result);
-	}
-
-
-EXPORT_C TBool Input::GetExpectedResultL(const TInt &aError /* in */, HBufC*& aResult /* out */)
-	{
-	TBool result;
-	CErrorConverter *errorConverter = CErrorConverter::NewLC();
-
-	result = errorConverter->GetExpectedResultL(aError, aResult);
-	CleanupStack::PopAndDestroy(errorConverter);
-	
-	return(result);
-	}
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C void Input::ParseElementL(HBufC*& aMember,
-								   const TDesC& aBuf, 
-								   const TDesC& aStart)
-	{
-	TInt pos = 0;
-	ParseElementL(aMember, aBuf, aStart, pos);
-	};
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C void Input::ParseElementL(HBufC8*& aMember,
-								   const TDesC& aBuf, 
-								   const TDesC& aStart)
-	{
-	TInt pos = 0;
-	ParseElementL(aMember, aBuf, aStart, pos);
-	};
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C void Input::ParseElementL(HBufC*& aMember,
-								   const TDesC& aBuf, 
-								   const TDesC& aStart,
-								   TInt& aPos)
-	{
-	TInt error = KErrNone;
-	ParseElementL(aMember, aBuf, aStart, aPos, error);
-	};
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C void Input::ParseElementL(HBufC8*& aMember,
-								   const TDesC& aBuf, 
-								   const TDesC& aStart,
-								   TInt& aPos)
-	{
-	TInt error = KErrNone;
-	ParseElementL(aMember, aBuf, aStart, aPos, error);
-	};
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C void Input::ParseElementL(HBufC*& aMember,
-								   const TDesC& aBuf, 
-								   const TDesC& aStart,
-								   TInt& aPos,
-								   TInt& aError)
-	{
-	__ASSERT_DEBUG(!aMember, User::Panic(_L("Input"), 1));
-
-
-	TPtrC value = ParseElement(aBuf, aStart, aPos, aError);
-	// copy file name to unicode buffer
-	aMember = HBufC::NewL(value.Length());
-	aMember->Des().Copy(value);
-	}
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C void Input::ParseElementL(HBufC8*& aMember,
-								   const TDesC& aBuf, 
-								   const TDesC& aStart,
-								   TInt& aPos,
-								   TInt& aError)
-	{
-	__ASSERT_DEBUG(!aMember, User::Panic(_L("Input"), 1));
-
-
-	TPtrC value = ParseElement(aBuf, aStart, aPos, aError);
-	// copy file name to narrow buffer
-	aMember = HBufC8::NewL(value.Length());
-	aMember->Des().Copy(value);
-	}
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart)
-	{
-	TInt pos = 0;
-	return(ParseElement(aBuf, aStart, pos));
-	};
-
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos)
-	{
-	TInt error = KErrNone;
-	return(ParseElement(aBuf, aStart, aPos, error));
-	};
-
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos, TInt& aError)
-	{
-	// using the start tag <abcd> create a matching tag terminator <\abcd>
-	HBufC* hend = HBufC::NewMaxLC(aStart.Length()+1);	
-
-	TPtr end = hend->Des();
-	end = aStart; // copy in start tag
-	end.Insert(1,_L("/"));  // make it into a terminator tag with same element name
-	// get value from element
-	TPtrC value = Input::ParseElement(aBuf, aStart, end, aPos, aError);
-
-	CleanupStack::PopAndDestroy(hend);
-	return(value);
-	}
-
-EXPORT_C HBufC8* Input::ReadFileL(const TDesC& aFilename, RFs& aFs)
-	{
-	HBufC8* ret = ReadFileLC(aFilename, aFs);
-	CleanupStack::Pop();
-	return ret;
-	}
-
-EXPORT_C HBufC8* Input::ReadFileL(const TDesC& aFilename, const TDesC& aPath, RFs& aFs)
-	{
-	HBufC8* ret = ReadFileLC(aFilename, aPath, aFs);
-	CleanupStack::Pop();
-	return ret;
-	}
-
-EXPORT_C HBufC8* Input::ReadFileLC(const TDesC& aFilename, RFs& aFs)
-	{
-	RFile file;
-	User::LeaveIfError(file.Open(aFs, aFilename, EFileRead));
-	CleanupClosePushL(file);
-	TInt size;
-	file.Size(size);
-	CleanupStack::PopAndDestroy();//fileClose
-
-	HBufC8* res = HBufC8::NewLC(size);
-	TPtr8 p(res->Des());
-	p.SetLength(size);
-
-	RFileReadStream stream;
-	User::LeaveIfError(stream.Open(aFs, aFilename, EFileStream));
-	CleanupClosePushL(stream);
-	stream.ReadL(p, size);
-	CleanupStack::PopAndDestroy();//streamClose
-	return res;
-	}
-
-EXPORT_C HBufC8* Input::ReadFileLC(const TDesC& aFilename, const TDesC& aPath, RFs& aFS)
-	{
-	TFileName fullname;
-	fullname.Append(aPath);
-	fullname.Append(aFilename);
-
-	RFile file;
-	User::LeaveIfError(file.Open(aFS, fullname, EFileRead));
-	CleanupClosePushL(file);
-	TInt size;
-	file.Size(size);
-	CleanupStack::PopAndDestroy();//fileClose
-
-	HBufC8* res = HBufC8::NewLC(size);
-	TPtr8 p(res->Des());
-	p.SetLength(size);
-
-	RFileReadStream stream;
-	User::LeaveIfError(stream.Open(aFS, fullname, EFileStream));
-	CleanupClosePushL(stream);
-	stream.ReadL(p, size);
-	CleanupStack::PopAndDestroy();//streamClose
-	return res;
-	}
-
-EXPORT_C void Input::ParseElementListL(const TDesC& aBuf, 
-									   const TDesC& aStart,
-									   const TDesC& aEnd, 
-									   RPointerArray<HBufC>& aElements,
-									   TInt& aPos)
-	{
-	TPtrC currentElement = ParseElement(aBuf, aStart, aEnd, aPos);
-	while (currentElement != KNullDesC)
-		{
-		HBufC* newElement = HBufC::NewL(currentElement.Size());
-		*newElement = currentElement;
-		User::LeaveIfError(aElements.Append(newElement));
-		currentElement.Set(ParseElement(aBuf, aStart, aEnd, aPos));
-		}
-	}
-
-EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, const TDesC8& aStart, const TDesC8& aEnd)
-	{
-	TInt pos  = 0;
-	return Input::ParseIntElement(aBuf, aStart, aEnd, pos);
-	}
-
-
-EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, 
-										const TDesC8& aStart, 
-										const TDesC8& aEnd, 
-										TInt& aPos)
-	{
-	TInt err = KErrNone;
-	return Input::ParseIntElement(aBuf, aStart, aEnd, aPos, err);
-	}
-
-
-EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, 
-									const TDesC8& aStart,
-									const TDesC8& aEnd, 
-									TInt& aPos,
-									TInt& aError)
-	{
-	aError = KErrNone;
-	TPtrC8 temp = ParseElement(aBuf, aStart, aEnd, aPos, aError);
-
-	TUint result = 0;
-
-	if(aError == KErrNone)
-		{
-		TLex8 lex;
-		if(temp.Left(2) == _L8("0x"))
-			{
-			lex = temp.Mid(2);
-			aError = lex.Val(result, EHex);
-			}
-		else
-			{
-			lex = temp;
-			aError = lex.Val(result);
-			};
-		
-		if(aError == KErrNone)
-			{
-			if(!lex.Eos())
-				{
-				aError = KErrArgument;
-				result = 0;
-				};
-			};
-		};
-	return(result);
-	}
-
-EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, const TDesC16& aStart, const TDesC16& aEnd)
-	{
-	TInt pos  = 0;
-	return Input::ParseIntElement(aBuf, aStart, aEnd, pos);
-	}
-
-
-EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, 
-										const TDesC16& aStart, 
-										const TDesC16& aEnd, 
-										TInt& aPos)
-	{
-	TInt err = KErrNone;
-	return Input::ParseIntElement(aBuf, aStart, aEnd, aPos, err);
-	}
-
-
-EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, 
-									const TDesC16& aStart,
-									const TDesC16& aEnd, 
-									TInt& aPos,
-									TInt& aError)
-	{
-	aError = KErrNone;
-	TPtrC16 temp = ParseElement(aBuf, aStart, aEnd, aPos, aError);
-
-	TUint result = 0;
-
-	if(aError == KErrNone)
-		{
-		TLex16 lex;
-		if(temp.Left(2) == _L16("0x"))
-			{
-			lex = temp.Mid(2);
-			aError = lex.Val(result, EHex);
-			}
-		else
-			{
-			lex = temp;
-			aError = lex.Val(result);
-			};
-		
-		if(aError == KErrNone)
-			{
-			if(!lex.Eos())
-				{
-				aError = KErrArgument;
-				result = 0;
-				};
-			};
-		};
-	return(result);
-	}
-
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart)
-	{
-	TInt pos = 0;
-	return(ParseIntElement(aBuf, aStart, pos));
-	};
-
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos)
-	{
-	TInt error = KErrNone;
-	return(ParseIntElement(aBuf, aStart, aPos, error));
-	};
-
-
-// Allocate memory on the heap and copy in the value of a tagged element
-EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos, TInt& aError)
-	{
-	// get value from element
-	TPtrC temp = Input::ParseElement(aBuf, aStart, aPos, aError);
-	TUint result = 0;
-
-	if(aError == KErrNone)
-		{
-		TLex16 lex;
-		if(temp.Left(2) == _L16("0x"))
-			{
-			lex = temp.Mid(2);
-			aError = lex.Val(result, EHex);
-			}
-		else
-			{
-			lex = temp;
-			aError = lex.Val(result);
-			};
-		
-		if(aError == KErrNone)
-			{
-			if(!lex.Eos())
-				{
-				aError = KErrArgument;
-				result = 0;
-				};
-			};
-		};
-
-	return(result);	
-	}
+/*
+* Copyright (c) 1998-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: 
+*
+*/
+
+
+#include <s32file.h>
+#include "t_input.h"
+#include "t_errorconverter.h"
+
+const TUint KMaxTagLength = 80;
+
+EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, const TDesC8& aStart, const TDesC8& aEnd)
+	{
+	TInt pos  = 0;
+	return Input::ParseElement(aBuf, aStart, aEnd, pos);
+	}
+
+EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, const TDesC8& aStart)
+	{
+	TInt pos = 0;
+	TBuf8<KMaxTagLength> end;
+	end.Copy(aStart);
+	end.Insert(1, _L8("/"));
+	return Input::ParseElement(aBuf, aStart, end, pos);	
+	}
+
+EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, 
+										const TDesC8& aStart, 
+										const TDesC8& aEnd, 
+										TInt& aPos)
+	{
+	TInt err = KErrNone;
+	return Input::ParseElement(aBuf, aStart, aEnd, aPos, err);
+	}
+
+
+// Find the portion of aBuf between aStart and aEnd, allowing for nesting
+EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, 
+									const TDesC8& aStart,
+									const TDesC8& aEnd, 
+									TInt& aPos,
+									TInt& aError)
+	{
+	aError = KErrNone;
+	TInt startPos = KErrNotFound;
+	TInt level = 0;
+	do
+		{
+		TPtrC8 data = aBuf.Mid(aPos);
+
+		// Find the first start or end tag
+		TInt nextStart = data.Find(aStart);
+		TInt nextEnd = data.Find(aEnd);
+
+		if (nextStart == KErrNotFound && nextEnd == KErrNotFound)
+			{
+			// None found
+			aError = KErrNotFound;
+			return TPtrC8();
+			}
+		else if (nextEnd == KErrNotFound || (nextStart != KErrNotFound && nextStart < nextEnd))
+			{
+			// Start tag found first
+			++level;
+			aPos += nextStart + aStart.Length();
+
+			if (startPos == KErrNotFound)
+				{
+				// Record position of first start tag
+				startPos = aPos;
+				}
+			}
+		else
+			{
+			// End tag found first
+			--level;
+			aPos += nextEnd + aEnd.Length();
+			}
+		}
+	while (level > 0);
+
+	if (level == -1)
+		{
+		// End tag found before start tag
+		aError = KErrArgument;
+		return TPtrC8();
+		}
+
+	ASSERT(startPos != KErrNotFound);
+	return aBuf.Mid(startPos, aPos - startPos - aEnd.Length());
+	}
+
+EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, const TDesC16& aStart, const TDesC16& aEnd)
+	{
+	TInt pos  = 0;
+	return Input::ParseElement(aBuf, aStart, aEnd, pos);
+	}
+
+
+EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, 
+										const TDesC16& aStart, 
+										const TDesC16& aEnd, 
+										TInt& aPos)
+	{
+	TInt err = KErrNone;
+	return Input::ParseElement(aBuf, aStart, aEnd, aPos, err);
+	}
+
+
+EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, 
+									const TDesC16& aStart,
+									const TDesC16& aEnd, 
+									TInt& aPos,
+									TInt& aError)
+	{
+	aError = KErrNone;
+	const TInt length = aBuf.Length();
+	TPtrC16 temp1 = aBuf.Right(length - aPos);
+	TInt elementStart = temp1.Find(aStart);
+	if (elementStart < 0)
+		{
+		aError = elementStart;
+		TPtrC16 res(KNullDesC16);
+		return res;
+		}
+	elementStart+= aStart.Length();
+	aPos+=elementStart;
+
+	TPtrC16 temp2 = temp1.Right(temp1.Length() - elementStart);
+	TInt elementEnd = temp2.Find(aEnd);
+	if (elementEnd < 0)
+		{
+		TPtrC16 res(KNullDesC16);
+		return res;
+		}
+
+	aPos+=elementEnd;
+	aPos+=aEnd.Length();
+
+	TPtrC16 element = temp2.Left(elementEnd);
+	return element;
+	}
+
+EXPORT_C HBufC8* Input::ParseElementHexL(const TDesC8& aBuf, const TDesC8& aStart)
+	{
+	TPtrC8 data = Input::ParseElement(aBuf, aStart);
+	__ASSERT_ALWAYS(data.Size() % 2 == 0, User::Panic(_L("ParseElementHexL"), 1));
+	TInt bytes = data.Size()/2;
+	HBufC8* buf = HBufC8::NewLC(bytes);
+	TPtr8 ptr = buf->Des();
+	ptr.SetLength(bytes);
+
+	if(bytes)
+		{
+		for (TInt i = 0 ; i < data.Length() ; i += 2)
+			{
+			TUint8 tmp;
+			tmp=(TUint8)(data[i]-(data[i]>'9'?('A'-10):'0'));
+			tmp*=16;
+			tmp|=(TUint8)(data[i+1]-(data[i+1]>'9'?('A'-10):'0'));
+			ptr[i/2] = tmp;
+			}
+		}
+	CleanupStack::Pop(buf);
+	return buf;
+	}
+
+EXPORT_C TBool Input::ParseElementBoolL(const TDesC8& aBuf, const TDesC8& aStart)	
+	{
+	TPtrC8 value = Input::ParseElement(aBuf, aStart);
+	if( value.CompareF(_L8("ETrue")) == 0 || value.CompareF(_L8("True")) == 0 )
+		{
+		return ETrue;
+		}
+	else if( value.CompareF(_L8("EFalse")) == 0 || value.CompareF(_L8("False")) == 0 )
+		{
+		return EFalse;
+		}
+	//if it's neither false nor true, leave
+	User::Leave(KErrArgument);
+	return EFalse;
+	}
+
+
+EXPORT_C TBool Input::GetExpectedResultL(const TDesC& aResult /* in */, TInt &aError /* out */)
+	{
+	TBool result;
+	CErrorConverter *errorConverter = CErrorConverter::NewLC();
+
+	result = errorConverter->GetExpectedResultL(aResult, aError);
+	CleanupStack::PopAndDestroy(errorConverter);
+	
+	return(result);
+	}
+
+
+EXPORT_C TBool Input::GetExpectedResultL(const TInt &aError /* in */, HBufC*& aResult /* out */)
+	{
+	TBool result;
+	CErrorConverter *errorConverter = CErrorConverter::NewLC();
+
+	result = errorConverter->GetExpectedResultL(aError, aResult);
+	CleanupStack::PopAndDestroy(errorConverter);
+	
+	return(result);
+	}
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C void Input::ParseElementL(HBufC*& aMember,
+								   const TDesC& aBuf, 
+								   const TDesC& aStart)
+	{
+	TInt pos = 0;
+	ParseElementL(aMember, aBuf, aStart, pos);
+	};
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C void Input::ParseElementL(HBufC8*& aMember,
+								   const TDesC& aBuf, 
+								   const TDesC& aStart)
+	{
+	TInt pos = 0;
+	ParseElementL(aMember, aBuf, aStart, pos);
+	};
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C void Input::ParseElementL(HBufC*& aMember,
+								   const TDesC& aBuf, 
+								   const TDesC& aStart,
+								   TInt& aPos)
+	{
+	TInt error = KErrNone;
+	ParseElementL(aMember, aBuf, aStart, aPos, error);
+	};
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C void Input::ParseElementL(HBufC8*& aMember,
+								   const TDesC& aBuf, 
+								   const TDesC& aStart,
+								   TInt& aPos)
+	{
+	TInt error = KErrNone;
+	ParseElementL(aMember, aBuf, aStart, aPos, error);
+	};
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C void Input::ParseElementL(HBufC*& aMember,
+								   const TDesC& aBuf, 
+								   const TDesC& aStart,
+								   TInt& aPos,
+								   TInt& aError)
+	{
+	__ASSERT_DEBUG(!aMember, User::Panic(_L("Input"), 1));
+
+
+	TPtrC value = ParseElement(aBuf, aStart, aPos, aError);
+	// copy file name to unicode buffer
+	aMember = HBufC::NewL(value.Length());
+	aMember->Des().Copy(value);
+	}
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C void Input::ParseElementL(HBufC8*& aMember,
+								   const TDesC& aBuf, 
+								   const TDesC& aStart,
+								   TInt& aPos,
+								   TInt& aError)
+	{
+	__ASSERT_DEBUG(!aMember, User::Panic(_L("Input"), 1));
+
+
+	TPtrC value = ParseElement(aBuf, aStart, aPos, aError);
+	// copy file name to narrow buffer
+	aMember = HBufC8::NewL(value.Length());
+	aMember->Des().Copy(value);
+	}
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart)
+	{
+	TInt pos = 0;
+	return(ParseElement(aBuf, aStart, pos));
+	};
+
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos)
+	{
+	TInt error = KErrNone;
+	return(ParseElement(aBuf, aStart, aPos, error));
+	};
+
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos, TInt& aError)
+	{
+	// using the start tag <abcd> create a matching tag terminator <\abcd>
+	HBufC* hend = HBufC::NewMaxLC(aStart.Length()+1);	
+
+	TPtr end = hend->Des();
+	end = aStart; // copy in start tag
+	end.Insert(1,_L("/"));  // make it into a terminator tag with same element name
+	// get value from element
+	TPtrC value = Input::ParseElement(aBuf, aStart, end, aPos, aError);
+
+	CleanupStack::PopAndDestroy(hend);
+	return(value);
+	}
+
+EXPORT_C HBufC8* Input::ReadFileL(const TDesC& aFilename, RFs& aFs)
+	{
+	HBufC8* ret = ReadFileLC(aFilename, aFs);
+	CleanupStack::Pop();
+	return ret;
+	}
+
+EXPORT_C HBufC8* Input::ReadFileL(const TDesC& aFilename, const TDesC& aPath, RFs& aFs)
+	{
+	HBufC8* ret = ReadFileLC(aFilename, aPath, aFs);
+	CleanupStack::Pop();
+	return ret;
+	}
+
+EXPORT_C HBufC8* Input::ReadFileLC(const TDesC& aFilename, RFs& aFs)
+	{
+	RFile file;
+	User::LeaveIfError(file.Open(aFs, aFilename, EFileRead));
+	CleanupClosePushL(file);
+	TInt size;
+	file.Size(size);
+	CleanupStack::PopAndDestroy();//fileClose
+
+	HBufC8* res = HBufC8::NewLC(size);
+	TPtr8 p(res->Des());
+	p.SetLength(size);
+
+	RFileReadStream stream;
+	User::LeaveIfError(stream.Open(aFs, aFilename, EFileStream));
+	CleanupClosePushL(stream);
+	stream.ReadL(p, size);
+	CleanupStack::PopAndDestroy();//streamClose
+	return res;
+	}
+
+EXPORT_C HBufC8* Input::ReadFileLC(const TDesC& aFilename, const TDesC& aPath, RFs& aFS)
+	{
+	TFileName fullname;
+	fullname.Append(aPath);
+	fullname.Append(aFilename);
+
+	RFile file;
+	User::LeaveIfError(file.Open(aFS, fullname, EFileRead));
+	CleanupClosePushL(file);
+	TInt size;
+	file.Size(size);
+	CleanupStack::PopAndDestroy();//fileClose
+
+	HBufC8* res = HBufC8::NewLC(size);
+	TPtr8 p(res->Des());
+	p.SetLength(size);
+
+	RFileReadStream stream;
+	User::LeaveIfError(stream.Open(aFS, fullname, EFileStream));
+	CleanupClosePushL(stream);
+	stream.ReadL(p, size);
+	CleanupStack::PopAndDestroy();//streamClose
+	return res;
+	}
+
+EXPORT_C void Input::ParseElementListL(const TDesC& aBuf, 
+									   const TDesC& aStart,
+									   const TDesC& aEnd, 
+									   RPointerArray<HBufC>& aElements,
+									   TInt& aPos)
+	{
+	TPtrC currentElement = ParseElement(aBuf, aStart, aEnd, aPos);
+	while (currentElement != KNullDesC)
+		{
+		HBufC* newElement = HBufC::NewL(currentElement.Size());
+		*newElement = currentElement;
+		User::LeaveIfError(aElements.Append(newElement));
+		currentElement.Set(ParseElement(aBuf, aStart, aEnd, aPos));
+		}
+	}
+
+EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, const TDesC8& aStart, const TDesC8& aEnd)
+	{
+	TInt pos  = 0;
+	return Input::ParseIntElement(aBuf, aStart, aEnd, pos);
+	}
+
+
+EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, 
+										const TDesC8& aStart, 
+										const TDesC8& aEnd, 
+										TInt& aPos)
+	{
+	TInt err = KErrNone;
+	return Input::ParseIntElement(aBuf, aStart, aEnd, aPos, err);
+	}
+
+
+EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, 
+									const TDesC8& aStart,
+									const TDesC8& aEnd, 
+									TInt& aPos,
+									TInt& aError)
+	{
+	aError = KErrNone;
+	TPtrC8 temp = ParseElement(aBuf, aStart, aEnd, aPos, aError);
+
+	TUint result = 0;
+
+	if(aError == KErrNone)
+		{
+		TLex8 lex;
+		if(temp.Left(2) == _L8("0x"))
+			{
+			lex = temp.Mid(2);
+			aError = lex.Val(result, EHex);
+			}
+		else
+			{
+			lex = temp;
+			aError = lex.Val(result);
+			};
+		
+		if(aError == KErrNone)
+			{
+			if(!lex.Eos())
+				{
+				aError = KErrArgument;
+				result = 0;
+				};
+			};
+		};
+	return(result);
+	}
+
+EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, const TDesC16& aStart, const TDesC16& aEnd)
+	{
+	TInt pos  = 0;
+	return Input::ParseIntElement(aBuf, aStart, aEnd, pos);
+	}
+
+
+EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, 
+										const TDesC16& aStart, 
+										const TDesC16& aEnd, 
+										TInt& aPos)
+	{
+	TInt err = KErrNone;
+	return Input::ParseIntElement(aBuf, aStart, aEnd, aPos, err);
+	}
+
+
+EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, 
+									const TDesC16& aStart,
+									const TDesC16& aEnd, 
+									TInt& aPos,
+									TInt& aError)
+	{
+	aError = KErrNone;
+	TPtrC16 temp = ParseElement(aBuf, aStart, aEnd, aPos, aError);
+
+	TUint result = 0;
+
+	if(aError == KErrNone)
+		{
+		TLex16 lex;
+		if(temp.Left(2) == _L16("0x"))
+			{
+			lex = temp.Mid(2);
+			aError = lex.Val(result, EHex);
+			}
+		else
+			{
+			lex = temp;
+			aError = lex.Val(result);
+			};
+		
+		if(aError == KErrNone)
+			{
+			if(!lex.Eos())
+				{
+				aError = KErrArgument;
+				result = 0;
+				};
+			};
+		};
+	return(result);
+	}
+
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart)
+	{
+	TInt pos = 0;
+	return(ParseIntElement(aBuf, aStart, pos));
+	};
+
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos)
+	{
+	TInt error = KErrNone;
+	return(ParseIntElement(aBuf, aStart, aPos, error));
+	};
+
+
+// Allocate memory on the heap and copy in the value of a tagged element
+EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos, TInt& aError)
+	{
+	// get value from element
+	TPtrC temp = Input::ParseElement(aBuf, aStart, aPos, aError);
+	TUint result = 0;
+
+	if(aError == KErrNone)
+		{
+		TLex16 lex;
+		if(temp.Left(2) == _L16("0x"))
+			{
+			lex = temp.Mid(2);
+			aError = lex.Val(result, EHex);
+			}
+		else
+			{
+			lex = temp;
+			aError = lex.Val(result);
+			};
+		
+		if(aError == KErrNone)
+			{
+			if(!lex.Eos())
+				{
+				aError = KErrArgument;
+				result = 0;
+				};
+			};
+		};
+
+	return(result);	
+	}