FCL/sf/app/organizer: comparison pimappsupport/vcardandvcal/src/VERSIT.CPP

equal deleted inserted replaced

--1:000000000000
+:f979ecb2b13e
+// 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 "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 <versit.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <versitlinereaderext.h>
+#include "versittlscontainer.h"
+#include "versit_internal.h"
+#endif
+// System includes
+#include <s32file.h>
+#include <s32mem.h>
+#include <utf.h>
+#include <charconv.h>
+#include <confndr.h>
+#include <concnf.h>
+#include <conlist.h>
+#include <e32base.h>
+// User includes
+#include <vutil.h>
+#include <vstaticutils.h>
+#include <versittls.h>
+#include "verror.h"
+#include <vobserv.h>
+#include <vcal.h>
+#include "VersitAdditionalStorage.h"
+// Constants
+_LIT8(KReplacementChars, "?");
+const TInt KVersitDatePropertySymbianConnectMessageMaximumLenght=1;
+#define UNUSED_VAR(a) a = a
+//
+// CLineReader
+//
+EXPORT_C CLineReader* CLineReader::NewL(RReadStream& aStream)
+/** Constructs and returns a CLineReader.
+@param aStream The stream to read the lines from. */
+	{
+	CLineReader* self=new(ELeave) CLineReader(aStream);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+EXPORT_C void CLineReader::ConstructL()
+	{
+	iSkipWhiteSpaceAtStart=ETrue;
+	iLineBuf=HBufC8::NewL(EInitialLineSize);
+	iBufPtr=iLineBuf->Des();
+#if defined(__VC32__)
+	iBufPtr.Set(iLineBuf->Des());    // workaround for VC6 bug
+#endif
+	iExtension=CLineReaderExtension::NewL();
+	}
+EXPORT_C CLineReader::~CLineReader()
+/** Frees all resources owned by the line reader prior to its destruction. */
+	{
+	delete iLineBuf;
+	if (iExtension && iReadStream)
+		{
+		if (iExtension->iSize - iExtension->iOffset > 0)
+			{
+			// there is data in the buffer that has not yet been parsed
+			// so we must adjust the seek pointer for the input stream to
+			// point exactly to the end of the data that has been parsed
+			// so that the rest will be re-read when the file is next accessed.
+			// The traps are neccesary because a destructor can't leave.
+			MStreamBuf* source = iReadStream->Source();
+			if (source != NULL)
+				{
+				TStreamPos pos(0);
+				TRAPD(err, pos = source->TellL(MStreamBuf::ERead));
+				if (err == KErrNone)
+					{
+					pos -= (iExtension->iSize - iExtension->iOffset);
+					TRAP(err, source->SeekL(MStreamBuf::ERead, pos));
+					}
+				}
+			}
+		}
+	delete iExtension;
+	}
+/** Read base64 multiple lines
+This should be only called when parsing multi-line base64 data, and the interface
+MVersitPlugInExtensionBase64Ending::BlankLineAndLeadingSpaceNotRequired returns ETrue
+If the character ':' is not contained in the current line,we know it is base64 value.It is therefore appended to
+iBufPtr. Otherwise we know it is a new property which will be held in CLineReaderExtension::iLineBase64Value
+temporarily until the next propery is to be parsed.
+@param aPosValueStart The position in the iLineBuffer where base64 value starts
+*/
+void CLineReader::ReadBase64ValueL(TInt aPosValueStart)
+	{
+	HBufC8* base64Buffer = iExtension->CreateBase64ValueBufferL();//Creat a buffer to hold a
+	iBufPtr.Delete(0, aPosValueStart);//To make sure iBufPtr only contains base64 value
+	TInt err = KErrNone;
+	TInt ret = ELineIsWhiteSpace;
+	TPtr8 ptr = base64Buffer->Des();
+	while (ret != ELineHasColon)
+		{
+		__ASSERT_DEBUG(ret==ELineHasContent ||ret==ELineIsWhiteSpace||ret==ELineIsCRLFOnly, Panic(ECurrentTokenNotFound));
+		if (ret == ELineHasContent)
+			{
+			iLineBuf = iLineBuf->ReAllocL(iLineBuf->Length() + ptr.Length());
+			iBufPtr.Set(iLineBuf->Des());
+			iBufPtr.Append(ptr);
+			}
+		ptr.SetLength(0);
+		ret = ReadLineL(base64Buffer, 0, err);
+		ptr.Set(base64Buffer->Des());
+		}
+	}
+/** Reads in a line from the stream.
+The line is stored in a buffer pointed to by iBufPtr. Data from the stream
+is appended to the buffer, starting at buffer position aPos, until the next
+'CRLF' ("/r/n") is reached. The line feed and carriage return are not added
+to the buffer. Using only linefeeds LF(\n) as the line delimiters is also supported.
+The buffer will be expanded if necessary to fit the line into it.
+If the end of stream is reached, aErr will contain KErrEof upon return.
+It would be normal to set aPos to the start of the buffer unless reading a
+multi-line value.
+@param aPos The position in the buffer pointed to by iBufPtr at which to begin
+appending data to the buffer. Allows lines to be appended to the buffer when
+reading multi-line values.
+@param aErr On return, this will be KErrEof if the end of the stream is reached
+and KErrNone otherwise.
+@return ELineHasContent if the line has content; ELineIsWhiteSpace if the line
+has only white space before the CRLF; ELineIsCRLFOnly if the line is only
+a CRLF.
+*/
+EXPORT_C TInt CLineReader::ReadLineL(TInt aPos,TInt& aErr)
+	{
+	TInt ret = ELineHasContent;
+	HBufC8* base64Buffer = iExtension->Base64ValueBuffer();
+	if(aPos==0 && base64Buffer && base64Buffer->Length()>0)
+		{//If the base64Buffer is not empty, we know the current line has
+		// already been read and the data is held in CLineReaderExtension::iLineBase64Value
+		// for a new property (see ReadBase64ValueL)
+		if(iBufPtr.MaxLength() < base64Buffer->Length())
+			{
+			iLineBuf = iLineBuf->ReAllocL(base64Buffer->Length());
+			}
+		*iLineBuf = *base64Buffer;
+		iBufPtr.Set(iLineBuf->Des());
+		iBufPtr.SetLength(base64Buffer->Length());
+		iExtension->DeleteBase64ValueBuffer();
+		}
+	else //Otherwise read the current line
+		{
+		ret = ReadLineL(iLineBuf, aPos, aErr);
+		if(ret == ELineHasColon)
+			{
+			ret = ELineHasContent;//For the sake of backwards compatability - ELineHasColon is only used by ReadBase64ValueL.
+			}
+		iBufPtr.Set(iLineBuf->Des());
+		}
+	return ret;
+	}
+TInt CLineReader::ReadLineL(HBufC8*& aHBuf, TInt aPos,TInt& aErr)
+/** Reads in a line from the stream.
+The line is stored in a buffer pointed to by aHBuf. Data from the stream
+is appended to the buffer, starting at buffer position aPos, until the next
+'CRLF' ("/r/n") is reached. The line feed and carriage return are not added
+to the buffer. Using only linefeeds LF(\n) as the line delimiters is also supported.
+The buffer will be expanded if necessary to fit the line into it.
+If the end of stream is reached, aErr will contain KErrEof upon return.
+It would be normal to set aPos to the start of the buffer unless reading a
+multi-line value.
+@param aPos The position in the buffer pointed to by aHBuf at which to begin
+appending data to the buffer. Allows lines to be appended to the buffer when
+reading multi-line values.
+@param aErr On return, this will be KErrEof if the end of the stream is reached
+and KErrNone otherwise.
+@return
+ELineHasContent if the line has content;
+ELineIsWhiteSpace if the line has only white space before the CRLF;
+ELineIsCRLFOnly if the line is only a CRLF.
+EELineHasColon If character ':' contained in the line
+*/
+	{
+	TInt crPos=-1;
+	TUint8 ch=STATIC_CAST(TUint8,iFirstCharNextLine);
+	TInt whiteSpaceLine=ELineIsCRLFOnly;
+	TBool truncateLine=ETrue;
+	TBool skipWhiteSpaceAtStart=iSkipWhiteSpaceAtStart;
+	TPtr8 ptrHbuf = aHBuf->Des();
+	ptrHbuf.SetLength(aPos);
+	if (iFirstCharNextLine>=0)
+		{
+		iFirstCharNextLine=-1;
+		goto CharacterRead;
+		}
+	FOREVER
+		{
+		ch=ReadChar(aErr);
+		if (aErr!=KErrEof)
+			User::LeaveIfError(aErr);
+		else
+			{
+			crPos=aPos-1;
+			while (crPos>=0 && (ptrHbuf[crPos]==CVersitParser::ELineFeed || ptrHbuf[crPos]==CVersitParser::ECarriageReturn))
+				{
+				--crPos;
+				}
+			truncateLine=(++crPos<aPos);
+			break;
+			}
+	CharacterRead:
+		if (ch==CVersitParser::ECarriageReturn)
+			{
+			if (crPos<0)
+				crPos=aPos;
+			skipWhiteSpaceAtStart=EFalse;
+			// next character should be a LF...
+			}
+		else if (ch==CVersitParser::ELineFeed)
+			{
+			if (crPos<0)
+				{
+				// LF without CR
+				crPos=aPos;
+				skipWhiteSpaceAtStart=EFalse;
+				}
+			break; // The end of a line.
+			}
+		else
+			{
+			crPos=-1;
+			if (whiteSpaceLine == ELineIsWhiteSpace || whiteSpaceLine == ELineIsCRLFOnly )
+				{
+				whiteSpaceLine=(VersitUtils::IsWhiteSpace(ch) ? ELineIsWhiteSpace:ELineHasContent);
+				if (!whiteSpaceLine)
+					skipWhiteSpaceAtStart=EFalse;
+				}
+			if (ch == CVersitParser::EColon)
+				{
+				whiteSpaceLine = ELineHasColon;
+				}
+			}
+		if (skipWhiteSpaceAtStart)
+			{
+			if (iPlugIn)
+				skipWhiteSpaceAtStart=iPlugIn->DeleteAllSpaces();
+			}
+		else
+			{
+			if (aPos==ptrHbuf.MaxLength())
+				{
+				aHBuf=aHBuf->ReAllocL(aPos+EExpandSize);
+				ptrHbuf.Set(aHBuf->Des());
+				}
+			++aPos;
+			ptrHbuf.Append(ch);
+			}
+		}
+	if (truncateLine)
+		ptrHbuf.SetLength(crPos);
+	return whiteSpaceLine;
+	}
+EXPORT_C TBool CLineReader::AppendLineIfSpaceNextL()
+/** Checks the first character of the next line and, if it is a white space, reads
+the next line into the buffer (pointed to by iBufPtr).
+The line is appended to the buffer rather than overwriting data already in
+the buffer.
+A plug-in option can determine that no space is to be written to the buffer
+between the lines. By default, a space will be written.
+Used by the Versit parser while it is reading multi-line property values.
+@return ETrue if a line was read (because the first character of the next
+line is a space); EFalse if a line wasn't read (because the first character
+of the next line isn't a space or an error occured). */
+	{
+	TInt err=KErrNone;
+	if (iFirstCharNextLine<0)
+		iFirstCharNextLine=ReadChar(err);
+	if (err!=KErrNone || !VersitUtils::IsWhiteSpace(iFirstCharNextLine))
+		return EFalse;
+	TInt len;
+	if (iPlugIn && !iPlugIn->AddSpace())
+		len=iBufPtr.Length();
+	else
+		len=AppendSpaceL();
+	ReadLineL(len,err);
+	return ETrue;
+	}
+EXPORT_C TBool CLineReader::IsSpaceNextL()
+/** Checks to see if the first character of the next line is white space.
+This function should not be called more than once without a line being read
+in.
+Used by the Versit parser while it is reading multi-line property values.
+@return ETrue if the next line starts with a white space character; EFalse
+if it doesn't or an error occurs. */
+	{
+	TInt err;
+	iFirstCharNextLine=ReadChar(err);
+	return (err==KErrNone && VersitUtils::IsWhiteSpace(iFirstCharNextLine));
+	}
+EXPORT_C TInt CLineReader::AppendSpaceL()
+/** Appends a space to the end of the buffer (pointed to by iBufPtr).
+The buffer will be expanded if necessary.
+This is called by AppendLineIfSpaceNextL() to create a space in the buffer
+between the lines being read (as long as there is no plug-in option to to
+indicate there should be no space).
+@param The length of the buffer after the space has been added. */
+	{
+	TInt len=iBufPtr.Length();
+	if (len==iBufPtr.MaxLength())
+		ExpandBufferL(len);
+	iBufPtr.Append(CVersitParser::ESpace);
+	return len+1;
+	}
+EXPORT_C void CLineReader::ExpandBufferL(TInt aCurrentSize)
+	{
+	iLineBuf=iLineBuf->ReAllocL(aCurrentSize+EExpandSize);
+	iBufPtr.Set(iLineBuf->Des());
+	}
+EXPORT_C TUint8 CLineReader::ReadChar(TInt& aErr)
+	{
+	// Return the next character from the read buffer. If it is the
+	// end of the buffer or it is empty then refill the buffer.
+	aErr = KErrNone;
+	if (iExtension->iOffset >= iExtension->iSize)
+		{
+		iExtension->iOffset = 0;
+		MStreamBuf* source = iReadStream->Source();
+		TRAP(aErr, iExtension->iSize = source->ReadL(iExtension->iBuf, 1024));
+		if (aErr != KErrNone)
+			{
+			return 0;
+			}
+		if (iExtension->iSize == 0)
+			{
+			aErr = KErrEof;
+			return 0;
+			}
+		}
+	return iExtension->iBuf[iExtension->iOffset++];
+	}
+EXPORT_C void CLineReader::Reserved()
+	{}
+//
+// CVersitParser
+//
+EXPORT_C CVersitParser::CVersitParser(TUint aFlags) : iFlags(aFlags)
+/** The first phase constructor for a Versit parser.
+Sets the default encoding to Versit::ENoEncoding and the default character
+set to Versit::EUSAsciiCharSet.
+Note: this function is called by the CParserVCal and CParserVCard constructors. It
+should only be called directly by a user if creating a new parser
+@param aFlags The flag to indicate whether this entity needs a version property.
+The possible values for this flag are given in the TVersitParserFlags enumeration.
+If a version property is needed, one will be created and appended to the
+start of the array of properties. */
+	{
+	SetDefaultEncoding(Versit::ENoEncoding);
+	SetDefaultCharSet(Versit::EUSAsciiCharSet);
+	RestoreLineCodingDetailsToDefault();
+	}
+void CloseTlsData(TAny *aData)
+	{
+	CVersitTlsData *data = static_cast<CVersitTlsData *>(aData);
+	data->CloseVersitTlsData();
+	}
+EXPORT_C void CVersitParser::ConstructL()
+/** The second phase constructor for a Versit parser.
+Stores a pointer to a CVersitTlsData (thread local storage data class). This
+is used to allow an instance of CVersitUnicodeUtils to be shared by all co-existing
+parsers, which provides a major performance improvement.
+Called by the CParserVCal and CParserVCard constructors.
+Should only be called directly by a user if creating a new parser. */
+	{
+	_LIT8(KEscapeCharacter8, "\\");
+	iStaticUtils=&CVersitTlsData::VersitTlsDataL();
+	//query charconv for the plugin dependant shift-jis escape character,
+	//store in TLS to be accessed by versit static utils
+	CCnvCharacterSetConverter::TAvailability avail=UnicodeUtils().SetCurrentCharSetL(KCharacterSetIdentifierShiftJis);
+	if (avail == CCnvCharacterSetConverter::EAvailable)
+		{
+		// Do the conversion
+		CCnvCharacterSetConverter& converter=UnicodeUtils().CharacterSetConverter();
+		TInt ignore = 0;
+		converter.SetReplacementForUnconvertibleUnicodeCharactersL(KReplacementChars);
+		CVersitTlsData& data = CVersitTlsData::VersitTlsDataL();
+		CleanupStack::PushL( TCleanupItem( CloseTlsData, &data ) );
+		CVersitAdditionalStorage& additionalStorage = data.AdditionalStorage();
+		CBase* storedValue = additionalStorage.FromStorage(KTLSVars);
+		if( NULL == storedValue )
+			{
+			CVersitTLSContainer *tlsContainer = CVersitTLSContainer::NewLC(2);
+			TPtrC8 ptr8 = KEscapeCharacter8();
+			TPtr ptr16( tlsContainer->iShiftJisEscape->Des() );
+			converter.ConvertToUnicode(ptr16, ptr8, ignore);
+			additionalStorage.AddToStorageL(KTLSVars, tlsContainer);
+			CleanupStack::Pop( tlsContainer );
+			}
+		CleanupStack::PopAndDestroy();//data
+		}
+	}
+EXPORT_C CVersitParser::~CVersitParser()
+// Note: CVersitParser never owns iReadStream/iWriteStream
+/** Frees all resources owned by the object, prior to its destruction. */
+	{
+	if (iArrayOfEntities)
+		{
+		iArrayOfEntities->ResetAndDestroy();
+		delete iArrayOfEntities;
+		}
+	if (iArrayOfProperties)
+		{
+		iArrayOfProperties->ResetAndDestroy();
+		delete iArrayOfProperties;
+		}
+	delete iCurrentProperty;
+	delete iEntityName;
+	delete iOwnedLineReader;
+	delete iLargeDataBuf;
+	delete iDecodedValue;
+	// Close any TLS storage
+	if (iStaticUtils)
+		iStaticUtils->VersitTlsDataClose();
+	}
+EXPORT_C void CVersitParser::InternalizeL(RFile& aInputFile,TInt& aBytesThroughFile)
+/** Internalises a versit entity (vCard or vCalendar) and all of its
+sub-entities and properties from a file.
+Stores all date/time in same format as received
+@param aInputFile  The file from which to internalise the entity.
+@param aBytesThroughFile The number of bytes into the file at which to begin
+reading. On return, is updated to contain the last position in the file which
+was read.
+@leave KErrEof The file position specified is beyond the end of the file. */
+	{
+	TInt size;
+	if (aInputFile.Size(size)==KErrNone)
+		{
+		RFileReadStream stream(aInputFile,aBytesThroughFile);
+		TInt size=stream.Source()->SizeL();
+		TRAPD(err,InternalizeL(stream));
+		if (err==KErrNone)
+			TRAP(err,aBytesThroughFile+=(size-stream.Source()->SizeL()));
+		STATIC_CAST(RFileBuf*,stream.Source())->Reset();
+		stream.Close();
+		User::LeaveIfError(err);
+		}
+	}
+EXPORT_C void CVersitParser::InternalizeL(RReadStream& aStream)
+/** Internalises a Versit entity (vCard or vCalendar) contained in the incoming stream
+and parses it, breaking it down into its constituent sub-entities (e.g. to-dos,
+events, and nested vCards) and properties.
+The presence of this function means that the standard templated operator>>()
+(defined in s32strm.h) is available to internalise objects of this class.
+This virtual function serves as a base function for derived classes to internalise an entity.
+@param aStream Stream from which the vCalendar should be internalised. */
+	{
+	iOwnedLineReader=CLineReader::NewL(aStream);
+	iOwnedLineReader->SetPlugIn(iPlugIn);
+	iLineReader=iOwnedLineReader;
+	TRAPD(err,DoInternalizeL());
+	delete iDecodedValue;
+	iDecodedValue=NULL;
+	delete iOwnedLineReader;
+	iOwnedLineReader=NULL;
+	iLineReader=NULL;
+	User::LeaveIfError(err);
+	}
+void CVersitParser::DoInternalizeL()
+	{
+	iParseBegin = TRUE;
+	ParseBeginL();
+	iParseBegin = FALSE;
+	do
+		{
+		delete iCurrentProperty;
+		iCurrentProperty=NULL;
+		ParsePropertiesL();
+		} while(ParseEntityL());
+	ParseEndL();
+	}
+EXPORT_C void CVersitParser::InternalizeL(HBufC* aEntityName,CLineReader* aLineReader)
+/** Internalises a vCalendar or vCard sub-entity.
+(Assumes "BEGIN : <EntityName> CRLF" has been parsed).
+This virtual function serves as a base function for derived classes to parse a
+sub-entity.
+@param aEntityName The entity name to be parsed. Ownership of aEntityName is taken by
+the parser.
+@param aLineReader Pointer to a line reader which is used by the super-entity. */
+	{
+	iLineReader=aLineReader;
+	ParsePropertiesL();
+	ParseEndL(*aEntityName);
+	delete iEntityName;
+	iEntityName = aEntityName;
+	iLineReader=NULL;
+	delete iDecodedValue;
+	iDecodedValue=NULL;
+	}
+EXPORT_C void CVersitParser::ExternalizeL(RFile& aOutputFile)
+/** Externalises a Versit entity (vCard or vCalendar) and all of its sub-entities
+and properties to a file.
+Adds a version property to the start of the current entity's array of properties
+if the entity supports this.
+This is a thin layer over the CVersitParser::ExternalizeL(RWriteStream& aStream)
+function to enable a versit entity to be externalised into an RFile.
+@param aOutputFile The file to which to write the entity. */
+	{
+	RFileWriteStream stream(aOutputFile);
+	CleanupClosePushL(stream);
+	ExternalizeL(stream);
+	CleanupStack::PopAndDestroy(&stream);
+	}
+EXPORT_C void CVersitParser::ExternalizeL(RWriteStream& aStream)
+/** Externalises a Versit entity (vCard or vCalendar) and all of its sub-entities
+and properties to a write stream.
+Adds a version property to the start of the current entity's array of properties
+if the entity supports this. (If there isn't an array of properties then one is made).
+The presence of this function means that the standard templated operator<<() (defined
+in s32strm.h) is available to externalise objects of this class.
+This virtual function serves as a base function for derived classes to externalise
+an entity.
+@param aStream Stream to which the entity should be externalised. */
+	{
+	iWriteStream=&aStream;
+	if (SupportsVersion())
+		{
+		if (!iArrayOfProperties)
+			iArrayOfProperties = new(ELeave)CArrayPtrFlat<CParserProperty>(5);
+		TUid uid = TUid::Uid(KVersitPropertyHBufCUid);
+		// get properties but don't take ownership of the elements of the array
+		CArrayPtr<CParserProperty>* properties = PropertyL(KVersitTokenVERSION, uid, EFalse);
+		if (properties)
+			delete properties;
+		else	//Need to add a version property
+			{
+			CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(iDefaultVersion);
+			value->SetPlugIn(iPlugIn);
+			CleanupStack::PushL(value);
+			CParserProperty* property = CParserProperty::NewL(*value, KVersitTokenVERSION, NULL);
+			CleanupStack::Pop(value);
+			CleanupStack::PushL(property);
+			iArrayOfProperties->InsertL(0,property);
+			CleanupStack::Pop(property);
+			}
+		}
+	AppendBeginL();
+	if (iArrayOfProperties)
+		{
+		TInt noOfProperties=iArrayOfProperties->Count();
+		for (TInt ii=0; ii<noOfProperties; ii++)
+			{
+			(*iArrayOfProperties)[ii]->ExternalizeL(aStream, this);
+			}
+		}
+	if (iArrayOfEntities)
+		{
+		const TInt noOfEntities = iArrayOfEntities->Count();
+		for (TInt ii=0; ii<noOfEntities; ii++)
+			{
+			// Ensure that the entities defaults match this parser's
+			CVersitParser& entity = *iArrayOfEntities->At(ii);
+			//
+			entity.SetDefaultCharSet(DefaultCharSet());
+			entity.SetDefaultEncoding(DefaultEncoding());
+			//
+			entity.ExternalizeL(aStream);
+			}
+		}
+	AppendEndL();
+	iWriteStream = NULL;
+	}
+/*void CVersitParser::AddTimeZonePropertyL()		//Function that may be useful one day
+	{
+	TLocale locale;
+	TTimeIntervalSeconds offSet(locale.UniversalTimeOffset());
+	CParserPropertyValue* timeZone=new(ELeave)CParserPropertyValueTimeZone(offSet);
+	CleanupStack::PushL(timeZone);
+	CParserProperty* property = CParserProperty::NewL(*timeZone,KVersitTokenTZ,NULL);
+	CleanupStack::Pop(timeZone);
+	CleanupStack::PushL(property);
+	iArrayOfProperties->InsertL(0,property);
+	CleanupStack::Pop(property);
+	}*/
+EXPORT_C void CVersitParser::AddPropertyL(CParserProperty* aProperty,TBool aInternalizing)
+/** Appends a property to the current entity's array of properties.
+This function may be used when building up a Versit parser object from
+a client application. It is not called internally.
+@param aProperty Pointer to the property to add to the entity.
+@param aInternalizing This parameter is used to distinguish between reading
+an entity from a stream or file (i.e. internalising), in which case the argument
+should have a value of ETrue, and building an entity "by hand" (e.g. creating
+a vCard in the Contacts application), in which case the argument should have
+a value of EFalse. */
+	{
+	if	(!aProperty)
+		return;
+	TUid tokenId=RecognizeToken(aProperty->Name());
+	CleanupStack::PushL(aProperty);
+	if ((tokenId.iUid==KVersitTokenUnknownUid) && aProperty->Name().CompareF(KVersitTokenATTACH)==0)
+		{
+		tokenId.iUid = KVersitPropertyBinaryUid;//In vCal standard, default value is binary
+		CParserParam* valueParam = aProperty->Param(KVersitTokenVALUE);
+		if (valueParam)
+			{
+			TPtrC8 pParameterValue(valueParam->Value());
+			if (pParameterValue.CompareF(KVersitTokenINLINE) && pParameterValue.CompareF(KVersitTokenBINARY))
+				{//If VALUE isn't specified as INLINE or BINARY, value is text type.
+				tokenId.iUid = KVersitPropertyHBufCUid;
+				}
+			}
+		}
+	aProperty->SetNameUid(tokenId);
+	if ((tokenId.iUid==KVersitTokenUnknownUid) && !aInternalizing)
+		{
+		//Do not prefix X-EPOC incase the property already has a prefix X- at the begining
+		if(aProperty->NameBuf()->Find(KVersitTokenXDash)!=0)
+			{
+			HBufC8*& name=aProperty->NameBuf();
+			HBufC8* newName=HBufC8::NewL(name->Length()+KVersitTokenXDashEPOC.iTypeLength);
+			TPtr8 ptr=newName->Des();
+			ptr=KVersitTokenXDashEPOC;
+			ptr+=*name;
+			delete name;
+			name=newName;
+			}
+		}
+	DoAddPropertyL(aProperty);
+	CleanupStack::Pop(aProperty);
+	}
+EXPORT_C void CVersitParser::DoAddPropertyL(CParserProperty* aProperty)
+	{
+	if	(!aProperty)
+		return;
+	if (!iArrayOfProperties)
+		iArrayOfProperties = new(ELeave)CArrayPtrFlat<CParserProperty>(5);
+	if (aProperty->Value())
+		aProperty->Value()->SetPlugIn(iPlugIn);
+	iArrayOfProperties->AppendL(aProperty);
+	}
+EXPORT_C void CVersitParser::AddEntityL(CVersitParser* aEntity)
+/** Adds a sub-entity (e.g. a to-do, event or a nested vCard) to the current entity.
+Sets the default encoding and character set to the default ones of the current
+Versit parser, then adds the entity to the array of entities owned by the
+parser.
+Note: This function may be used when building up a Versit parser object from
+a client application.
+Called by ParseEntityL().
+@param aEntity The entity to be added into the array of entities. Ownership
+of aEntity is taken at beginning of the function. */
+	{
+	CleanupStack::PushL(aEntity);
+	if	(!iArrayOfEntities)
+		iArrayOfEntities = new(ELeave)CArrayPtrFlat<CVersitParser>(5);
+	if	(aEntity)
+		{
+		// Ensure that the entity contains the same defaults as this parser
+		aEntity->SetDefaultCharSet(DefaultCharSet());
+		aEntity->SetDefaultEncoding(DefaultEncoding());
+		//
+		aEntity->SetLineCharacterSet(LineCharSet());
+		aEntity->SetLineEncoding(LineEncoding());
+		//
+		iArrayOfEntities->AppendL(aEntity);
+		}
+	CleanupStack::Pop(); //aEntity
+	}
+EXPORT_C CArrayPtr<CVersitParser>* CVersitParser::EntityL(const TDesC& aEntityName,TBool aTakeOwnership)
+/** Gets all sub-entities in the current entity, whose name matches the
+name specified.
+@param aEntityName The sub-entity name of interest, e.g. KVersitVarTokenVEVENT or
+KVersitVarTokenVTODO. All sub-entities which match this name are returned in the
+array of pointers.
+@param aTakeOwnership If ETrue, the calling code takes ownership of each matching
+sub-entity, in which case the sub-entities are deleted from the current object's
+array of entities. If EFalse, ownership remains with the Versit parser.
+@return An array of pointers to all sub-entities with the specified name.
+(Ownership is taken by the calling code). */
+	{
+	CArrayPtr<CVersitParser>* arrayOfNamedEntities = NULL;
+	if (iArrayOfEntities)
+		{
+		TInt entities=iArrayOfEntities->Count();
+		arrayOfNamedEntities=new(ELeave) CArrayPtrFlat<CVersitParser>(5);
+		//CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfEntities,arrayOfNamedEntities));
+		CleanupStack::PushL(arrayOfNamedEntities);
+		for (TInt ii=0; ii<entities; ii++)
+			{
+			if ((*iArrayOfEntities)[ii]->EntityName()==aEntityName)
+				{
+				arrayOfNamedEntities->AppendL((*iArrayOfEntities)[ii]);
+				}
+			}
+		CleanupStack::Pop(); //arrayOfNamedEntities
+		if (arrayOfNamedEntities->Count() == 0)
+			{
+			delete arrayOfNamedEntities;
+			arrayOfNamedEntities = NULL;
+			}
+		else if(aTakeOwnership)
+			{
+			for (TInt ii = entities-1; ii>=0; --ii)
+				{
+				if ((*iArrayOfEntities)[ii]->EntityName()==aEntityName)
+					{
+					iArrayOfEntities->Delete(ii);
+					} // if
+				} // for
+			} // else if
+		}
+	return arrayOfNamedEntities;
+	}
+EXPORT_C CArrayPtr<CVersitParser>* CVersitParser::ArrayOfEntities(TBool aTakeOwnership)
+/** Gets the current entity's array of sub-entities.
+Note: the current entity may be a top level entity, or may itself be a sub-entity.
+@param aTakeOwnership If ETrue, the calling code takes ownership of the array;
+the array of entities owned by the current entity is then deleted. If EFalse,
+ownership remains with the Versit parser.
+@return Array of pointers to the current entity's array of sub-entities. */
+	{
+	CArrayPtr<CVersitParser>* arrayOfEntities=iArrayOfEntities;
+	if (aTakeOwnership)
+		iArrayOfEntities=NULL;
+	return arrayOfEntities;
+	}
+EXPORT_C CArrayPtr<CParserProperty>* CVersitParser::PropertyL(const TDesC8& aPropertyName,const TUid& aPropertyUid,TBool aTakeOwnership) const
+/** Gets all properties in the current entity's array of properties whose name and
+value match the name and value specified.
+@param aPropertyName The property name of interest. Property names are defined
+in vtoken.h.
+@param aPropertyUid The ID of the property value of interest (which has the
+format "K<Versit/Card/Cal>Property<Type>Uid"). The values are defined in file vuid.h.
+@param aTakeOwnership If ETrue, the calling code takes ownership of each matching
+property; the property is then deleted from the current entity's array. If
+EFalse, ownership remains with the entity.
+@return An array of pointers to all properties with the name and value specified,
+or NULL if there are none. */
+	{
+	CArrayPtr<CParserProperty>* arrayOfNamedProperties = NULL;
+	if (iArrayOfProperties)
+		{
+		const TInt properties = iArrayOfProperties->Count();
+		arrayOfNamedProperties = new(ELeave) CArrayPtrFlat<CParserProperty>(5);
+		//CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfProperties, arrayOfNamedProperties));
+		CleanupStack::PushL(arrayOfNamedProperties);
+		CParserProperty* parserProperty = NULL;
+		for (TInt ii = 0; ii < properties; ++ii)
+			{
+			parserProperty = (*iArrayOfProperties)[ii];
+			if (parserProperty->Value() && parserProperty->Name().CompareF(aPropertyName)==0)
+				{
+				if(parserProperty->Value()->Uid()==aPropertyUid || aPropertyUid == KNullUid)
+					{
+					arrayOfNamedProperties->AppendL(parserProperty);
+					}
+				}
+			}
+		CleanupStack::Pop(arrayOfNamedProperties);
+		if (arrayOfNamedProperties->Count() == 0)
+			{
+			delete arrayOfNamedProperties;
+			arrayOfNamedProperties = NULL;
+			}
+		else if (aTakeOwnership)
+			{
+			for (TInt ii = properties-1; ii>=0; --ii)
+				{
+				parserProperty = (*iArrayOfProperties)[ii];
+				if (parserProperty->Name().CompareF(aPropertyName)==0)
+					{
+					if (parserProperty->Value()->Uid()==aPropertyUid || aPropertyUid == KNullUid)
+						{
+						iArrayOfProperties->Delete(ii);
+						}
+					}
+				}
+			}
+		}
+	return arrayOfNamedProperties;
+	}
+EXPORT_C CArrayPtr<CParserProperty>* CVersitParser::ArrayOfProperties(TBool aTakeOwnership)
+/** Gets the current entity's array of properties.
+@param aTakeOwnership If ETrue, the calling code takes ownership of the array;
+the entity's array of properties is then deleted . If EFalse, ownership
+remains with the entity.
+@return Array of pointers to the entity's properties. */
+	{
+	CArrayPtr<CParserProperty>* arrayOfProperties=iArrayOfProperties;
+	if (aTakeOwnership)
+		iArrayOfProperties=NULL;
+	return arrayOfProperties;
+	}
+EXPORT_C void CVersitParser::SetEntityNameL(const TDesC& aEntityName)
+/** Sets the name for the current entity to one of: VCARD, VCALENDAR, VEVENT or
+VTODO.
+@param aEntityName The new name for the current parser entity. Any existing
+name is first deleted.
+@leave KErrNoMemory Memory is allocated for the new entity name on the heap,
+so it can leave if there is insufficient memory available. */
+	{
+	delete iEntityName;
+	iEntityName = NULL;
+	iEntityName = aEntityName.AllocL();
+	}
+EXPORT_C TPtrC CVersitParser::EntityName() const
+/** Gets the current entity's name.
+If no name has been set, returns an empty descriptor.
+@return The current entity's name. */
+	{
+	if (iEntityName)
+		return iEntityName->Des();
+	return KVersitTokenEmpty();
+	}
+EXPORT_C TBool CVersitParser::IsValidLabel(const TDesC& aLabel, TInt& aPos)
+/** Tests whether a property name is valid.
+The property name is invalid if it contains any of the following characters:-
+[] (left or right square bracket)
+= (equals sign)
+: (colon)
+. (dot)
+, (comma)
+@param aLabel The property name to test.
+@param aPos On return, contains the character position within the property
+name of the first invalid character found.
+@return ETrue if valid, EFalse if invalid. */
+	{
+	return !(((aPos = aLabel.Locate(KVersitTokenLSquareBracketVal)) != KErrNotFound) ||
+		((aPos = aLabel.Locate(KVersitTokenRSquareBracketVal)) != KErrNotFound) ||
+		((aPos = aLabel.Locate(KVersitTokenEqualsVal)) != KErrNotFound) ||
+		((aPos = aLabel.Locate(KVersitTokenColonVal)) != KErrNotFound) ||
+		((aPos = aLabel.Locate(KVersitTokenPeriodVal)) != KErrNotFound) ||
+		((aPos = aLabel.Locate(KVersitTokenCommaVal)) != KErrNotFound));
+	}
+EXPORT_C CArrayPtr<CParserParam>* CVersitParser::ReadLineAndDecodeParamsLC(TInt& aValueStart,TInt& aNameLen)
+	{
+	//Read in line from stream skipping lines made up only of white space TChar
+	TInt err;
+	do
+		{
+		const TInt readLineResponse = iLineReader->ReadLineL(0,err);
+		if  (readLineResponse == CLineReader::ELineIsWhiteSpace || readLineResponse == CLineReader::ELineIsCRLFOnly)
+			{
+			aValueStart = 0;
+			}
+		else
+			{
+			TBool continueSearch;
+			do
+				{
+				continueSearch = EFalse;
+				aValueStart = BufPtr().Find(KVersitTokenColon) + 1;
+				if (aValueStart == 0)
+					{
+					continueSearch = iLineReader->AppendLineIfSpaceNextL();
+					}
+				}
+			while (continueSearch && aValueStart == 0);
+			}
+		}
+	while (aValueStart==0 && err!=KErrEof);
+	//
+	if (aValueStart==0)
+		User::Leave(err);
+	iFlags&=~ECharSetIdentified;
+	if(iFlags & EUseDefaultCharSetForAllProperties)
+		{
+		SetLineCharacterSet(DefaultCharSet());
+		iFlags|= ECharSetIdentified;
+		}
+	//Scan for semi-colon and split off params
+	CArrayPtr<CParserParam>* arrayOfParams=NULL;
+	aNameLen=BufPtr().Find(KVersitTokenSemiColon);		//First ";" can't be escaped
+	TInt lenParams=aValueStart-aNameLen-2;
+	if (aNameLen==KErrNotFound || lenParams<=0)
+		{
+		aNameLen=(lenParams==0&&aNameLen>=0 ? aNameLen:aValueStart-1);
+		CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfParams,arrayOfParams));
+		}
+	else
+		{
+		TPtr8 params(&BufPtr()[aNameLen+1],lenParams,lenParams);
+		arrayOfParams=GetPropertyParamsLC(params);
+		AnalysesEncodingCharset(arrayOfParams);
+		}
+	return arrayOfParams;
+	}
+EXPORT_C void CVersitParser::MakePropertyL(TPtr8& aPropName,TInt aValueStart)
+	{
+	VersitUtils::StripWhiteSpace(aPropName);
+	TUid propertyUid=RecognizeToken(aPropName);
+	iCurrentProperty->SetNameL(aPropName);
+	//Deal with the value
+	TInt lenValue=BufPtr().Length()-aValueStart;
+	TPtr8 propValue(NULL,0);
+	if (lenValue>0)
+		propValue.Set(&BufPtr()[aValueStart],lenValue,lenValue);
+	TBool beginOrEnd=VersitUtils::IsBeginOrEnd(propertyUid);
+	TBool readMultiLine=!beginOrEnd;
+	Versit::TVersitEncoding encoding=Versit::ENoEncoding;
+	if (!readMultiLine)
+		{
+		encoding=LineEncoding();
+		readMultiLine=(encoding==Versit::EBase64Encoding || encoding==Versit::EQuotedPrintableEncoding);
+		}
+	/**
+		Ignore junk lines between vCal entities.
+		Skip readMultiLine within ParseBegin.
+	*/
+	if (readMultiLine && !iParseBegin)
+		{
+		CParserParam* valueParam = iCurrentProperty->Param(KVersitTokenVALUE);
+		if (valueParam)
+			{
+			TPtrC8 pParameterValue(valueParam->Value());
+			if (!pParameterValue.CompareF(KVersitTokenINLINE))
+				{
+				encoding = Versit::EBase64Encoding;
+				}
+			}
+		TBool isBinary = ((propertyUid.iUid==KVersitPropertyBinaryUid) ||
+						  ((propertyUid.iUid==KVCalPropertyExtendedAlarmUid) && (encoding==Versit::EBase64Encoding)));
+		ReadMultiLineValueL(propValue, aValueStart, isBinary);
+		}
+	if (beginOrEnd)
+		{
+		VersitUtils::StripWhiteSpace(propValue);
+		if (encoding!=Versit::EBase64Encoding)
+			propValue.UpperCase();
+		}
+	iCurrentProperty->SetNameUid(propertyUid);
+	HBufC* valueBuf=DecodePropertyValueL(propValue);
+	CleanupStack::PushL(TCleanupItem(DestroyHBufC, &valueBuf));
+	if (iPlugIn && (valueBuf != NULL))
+		{
+		TPtr ptr(valueBuf->Des());
+	#if defined(__VC32__)    // workaround for VC6 bug
+		ptr.Set(valueBuf->Des());
+	#endif
+		iPlugIn->RemoveEscaping(ptr);
+		}
+	CParserPropertyValue* value = MakePropertyValueL(propertyUid,valueBuf);
+	delete iLargeDataBuf;
+	iLargeDataBuf=NULL;
+	iCurrentProperty->SetValue(value);
+	CleanupStack::PopAndDestroy(&valueBuf);
+	}
+EXPORT_C void CVersitParser::ParsePropertyL()
+	{
+	TInt valueStart;
+	TInt lenName;
+	CArrayPtr<CParserParam>* arrayOfParams=ReadLineAndDecodeParamsLC(valueStart,lenName);
+	delete iCurrentProperty;
+	iCurrentProperty=NULL;
+	iCurrentProperty=new(ELeave) CParserProperty(arrayOfParams);
+	CleanupStack::Pop(arrayOfParams);
+	if (lenName>0)
+		{
+		TPtr8 propName(&BufPtr()[0],lenName,lenName);
+		MakePropertyL(propName,valueStart);
+		}
+	}
+EXPORT_C void CVersitParser::ReadMultiLineValueL(TPtr8& aValue,TInt aValueStart,TBool aBinaryData)
+	{
+	if (iLargeDataBuf)
+		iLargeDataBuf->Reset();
+	Versit::TVersitEncoding encoding=LineEncoding();
+	TInt lineLen=BufPtr().Length();
+	TInt err;
+	TBool secondLine=ETrue;
+	__ASSERT_DEBUG(encoding!=Versit::EEightBitEncoding, Panic(EVersitPanicUnexpectedEightBitEncoding));
+	if (encoding!=Versit::EBase64Encoding)
+		{
+		if (encoding==Versit::EQuotedPrintableEncoding)
+			{
+			iLineReader->SetSkipWhiteSpaceAtStart(EFalse); // avoid space skiping for Quoted Printable encoding
+			}
+		TBool moreLinesToCome=ETrue;
+		if (encoding!=Versit::EQuotedPrintableEncoding)
+			moreLinesToCome=iLineReader->IsSpaceNextL();
+		while (moreLinesToCome && (BufPtr()[lineLen-1]==KVersitTokenEqualsVal || encoding!=Versit::EQuotedPrintableEncoding))
+			{
+			if (secondLine)
+				{
+				lineLen-=aValueStart;
+				BufPtr()=BufPtr().Mid(aValueStart,lineLen);
+				secondLine=EFalse;
+				}
+			if (encoding==Versit::EQuotedPrintableEncoding)
+				{
+				--lineLen;
+				moreLinesToCome=!iLineReader->ReadLineL(lineLen,err);
+				}
+			else if (lineLen==0)
+				{
+				iLineReader->ReadLineL(lineLen,err);
+				moreLinesToCome=iLineReader->IsSpaceNextL();
+				}
+			else
+				{
+				moreLinesToCome=iLineReader->AppendLineIfSpaceNextL();
+				}
+			lineLen=BufPtr().Length();
+			}
+		iLineReader->SetSkipWhiteSpaceAtStart(ETrue); //The SetSkipWhiteSpaceAtStart function as been added for a defect fixing this line ensure that every other code calling ReadLineL behave the same than before. Stephane Lenclud.
+		}
+	else		// encoding == Versit::EBase64Encoding
+		{
+		if (aBinaryData)
+			{
+			if (!iLargeDataBuf)
+				iLargeDataBuf=CBufSeg::NewL(128);
+			}
+		TInt bufLen=0;		//Initialise to stop warning "local variable may be used without having been initialized"
+		TBool moreLinesToCome=ETrue;
+		if (iPlugIn)
+			{
+			TAny* extPlugIn  = NULL;
+			iPlugIn->GetInterface(KUidVersitPluginExtensionBase64Termination, extPlugIn);
+			if (extPlugIn && static_cast<MVersitPlugInExtensionBase64Ending*>(extPlugIn)->BlankLineAndLeadingSpaceNotRequired())
+				{
+				iLineReader->ReadBase64ValueL(aValueStart);
+				if(aBinaryData)
+					{
+					iLargeDataBuf->InsertL(bufLen,BufPtr());
+					}
+				lineLen=BufPtr().Length();
+				moreLinesToCome = EFalse;
+				secondLine=EFalse;
+				}
+			}
+		while (moreLinesToCome)
+			{
+			if (secondLine)
+				{
+				lineLen-=aValueStart;
+				TPtrC8 data=BufPtr().Mid(aValueStart,lineLen);
+				if (aBinaryData)
+					{
+					iLargeDataBuf->InsertL(0,data);
+					bufLen=lineLen;
+					lineLen=0;
+					}
+				else
+					BufPtr()=data;
+				secondLine=EFalse;
+				}
+			if (iPlugIn && !iPlugIn->NeedsBlankLine())
+				{
+				moreLinesToCome=iLineReader->AppendLineIfSpaceNextL();
+				}
+			else
+				{
+				TPtrC8 lineData = BufPtr().Mid(0); //Grab a copy of last line, used to check if the end has been reached if only whitespace is present
+				TInt lineEval = iLineReader->ReadLineL(lineLen,err);
+				moreLinesToCome=(lineEval !=CLineReader::ELineIsCRLFOnly);
+				if (lineEval == CLineReader::ELineIsWhiteSpace)
+					{
+					//White space lines are not really part of the spec, however can be present
+					//through transmission errors. For the sake of robustness it is ignored, however if
+					//it is present after the last line instead of CRLF then it is a problem. We can check
+					//for the other delimiter mentioned in the spec to see if the last line has been reached
+					//by checking for the '=' character. This is not perfect as these are padding characters and
+					//will not be present if the length of the data is a multiple of 3 but as the data is not
+					//conformant with the spec then this is the best we can do to recover from the error
+					//which is present.
+					if ( lineData.LocateReverse('=') != KErrNotFound)
+						{
+						//Found an '=' so the end has been reached.
+						moreLinesToCome = EFalse;
+						}
+					}
+				}
+			if (aBinaryData)
+				{
+				iLargeDataBuf->InsertL(bufLen,BufPtr());
+				bufLen+=BufPtr().Length();
+				}
+			else
+				lineLen=BufPtr().Length();
+			}//while
+		if (!aBinaryData && lineLen==0)
+			{		//The bad ending, to the Base64 data, in other situations does not cause a crash
+			BufPtr().Append(KVersitLineBreak);
+			BufPtr().Append(KVersitTokenCRLF);
+			lineLen=BufPtr().Length();
+			}
+		}//base64
+	if (aBinaryData)
+		{
+		if (!iLargeDataBuf)
+			iLargeDataBuf=CBufSeg::NewL(128);
+		if (secondLine)
+			iLargeDataBuf->InsertL(0,aValue);
+		else if (encoding!=Versit::EBase64Encoding)
+			iLargeDataBuf->InsertL(0,BufPtr());
+		aValue.Set(NULL,0,0);
+		}
+	else
+		{
+		if (!secondLine && BufPtr().Length() > 0)
+			aValue.Set(&BufPtr()[0],lineLen,lineLen);
+		delete iLargeDataBuf;
+		iLargeDataBuf=NULL;
+		}
+	}
+//
+// Parsing
+//
+EXPORT_C void CVersitParser::ParseBeginL()
+// Parse start of entity (and extract iEntityName)
+	{
+	ParsePropertyL();
+	// Parse until token Begin or EOF is reached.
+	while (iCurrentProperty->NameUid().iUid!=KVersitTokenBeginUid)
+		{
+		delete iCurrentProperty;
+		iCurrentProperty=NULL;
+		ParsePropertyL();
+		}
+	delete iEntityName;
+	iEntityName=NULL;
+	iEntityName=STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->TakeValueOwnership();
+	}
+EXPORT_C void CVersitParser::ParseEndL()
+// Parse end of entity
+	{
+	ParseEndL(*iEntityName);
+	}
+void CVersitParser::ParseEndL(HBufC16& aEntityName)
+// Parse end of entity
+	{
+	if (iCurrentProperty->NameUid().iUid!=KVersitTokenEndUid)
+		{
+		User::Leave(KErrNotFound);
+		}
+	TBool result = (aEntityName==STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->Value());
+	delete iCurrentProperty;
+	iCurrentProperty=NULL;
+	if	(!result)
+		User::Leave(KErrNotFound);
+	}
+EXPORT_C TBool CVersitParser::ParseEntityL()
+//
+//	Parse next entity in stream, and add to iArrayOfEntities
+//
+	{
+	TBool entityWasFound = EFalse;
+	TInt32 uid=0;
+	if (iCurrentProperty)
+		uid=iCurrentProperty->NameUid().iUid;
+	if (uid==KVersitTokenBeginUid)
+		{
+		TInt uid = RecognizeEntityName();
+		HBufC* entityName=STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->TakeValueOwnership();
+		CleanupStack::PushL(entityName);
+		CVersitParser* entity = MakeEntityL(uid,entityName);
+		CleanupStack::Pop(entityName);
+		AddEntityL(entity);
+		entityWasFound = ETrue;
+		}
+	// Returns whether or not an entity was found
+	return entityWasFound;
+	}
+EXPORT_C void CVersitParser::ParsePropertiesL()
+//Parse all properties in stream
+	{
+#if defined(_DEBUG)
+	TInt propCount = 0;
+#endif
+	FOREVER
+		{
+#if defined(_DEBUG)
+		propCount++;
+#endif
+		// For every single property that is parsed, any decoding or character set conversion
+		// will use the default character set and encoding type set during the call to this
+		// class' constructor.
+		// To ensure (after a property is read) that the default is restored, a call to this
+		// method is made before each property is read.
+		RestoreLineCodingDetailsToDefault();
+		TRAPD(err, ParsePropertyL());
+		if (VersitUtils::CheckAndIgnoreCustomErrorL(err))
+			{
+			delete iCurrentProperty;
+			iCurrentProperty = NULL;
+			}
+		else
+			{
+			if (iCurrentProperty)
+				{
+				if (VersitUtils::IsBeginOrEnd(iCurrentProperty->NameUid()))
+					return;
+				DoAddPropertyL(iCurrentProperty);
+				if (iObserver && iCurrentProperty->Name()==KVersitTokenVERSION)
+					iObserver->VersionSet(this,STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->Value());
+				iCurrentProperty=NULL;
+				}
+			else
+				{
+				User::Leave(KErrEof);
+				}
+			}
+		}
+	}
+EXPORT_C void CVersitParser::ConvertAllPropertyDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight)
+/** Converts all date/time property values contained in the current entity's array
+of properties into machine local values.
+This conversion is needed because of differences in universal and local times
+due to time zones and daylight savings (seasonal time shifts).
+First, all of the date/times are converted to universal time, if they are
+not already:
+If daylight saving is in effect then the daylight savings rule (held in the
+aDaylight parameter) will be used to compensate for differences between universal
+and local times due to both time zones and the daylight saving. Otherwise,
+the aIncrement parameter is used to compensate for any difference due to time
+zones alone.
+Then, these universal time values are converted into machine local
+times by adding the universal time offset for the machine's locale.
+@param aIncrement A time interval in seconds which represents the negative
+of the time zone of the originating machine. For instance, if the time zone
+is +04:30, aIncrement should be set to -04:30.
+@param aDaylight Pointer to the specification for daylight saving. If the date/time
+value is within the period for daylight saving, the value is modified by the
+daylight saving offset (which accounts for both the time zone and daylight
+saving rule).
+@deprecated since 9.1
+*/
+	{
+	TUid uid;
+	uid.iUid = KVersitTimePropertyUid;
+	if (iArrayOfProperties)
+		{
+		CParserTimePropertyValue* timeValue;
+		TInt properties = iArrayOfProperties->Count();
+		for (TInt ii = 0; ii < properties; ii++)
+			{
+			CParserPropertyValue* value=(*iArrayOfProperties)[ii]->Value();
+			if (value && value->SupportsInterface(uid))
+				{
+				timeValue = STATIC_CAST(CParserTimePropertyValue*, value);
+				timeValue->ConvertAllDateTimesToUTCL(aIncrement, aDaylight);
+				}
+			}
+		TLocale locale;
+		TTimeIntervalSeconds localeIncrement(locale.UniversalTimeOffset());
+		if ((iFlags&EImportSyncML) && aDaylight && localeIncrement.Int()==-aIncrement.Int())	//If Importing from a SyncML Server and working in same time zone which has a daylight rule
+			ConvertAllUTCDateTimesToMachineLocalL(localeIncrement,aDaylight);
+		else
+			{
+			AdjustAllPropertyDateTimesToMachineLocalL();
+			}
+		}
+	}
+/*
+* Converts all date/time property values contained in the current
+* array of properties into machine local values.
+@deprecated since 9.1
+*/
+EXPORT_C void CVersitParser::AdjustAllPropertyDateTimesToMachineLocalL()
+	{
+	if (iArrayOfProperties)
+		{
+		TUid uid;
+		uid.iUid = KVersitTimePropertyUid;
+		TInt properties = iArrayOfProperties->Count();
+		CParserTimePropertyValue* timeValue;
+		TLocale locale;
+		TTimeIntervalSeconds localeIncrement(locale.UniversalTimeOffset());
+		for (TInt jj = 0; jj < properties; jj++)
+			{
+			CParserPropertyValue* value=(*iArrayOfProperties)[jj]->Value();
+			if (value && value->SupportsInterface(uid))
+				{
+				timeValue = STATIC_CAST(CParserTimePropertyValue*, value);
+				timeValue->ConvertAllUTCDateTimesToMachineLocalL(localeIncrement);
+				}
+			}
+		}
+	}
+void CVersitParser::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight)
+	{
+	CParserPropertyValue* value;
+	CParserTimePropertyValue* timeValue;
+	TInt properties=iArrayOfProperties->Count();
+	TUid uid;
+	uid.iUid = KVersitTimePropertyUid;
+	for (TInt jj = 0; jj < properties; jj++)
+		{
+		value=(*iArrayOfProperties)[jj]->Value();
+		if (value && value->SupportsInterface(uid))
+			{
+			timeValue = STATIC_CAST(CParserTimePropertyValue*, value);
+			switch (timeValue->Uid().iUid)
+				{
+			case KVCalPropertyAlarmUid:
+				{
+				CVersitAlarm* alarm=STATIC_CAST(CParserPropertyValueAlarm*,timeValue)->Value();
+				if (alarm && alarm->iRunTime)
+					ConvertUTCDateTimeToMachineLocal(alarm->iRunTime,aIncrement,aDaylight);
+				}
+				break;
+			case KVersitPropertyDateTimeUid:
+				{
+				TVersitDateTime* dateTime=STATIC_CAST(CParserPropertyValueDateTime*,timeValue)->Value();
+				if (dateTime)
+					ConvertUTCDateTimeToMachineLocal(dateTime,aIncrement,aDaylight);
+				}
+				break;
+			case KVersitPropertyMultiDateTimeUid:
+				{
+				CArrayPtr<TVersitDateTime>* values=STATIC_CAST(CParserPropertyValueMultiDateTime*,timeValue)->Value();
+				if (values)
+					{
+					TInt count=values->Count();
+					for (TInt ii=0;ii<count; ii++)
+						ConvertUTCDateTimeToMachineLocal((*values)[ii],aIncrement,aDaylight);
+					}
+				}
+				break;
+			default:
+				timeValue->ConvertAllUTCDateTimesToMachineLocalL(aIncrement);
+				}
+			}
+		}
+	}
+void CVersitParser::ConvertUTCDateTimeToMachineLocal(TVersitDateTime* aDateTime,const TTimeIntervalSeconds& aIncrement,const CVersitDaylight* aDaylight)
+	{
+	if (aDateTime && aDateTime->iRelativeTime==TVersitDateTime::EIsUTC)
+		{
+		CParserTimePropertyValue::ConvertDateTime(aDateTime->iDateTime,aIncrement,aDaylight,EFalse);
+		aDateTime->iRelativeTime=TVersitDateTime::EIsMachineLocal;
+		}
+	}
+//
+// Recognition
+//
+EXPORT_C TBool CVersitParser::IsValidParameterValue(TInt& aPos,const TDesC& aParamValue)
+/** Tests whether a property parameter name or value is valid.
+If the string aParamValue contains any punctuation characters, the string
+is invalid. Otherwise, it is valid. Punctuation characters are defined as
+any of the following:-
+[] (left or right square bracket)
+= (equals sign)
+: (colon)
+; (semi colon)
+. (dot)
+, (comma)
+@param aPos On return, contains the character position of the first invalid
+character in the property parameter name or value.
+@param aParamValue The property parameter name or value to test.
+@return ETrue if valid, EFalse if invalid. */
+	{
+	TInt length = aParamValue.Length();
+	for (aPos = 0; aPos < length; aPos++)
+		{
+		if (IsPunctuationToken(aParamValue[aPos]))
+			return EFalse;
+		}
+	return ETrue;
+	}
+EXPORT_C CArrayPtr<CParserParam>* CVersitParser::GetPropertyParamsLC(TPtr8 aParams)
+	{
+	CArrayPtr<CParserParam>* arrayOfParams=new(ELeave)CArrayPtrFlat<CParserParam>(5);
+	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfParams,arrayOfParams));
+	TUint8* currentChar=&aParams[0];
+	TUint8* dest;
+	TUint8* afterLastChar=currentChar+aParams.Length();
+	TUint8* startField;
+	TBool escaping;
+	TInt len;
+	while (currentChar<=afterLastChar)
+		{
+		startField=currentChar;
+		escaping=EFalse;
+		while (currentChar<afterLastChar && *currentChar!=KVersitTokenSemiColonVal && *currentChar!=KVersitTokenBackslashVal)
+			++currentChar;
+		dest=currentChar;
+		if (*currentChar==KVersitTokenBackslashVal && currentChar<afterLastChar)
+			{
+			do	{
+				if (!escaping)
+					{
+					if (*currentChar==KVersitTokenSemiColonVal)
+						break;
+					escaping=(*currentChar==KVersitTokenBackslashVal);
+					if (escaping)
+						{
+						++currentChar;
+						continue;
+						}
+					}
+				else
+					{
+					if (*currentChar!=KVersitTokenBackslashVal && *currentChar!=KVersitTokenSemiColonVal)
+						*dest++=KVersitTokenBackslashVal;
+					escaping=EFalse;
+					}
+				*dest++=*currentChar++;
+				} while(currentChar<afterLastChar);
+			if (escaping)
+				*dest++=KVersitTokenBackslashVal;
+			}
+		len=dest-startField;
+		if (len>0)
+			ParseParamL(arrayOfParams,TPtr8(startField,len,len));
+		++currentChar;
+		}
+	return arrayOfParams;
+	}
+EXPORT_C void CVersitParser::ParseParamL(CArrayPtr<CParserParam>* aArray,TPtr8 aParam)
+	{
+	TPtr8 paramName(aParam);
+	TPtr8 paramValue(NULL,0);
+	TInt equalsPos=aParam.Find(KVersitTokenEquals);
+	if (equalsPos>KErrNotFound)
+		{
+		paramName.Set(&aParam[0],equalsPos,equalsPos);
+		++equalsPos;
+		TInt valLen=aParam.Length()-equalsPos;
+			if (valLen>0)
+				{
+				paramValue.Set(&aParam[equalsPos],valLen,valLen);
+				VersitUtils::StripWhiteSpace(paramValue);
+			}
+		}
+	VersitUtils::StripWhiteSpace(paramName);
+	CParserParam* newParam = CParserParam::NewL(paramName, paramValue);
+	CleanupStack::PushL(newParam);
+	aArray->AppendL(newParam);
+	CleanupStack::Pop(newParam);
+	}
+EXPORT_C void CVersitParser::AnalysesEncodingCharset(CArrayPtr<CParserParam>* aArrayOfParams)
+//
+// This method checks each parameter in turn to establish if any of the parameters (should some
+// exist) contain references to the CHARSET parameter or the ENCODING parameter.
+//
+// Should references exist to CHARSET then a character set override is applied to the current
+// property value during the decoding process.
+//
+// Note that it is  also valid syntax to simply indicate that the property value is encoded
+// using QUOTED-PRINTABLE  simply by specifying QUOTED-PRINTABLE without following the normal
+// PARAMETER_NAME=VALUE syntax (i.e the parameter might just consist of the PARAMETER_NAME
+// part (in which case VALUE will be  null and PARAMETER_NAME will be QUOTED-PRINTABLE etc).
+//
+// Method could leave while creating a UID
+//
+	{
+	CParserParam* parameter;
+	TPtrC8 pParameterName;
+	TPtrC8 pParameterValue;
+	TInt noOfParams = (aArrayOfParams)? aArrayOfParams->Count() : 0;
+	TInt tokenUidValue = 0;
+	//
+	// Check each parameter for coding related tags, such as CHARSET, ENCODING, etc and
+	// set up state ready for the decoding of the parameter value
+	//
+	for(TInt ii = 0; ii < noOfParams; ii++)
+		{
+		parameter = aArrayOfParams->At(ii);
+		pParameterName.Set(parameter->Name());
+		pParameterValue.Set(parameter->Value());
+		// Attempt to recognize this property parameter
+		tokenUidValue = RecognizeToken(pParameterName).iUid;
+		// The parameter NAME is CHARSET
+		if	(tokenUidValue == KVersitParamCharsetUid)
+			{
+			// Charset identifier found, so establish the encoding type (e.g UTF8, ISO8859-X etc).
+			TUint charSetUid=KCharacterSetIdentifierAscii;
+			charSetUid=UnicodeUtils().ConvertStandardNameL(pParameterValue); // Method could leave while creating a UID
+			if (charSetUid!=0)
+				{
+				SetLineCharacterSetId(charSetUid);
+				iFlags|=ECharSetIdentified;
+				}
+			// The CHARSET parameter of this property is no longer required so remove it from the array.
+			delete parameter;
+			aArrayOfParams->Delete(ii);
+			--ii;
+			--noOfParams;
+			}
+		// The parameter NAME is ENCODING
+		else if (tokenUidValue == KVersitParamEncodingUid)
+			{
+			const TUint conversionUid = RecognizeToken(pParameterValue).iUid;
+			SetLineEncoding(conversionUid);
+			}
+		// The parameter NAME is QUOTED-PRINTABLE
+		else if (tokenUidValue == KVersitParamEncodingQuotedPrintableUid)
+			{
+			SetLineEncoding(Versit::EQuotedPrintableEncoding);
+			}
+		// The parameter NAME is BASE64
+		else if (tokenUidValue == KVersitParamEncodingBase64Uid)
+			{
+			SetLineEncoding(Versit::EBase64Encoding);
+			}
+		} // end FOR
+	}
+HBufC* CVersitParser::ConvertToUnicodeL(const TDesC8& aValue)
+	{
+	if (!(iFlags&ECharSetIdentified))
+		{
+		if (iFlags&EUseAutoDetection && !VersitUtils::IsBeginOrEnd(iCurrentProperty->NameUid())
+																	&& iCurrentProperty->NameUid().iUid!=KVersitTokenVersionUid)
+			SetLineCharacterSetId(UnicodeUtils().AutoDetectCharSetL(aValue,iAutoDetectCharSets));
+		else
+			SetLineCharacterSet(Versit::EUSAsciiCharSet);
+		}
+	if	(LineCharSet() != Versit::EUSAsciiCharSet)
+		{
+		HBufC* value = HBufC::NewLC(aValue.Size());
+		TPtr ptr(value->Des());
+		if	(aValue.Length())
+			{
+			User::LeaveIfError(ConvertToUnicodeFromISOL(ptr, aValue, LineCharSetId()));
+			__ASSERT_DEBUG(ptr.Length(), User::Invariant());
+			}
+		CleanupStack::Pop(value);
+		return value;
+		}
+	else
+		return UnicodeUtils().WidenL(aValue);
+	}
+EXPORT_C HBufC* CVersitParser::DecodePropertyValueL(const TDesC8& aValue)
+//
+// This method is used to decode the property value given that any
+// parameters to the property have been established.
+//
+	{
+	// If this property has an overridden encoding type, or the default encoding is not ENoEncoding
+	// then do the decode here... otherwise leave it up to MakeXXXX instead.
+	if	(LineEncoding() != Versit::ENoEncoding)
+		{
+		const TUid propertyEncodingUid = { LineEncodingId() };
+		TRAPD(err,DecodePropertyValueL(aValue,propertyEncodingUid));
+		if	(err != KErrNotSupported)
+			{
+			User::LeaveIfError(err);
+			if (iLargeDataBuf)
+				return NULL;
+			return ConvertToUnicodeL(*iDecodedValue);
+			}
+		}
+	if (iLargeDataBuf)
+		return NULL;
+	return ConvertToUnicodeL(aValue);
+	}
+EXPORT_C void CVersitParser::DecodePropertyValueL(const TDesC8& aValue,const TUid& aEncodingUid)
+	{
+	CCnaConverterList* convList=CCnaConverterList::NewLC();
+	CConverterBase* conv = convList->NewConverterL(aEncodingUid);
+	if (!conv)
+		User::Leave(KErrNotSupported);
+	CleanupStack::PushL(conv);
+	CBufSeg* destBuf=NULL;		//Initialise to stop warning "local variable may be used without having been initialized"
+	RBufReadStream bufRead;
+	RBufWriteStream bufWrite;
+	RDesReadStream desRead;
+	RDesWriteStream desWrite;
+	RReadStream* readStream;
+	RWriteStream* writeStream;
+	if (iLargeDataBuf)
+		{
+		destBuf=CBufSeg::NewL(128);
+		CleanupStack::PushL(destBuf);
+		bufRead.Open(*iLargeDataBuf);
+		bufWrite.Open(*destBuf);
+		readStream=&bufRead;
+		writeStream=&bufWrite;
+		}
+	else
+		{
+		if (!iDecodedValue)
+			iDecodedValue=HBufC8::NewL(aValue.Length());
+		else
+			{
+			TPtr8 value=iDecodedValue->Des();
+			if(value.MaxLength()<aValue.Length())
+				iDecodedValue=iDecodedValue->ReAllocL(aValue.Length());
+			}
+		desRead.Open(aValue);
+		TPtr8 ptr=iDecodedValue->Des();		//To stop warning: nonstandard extension used : 'argument' : conversion from 'class TPtr8' to 'class TDes8 &'
+		desWrite.Open(ptr);
+		readStream=&desRead;
+		writeStream=&desWrite;
+		}
+	//
+	conv->ConvertObjectL(*readStream,*writeStream);
+	//
+	writeStream->CommitL();
+	readStream->Close();
+	writeStream->Close();
+	//
+	if (iLargeDataBuf)
+		{
+		CleanupStack::Pop(destBuf);
+		delete iLargeDataBuf;
+		iLargeDataBuf=destBuf;
+		}
+	CleanupStack::PopAndDestroy(2, convList); // conv, convList
+	}
+EXPORT_C void CVersitParser::AppendBeginL()
+// Write beginning of entity to stream
+	{
+	iWriteStream->WriteL(KVersitTokenBEGIN);
+	AppendEntityNameL();
+	}
+EXPORT_C void CVersitParser::AppendEndL()
+// Write end of entity to stream
+	{
+	iWriteStream->WriteL(KVersitTokenEND);
+	AppendEntityNameL();
+	}
+void CVersitParser::AppendEntityNameL()
+	{
+	iWriteStream->WriteL(KVersitTokenColon);
+	if (iEntityName)
+		{
+		UnicodeUtils().SetCurrentCharSetL(KCharacterSetIdentifierCodePage1252);
+		HBufC8* narrow = UnicodeUtils().NarrowLC(*iEntityName);
+		iWriteStream->WriteL(*narrow);
+		CleanupStack::PopAndDestroy(narrow);
+		}
+	iWriteStream->WriteL(KVersitTokenCRLF);
+	}
+EXPORT_C CVersitParser* CVersitParser::MakeEntityL(TInt /*aEntityUid*/,HBufC* /*aEntityName*/)
+// Make an entity from iReadStream
+	{
+	User::Leave(KErrNotSupported); //entities not supported
+	return NULL;
+	}
+EXPORT_C CParserPropertyValue* CVersitParser::MakePropertyValueL(const TUid& aPropertyUid,HBufC16*& aValue)
+// Every property value has a specific property UID type which identifies the type of
+// container object the property value (returned from this method) is derived from.
+	{
+	if(!aValue && (aPropertyUid.iUid != KVersitPropertyBinaryUid || !iLargeDataBuf))
+		{
+		return NULL;
+		}
+	CParserPropertyValue* value = NULL;
+	switch(aPropertyUid.iUid)
+		{
+		case KVersitPropertyCDesCArrayUid:
+			{
+			CDesCArray* array=MakePropertyValueCDesCArrayL(aValue->Des());
+			CleanupStack::PushL(array);
+			value=new(ELeave)CParserPropertyValueCDesCArray(array);
+			CleanupStack::Pop(array);
+			break;
+			}
+		case KVersitPropertyTimeZoneUid:
+			{
+			TPtr16 ptr=aValue->Des();
+			VersitUtils::StripWhiteSpace(ptr);
+			TTimeIntervalSeconds timeZone=DecodeTimeZoneL(ptr);
+			value=new(ELeave)CParserPropertyValueTimeZone(timeZone);
+			break;
+			}
+		case KVersitPropertyDaylightUid:
+			{
+			CVersitDaylight* daylight=MakePropertyValueDaylightL(aValue->Des());
+			CleanupStack::PushL(daylight);
+			value=new(ELeave)CParserPropertyValueDaylight(daylight);
+			CleanupStack::Pop(daylight);
+			break;
+			}
+		case KVersitPropertyDateTimeUid:
+			{
+			TPtr16 ptr=aValue->Des();
+			if (ptr.Length()<=KVersitDatePropertySymbianConnectMessageMaximumLenght)
+				{
+				//date is not valid, exception implemented to satisfy symbian connect protocol
+				value=MakeDefaultPropertyValueL(aValue);
+				}
+			else
+				{
+				TVersitDateTime* dateTime=DecodeDateTimeL(ptr);
+				CleanupStack::PushL(dateTime);
+				value=new(ELeave)CParserPropertyValueDateTime(dateTime);
+				CleanupStack::Pop(dateTime);
+				}
+			break;
+			}
+		case KVersitPropertyDateUid:
+			{
+			TPtr16 ptr=aValue->Des();
+			if (ptr.Length()<=KVersitDatePropertySymbianConnectMessageMaximumLenght)
+				{
+				//date is not valid, exception implemented to satisfy symbian connect protocol
+				value=MakeDefaultPropertyValueL(aValue);
+				}
+			else
+				{
+				TVersitDateTime* dateTime=DecodeDateTimeL(ptr);
+				CleanupStack::PushL(dateTime);
+				value=new(ELeave)CParserPropertyValueDate(dateTime);
+				CleanupStack::Pop(dateTime);
+				}
+			break;
+			}
+		case KVersitPropertyMultiDateTimeUid:
+			{
+			CArrayPtr<TVersitDateTime>*	multiDateTime=MakePropertyValueMultiDateTimeL(aValue->Des());
+			CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfDateTimes,multiDateTime));
+			value=new(ELeave)CParserPropertyValueMultiDateTime(multiDateTime);
+			CleanupStack::Pop(multiDateTime);
+			break;
+			}
+		case KVersitPropertyIntUid:
+			{
+			TInt number;
+			Val(*aValue, number);
+			value=new(ELeave)CParserPropertyValueInt(number);
+			break;
+			}
+		case KVersitPropertyBinaryUid:
+			value=new(ELeave) CParserPropertyValueBinary(*iLargeDataBuf);
+			iLargeDataBuf=NULL;
+			break;
+		default://KVersitPropertyHBufCUid
+			{
+			value=MakeDefaultPropertyValueL(aValue);
+			}
+		}
+	return value;
+	}
+CParserPropertyValueHBufC* CVersitParser::MakeDefaultPropertyValueL(HBufC16*& aValue)
+/**
+* Instantiates and gives ownership of a CParserPropertyValueHBufC object.
+*/
+	{
+	if(!aValue && !iLargeDataBuf)
+		return NULL;
+	VersitUtils::RemoveEscapeChars(*aValue,LineCharSetId());
+	CParserPropertyValueHBufC* returnedValue=new(ELeave) CParserPropertyValueHBufC(aValue);
+	aValue=NULL;
+	return returnedValue;
+	}
+EXPORT_C CDesCArray* CVersitParser::MakePropertyValueCDesCArrayL(TPtr16 aStringValue)
+/** Parses a compound property value string.
+The sub-values found are appended to an array, after removal of escape characters.
+The array is returned, and ownership is transferred to the caller.
+@param aStringValue Compound property value string.
+@return Array of property values found in the string. */
+	{
+CDesCArray* arrayOfValues = VersitUtils::ParseForArrayPropertiesL(aStringValue, LineCharSetId());
+	return arrayOfValues;
+	}
+EXPORT_C TBool CVersitParser::FindFirstField(TPtr16& aField,TPtr16& aRemaining, TBool aTrimSpace)
+	{
+	TInt len=aRemaining.Length();
+	TInt posSemicolon=aRemaining.Locate(KVersitTokenSemiColonVal);
+	TInt startRest=posSemicolon+1;
+	TBool ret=(posSemicolon==KErrNotFound);
+	if (ret)
+		{
+		if (len==0)
+			{
+			aField.Set(NULL,0,0);
+			return ETrue;
+			}
+		posSemicolon=len;
+		startRest=len;
+		}
+	aField.Set(&aRemaining[0],posSemicolon,posSemicolon);
+	len-=startRest;
+	if (len==0)
+		startRest=0;
+	aRemaining.Set(&aRemaining[startRest],len,len);
+	if(aTrimSpace)
+		VersitUtils::StripWhiteSpace(aField);
+	return ret;
+	}
+/** Sets up a pointer to the remaining field. Sets the original remaining field pointers length to 0.
+@param aField on return points to the data and length that aRemaining originally pointed to.
+@param aRemaining as input references a location that the descriptor is to represent. On return length is set to 0.
+*/
+EXPORT_C void CVersitParser::FindRemainingField(TPtr16& aField,TPtr16& aRemaining)
+	{
+	TInt len=aRemaining.Length();
+	aField.Set(&aRemaining[0],len,len);
+	aRemaining.Set(&aRemaining[0], 0, 0);
+	}
+EXPORT_C CVersitDaylight* CVersitParser::MakePropertyValueDaylightL(TPtr16 aDaylightValue)
+	{
+	if(aDaylightValue.MatchF(KVersitVarTokenFALSE)>KErrNotFound)
+		return CVersitDaylight::NewL(EFalse, NULL, NULL, NULL, KVersitTokenEmpty, KVersitTokenEmpty);
+	TPtr16 field(NULL,0);
+	FindFirstField(field,aDaylightValue);
+	if(field.CompareC(KVersitVarTokenTRUE))
+		return NULL;
+	FindFirstField(field,aDaylightValue);
+	TTimeIntervalSeconds offset=0;
+	if(field.Length()>0)
+		offset = DecodeTimeZoneL(field);
+	FindFirstField(field,aDaylightValue);
+	TVersitDateTime* startTime = NULL;
+	if(field.Length()>0)
+		startTime = DecodeDateTimeL(field);
+	CleanupStack::PushL(startTime);
+	FindFirstField(field,aDaylightValue);
+	TVersitDateTime* endTime = NULL;
+	if(field.Length()>0)
+		endTime = DecodeDateTimeL(field);
+	CleanupStack::PushL(endTime);
+	FindFirstField(field,aDaylightValue);
+	TPtr16 edt(NULL,0);
+	FindFirstField(edt,aDaylightValue);
+	if(!startTime || !endTime)
+		User::Leave(KVersitErrBadDateTime);
+	CVersitDaylight* daylight = CVersitDaylight::NewL(ETrue, offset, startTime, endTime, field, edt);
+	CleanupStack::Pop(2,startTime);
+	return (daylight);
+	}
+EXPORT_C CArrayPtr<TVersitDateTime>* CVersitParser::MakePropertyValueMultiDateTimeL(TPtr16 aDateTimeGroup)
+// Make a property from aDateTimeGroup, with a CArrayPtr<TDateTime> value
+	{
+	VersitUtils::StripWhiteSpace(aDateTimeGroup);
+	if(aDateTimeGroup.Length()==0)
+		return NULL;
+	CArrayPtr<TVersitDateTime>* arrayOfDateTimes=new(ELeave)CArrayPtrFlat<TVersitDateTime>(5);
+	CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfDateTimes,arrayOfDateTimes));
+	TPtr16 field(NULL,0);
+	do
+		{
+		FindFirstField(field,aDateTimeGroup);
+		if(field.Length()>0)
+			{
+			TVersitDateTime* dateTime = DecodeDateTimeL(field);
+			CleanupStack::PushL(dateTime);
+			arrayOfDateTimes->AppendL(dateTime);
+			CleanupStack::Pop(dateTime);
+			}
+		}while (aDateTimeGroup.Length()!=0);
+	CleanupStack::Pop(arrayOfDateTimes); //arrayOfDateTimes
+	return arrayOfDateTimes;
+	}
+EXPORT_C TInt CVersitParser::Val(const TDesC& aString, TInt& aNumber)
+// static
+/** Converts a string into an integer, for example, it converts "438" to 438.
+@param aString The string to be converted. Every character contained in
+the string needs to be number presentable, i.e. between '0' and '9'.
+@param aNumber On return, the integer corresponding to aString.
+@return KErrNone if the number has been converted from the string;
+KVersitErrNumberExpected otherwise. */
+	{
+	aNumber = 0;
+	TInt length=aString.Length();
+	for(TInt i=0;i<length;i++)
+		{
+		if(aString[i]<'0'||aString[i]>'9')
+			return(KVersitErrNumberExpected);
+		aNumber = aNumber * 10 + aString[i] - '0';
+		}
+	return KErrNone;
+	}
+EXPORT_C TVersitDateTime* CVersitParser::DecodeDateTimeL(TDes& aToken) const
+// Extracts the date and time portion from aToken and returns it as a
+// TVersitDateTime (Format YYYY(:)MM(:)DD(:)(THH(:)MM(:)SS(:)(Z))
+	{
+	const TInt KSymbianOSDefaultMidnightValue = 0;
+	const TInt KVersitAlternativeMidnightValue = 24;
+	aToken.TrimAll();
+	TInt length = aToken.Length();
+	if (length==0)
+		User::Leave(KVersitErrBadDateTime);
+	TInt position = 0;
+	if (length < 8)
+		User::Leave(KVersitErrBadDateTime);
+	TVersitDateTime::TRelativeTime relativeTime = TVersitDateTime::EIsVCardLocal;
+	TInt year;
+	User::LeaveIfError(Val(aToken.Left(4), year));
+	position += 4;
+	if(aToken[position] == KVersitTokenMinusVal)
+		position++;
+	TInt month;
+	User::LeaveIfError(Val(aToken.Mid(position, 2), month));
+	position += 2;
+	if(aToken[position] == KVersitTokenMinusVal)
+		position++;
+	if (length < (position + 2))
+		User::Leave(KVersitErrBadDateTime);
+	TInt day;
+	User::LeaveIfError(Val(aToken.Mid(position, 2), day));
+	position += 2;
+	//
+	// Parse time aspect
+	//
+	TBool adjustDayToNextAvailable = EFalse;
+	TInt hour = 0;
+	TInt minute = 0;
+	TInt second = 0;
+	//	position is now sitting left of the "T" in the date string YYYY(-)MM(-)DD(-)THH(:)MM(:SS)
+	if (length >= (position + 5))
+		{
+		TBool parseSeconds = EFalse;
+		// Time value can be in "HHMM" or "HHMMSS" format.
+		if(length >= (position + 7))
+			parseSeconds = ETrue;
+		if(aToken[position++] != KVersitTimePeriodTimeVal)
+			User::Leave(KVersitErrBadDateTime);
+		User::LeaveIfError(Val(aToken.Mid(position, 2), hour));
+		// If the hour value is "24" then, this is deemed to be at the end
+		// of the specified day. This can be thought of as synonymous with the
+		// start of the next day.
+		if	(hour == KVersitAlternativeMidnightValue)
+			{
+			adjustDayToNextAvailable = ETrue;
+			hour = KSymbianOSDefaultMidnightValue;
+			}
+		position += 2;
+		if(aToken[position] == KVersitTokenColonVal)
+			position++;
+		if(length < position+2)
+			User::Leave(KVersitErrBadDateTime);
+		User::LeaveIfError(Val(aToken.Mid(position, 2), minute));
+		position += 2;
+		if(parseSeconds)
+			{
+			if(aToken[position] == KVersitTokenColonVal)
+				position++;
+			if (length < (position + 2))
+				User::Leave(KVersitErrBadDateTime);
+			User::LeaveIfError(Val(aToken.Mid(position, 2), second));
+			position += 2;
+			}
+		if ((length > position) && (aToken[position] == KVersitTokenUniversalTimeVal))
+			relativeTime = TVersitDateTime::EIsUTC;
+		}
+	TDateTime date;
+	const TInt error = date.Set(year, (TMonth)(month - 1), day - 1, hour, minute, second, 0);
+	if(error!=KErrNone)
+		User::LeaveIfError(KVersitErrBadDateTime);
+	// In the instance whereby we need to treat 24 as being the start of the next
+	// day, we should increment the day value by one.
+	if	(adjustDayToNextAvailable)
+		{
+		const TInt KVersitSingleDay = 1;
+		//
+		TTime time(date);
+		time += TTimeIntervalDays(KVersitSingleDay);
+		date = time.DateTime();
+		}
+	return new(ELeave) TVersitDateTime(date, relativeTime);
+	}
+EXPORT_C TTimeIntervalSeconds CVersitParser::DecodeTimeZoneL(const TDesC& aToken) const
+// Extracts the date and time portion from aToken and returns it as a
+// TVersitDateTime Format: (-)(+)HH((:)MM)
+	{
+	TInt length = aToken.Length();
+	if (length < 1)
+		User::Leave(KVersitErrBadTimeZone);
+	TInt position = 0;
+	TInt sign = 1;
+	TInt hour = 0,minute = 0;
+	if(aToken[position] == KVersitTokenMinusVal)
+		{
+		position++;
+		sign = -1;
+		}
+	else if(aToken[position] == KVersitTokenPlusVal)
+		position++;
+	if(length-position<1)
+		User::Leave(KVersitErrBadTimeZone);
+	if((length-position)==1 || aToken.Mid(position+1,1)==KVersitTokenColonUnicode)
+		{
+		User::LeaveIfError(Val(aToken.Mid(position, 1), hour));
+		position += 1;
+		}
+	else
+		{
+		User::LeaveIfError(Val(aToken.Mid(position, 2), hour));
+		position += 2;
+		}
+	if (length >= (position + 1))
+		{
+		if(aToken[position] == KVersitTokenColonVal)
+			position++;
+		if(length-1==position)
+			User::LeaveIfError(Val(aToken.Mid(position, 1), minute));
+		else if(length-1>position)
+			User::LeaveIfError(Val(aToken.Mid(position, 2), minute));
+		}
+	return TTimeIntervalSeconds(sign * (hour * 3600 + minute * 60));
+	}
+EXPORT_C TTime* CVersitParser::DecodeTimePeriodL(const TDesC& aToken) const
+// Extracts the date and time portion from aToken and returns it as a
+// TDateTime time period
+	{
+	TInt length = aToken.Length();
+	TInt ii = 0;
+	if (!length || (aToken[ii++] != KVersitTimePeriodBeginVal))
+		User::Leave(KVersitErrBadTimePeriod);
+	TInt number = 0;
+	TInt year = 0;
+	TInt month = 0;
+	TInt week = 0;
+	TInt day = 0;
+	TInt hour = 0;
+	TInt minute = 0;
+	TInt second = 0;
+	TBool isTimeOfDay = EFalse;
+	while (ii < length)
+		{
+		TChar tokenChar = aToken[ii];
+		if ((tokenChar >= '0') && (tokenChar <= '9'))
+			{
+			TInt numChars;
+			number = GetNumberL(aToken.Right(length - ii),numChars);
+			ii+=numChars;
+			}
+		else
+			{
+			if (isTimeOfDay)
+				{
+				if (tokenChar == KVersitTimePeriodHourVal)
+					hour = number;
+				else if (tokenChar == KVersitTimePeriodMinuteVal)
+					minute = number;
+				else if (tokenChar == KVersitTimePeriodSecondVal)
+					second = number;
+				}
+			else
+				{
+				if (tokenChar == KVersitTimePeriodTimeVal)
+					isTimeOfDay = ETrue;
+				else if (tokenChar == KVersitTimePeriodYearVal)
+					year = number;
+				else if (tokenChar == KVersitTimePeriodMonthVal)
+					month = number;
+				else if (tokenChar == KVersitTimePeriodWeekVal)
+					week = number;
+				else if (tokenChar == KVersitTimePeriodDayVal)
+					day = number;
+				}
+			ii++;
+			number = 0;
+			}
+		}
+	//TBuf<KVersitDefaultBufferSize> time;
+	//_LIT(formatString, "%04d%02d%02d:%02d%02d%02d.");
+	//time.Format(formatString, year, month, day, hour, minute, second);
+	TDateTime dateTime(year,REINTERPRET_CAST(TMonth&,month),day,hour,minute,second,0);
+	//TTime* timeVal = new(ELeave) TTime(time);
+	TTime* timeVal = new(ELeave) TTime(dateTime);
+	*timeVal += TTimeIntervalDays(week * 7);
+	return timeVal;
+	}
+EXPORT_C TInt CVersitParser::GetNumberL(const TDesC& aToken,TInt& aNumChars) const
+// Converts aToken to an integer
+	{
+	TInt length = aToken.Length();
+	TPtrC numBuf(aToken);
+	TInt num;
+	aNumChars = 0;
+	while ((aNumChars < length) && (aToken[aNumChars] >= '0') && (aToken[aNumChars] <= '9'))
+		++aNumChars;
+	numBuf.Set(aToken.Left(aNumChars));
+	User::LeaveIfError(Val(numBuf, num));
+	return num;
+	}
+EXPORT_C TUid CVersitParser::RecognizeToken(const TDesC8& aToken) const
+/** Returns a UID for the specified token.
+This function only recognizes generic Versit tokens. For example, if aToken
+contains the property name KVersitTokenBEGIN, the function returns KVersitTokenBeginUid.
+More specific recognition should occur in derived classes which implement
+this function, using this as the base recogniser.
+@param aToken The token to be recognized.
+@return A defined UID value if the token has been recognized; KVersitTokenUnknownUid
+otherwise. */
+	{
+	TUid uid = TUid::Uid(KVersitTokenUnknownUid);
+	TChar firstChar(aToken.Ptr()[0]);
+	firstChar=firstChar.GetUpperCase();
+	switch (firstChar)
+		{
+	case 'B':
+		if (!aToken.CompareF(KVersitTokenBEGIN))
+			uid.iUid = KVersitTokenBeginUid;
+		else if (!aToken.CompareF(KVersitTokenBASE64))
+			uid.iUid = KVersitParamEncodingBase64Uid;
+		break;
+	case 'C':
+		if (!aToken.CompareF(KVersitTokenCHARSET))
+			uid.iUid = KVersitParamCharsetUid;
+		break;
+	case 'E':
+		if (!aToken.CompareF(KVersitTokenEND))
+			uid.iUid = KVersitTokenEndUid;
+		else if (!aToken.CompareF(KVersitTokenENCODING))
+			uid.iUid = KVersitParamEncodingUid;
+		break;
+	case 'Q':
+		if (!aToken.CompareF(KVersitTokenQUOTEDPRINTABLE))
+			uid.iUid = KVersitParamEncodingQuotedPrintableUid;
+		break;
+	default:
+		break;
+		}
+	return uid;
+	}
+EXPORT_C TInt CVersitParser::RecognizeEntityName() const
+// From CVersitParser
+/** Tests the current entity to see if it is a vEvent or vTodo.
+This function is virtual. Actual testing only occurs in derived classes which
+implement this function.
+@return Zero. Derived classes' implementations would return a value that indicates
+the current entity's type. */
+	{
+	return 0;
+	}
+EXPORT_C void CVersitParser::ResetAndDestroyArrayOfParams(TAny* aObject)
+/** Destroys an array of parameters.
+@param aObject Pointer to the array of parameters to be destroyed. */
+	{
+	CArrayPtr<CParserParam>* array=REINTERPRET_CAST(CArrayPtr<CParserParam>*,aObject);
+	if (array)
+		array->ResetAndDestroy();
+	delete array;
+	}
+EXPORT_C void CVersitParser::ResetAndDestroyArrayOfProperties(TAny* aObject)
+/** Destroys an array of properties.
+@param aObject Pointer to the array of properties to be destroyed. */
+	{
+	CArrayPtr<CParserProperty>* array=REINTERPRET_CAST(CArrayPtr<CParserProperty>*,aObject);
+	if (array)
+		array->ResetAndDestroy();
+	delete array;
+	}
+EXPORT_C void CVersitParser::ResetAndDestroyArrayOfEntities(TAny* aObject)
+/** Destroys an array of entities.
+@param aObject Pointer to the array of entities to be destroyed. */
+	{
+	CArrayPtr<CVersitParser>* array=REINTERPRET_CAST(CArrayPtr<CVersitParser>*,aObject);
+	if (array)
+		array->ResetAndDestroy();
+	delete array;
+	}
+EXPORT_C void CVersitParser::ResetAndDestroyArrayOfDateTimes(TAny* aObject)
+/** Destroys an array of Versit dates and times.
+@param aObject Pointer to the array of Versit dates and times to be destroyed. */
+	{
+	CArrayPtr<TVersitDateTime>* array=REINTERPRET_CAST(CArrayPtr<TVersitDateTime>*,aObject);
+	if (array)
+		array->ResetAndDestroy();
+	delete array;
+	}
+TBool CVersitParser::IsPunctuationToken(TUint aChar)		//static function
+	{
+	return (aChar == KVersitTokenColonVal ||
+			aChar == KVersitTokenSemiColonVal ||
+			aChar == KVersitTokenEqualsVal ||
+			aChar == KVersitTokenPeriodVal ||
+			aChar == KVersitTokenCommaVal ||
+			aChar == KVersitTokenLSquareBracketVal ||
+			aChar == KVersitTokenRSquareBracketVal);
+	}
+EXPORT_C TInt CVersitParser::ConvertFromUnicodeToISOL(TDes8& aIso, const TDesC16& aUnicode, CCnvCharacterSetConverter* aConverter)
+/** Converts text in the Unicode character set (UCS-2) into a
+non-unicode (International Standards Organisation) character set.
+Which ISO character set the string is converted to is determined by
+the value of the character set identifier in the aConverter parameter.
+@param aIso On return, the converted text string in the specified ISO
+character set.
+@param aUnicode The Unicode text string to be converted.
+@param aConverter The character set converter.
+@return If no error occurs, this is the number of unconverted characters
+left at the end of the input descriptor. This is zero if the whole string
+is converted, but may be greater than zero (e.g. because the output
+descriptor is not long enough to hold all the text). Otherwise, one of
+the error values defined in TError in the CCnvCharacterSetConverter class, or
+KErrNotFound if aConverter does not point to a valid character
+set converter object. */
+	{
+	if	(aConverter)
+		{
+		// Do the conversion
+		aConverter->SetReplacementForUnconvertibleUnicodeCharactersL(KReplacementChars);
+		return aConverter->ConvertFromUnicode(aIso, aUnicode);
+		}
+	return KErrNotFound;
+	}
+EXPORT_C TInt CVersitParser::ConvertToUnicodeFromISOL(TDes16& aUnicode, const TDesC8& aIso,TUint aCharacterSet)
+/** Converts text in a non-Unicode character set into Unicode (UCS-2).
+@param aUnicode On return, the converted text string in the Unicode character set.
+@param aIso  The non-Unicode text string to be converted.
+@param aCharacterSet The non-Unicode character set in which aIso is encoded.
+@return If no error occurs, the number of unconverted bytes left at the end of
+the input descriptor. This is zero if the whole string is converted; but it may
+be greater than zero, e.g. because the output descriptor is not long enough to
+hold all the text. Otherwise, one of the error values defined in TError in the
+CCnvCharacterSetConverter class, or KErrNotFound if aCharacterSet cannot be
+converted. */
+	{
+	CCnvCharacterSetConverter::TAvailability avail=UnicodeUtils().SetCurrentCharSetL(aCharacterSet);
+	if	(avail == CCnvCharacterSetConverter::EAvailable)
+		{
+		// Do the conversion
+		CCnvCharacterSetConverter& converter=UnicodeUtils().CharacterSetConverter();
+		TInt ignore = 0;
+		converter.SetReplacementForUnconvertibleUnicodeCharactersL(KReplacementChars);
+		return converter.ConvertToUnicode(aUnicode, aIso, ignore);
+		}
+	return KErrNotFound;
+	}
+EXPORT_C void CVersitParser::SetDefaultEncoding(Versit::TVersitEncoding aEncoding)
+/** Sets the parser's default encoding to aEncoding.
+@param aEncoding An encoding. Cannot be 8-bit.
+@panic Versit-Parser 7 aEncoding is Versit::EEightBitEncoding. */
+	{
+	// 8-bit is reserved for versit - it uses it when it needs to, but it's not
+	// settable by 3rd parties.
+	__ASSERT_ALWAYS(aEncoding!=Versit::EEightBitEncoding, Panic(EVersitPanicCannotSetEightBitEncoding));
+	//
+	iDefaultCodingDetails.iEncoding		= aEncoding;
+	iDefaultCodingDetails.iEncodingUid	= MapVersitEncodingToConArcUid(aEncoding);
+	}
+EXPORT_C void CVersitParser::SetDefaultCharSet(Versit::TVersitCharSet aCharSet)
+/** Sets the default character set or transformation format.
+This may be used to represent property values in Versit objects.
+@param aCharSet The default character set. */
+	{
+	iDefaultCodingDetails.iCharSet		= aCharSet;
+	iDefaultCodingDetails.iCharSetUid	= MapVersitCharsetToCharConvCharset(aCharSet);
+	}
+EXPORT_C void CVersitParser::SetDefaultCharSetId(TUint aCharSetId)
+/** Sets the default character set or transformation format.
+This may be used to represent property values in Versit objects.
+@param aCharSetId The UID for the character set. These are defined in charconv.h. */
+	{
+	iDefaultCodingDetails.iCharSet		= VersitUtils::CharSet(aCharSetId);
+	iDefaultCodingDetails.iCharSetUid	= aCharSetId;
+	}
+EXPORT_C void CVersitParser::RestoreLineCodingDetailsToDefault()
+	{
+	// Set the [en|de]coding details for the current line back to the default values specified
+	SetLineCharsetDetailsToDefault();
+	SetLineEncodingDetailsToDefault();
+	}
+EXPORT_C void CVersitParser::SetLineEncoding(Versit::TVersitEncoding aLineEncoding)
+	{
+	iCurrentPropertyCodingDetails.iEncoding		= aLineEncoding;
+	iCurrentPropertyCodingDetails.iEncodingUid	= MapVersitEncodingToConArcUid(aLineEncoding);
+	}
+EXPORT_C void CVersitParser::SetLineEncoding(TUint aVersitEncodingUid)
+	{
+	switch (aVersitEncodingUid)
+		{
+		case KQuotedPrintableToTextConverter:
+		case KVersitParamEncodingQuotedPrintableUid:
+			iCurrentPropertyCodingDetails.iEncoding		= Versit::EQuotedPrintableEncoding;
+			iCurrentPropertyCodingDetails.iEncodingUid	= KQuotedPrintableToTextConverter;
+			break;
+		case KBase64ToTextConverter:
+		case KVersitParamEncodingBase64Uid:
+			iCurrentPropertyCodingDetails.iEncoding		= Versit::EBase64Encoding;
+			iCurrentPropertyCodingDetails.iEncodingUid	= KBase64ToTextConverter;
+			break;
+		default:
+			iCurrentPropertyCodingDetails.iEncoding		= Versit::ENoEncoding;
+			iCurrentPropertyCodingDetails.iEncodingUid	= 0;
+			break;
+		}
+	}
+EXPORT_C void CVersitParser::SetLineCharacterSet(Versit::TVersitCharSet aLineCharSet)
+	{
+	iCurrentPropertyCodingDetails.iCharSet		= aLineCharSet;
+	iCurrentPropertyCodingDetails.iCharSetUid	= MapVersitCharsetToCharConvCharset(aLineCharSet);
+	}
+EXPORT_C void CVersitParser::SetLineCharacterSetId(TUint aLineCharSetId)
+	{
+	iCurrentPropertyCodingDetails.iCharSet		= VersitUtils::CharSet(aLineCharSetId);
+	iCurrentPropertyCodingDetails.iCharSetUid	= aLineCharSetId;
+	}
+EXPORT_C void CVersitParser::SetLineCoding(Versit::TVersitCharSet aLineCharSet,Versit::TVersitEncoding aLineEncoding)
+	{
+	SetLineCharacterSet(aLineCharSet);
+	SetLineEncoding(aLineEncoding);
+	}
+EXPORT_C Versit::TVersitEncoding CVersitParser::DefaultEncoding() const
+/** Gets the parser's default encoding.
+This value is initialised on construction, to ENoEncoding.
+@return The parser's default encoding. */
+	{
+	return iDefaultCodingDetails.iEncoding;
+	}
+EXPORT_C Versit::TVersitCharSet CVersitParser::DefaultCharSet() const
+/** Gets the default character set or transformation format. This may be used to
+represent property values in Versit objects.
+@return The default character set. */
+	{
+	return iDefaultCodingDetails.iCharSet;
+	}
+EXPORT_C TUint CVersitParser::DefaultCharSetId() const
+/** Gets the default character set or transformation format.
+This may be used to represent property values in Versit objects.
+@return The default character set identifier. Possible values are defined in charconv.h. */
+	{
+	return iDefaultCodingDetails.iCharSetUid;
+	}
+EXPORT_C Versit::TVersitEncoding CVersitParser::LineEncoding() const
+	{
+	return iCurrentPropertyCodingDetails.iEncoding;
+	}
+EXPORT_C Versit::TVersitCharSet CVersitParser::LineCharSet() const
+	{
+	return iCurrentPropertyCodingDetails.iCharSet;
+	}
+EXPORT_C TUint CVersitParser::LineEncodingId() const
+	{
+	return iCurrentPropertyCodingDetails.iEncodingUid;
+	}
+EXPORT_C TUint CVersitParser::LineCharSetId() const
+	{
+	return iCurrentPropertyCodingDetails.iCharSetUid;
+	}
+TUint CVersitParser::MapVersitCharsetToCharConvCharset(Versit::TVersitCharSet aVersitSet)
+// Converts between the Versit character set enumeration and the constant character set identifier that CharConv
+// uses during the conversion process
+	{
+	return VersitUtils::CharConvCharSetUid(aVersitSet).iUid;
+	}
+TUint CVersitParser::MapVersitEncodingToConArcUid(Versit::TVersitEncoding aVersitEncoding)
+// Map from a versit specific encoding enumeration...
+	{
+	switch(aVersitEncoding)
+		{
+		case Versit::EQuotedPrintableEncoding:
+			return KQuotedPrintableToTextConverter;
+		case Versit::EBase64Encoding:
+			return KBase64ToTextConverter;
+		default:
+			return 0;
+		}
+	}
+void CVersitParser::SetLineCharsetDetailsToDefault()
+	{
+	iCurrentPropertyCodingDetails.iCharSet		= iDefaultCodingDetails.iCharSet;
+	iCurrentPropertyCodingDetails.iCharSetUid	= iDefaultCodingDetails.iCharSetUid;
+	}
+void CVersitParser::SetLineEncodingDetailsToDefault()
+	{
+	iCurrentPropertyCodingDetails.iEncoding		= iDefaultCodingDetails.iEncoding;
+	iCurrentPropertyCodingDetails.iEncodingUid	= iDefaultCodingDetails.iEncodingUid;
+	}
+EXPORT_C void CVersitParser::SetCharacterConverter(Versit::TEncodingAndCharset& aEncodingAndCharset)
+/** Sets a character converter suitable for converting strings between
+Unicode and the specified character set.
+The function finds a suitable converter for the character set
+specified in aEncodingAndCharset.iCharSetId, if one is available,
+and assigns it to aEncodingAndCharset.iConverter.
+If there is no converter available for the specified character set then iConverter
+is set to NULL.
+This function is only of use if executing a major change to the externalisation
+behaviour, particularly if overriding CParserProperty::ExternalizeL() - the
+function from which this function is called.
+@param aEncodingAndCharset A utility class from which the character set
+information is extracted (from its member iCharSetId) and to which the
+suitable character converter is set (to its member iConverter). */
+	{
+	CCnvCharacterSetConverter::TAvailability avail=CCnvCharacterSetConverter::ENotAvailable;
+	TRAPD(err,avail=UnicodeUtils().SetCurrentCharSetL(aEncodingAndCharset.iCharSetId));
+	UNUSED_VAR(err); // used to suppress build warnings
+	if (avail==CCnvCharacterSetConverter::EAvailable)
+		aEncodingAndCharset.iConverter=&UnicodeUtils().CharacterSetConverter();
+	else
+		aEncodingAndCharset.iConverter=NULL;
+	}
+EXPORT_C void CVersitParser::SetAutoDetect(TBool aOn,const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* aAutoDetectCharSets/*=NULL*/)
+/** Turns auto detection of character sets on or off.
+If a property does not specify a character set, then it is possible to
+guess its character set. This function turns this behaviour on or off.
+When the behaviour is on, it also lets the caller specify a restricted
+set of character sets to be considered.
+Auto-detection of character sets is used (if auto detection is on)
+when converting a property value to Unicode while internalising a stream.
+@param aOn If ETrue, auto detection is turned on; if EFalse (the default value),
+auto detection is turned off
+@param aAutoDetectCharSets If specified then auto detection will only consider
+the character sets listed. If NULL, all available character sets are considered. */
+	{
+	if (aOn)
+		{
+		iAutoDetectCharSets=aAutoDetectCharSets;
+		iFlags|=EUseAutoDetection;
+		}
+	else
+		iFlags&=~EUseAutoDetection;
+	}
+EXPORT_C TInt CVersitParser::SaveBinaryValuesToFilesL(TInt aSizeThreshold,const TDesC& aPath)
+/** Saves all binary property values larger than a specified threshold to files,
+and sets each property value to be a URI representing the file, rather than
+the binary data iself.
+The files are created in the folder identified by aPath, and are assigned
+unique filenames that consist of the property name and some random numbers.
+Each new URI property value is prefixed with file:// and contains the path
+and filename of the file created.
+If a vCard contains any agent property values and if they contain binary data
+whose size exceeds the threshold, these property values are replaced with
+URI property values.
+The function sets up its own file server session, which is needed to create
+the files. It leaves if there is a problem creating any of the files.
+@param aSizeThreshold The threshold number of bytes for the binary data, above
+which the binary data is stored in a file.
+@param aPath The path identifying the location in which the files are created.
+This must not be greater than 240 characters long or the function leaves with
+KErrArgument. If it doesn't end in a slash, then one is appended.
+@return The number of files created. */
+	{
+	TInt files = 0;
+	// create a file server session
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	// parse through all the properties
+	const TInt countofproperties = iArrayOfProperties->Count();
+	for (TInt i = 0; i < countofproperties; i++)
+		{
+			files += iArrayOfProperties->At(i)->SaveBinaryValuesToFilesL(aSizeThreshold,aPath,fs);
+		}
+	// this never gets executed for a vcard since there are no entities for a vcard.
+	// But since this implementation is in the generic parser class, the code had been added.
+	if(iArrayOfEntities)
+		{
+			const TInt countofentities = iArrayOfEntities->Count();
+			for (TInt i = 0; i < countofentities; i++)
+				{
+					files += iArrayOfEntities->At(i)->SaveBinaryValuesToFilesL(aSizeThreshold,aPath,fs);
+				}
+		}
+	CleanupStack::PopAndDestroy(&fs);
+	return files;
+	}
+EXPORT_C TInt CVersitParser::LoadBinaryValuesFromFilesL()
+/** Loads all files represented by URI property values and sets the binary data
+contained in the files to be the property values instead of the URIs.
+For every property in the parser, if its value is a URI containing file://
+followed by a path and filename, then the file is opened and the binary data
+it contains is read into a CParserPropertyValueBinary object. This replaces
+the URI as the property value. The function also operates on any agents in
+the vCard that contain URI property values.
+The function creates its own file server session, which is needed to open
+the files. It leaves if there is a problem opening any of the files.
+@return The number of files that were read. */
+	{
+	TInt files = 0;
+	// create a file server session
+	RFs fs;
+	User::LeaveIfError(fs.Connect());
+	CleanupClosePushL(fs);
+	// parse through all the properties
+	const TInt countofproperties = iArrayOfProperties->Count();
+	for (TInt i = 0; i < countofproperties; i++)
+		{
+			files += iArrayOfProperties->At(i)->LoadBinaryValuesFromFilesL(fs);
+		}
+// this never gets executed for a vcard since there are no entities for a vcard.
+	// But since this implementation is in the generic parser class, the code had been added.
+	if(iArrayOfEntities)
+		{
+			const TInt countofentities = iArrayOfEntities->Count();
+			for (TInt i = 0; i < countofentities; i++)
+				{
+					files += iArrayOfEntities->At(i)->LoadBinaryValuesFromFilesL(fs);
+				}
+		}
+	CleanupStack::PopAndDestroy(&fs);
+	return files;
+	}
+EXPORT_C TInt CVersitParser::SaveBinaryValuesToFilesL(TInt aSizeThreshold,const TDesC& aPath,RFs& aFileSession)
+/** Saves all binary property values larger than a specified threshold to files,
+and sets each property value to be a URI representing the file rather than
+the binary data iself.
+The files are created in the folder identified by aPath, and are assigned
+unique filenames that consist of the property name and some random numbers.
+Each new URI property value is prefixed with file:// and contains the path
+and filename of the file created.
+If a vCard contains any agent property values and if they contain binary data
+whose size exceeds the threshold, these property values are replaced with
+URI property values.
+The function uses the file server session supplied, which is needed to create
+the files. It leaves if there is a problem creating any of the files.
+@param aSizeThreshold The threshold number of bytes for the binary data, above
+which the binary data is stored in a file.
+@param aPath The path identifying the location in which the files are created.
+This must not be greater than 240 characters long or the function leaves with
+KErrArgument. If it doesn't end in a slash, then one is appended.
+@param aFileSession The file server session used to create the files.
+@return The number of files created. */
+	{
+	TInt files = 0;
+	const TInt countofproperties = iArrayOfProperties->Count();
+	for (TInt i = 0; i < countofproperties; i++)
+		{
+			files += iArrayOfProperties->At(i)->SaveBinaryValuesToFilesL(aSizeThreshold,aPath,aFileSession);
+		}
+	 // this never gets executed for a vcard since there are no entities for a vcard.
+	// But since this implementation is in the generic parser class, the code had been added.
+	if(iArrayOfEntities)
+		{
+			const TInt countofentities = iArrayOfEntities->Count();
+			for (TInt i = 0; i < countofentities; i++)
+				{
+					files += iArrayOfEntities->At(i)->SaveBinaryValuesToFilesL(aSizeThreshold,aPath,aFileSession);
+				}
+		}
+	return files;
+	}
+EXPORT_C TInt CVersitParser::LoadBinaryValuesFromFilesL(RFs& aFileSession)
+/** Loads all files represented by URI property values and sets the binary data
+contained in the files to be the property values instead of the URIs.
+For every property in the parser, if its value is a URI containing file://
+followed by a path and filename, then the file is opened and the binary data
+it contains is read into a CParserPropertyValueBinary object. This replaces
+the URI as the property value. The function also operates on any agents in
+the vCard that contain URI property values.
+The function uses the file server session supplied, which is needed to open
+the files. It leaves if there is a problem opening any of the files.
+@param aFileSession The file server session used to open the files.
+@return The number of files that were read. */
+	{
+	TInt files = 0;
+	const TInt countofproperties = iArrayOfProperties->Count();
+	for (TInt i = 0; i < countofproperties; i++)
+		{
+			files += iArrayOfProperties->At(i)->LoadBinaryValuesFromFilesL(aFileSession);
+		}
+	 // this never gets executed for a vcard since there are no entities for a vcard.
+	// But since this implementation is in the generic parser class, the code had been added.
+	if(iArrayOfEntities)
+		{
+			const TInt countofentities = iArrayOfEntities->Count();
+			for (TInt i = 0; i < countofentities; i++)
+				{
+					files += iArrayOfEntities->At(i)->LoadBinaryValuesFromFilesL(aFileSession);
+				}
+		}
+	return files;
+	}
+CVersitTLSContainer *CVersitTLSContainer::NewLC(const TInt aSize)
+	{
+	CVersitTLSContainer *ret = new (ELeave) CVersitTLSContainer();
+	CleanupStack::PushL( ret );
+	ret->iShiftJisEscape = HBufC::NewL(aSize);
+	return ret;
+	}
+CVersitTLSContainer::~CVersitTLSContainer()
+	{
+	delete iShiftJisEscape;
+	iShiftJisEscape = NULL;
+	}
+EXPORT_C void CVersitParser::Reserved1()
+	{}
+EXPORT_C void CVersitParser::Reserved2()
+	{}
+//
+// MVersitObserver
+//
+EXPORT_C void MVersitObserver::Reserved1()
+	{}
+EXPORT_C void MVersitObserver::Reserved2()
+	{}
+//
+// MVersitPlugIn
+//
+EXPORT_C void MVersitPlugIn::GetInterface(TUid /*aInterfaceUid*/, TAny*& /*aInterface*/)
+	{}
+EXPORT_C void MVersitPlugIn::Reserved2()
+/**
+Reserved function.
+@internalComponent
+*/
+	{}
+//
+// Dll entry point
+//
+EXPORT_C void Panic(TVersitParserPanic aPanic)
+	{
+	_LIT(KCategory,"Versit-Parser");
+	User::Panic(KCategory,aPanic);
+	}
+//
+// class CLineReaderExtension
+//
+CLineReaderExtension::CLineReaderExtension()
+	{}
+CLineReaderExtension::~CLineReaderExtension()
+	{
+	delete iLineBase64Value;
+	}
+void CLineReaderExtension::DeleteBase64ValueBuffer()
+	{
+	delete iLineBase64Value;
+	iLineBase64Value = NULL;
+	}
+HBufC8* CLineReaderExtension::CreateBase64ValueBufferL()
+	{
+	if (!iLineBase64Value)
+		{
+		iLineBase64Value = HBufC8::NewL(CLineReader::EInitialLineSize);
+		}
+	return iLineBase64Value;
+	}
+HBufC8* CLineReaderExtension::Base64ValueBuffer()
+	{
+	return iLineBase64Value;
+	}
+CLineReaderExtension* CLineReaderExtension::NewL()
+	{
+	CLineReaderExtension* self=new(ELeave) CLineReaderExtension();
+	return self;
+	}