/*

* Copyright (c) 2003 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: Implementation of CXmlPullParser.

*

*/

#include <eikenv.h>

#include <e32std.h>

#include <e32des8.h>

#include "XppImpl.h"

const TInt KExtraPunctuation = 5;

const TInt KBufSizeIncrement = 1024;

const TInt KBufInitSize = 2048;

//

// Common literal text

//

_LIT8(KOpenBracket, "<");

_LIT8(KCloseBracket, ">");

//_LIT8(KStartEndTag, "</");

//_LIT8(KCloseTag, "/>");

_LIT8(KSpace, " ");

_LIT8(KEquals, "=");

_LIT8(KSlash, "/");

_LIT8(KSingleQuote, "\'");

_LIT8(KDoubleQuote, "\"");

//_LIT8(KQuestionMark, "?");

//_LIT8(KExclamationMark, "!");

//_LIT8(KOpenCurlyBracket, "{");

//_LIT8(KCloseCurlyBracket, "}");

//_LIT8(KHyphen, "-");

_LIT8(KOpenAngleBracket , "[");

_LIT8(KCloseAngleBracket, "]");

_LIT8(KAmpersand, "&");

_LIT8(KAmpersandHash, "&#");

_LIT8(KSemicolon, ";");

// XML special marks

//_LIT8(KStartXmlProlog, "<?xml");

//_LIT8(KStartComment, "<!--");

_LIT8(KEndComment, "-->");

//_LIT8(KStartProcessingInstructions, "<?");

_LIT8(KEndPIAndProlog, "?>");

_LIT8(KStartCData, "<![CDATA[");

_LIT8(KEndCData, "]]>");

//_LIT8(KStartDocType, "<!DOCTYPE");

//_LIT8(KStartElement, "<!ELEMENT");

//_LIT8(KStartAttList, "<!ATTLIST");

//_LIT8(KStartEntity, "<!ENTITY");

//_LIT8(KStartNotation, "<!NOTATION");

//_LIT8(KEndCdata, "]]>");

_LIT8(KEntityLowerThan, "&lt;");           // <

_LIT8(KEntityGreaterThan, ">");         // >

_LIT8(KEntityAmpersand, "&");          // &

_LIT8(KEntityApostrophe, "'");        // '

_LIT8(KEntityQuotation, """);         // "

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

CXmlPullParser::CXmlPullParser()

: iState(EStateStartDocument), iCurrentElementPos(0), iPathBufPtr(NULL, 0), iDepth(0), 

iIsEmptyElement(EFalse), iCdataStartFound(EFalse), iCdataSectionText(EFalse),

iStringValuePtr(NULL, 0), iStringValueArray(NULL)

    {

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

// NewLC with two stage construction 

EXPORT_C CXmlPullParser* CXmlPullParser::NewLC(CDesC8ArrayFlat& aStringValueArray)

    {

    // get new, leave if can't

    CXmlPullParser* self = new (ELeave) CXmlPullParser();

    // push onto cleanup stack in case self->ConstructL leaves 

    CleanupStack::PushL(self);

    // complete construction with second phase constructor 

    self->ConstructL(aStringValueArray);

    return self;

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C CXmlPullParser* CXmlPullParser::NewL(CDesC8ArrayFlat& aStringValueArray) 

    {

    CXmlPullParser* self=NewLC(aStringValueArray);

    CleanupStack::Pop();

    return self;

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

void CXmlPullParser::ConstructL(CDesC8ArrayFlat& aStringValueArray)

    {

    iPathBuf = HBufC8::NewMaxL(KBufInitSize);

    iPathBufPtr.Set(iPathBuf->Des());

    iPathBufPtr.SetLength(0);  // Otherwise the Length is set to KBufInitSize

    iCAttrDataArray = new (ELeave) CArrayFixFlat<TAttrData>(1);

    iStringValue = HBufC8::NewMaxL(KBufInitSize);

    iStringValuePtr.Set(iStringValue->Des());

    iStringValuePtr.SetLength(0);  // Otherwise the Length is set to KBufInitSize

    //iStringValueArray = new (ELeave) CDesC8ArrayFlat(1);

    iStringValueArray = &aStringValueArray;

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

CXmlPullParser::~CXmlPullParser()

    {

    delete (iPathBuf);

    delete iCAttrDataArray;

    delete (iStringValue);

    //delete iStringValueArray;

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

void CXmlPullParser::CheckSpaceL(const TDesC8& aText)

    {

    TInt spaceLeft = iPathBufPtr.MaxLength() - iPathBufPtr.Length() - KExtraPunctuation;

    if (aText.Length() > spaceLeft)

        {

        TInt newMaxLength = iPathBufPtr.MaxLength() + aText.Length() + KBufSizeIncrement;

        iPathBuf = iPathBuf->ReAllocL(newMaxLength);

        iPathBufPtr.Set(iPathBuf->Des());

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CXmlPullParser::SetInput(const TDesC8& aInput)

    {

    iState = EStateStartDocument;

    iText.Set(KNullDesC8);

    iCAttrDataArray->Delete(0, iCAttrDataArray->Count());

    iDocument.Set(aInput);

    iDocPart.Set(KNullDesC8);

    iLexer.Assign(aInput);  // Assigns a string to this object from a descriptor

    iCurrentElementPos = 0;

    iPathBufPtr.Zero();

    iElement.Set(KNullDesC8);

    iDepth = 0;

    iIsEmptyElement = EFalse;

    iCdataStartFound = EFalse;

    iCdataSectionText = EFalse;

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::NextL()

    {

    TInt rv;

    switch (iState)

        {

        case EStateStartDocument:

            // skip

            if ((rv = SkipLeadingNonRelevantElements()) == ERcDocumentError)

                {

                return rv;

                }

            else

                {

                iCurrentElementPos = iLexer.Offset();

                rv = GetElementStartTagL();

                return rv;

                }

            //break;

        case EStateStartTag:

            // skip

            if ((rv = SkipNonRelevantElements()) == ERcDocumentError)

                {

                return rv;

                }

            else

                {

                iCurrentElementPos = iLexer.Offset();

                if (iIsEmptyElement)

                    {

                    // delete /end tag from the iPathBuf

                    // this is done by subtracting the length of the buffer

                    iPathBufPtr.SetLength(iPathBufPtr.LocateReverse('/'));

                    // decrement iDepth

                    iDepth--;

                    // if we have an XML-document that is only one empty-element

                    // then we must check if we are already in the end of the document

                    if (CheckIfEndOfFile())

                        {

                        return KErrNone;

                        }

                    }

                if (CheckIfNextEndTag())  // Check iState!!

                    {

                    if (iState == EStateError)

                        {

                        return ERcDocumentError;

                        }

                    else

                        {

                        rv = GetElementEndTag();

                        return rv;

                        }

                    }

                else if (CheckIfNextStartTag())  // Check iState!!

                    {

                    if (iState == EStateError)

                        {

                        return ERcDocumentError;

                        }

                    else

                        {

                        rv = GetElementStartTagL();

                        return rv;

                        }

                    }

                else // etext

                    {

                    rv = GetElementText();

                    return rv;

                    }

                }

            //break;

        case EStateText:

            // skip

            if ((rv = SkipNonRelevantElements()) == ERcDocumentError)

                {

                return rv;

                }

            else

                {

                iCurrentElementPos = iLexer.Offset();

                if (iState == EStateEndDocument)

                    {

                    // in EStateText we can not be in the end of the xml-document

                    iState = EStateError;

                    return ERcDocumentError;

                    }

                if (iCdataStartFound)

                    {

                    rv = GetElementText();

                    return rv;

                    }

                else

                    {

                    if (CheckIfNextEndTag())  // Check iState!!

                        {

                        if (iState == EStateError)

                            {

                            return ERcDocumentError;

                            }

                        else

                            {

                            // get end tag

                            rv = GetElementEndTag();

                            return rv;

                            }

                        }

                    else if (CheckIfNextStartTag())  // Check iState!!

                        {

                        if (iState == EStateError)

                            {

                            return ERcDocumentError;

                            }

                        else

                            {

                            // get start tag

                            rv = GetElementStartTagL();

                            return rv;

                            }

                        }

                    else // etext

                        {

                        // get text

                        rv = GetElementText();

                        return rv;

                        }

                    }

                }

            //break;

        case EStateEndTag:

            // after end tag can be end of file, new start tag, new end tag or etext

            // skip

            if ((rv = SkipNonRelevantElements()) == ERcDocumentError)

                {

                return rv;

                }

            else

                {

                iCurrentElementPos = iLexer.Offset();

                if (CheckIfEndOfFile())

                    {

                    return KErrNone;

                    }

                else

                    {

                    if (CheckIfNextStartTag())  // Check iState

                        {

                        if (iState == EStateError)

                            {

                            return ERcDocumentError;

                            }

                        else

                            {

                            rv = GetElementStartTagL();

                            return rv;

                            }

                        }

                    else if (CheckIfNextEndTag())  // Check iState!!

                        {

                        if (iState == EStateError)

                            {

                            return ERcDocumentError;

                            }

                        else

                            {

                            rv = GetElementEndTag();

                            return rv;

                            }

                        }

                    else // etext

                        {

                        // get text

                        rv = GetElementText();

                        return rv;

                        }

                    }

                }

            //break;

        case EStateEndDocument:

            return ERcWrongParserState;

            //break;

        case EStateError:

            return ERcWrongParserState;

            //break;

        default:

            return ERcUnknown;  // all the States are handled above

            //break;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C CXmlPullParser::TParserState CXmlPullParser::State()

    {

    return iState;

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::Name(TPtrC8& aName)

    {

    if ((iState == EStateStartTag) || 

        (iState == EStateText) || 

        (iState == EStateEndTag) ||

        (iState == EStateEndDocument))

        {

        aName.Set(iElement);

        return KErrNone;

        }

    else

        {

        return ERcWrongParserState;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::PathL(TPtrC8& aPath)

    {

    if ((iState == EStateStartTag) || 

        (iState == EStateText) || 

        (iState == EStateEndTag))

        {

        aPath.Set(iPathBufPtr);

        return KErrNone;

        }

    else

        {

        return ERcWrongParserState;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::Depth(TInt& aDepth)

    {

    if ((iState == EStateStartTag) || 

        (iState == EStateText) || 

        (iState == EStateEndTag))

        {

        aDepth = iDepth;

        return KErrNone;

        }

    else

        {

        return ERcWrongParserState;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::AttributeCount(TInt& aCount)

    {

    if (iState == EStateStartTag)

        {

        aCount = iCAttrDataArray->Count();

        return KErrNone;

        }

    else

        {

        return ERcWrongParserState;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::AttributeName(TInt aIndex, TPtrC8& aName)

    {

    if (iState == EStateStartTag)

        {

        if ((aIndex < iCAttrDataArray->Count()) && (aIndex >= 0))

            {

            aName.Set(iCAttrDataArray->At(aIndex).iName);

            return KErrNone;

            }

        else

            {

            return KErrNotFound;

            }

        }

    else

        {

        return ERcWrongParserState;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::AttributeValuePredefEntitiesNotEscaped(TInt aIndex, TPtrC8& aValue)

    {

    if (iState == EStateStartTag)

        {

        if ((aIndex < iCAttrDataArray->Count()) && (aIndex >= 0))

            {

            aValue.Set(iCAttrDataArray->At(aIndex).iValue);

            return KErrNone;

            }

        else

            {

            return KErrNotFound;

            }

        }

    else

        {

        return ERcWrongParserState;

        }

    }

////////////////////////////////////////////////////////////////////////////////////////

// 

////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CXmlPullParser::AttributeValuePredefEntitiesNotEscaped(const TDesC8& aName, TPtrC8& aValue)

    {

    TInt count;

    TInt index = 0;

    if (iState == EStateStartTag)

        {

        count = iCAttrDataArray->Count();

        while (index < count)

            {

            if (iCAttrDataArray->At(index).iName == aName)

                {

                aValue.Set(iCAttrDataArray->At(index).iValue);

                return KErrNone;

                }

            else

                {

                index ++;

                }

            }

        return KErrNotFound;

        }

    else

        {

        return ERcWrongParserState;

        }

    }