// 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:

// Implements methods for parsing XML data

//

#include <stdlib.h>

#include <xml/dom/xmlengdomparser.h>

#include <xml/dom/xmlengdocument.h>

#include <xml/dom/xmlengerrors.h>

#include <xml/utils/xmlengmem.h>

#include <xml/utils/xmlengxestd.h>

#include <stdapis/libxml2/libxml2_parser.h>

#define PARSER_CTXT (static_cast<xmlParserCtxtPtr>(iInternal))

// ---------------------------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------------------------

//

EXPORT_C RXmlEngDOMParser::RXmlEngDOMParser(): iInternal(NULL), iError(0), iImpl(NULL)

	{

	}

// ---------------------------------------------------------------------------------------------

// Opens parser

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TInt RXmlEngDOMParser::Open(RXmlEngDOMImplementation& aDOMImpl)

    {

    iImpl = &aDOMImpl;

    return KErrNone;

    };

// ---------------------------------------------------------------------------------------------

// Frees all allocated by parser resources.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void RXmlEngDOMParser::Close()

    {

    Cleanup();

    iImpl = NULL;

    }

// ---------------------------------------------------------------------------------------------

// Builds DOM document from file. File is read by blocks of specified size, thus,

// avoiding keeping in memory both file and DOM tree for it.

//

// @note Use RDOMPushParser for parsing large files.

// @param aRFs File server session

// @param aFileName File name

// @return The created document

// @see GetLastParsingError()

// @leave KXmlEngErrParsing Parsing error

// @leave KXmlEngErrWrongUseOfAPI OpenL() not previously called

// @leave - One of the system-wide error codes

// ---------------------------------------------------------------------------------------------

//

EXPORT_C RXmlEngDocument RXmlEngDOMParser::ParseFileL(

    RFs &aRFs,

    const TDesC& aFileName,

    TUint aChunkSize )

    {

    if  ( aChunkSize == 0 )

    	{

    	return ParseFileWithoutChunksL( aRFs, aFileName );

    	}

    RFile xmlFile;

    TInt res;

    User::LeaveIfError(xmlFile.Open(aRFs, aFileName, EFileRead | EFileShareReadersOnly));

    CleanupClosePushL(xmlFile);

    RBuf8 buffer;

    if (aChunkSize < (KMaxTInt/2))

        {

        buffer.CreateL(aChunkSize);

        }

    else

        {

        User::Leave(KErrArgument);

        }

    CleanupClosePushL(buffer);

   	User::LeaveIfError(xmlFile.Read(buffer,aChunkSize));

	TUint length;

	do

		{

		ParseChunkL(buffer);

		res = xmlFile.Read(buffer, aChunkSize);

		if(res)

		    {

		    Close();

		    User::Leave(res);

		    }

		length = buffer.Length();

		} while (length);

	CleanupStack::PopAndDestroy(&buffer);

    CleanupStack::PopAndDestroy(&xmlFile);

    return FinishL();

    }

// ---------------------------------------------------------------------------------------------

// Builds DOM document from file.

// @see ParseFileL(RFs,TDesC&,TUint)

// ---------------------------------------------------------------------------------------------

//

EXPORT_C RXmlEngDocument RXmlEngDOMParser::ParseFileL(

    const TDesC& aFileName,

    TUint aChunkSize )

    {

    RFs aRFs;

    User::LeaveIfError(aRFs.Connect());

    CleanupClosePushL(aRFs);

    RXmlEngDocument doc = ParseFileL(aRFs, aFileName, aChunkSize);

    CleanupStack::PopAndDestroy(); // aRFs

    return doc;

    }

// ---------------------------------------------------------------------------------------------

// Pushes new data from buffer to DOM parser.

// Parsing is performed synchronously; method returns as soon as block is parsed.

//

// Buffer contents is not needed for further parsing after this method.

// Method may leave with KErrXMLSyntax code or one of general codes (e.g. KErrNoMemory)

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void RXmlEngDOMParser::ParseChunkL(

    const TDesC8& aBuffer )

    {

    if(!iImpl)

        {

        User::Leave(KXmlEngErrWrongUseOfAPI);

        }

    xmlParserCtxtPtr ctxt = PARSER_CTXT;

    if(!ctxt)

        {

        iError = KErrNone;

        // First call after reset or parser creation

        ctxt = xmlCreatePushParserCtxt(

                            NULL , /* default set of callbacks is used (for building tree) */

                            NULL , /* save as userData */

                            (const char*)aBuffer.Ptr(),

                            aBuffer.Size(),

                            NULL /* filename or URI */);

        if(!ctxt)

            {

            XmlEngOOMTestL();

            };

        iInternal = ctxt;    

        xmlCtxtUseOptions(ctxt, XML_PARSE_DTDLOAD | XML_PARSE_NOENT | XML_PARSE_NODICT);

        iError = xmlParseChunk(ctxt,

                      ""   , /* char* data */

                      0    , /* int size */

                      0);    /* flag: 0 - not the last chunk */

        }

    else

        {

        iError = xmlParseChunk(ctxt,

                      (char*)aBuffer.Ptr(), /* char* data */

                      (TInt)aBuffer.Size(), /* int size */

                      0);                   /* flag: 0 - not the last chunk */

        }

    if(iError != XML_ERR_OK && ctxt->lastError.level == XML_ERR_FATAL)

        {

        Cleanup();        

        XmlEngOOMTestL();

        User::Leave(KXmlEngErrParsing);

        }

    }

// ---------------------------------------------------------------------------------------------

// Returns constructed document after the last block of XML document is parsed.

// Ownership over returned RXmlEngDocument object is transferred to the caller of the method.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C RXmlEngDocument RXmlEngDOMParser::FinishL()

    {

    if(!iImpl)

        {

        User::Leave(KXmlEngErrWrongUseOfAPI);

        }

    xmlDocPtr doc;

    xmlParserCtxtPtr ctxt = PARSER_CTXT;

    if(!ctxt)

        {

        User::Leave(KXmlEngErrWrongUseOfAPI);

        }

    iError = xmlParseChunk(ctxt,

                        NULL /* char* data */,

                        0    /* int size */,

                        1    /* flag: 1 - the last chunk */);

    if(iError != XML_ERR_OK  && ctxt->lastError.level == XML_ERR_FATAL)

        {

        Cleanup();

        XmlEngOOMTestL();        

        User::Leave(KXmlEngErrParsing);

        }

    doc = ctxt->myDoc;

    ctxt->myDoc = NULL;

    xmlFreeParserCtxt(ctxt);

    iInternal = NULL;

    RXmlEngDocument rdoc;

    rdoc.OpenL(*iImpl,doc);

    return rdoc;

    }

// ---------------------------------------------------------------------------------------------

// Parses XML data from memory buffer and builds DOM RXmlEngDocument

//

// May leave with KXmlEngErrParsing code

// ---------------------------------------------------------------------------------------------

//

EXPORT_C RXmlEngDocument RXmlEngDOMParser::ParseL(

    const TDesC8& aBuffer )

    {

    if(!iImpl)

        {

        User::Leave(KXmlEngErrWrongUseOfAPI);

        }

    TInt code = 0;

    xmlDocPtr tree = xmlSAXParseDoc(

                        NULL, 

                        (xmlChar*) aBuffer.Ptr(), 

                        aBuffer.Size(), 

                        0, 

                        &code /* errorCode */);

    TEST_OOM_FLAG;

    iError = code;

    if(!tree)

        XmlEngLeaveL(KXmlEngErrParsing);

    RXmlEngDocument doc;

    doc.OpenL(*iImpl,tree);

    return doc;

    }

// ---------------------------------------------------------------------------------------------

// Return last parsing error

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TInt RXmlEngDOMParser::GetLastParsingError()

    {

    return iError;

    }

// ---------------------------------------------------------------------------------------------

// Parses XML file and builds DOM RXmlEngDocument without usage of chunks

//

// May leave with KXmlEngErrParsing code (besides system I/O error codes)

// ---------------------------------------------------------------------------------------------

//

RXmlEngDocument RXmlEngDOMParser::ParseFileWithoutChunksL(

    RFs &aRFs, 

    const TDesC& aFileName )

    {

    TInt size;

    RFile xmlFile;

    // Read file

    User::LeaveIfError(xmlFile.Open(aRFs, aFileName, EFileRead | EFileShareReadersOnly));

    CleanupClosePushL(xmlFile);

    User::LeaveIfError(xmlFile.Size(size));

    HBufC8* buffer = HBufC8::NewLC(size);

    TPtr8 bufferPtr = buffer->Des();

    User::LeaveIfError(xmlFile.Read(bufferPtr, size));

    RXmlEngDocument doc = ParseL(bufferPtr);

    CleanupStack::PopAndDestroy(buffer);

    CleanupStack::PopAndDestroy(&xmlFile);

    return doc;

    }

// ---------------------------------------------------------------------------------------------

// Cleanup internal data

// ---------------------------------------------------------------------------------------------

//

void RXmlEngDOMParser::Cleanup()

    {

    xmlParserCtxtPtr ctxt = PARSER_CTXT;

    // free all allocated resources

    if(ctxt)

        {

        if(ctxt->myDoc)

            xmlFreeDoc(ctxt->myDoc);

        xmlFreeParserCtxt(ctxt);

        iInternal = NULL;

        }

    }