// Copyright (c) 2006-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:
// SAX libxml2 parser plugin
//

#include "xmlengsaxplugin.h"
#include "xmlengsaxpluginerror.h"
#include "libxml2_globals_private.h"

MParser* CXMLEngineSAXPlugin::NewL(TAny* aInitParams)
	{

	CXMLEngineSAXPlugin* self = new(ELeave) 
		CXMLEngineSAXPlugin(reinterpret_cast<TParserInitParams*>(aInitParams));
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);

	return (static_cast<MParser*>(self));
	}
	
	
CXMLEngineSAXPlugin::CXMLEngineSAXPlugin(TParserInitParams* aInitParams)
:	iContentHandler (reinterpret_cast<MContentHandler*>(aInitParams->iContentHandler)),
	iStringDictionaryCollection (reinterpret_cast<RStringDictionaryCollection*>
											(aInitParams->iStringDictionaryCollection)),
	iCharSetConverter (reinterpret_cast<CCharSetConverter*>(aInitParams->iCharSetConverter)),
	iElementStack (reinterpret_cast<RElementStack*>(aInitParams->iElementStack))
	{
	}	


void CXMLEngineSAXPlugin::ConstructL() 
	{

	//settings flag as EFalse
	Flag_Error_Status = EFalse;
		
	//setting the callbacks for LibXML2 sax parser
	iParserEvents.externalSubset = ExternalSubset;
	iParserEvents.entityDecl = EntityDeclaration;		
	iParserEvents.getEntity = GetEntityCal;
	iParserEvents.resolveEntity = ResolveEntity;	
	iParserEvents.startDocument = StartDocument;
	iParserEvents.endDocument = EndDocument;		
	iParserEvents.characters = Characters;
	iParserEvents.startPrefixMapping = StartPrefixMapping;		
	iParserEvents.endPrefixMapping = EndPrefixMapping;
	iParserEvents.initialized = XML_SAX2_MAGIC;
	iParserEvents.startElementNs = StartElementNs;
	iParserEvents.endElementNs = EndElementNs;
	iParserEvents.ignorableWhitespace = IgnorableWhitespace;		
	iParserEvents.processingInstruction = ProcessingInstruction;
	iParserEvents.serror = StructuredError;
	iParserEvents.getParameterEntity = GetParameterEntity;
		
	//checking if content handler or dictionary are null
	User::LeaveIfNull(iContentHandler);  		
	User::LeaveIfNull(iStringDictionaryCollection);
	
	iStringPool = iStringDictionaryCollection->StringPool();
	XmlEngineAttachL();	
	}

CXMLEngineSAXPlugin::~CXMLEngineSAXPlugin()
    {
    XmlEngineCleanup(iParserContext);    	
    iParserContext = NULL;
        
    //releasing rest of objects
    iStringDictionaryCollection = NULL;
	iContentHandler = NULL;
	iCharSetConverter = NULL;
	iElementStack = NULL;
	
	//releasing entity object
	iEntity.name = NULL;
	iEntity.orig = NULL;
	iEntity.content = NULL;
	}


//From MParser
		
/** 
 * Enable a feature. 
 */
TInt CXMLEngineSAXPlugin::EnableFeature(TInt aParserFeature)
	{
	if(aParserFeature & ~(KFeatures))
		return KErrNotSupported;

	iParserMode |= aParserFeature;

	return KErrNone;
	}
		 
/** 
 * Disable a feature. 
 */
TInt CXMLEngineSAXPlugin::DisableFeature(TInt aParserFeature)
	{
	if(aParserFeature & ~(KFeatures))
		return KErrNotSupported;

	iParserMode &= ~aParserFeature;

	return KErrNone;
	}	

/** 
 * See if a feature is enabled. 
 */	
TBool CXMLEngineSAXPlugin::IsFeatureEnabled(TInt aParserFeature) const
	{
	return iParserMode & aParserFeature;
	}

void CXMLEngineSAXPlugin::StopParsing(TInt aError)
    {
    if(iParserContext)
        {
        xmlStopParser(iParserContext);
        iParserContext->errNo = aError;    
        if ( aError == KErrNoMemory ) 
            {
            xmlSetOOM();
            }
        }    
    }

/** 
 * Parses a descriptor that contains part of a document. 
 */
void CXMLEngineSAXPlugin::ParseChunkL(const TDesC8& aDescriptor)
	{	
	
	TInt result = KErrNone;
	
	if (!iParserContext)
		{		
		//creating sax parser object
	    iParserContext = xmlCreatePushParserCtxt( 
   						(xmlSAXHandler*) &iParserEvents, 
   						this, 
  						(const char *) aDescriptor.Ptr(), 
						aDescriptor.Length(),
   						NULL
   						);
		if(!iParserContext)
			{
			CleanupAndLeaveL(KErrNoMemory);			
			}
		
		//creating empty document object
		iParserContext->myDoc = xmlNewDoc(BAD_CAST "SAX compatibility mode document");
		if(!iParserContext->myDoc)
			{
			CleanupAndLeaveL(KErrNoMemory);			
			}
		iParserContext->myDoc->intSubset = xmlNewDtd(iParserContext->myDoc, BAD_CAST "fake", NULL, NULL);
		if(!iParserContext->myDoc->intSubset)
			{
			CleanupAndLeaveL(KErrNoMemory);			
			}
		
		//parsing process
	    result = xmlParseChunk(iParserContext, NULL, 0, 0);					
		}
	else
		{
		//parsing process
		result = xmlParseChunk(
				iParserContext, 
				(const char *) aDescriptor.Ptr(), 
				aDescriptor.Length(),
				0);		
		}
					
	//handling error situation
	//if fatal error, function throws exception 
	//in any other case next chunk is taken (recoverable)
	if ((result == XML_ERR_NO_MEMORY) || (iParserContext->lastError.level == XML_ERR_FATAL)
	        || (result < 0))
		{
		CleanupAndLeaveL(GetErrorNum(result));	
		}
	}
	
/** 
 * Parses a descriptor that contains the last  part of a document. 
 */
void CXMLEngineSAXPlugin::ParseLastChunkL(const TDesC8& /*aDescriptor*/)
	{
	if (!iParserContext)
		{
		User::Leave(EXmlParserError);
		}

	//parsing process
	TInt result(KErrNone);
	result = xmlParseChunk(iParserContext, NULL, 0, 1);
	if ((result == XML_ERR_NO_MEMORY) || (iParserContext->lastError.level == XML_ERR_FATAL)
	        || (result < 0))
		{
		CleanupAndLeaveL(GetErrorNum(result));			
		}			
		
	//releasing context to the parser
    xmlParserCtxtPtr ctxt = reinterpret_cast<xmlParserCtxtPtr>(iParserContext);
    if(ctxt->myDoc)                     
       {
       xmlFreeDoc(ctxt->myDoc); 
       }
    xmlFreeParserCtxt(ctxt);
	iParserContext = NULL;	
	
	}

/** 
 * Interfaces don't have a destructor, so we have an explicit method instead. 
 */
void CXMLEngineSAXPlugin::Release()
	{
	delete this;
	}

void CXMLEngineSAXPlugin::CleanupAndLeaveL(TInt aError)
	{
	// reseting OOM flag
	if((aError == KErrNoMemory) && xmlOOMFlag())
	    {
	    xmlResetOOM();
	    }

	//releasing context to the parser
	if(iParserContext)
	    {	    
        xmlParserCtxtPtr ctxt = reinterpret_cast<xmlParserCtxtPtr>(iParserContext);
        if(ctxt->myDoc)                     
            {
            xmlFreeDoc(ctxt->myDoc); 
            }
        xmlFreeParserCtxt(ctxt);		
	    }
    iParserContext = NULL;
	
	if (aError)
		{
		User::Leave(aError);			
		}
	else
		{
		User::Leave(EXmlParserError);
		}
	}

// From MContentSouce
	
/** 
 * This method tells us what's the next content handler in the chain. 
 */			
void CXMLEngineSAXPlugin::SetContentSink (MContentHandler& aContentHandler)
	{
	iContentHandler = &aContentHandler;
	}


//Public getter and setter method
		
/**
 * This method returns a parser context object. 
 */	
xmlParserCtxtPtr CXMLEngineSAXPlugin::getParserContext() const
	{
	return iParserContext;
	}
	
xmlEntity& CXMLEngineSAXPlugin::GetEntity()
	{
	return iEntity;
	}


// __________________________________________________________________________
// Exported proxy for instantiation method resolution
// Define the interface UIDs
const TImplementationProxy ImplementationTable[] = {
	IMPLEMENTATION_PROXY_ENTRY(0x101f9783, CXMLEngineSAXPlugin::NewL)
	};


EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
	{
	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;
	}