--- 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);
+ }