// Copyright (c) 1999-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:

//

// Local includes

//

#include "XmlPars.h"

// System includes

//

#include <attrlut.h>

#include <cbnfnode.h>

#include <xmlelemt.h>

#include <cnode.h>

#include <xmllib.h>	// For the error codes

LOCAL_C TBool Compare(TInt aLength,const TText* aStringA,const TDesC& aStringB)

	{

	if(aLength==aStringB.Length())

		{

		const TText* stringB=aStringB.Ptr();

		while(aLength>=(TInt)(sizeof(TInt32)/sizeof(TText)))

			{

			if(*(TInt32*)stringB!=*(TInt32*)aStringA)

				return EFalse;

			stringB+=(sizeof(TInt32)/sizeof(TText));

			aStringA+=(sizeof(TInt32)/sizeof(TText));

			aLength-=(sizeof(TInt32)/sizeof(TText));

			}

		while(aLength>0)

			{

			if(*stringB++!=*aStringA++)

				return EFalse;

			aLength--;

			}

		return ETrue;

		}

	return EFalse;

	}

CXmlParser::CXmlParser(CAttributeLookupTable& aAttributeLUT) 

: CBNFParser(aAttributeLUT), iErrorCode(KErrNone), iDataGathering(EFalse)

	{

	}

CXmlParser* CXmlParser::NewL(CAttributeLookupTable& aAttributeLUT)

	{

	CXmlParser* self = new(ELeave) CXmlParser(aAttributeLUT);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

	}

CXmlParser::~CXmlParser()

	{

	__XML_LOG_ENTER(_L("CXmlParser::~CXmlParser()"));

	PreAttribute(*this);	// Clears up attribute variables

	PreExternalID(*this);

	delete iName;

	delete iCData;

	delete iDTDUrl;

	delete iDocType;

	delete iXmlVersionString;

	delete iDocRootName;

	__XML_LOG_RETURN;

	__XML_CLOSE_LOG;

	}

void CXmlParser::ConstructL()

	{

	__XML_OPEN_LOG(__LOG_WAP_FILE_NAME);

	__XML_LOG_ENTER(_L("CXmlParser::CXmlParser()"));

	__XML_LOG_RETURN;

	}

void CXmlParser::ResetL(CXmlElement* aRootNode)

// Reseting method with which the parser can be prepared for parsing another document

	{

	__XML_LOG_ENTER(_L("CXmlParser::ResetL()"));

	iRootNode = aRootNode;

	iCurrentNode = iRootNode;

	ResetL();

	__XML_LOG_RETURN;

	}

void CXmlParser::ResetL()

// Inherited reseting method

	{

	__XML_LOG_ENTER(_L("CXmlParser::ResetL()"));

	CBNFParser::ResetL();

	PreAttribute(*this);

	PreExternalID(*this);

	iRootTagFound = EFalse;

	iDataGathering = EFalse;

	iErrorCode = KErrNone;

	delete iName;

	iName = NULL;

	delete iCData;

	iCData = NULL;

	delete iDTDUrl;

	iDTDUrl = NULL;

	delete iDocType;

	iDocType = NULL;

	delete iDocRootName;

	iDocRootName = NULL;

	delete iXmlVersionString;

	iXmlVersionString = NULL;

	__XML_LOG_RETURN;

	}

void CXmlParser::ContinueL()

// Continue parsing without adding data

	{

	__XML_LOG_ENTER(_L("CXmlParser::ContinueL()"));

	iErrorCode = KErrNone;

	if( !iDataGathering )

		{

		ParseL();

		}

	__XML_LOG_RETURN;

	}

void CXmlParser::ProcessDataL(HBufC8& aData)

// Parse incoming data. Data is copied.

	{

	__XML_LOG_ENTER(_L("CXmlParser::()"));

	HBufC* newData = HBufC::NewL(aData.Length());

	newData->Des().Copy(aData.Des());

	ProcessDataL(newData);

	__XML_LOG_RETURN;

	}

void CXmlParser::ProcessDataL(HBufC* aData)

// Process given data. Parser takes owneship of the data.

	{

	__XML_LOG_ENTER(_L("CXmlParser::ProcessDataL()"));

	EolNormalization(aData->Des());

	iString.AddStringL(aData);

	if( iRootNode == NULL )

		{

		iErrorCode = EWapErrXmlLibMissingDocumentRootNode;

		__XML_LOG(_L("ProcessDataL setting error code EWapErrXmlLibMissingDocumentRootNode"));

		__XML_LOG_RETURN;

		return;

		}

	if( !iDataGathering )

		{

		ParseL();

		}

	__XML_LOG_RETURN;

	}

void CXmlParser::CommitL()

// All the data has been passed in. Finish.

	{

	__XML_LOG_ENTER(_L("CXmlParser::CommitL()"));

	if( iDataGathering )

		{

		const HBufC* id = iLUT.Des2IDL(KXmlLibBufferedDocumentAttribute);

		CDataNoDelete* attributeValue = new(ELeave) CDataNoDelete(iString.ContentL());

		CleanupStack::PushL(attributeValue);

		iRootNode->AddAttributeL(id, attributeValue);

		CleanupStack::Pop(attributeValue);

		iErrorCode = EWapErrXmlLibDocumentBuffered;

		__XML_LOG(_L("CommitL setting error code EWapErrXmlLibDocumentBuffered"));

		__XML_LOG_RETURN;

		return;

		}

	CBNFParser::CommitL();

	__XML_LOG_RETURN;

	}

//

//	CALLBACK FUNCTIONS

//

// These methods are bound to specific rules and they are called when ever a rule finishes,

// regardless of the success of the matching of the rule.

// Functions, whose name start with "Post" are executed _after_ the rule and "Pre" rules

// are executed prior to the matching attempt of a rule.

void CXmlParser::PostCharDataL(CBNFParser& aParser)

// Handle "ordinary" character data. This generates #PCDATA nodes for the body text

// of the document. Nodes consisting only of white spaces are ignored.

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostCharDataL()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		HBufC* data = parser.MarkedL();

		TInt i=0;

		TPtr text = data->Des();

		for(; i < data->Length(); i++)

			{

			TInt ch=text[i];

			if( !(ch == 0x9 || ch == 0xA || ch == 0xD || ch == 0x20)  )

				{

				break;

				}

			}

		if( i >= data->Length() )

			{

			delete data;

			parser.DeleteMark();

			__XML_EXT_LOG_RETURN;

			return;

			}

		parser.CharRefReplacement(text);

		CleanupStack::PushL(data);

		const HBufC* id = parser.iLUT.Des2IDL(KPCDataID);

		CXmlElement* newNode = CXmlElement::NewL(id, parser.iCurrentNode);

		parser.iCurrentNode->AppendChildL(newNode);  // Now the node is owned by the parent and would hence get deleted in a leave

		newNode->SetDataL(data);

		CleanupStack::Pop();

		}

	parser.DeleteMark();

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostCDStart(CBNFParser& aParser)

// Initialize matching of CDATA sections

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostCDStart()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		delete parser.iCData;

		parser.iCData = NULL;

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostCDataL(CBNFParser& aParser)

// Store the matched text withing CDATA section

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostCData()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		parser.iCData = parser.MarkedL();

		}

	parser.DeleteMark();

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostCDSectL(CBNFParser& aParser)

// If whole of the CDATA section matches, a CDATA node is generated

// and the data is attached to that node. In other cases the document

// is in error.

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostCDSectL()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		const HBufC* id = parser.iLUT.Des2IDL(KCDataID);

		CXmlElement* newNode = CXmlElement::NewL(id, parser.iCurrentNode);

		parser.iCurrentNode->AppendChildL(newNode);

		newNode->SetDataL(parser.iCData);

		parser.iCData = NULL;

		}

	else if( parser.iCData != NULL )

		{

		delete parser.iCData;

		parser.iCData = NULL;

		parser.iErrorCode = EWapErrXmlLibMissingCDATASectionEndTag;

		parser.SetState(EStopped);

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostNameL(CBNFParser& aParser)

// Store string matching the Name -rule

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostName()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		delete parser.iName;	// Get rid of the possibly errorneous, leftover name!

		parser.iName = parser.MarkedL();

		}

	parser.DeleteMark();

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostNodeNameL(CBNFParser& aParser)

// Wrapper function for storing the matched Name string as a name of a Node.

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostNodeNameL()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		// Validity constraint: root element name must match the Name declared in DOCTYPE

		if( parser.iCurrentNode == parser.iRootNode )

			{

			if( parser.iDocRootName == NULL )

				{

				parser.iErrorCode = EWapErrXmlLibInvalidDocumentStructure;

				parser.SetState(EStopped);

				return;	

				}

			if( parser.iDocRootName->Compare(parser.iName->Des()) != 0 )

				{

				parser.iErrorCode = EWapErrXmlLibRootElementNameMismatch;

				parser.SetState(EStopped);

				return;

				}

			}

		const HBufC* type = parser.iLUT.Des2IDL(parser.iName->Des());

		parser.iCurrentNode->SetType(type);

		delete parser.iName;

		parser.iName = NULL;

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PreAttribute(CBNFParser& aParser)

// Prepare for matching an attribute definition (attrName = "attrValue")

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PreAttribute()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	delete parser.iAttrName;

	delete parser.iAttValue;

	parser.iAttrName = parser.iAttValue = NULL;

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostAttrName(CBNFParser& aParser)

// Store the matched Name-string as attribute name

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostAttrName()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		parser.iAttrName = parser.iName;

		parser.iName = NULL;

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostPureAttValueL(CBNFParser& aParser)

// Store the matched string as attribute value

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostPureAttValue()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		delete parser.iAttValue;

		parser.iAttValue = parser.MarkedL();

		}

	parser.DeleteMark();

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostAttributeL(CBNFParser& aParser)

// Should all the parts of an attribute definition match, an attribute

// is created for the current node.

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostAttributeL()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		if(parser.iAttrName != NULL)

			{

			// Add the attribute

			if(parser.iAttValue != NULL)

				{

				TPtr attrValText = parser.iAttValue->Des();

				parser.CharRefReplacement(attrValText);

				parser.iCurrentNode->SetAttributeL(*parser.iAttrName, *parser.iAttValue, parser.iLUT);

				}

			else

				parser.iCurrentNode->SetAttributeL(*parser.iAttrName, KNullDesC, parser.iLUT);

			}

		delete parser.iAttValue;

		delete parser.iAttrName;

		parser.iAttrName = parser.iAttValue = NULL;

		}

	else if( parser.iAttValue != NULL || parser.iAttrName != NULL )

		{

		parser.iErrorCode = EWapErrXmlLibInvalidAttributeDeclaration;

		parser.SetStatus(EStopped);

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostTagStartL(CBNFParser& aParser)

// A new tag start ("<") is matched, generate new node and attach it as child for its parent

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostTagStartL()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		if( parser.iRootTagFound )

			{

			CXmlElement* newNode = CXmlElement::NewL(NULL, parser.iCurrentNode);

			CleanupStack::PushL(newNode);

			parser.iCurrentNode->AppendChildL(newNode);

			CleanupStack::Pop();

			parser.iCurrentNode = newNode;

			}

		else

			{

			parser.iRootTagFound = ETrue;

			}

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostEmptyElemClose(CBNFParser& aParser)

// If we match a closing empty element (i.e. <tag /> ) then this tag has no children

// and current node pointer is moved up to the parent

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostEmptyElemClose()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		parser.iCurrentNode = (CXmlElement *)parser.iCurrentNode->Parent();

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostETag(CBNFParser& aParser)

// Post rule for an end tag. We check that the end tag name matches

// the name of the node pointer by iCurrentNode (if everything is fine and

// all the tags are properly opened and closed, the pointer should point

// to the node that opened this tag). 

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostETag()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		TDesC* type = (TDesC*)parser.iCurrentNode->Type();

		if( type->Compare(*parser.iName) )

			{

			parser.iErrorCode = EWapErrXmlLibEndTagMismatch;

			parser.SetState(EStopped);

			}

		else

			{

			// This is the end tag for iCurrentNode

			if( parser.iCurrentNode != parser.iRootNode)

				{

				parser.iCurrentNode = (CXmlElement*)parser.iCurrentNode->Parent();

				}

			// Here we don't need to make a notification of the node being the document closing (e.g. </wml> )

			// tag, since our rule tree won't match any subsequent tags and this will result in

			// EWapErrXmlLibInvalidDocument on call to CommitL.

			}

		delete parser.iName;

		parser.iName = NULL;

		}

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PreExternalID(CBNFParser& aParser)

// Prepare for matching an external ID

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PreExternalID()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	delete parser.iSystemLiteral;

	delete parser.iPubidLiteral;

	parser.iSystemLiteral = parser.iPubidLiteral = NULL;

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostPureSystemLiteralL(CBNFParser& aParser)

// Store the contents of the SystemLiteral

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostPureSystemLiteral()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		parser.iSystemLiteral = parser.MarkedL();

		}

	parser.DeleteMark();

	__XML_EXT_LOG_RETURN;

	}

void CXmlParser::PostPubidLiteralL(CBNFParser& aParser)

// Post rule for PubidLiteral

	{

	__XML_EXT_LOG_ENTER(_L("CXmlParser::PostPubidLiteral()"));

	CXmlParser& parser = REINTERPRET_CAST(CXmlParser&, aParser);

	if( parser.RuleMatched() )

		{

		HBufC* data = parser.MarkedL();

		// Since this entire rule matched, there must be quotation marks in the beginning

		// and at the end of the string. Those are now removed.

		TPtr pureLiteral = data->Des();

		pureLiteral.Delete(pureLiteral.Length()-1,1);

		pureLiteral.Delete(0,1);

		parser.iPubidLiteral = data;

		}