// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// @file

// This file contains the definition of the generic CMDXMLParser class

// which is responsible for creating a DOM structure

// from a given XML file.

// 

//

#include <f32file.h>

#include <utf.h>

#include <bautils.h>

#include <gmxmlconstants.h>

#include <gmxmlcomposer.h>

#include <gmxmlentityconverter.h>

#include <gmxmlnode.h>

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#include <gmxmlparser.h>

#include <gmxmlprocessinginstruction.h>

#include <gmxmlcomment.h>

#include <gmxmlcdatasection.h>

#include <gmxmltext.h>

#include "GMXMLFileDataSource.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include "gmxmldummydtd.h"

#endif

const TInt KGMXMLDefaultTextBufferSize = 1024;

const TInt KUTF8EdgeBufferLen = 6;

//

// Global functions					//

//

//==================================================================================

//

//CMDXParser						//

//

//==================================================================================

void CMDXMLParser::Panic(TPanicCode aReason) const

	{

	_LIT(KClassName, "CMDXMLParser");

	User::Panic(KClassName, aReason);

	}

EXPORT_C CMDXMLParser* CMDXMLParser::NewL(MMDXMLParserObserver* aParserObserver)

//

// Two phase static factory function constructor

// @return Created CMDXMLParser

// @leave can Leave due to OOM

//

	{

	CMDXMLParser* self = NewLC(aParserObserver);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CMDXMLParser* CMDXMLParser::NewL(MMDXMLParserObserver* aParserObserver, MXMLDtd* aDtdRepresentation)

//

// Two phase static factory function constructor

// @return Created CMDXMLParser

// @param aDtdRepresentation specid DTD represention class to be used for validation

// @leave can Leave due to OOM

//

	{

	CMDXMLParser* self = NewLC(aParserObserver, aDtdRepresentation);

	CleanupStack::Pop();

	return self;

	}

//==================================================================================

EXPORT_C CMDXMLParser* CMDXMLParser::NewLC(MMDXMLParserObserver* aParserObserver)

//

// Two phase static factory function constructor

// @return Created CMDXMLParser

// @leave can Leave due to OOM

//

	{

	CMDXMLParser* self = new (ELeave) CMDXMLParser(aParserObserver);

	CleanupStack::PushL(self);

	// This overload of NewLC doesn't take a MXMLDtd*, but we need to provide one to

	// ConstructL where ownership is taken if we do have one.  Just pass NULL.

	self->ConstructL(NULL);

	return self;

	}

EXPORT_C CMDXMLParser* CMDXMLParser::NewLC(MMDXMLParserObserver* aParserObserver, MXMLDtd* aDtdRepresentation)

//

// Two phase static factory function constructor

// @return Created CMDXMLParser

// @param aDtdRepresentation specid DTD represention class to be used for validation

// @leave can Leave due to OOM

//

	{

	CMDXMLParser* self = new (ELeave) CMDXMLParser(aParserObserver);

	CleanupStack::PushL(self);

	self->ConstructL(aDtdRepresentation);

	return self;

	}

//==================================================================================

void CMDXMLParser::ConstructL(MXMLDtd* aDtdRepresentation)

//

// Second stage constructor

// @param aDtdRepresentation The DTD to be used for validation

// @leave can Leave due to OOM

//

	{

	CMDXMLEntityConverter* entityConverter = new(ELeave) CMDXMLEntityConverter();

	SetEntityConverter(entityConverter);

	// This doesn't leave, but if CMDXMLParser::NewLC() Leaves after taking ownership

	// of this we'll get a double deletion as the caller will have pushed 

	// aDtdRepresentation onto the CleanupStack.  As such we can only take ownership

	// once we are sure we aren't going to leave.

	iDtdRepresentation = aDtdRepresentation;

	}

CMDXMLParser::CMDXMLParser(MMDXMLParserObserver* aParserObserver)

	: CActive(EPriorityNormal)

//

// Constructor

//

	{

	iParserObserver = aParserObserver;

	iStoreInvalid = ETrue;

	CActiveScheduler::Add(this);

	}

//==================================================================================

EXPORT_C CMDXMLParser::~CMDXMLParser()

	{

	Cancel();

	delete iBomBuffer;

	if( iFileSource == NULL )

		{

		// iFileSource has not been allocated yet, so the file path or file

		// handle are still owned

		if( iFileToParse!=NULL )

			delete iFileToParse;

		else

			iFileHandleToParse.Close();

		}

	else

		{

		delete iFileSource;

		}

	delete iUTF8EdgeBuffer;

	delete iXMLDoc;

	delete iEntityConverter;

	delete iElementTag;

	delete iDtdRepresentation;

	delete iText;

	}

//==================================================================================

//Defect fix for INC036136- Enable the use of custom entity converters in GMXML

EXPORT_C void CMDXMLParser::SetEntityConverter(CMDXMLEntityConverter* aEntityConverter)

/*

	 * Sets the entity converter to be used

	 * and  take ownership of the passed entity converter

	 * @param aEntityConverter The entity converter to be used

	 */

	{

	delete iEntityConverter;

	iEntityConverter = aEntityConverter;

	}

//End Defect fix for INC036136

//==================================================================================

EXPORT_C void CMDXMLParser::SetStoreInvalid(TBool aStoreInvalid)

	{

	iStoreInvalid = aStoreInvalid;

	}

//==================================================================================

// Defect fix for INC105134 - GmXML consumes whitespace characters 

//==================================================================================	

EXPORT_C void CMDXMLParser::SetWhiteSpaceHandlingMode(TBool aPreserve)

    {

    iPreserve = aPreserve;

    }

// End Defect fix for INC105134

//==================================================================================

EXPORT_C CMDXMLDocument* CMDXMLParser::DetachXMLDoc()

//

// @return CMDXMLDocument* to the created DOM, should be called after the

// conclusion of the parser process.  Note that internal variable pointing to

// the document is set to NULL so this function can only be called once per file

// parse.  Client application must take ownership of document for cleanup purposes.

//

	{

	CMDXMLDocument* returnDoc = iXMLDoc;

	iXMLDoc = NULL;

	return returnDoc;

	}

//==================================================================================

CMDXMLEntityConverter* CMDXMLParser::EntityConverter()

//

// @return the CMDXMLEntityConverter for use in converting built in entity

// and character entities back to their original format

//

	{

	return iEntityConverter;

	}

//==================================================================================

EXPORT_C TInt CMDXMLParser::ParseFile(RFs aRFs, const TDesC& aFileToParse)

//

// ParseFile opens a file ready for parsing

// @param aRFs a resource file session used for file I/O

// @param aFileToParse the file name to parse

// @return KErrNone if all OK or file read error code

//

	{

	//Find out whether the file exists. If not dont start the active object

	if(!BaflUtils::FileExists(aRFs,aFileToParse))

		{

		return KErrNotFound;

		}

	else

		{	

		//Check whether the file is locked by any other process				

		RFile tempFile;

		TInt err=tempFile.Open(aRFs, aFileToParse, EFileRead | EFileShareReadersOnly);		

		if(err!=KErrNone)

			{

			return err;					

			}

		tempFile.Close();	

		}	

	Cancel();

	iSuspiciousCharacter = KErrNotFound;

	iError = KErrNone;

	iSeverity = EXMLNone;

	iDocTypeSet = EFalse;

	iVersionSet = EFalse;

	/* We need to open our file in a leave-safe place as it involves

	   a heap alloc, and so we'll set up the AO to do that when it runs next.

	*/

	delete iFileToParse;

	iFileToParse = aFileToParse.Alloc();

	if(iFileToParse == NULL)

		{

		return KErrNoMemory;

		}

	iRFs = aRFs;

	iState = KInitFromFile;

	SetActive();

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrNone);

	return KErrNone;

	}

/** 

Parses a specified XML file into a DOM object tree.

Parses a specified XML file into a DOM object tree using an open file handle. The 

parser takes ownership of the open file handle and will close handle when completed.

@param aFileHandleToParse An open file handle for the file to parse. Ownership of the

	   file handle is passed.

@return KErrNone if successful.

*/

EXPORT_C TInt CMDXMLParser::ParseFile(RFile& aFileHandleToParse)

	{	

	iFileHandleToParse = aFileHandleToParse;

	Cancel();

	iSuspiciousCharacter = KErrNotFound;

	iError = KErrNone;

	iSeverity = EXMLNone;

	iDocTypeSet = EFalse;

	iVersionSet = EFalse;

	iState = KInitFromFile;

	iStatus = KRequestPending;

	SetActive();

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrNone);

	return KErrNone;

	}

//==================================================================================

EXPORT_C void CMDXMLParser::ParseSourceL(MMDXMLParserDataProvider *aSource)

	{

	iSuspiciousCharacter = KErrNotFound;

	iError = KErrNone;

	iSeverity = EXMLNone;

	iDocTypeSet = EFalse;

	iVersionSet = EFalse;

	iDataSource = aSource;

	PrepareForReuseL();

	GetMoreData();

	}

//==================================================================================

void CMDXMLParser::PrepareForReuseL()

	{

	Cancel();

	iError = KErrNone;

	iSeverity = EXMLNone;

	iDocTypeSet = EFalse;

	iVersionSet = EFalse;

	iBytesPerChar = 0;

	iNextChar = 0;

	iInputBytesRemaining = 0;

	iOpened = EFalse;

	iClosed = EFalse;

	iNewElement = NULL;

	iParentElement = NULL;

	delete iUTF8EdgeBuffer;

	iUTF8EdgeBuffer = NULL;

	delete iBomBuffer;

	iBomBuffer = NULL;

	CreateDocumentL();

	iState = KDetermineCharset;

	}

//==================================================================================

TBool CMDXMLParser::DetectFileType()

//

// Detects the type of a data source - can be Unicode, UTF-8 or ASCII (because ASCII is

// a subset of UTF-8).

// If the file is empty it is assumed to be Utf-8.

	{

	TBuf8<3> bom;

	// Read the first 3 bytes of the file.  These contain any BOM present.  If it turns out

	// there's not a bom we leave the pointer untouched so we can parse these bytes

	// as usual.  

	if(iInputBufferPtr.Length() < 3)

		return EFalse;

	else

		bom.Copy(iInputBufferPtr.Left(3));

	TInt hichar = (CEditableText::EByteOrderMark & 0xFF00)>>8;

	TInt lochar = CEditableText::EByteOrderMark & 0xFF;

	if((bom[0] == 0xEF) && (bom[1] == 0xBB) && (bom[2] == 0xBF))

		{

		// Utf-8 with a bom.  We don't want to parse the bom, so add 3 bytes offset to the read pos.

		iBytesPerChar = 1;

		iNextChar = 3;

		}

	else

		{

		if((bom[0] == lochar) && (bom[1] == hichar))

			{

			// Little Endian Unicode.  Move the read position on 2 bytes to ignore the bom.

			iBytesPerChar = 2;

			// would normally skip first 2 characters

			iNextChar = 2;

			}

		else if((bom[0] == hichar) && (bom[1] == lochar))

			{

			// We have a bom, but it indicates endianess opposite to that of the platform.  We

			// don't currently support this so set an error.

			SetError(KErrNotSupported, EXMLFatal);

			}

		else

			{

			// Default to Utf-8

			iBytesPerChar = 1;

			}

		}

	return ETrue;

	}

//==================================================================================

EXPORT_C void CMDXMLParser::DoCancel()

//

// DoCancel function inherited from CActive base class

//

	{

	if (iDataSource)

	  {

	  iDataSource->Disconnect();

	  iDataSource = NULL;

	  }

	}

//==================================================================================

EXPORT_C TInt CMDXMLParser::RunError(TInt aError)

//

// RunError function inherited from CActive base class - intercepts any Leave from

// the RunL() function, sets an appropriate errorcode and calls ParseFileCompleteL

//

	{

	if(iDataSource)

		{

		iDataSource->Disconnect();

		iDataSource = NULL;

		}

	iSeverity = EXMLFatal;

	iError = aError;

	if (iFileToParse)

		{

		delete iFileToParse;

		iFileToParse = NULL;

		}

	else if( iFileSource==NULL )

		{

		// iFileSource is not set so the ownership of the file handle has not been passed

		iFileHandleToParse.Close();

		}

	__ASSERT_DEBUG(iParserObserver != NULL, Panic(ENullMemVarParserObserver));

	TRAPD(err, iParserObserver->ParseFileCompleteL());

	return err;

	}

//==================================================================================

TBool CMDXMLParser::DoParseLoopL()

//

// RunL function inherited from CActive base class - carries out the actual parsing.

// @leave can Leave due to OOM

//

	{

	TBuf<1> singleChar;

	TGetCharReturn getCharReturn = KError;

	TInt error;

	while(iSeverity != EXMLFatal && (getCharReturn = GetChar(singleChar), getCharReturn == KCharReturned) )

		{

#if 0	// THIS NEEDS TO BE REMOVED - IT'S A VERY HANDY DEBUGGING TOOL WHEN YOU'RE MANUALLY DOING 

		// BYTE ORDERING ON MISALIGNED STREAMS THOUGH...

		{

#define DES_AS_8_BIT(str) (TPtrC8((TText8*)((str).Ptr()), (str).Size()))

		RFs aRFs;

		RFile aFile;

		_LIT(KFileName, "c:\\documents\\SMIL_Test_Files\\echoOutput.txt");

		TPtrC file;

		TInt err;

		file.Set(KFileName);

		aRFs.Connect();

		err = aFile.Open(aRFs, file, EFileWrite);

		if(err != KErrNone)

			err = aFile.Create(aRFs, file, EFileWrite);

		err = 0;

		aFile.Seek(ESeekEnd, err);

		aFile.Write(DES_AS_8_BIT(singleChar));

		aFile.Close();

		aRFs.Close();

		}

#endif

		if((!iOpened) && singleChar != KXMLStartTag)

			{

			HandleTextL(singleChar);

			}

		if((iOpened) || (singleChar == KXMLStartTag))			

			{

			if(singleChar == KXMLStartTag)

				{

				if(iOpened)

					{

					if((iSuspiciousCharacter == KErrNotFound))

						{

						iSuspiciousCharacter = iElementTag->Length();

						}

					}

				else

					{

					AddTextL(iParentElement);

					iOpened = ETrue;

					}

				}

			else if(singleChar == KXMLEndTag)

				{

				if(iSuspiciousCharacter != KErrNotFound)

					{

					TPtrC suspiciousSection = iElementTag->Mid(iSuspiciousCharacter);

					if( CheckForStartCData(suspiciousSection) == 0 )

						{

						TInt endCDataLen = TPtrC(KXMLEndCDataSection).Length();

						// The suspicious character begins a CDataSection.  Check if

						// this End Tag is closing it.

						if( suspiciousSection.Right(endCDataLen - 1) 

							== TPtrC(KXMLEndCDataSection).Left(endCDataLen - 1) )

							{

							// Any dodgy characters began the CDataSection or were in it