/*

* Copyright (c) 2005-2007 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:  ConML parser/generator

*

*/

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

// Includes

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

#include <s32mem.h>

#include "sconconmlhandler.h"

#include "debug.h"

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

// CreateCSConConMLHandlerL

// Creates a new instance of CSConConMLHandler

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

//  

EXPORT_C CSConConMLHandler* CreateCSConConMLHandlerL()

    {

    LOGGER_ENTERFN( "CreateCSConConMLHandlerL()" );

    LOGGER_LEAVEFN( "CreateCSConConMLHandlerL()" );

    return CSConConMLHandler::NewL();

    }

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

// CSConConMLHandler::CSConConMLHandler()

// Default constructor

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

//  

CSConConMLHandler::CSConConMLHandler()

    {

    }

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

// CSConConMLHandler::CSConConMLHandler()

// Default constructor

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

//  

CSConConMLHandler::~CSConConMLHandler()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::~CSConConMLHandler()" );

    if ( iParseBuffer )

        {

        LOGGER_WRITE( "CSConConMLHandler::~CSConConMLHandler() : phase 1/4 " );

        delete iParseBuffer;

        iParseBuffer = NULL;

        }

    if ( iBuffer )

        {

        LOGGER_WRITE( "CSConConMLHandler::~CSConConMLHandler() : phase 2/4 " );

        delete iBuffer;

        iBuffer = NULL;

        }

    if ( iGenerator )

        {

        LOGGER_WRITE( "CSConConMLHandler::~CSConConMLHandler() : phase 3/4 " );

        delete iGenerator;

        iGenerator = NULL;

        }

    if ( iStringTable )

        {

        LOGGER_WRITE( "CSConConMLHandler::~CSConConMLHandler() : phase 4/4 " );

        delete iStringTable;

        iStringTable = NULL;

        }

    iElemStack.Close();

    LOGGER_LEAVEFN( "CSConConMLHandler::~CSConConMLHandler()" );

    }

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

// CSConConMLHandler::CSConConMLHaNewL()

// Creates a new instance of CSConConMLHandler

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

//  

CSConConMLHandler* CSConConMLHandler::NewL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::NewL()" );

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    LOGGER_LEAVEFN( "CSConConMLHandler::NewL()" );

    return self;

    }

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

// CSConConMLHandler::ConstructL()

// 2nd phase constructor

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

//  

void CSConConMLHandler::ConstructL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ConstructL()" );

    iGenerator = CSConConMLGenerator::NewL();

    iBuffer = CBufFlat::NewL( KSConBufferGranularity );

    iParseBuffer = CBufFlat::NewL( KSConDefaultDocumentSize );

    LOGGER_LEAVEFN( "CSConConMLHandler::ConstructL()" );

    }

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

// CSConConMLHandler::ParseDocumentL()

// Handles the document parsing, document in aInput

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

//  

TInt CSConConMLHandler::ParseDocumentL( 

    CBufFlat& aInput, MWBXMLConMLCallback* aCallback )

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ParseDocument()" );

    TInt ret ( KErrNone );

    iPos = 0;

    iParseBuffer->Reset();

    iParseBuffer->ResizeL( aInput.Size() );

    iParseBuffer->Write( 0, aInput.Ptr(0) );

    iHeaderParsed = EFalse;

    iGenerator->SetCallback( aCallback );

    while (ret == KWBXMLParserErrorOk )

        {

        ret = ParseL();

        }

    if ( ret == KWBXMLParserErrorEof ) 

        {

        ret = KErrNone;

        }

    LOGGER_WRITE_1( "CSConConMLHandler::ParseDocument()\

     returned %d", ret );   

    return ( ret );

    }

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

// CSConConMLHandler::GenerateDocument()

// Starts the generating of a document

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

//  

TInt CSConConMLHandler::GenerateDocument( ConML_ConMLPtr_t aContent )

    {

    LOGGER_ENTERFN( "CSConConMLHandler::GenerateDocument()" );

    iGenerator->GenerateConMLDocument ( aContent );

    LOGGER_LEAVEFN( "CSConConMLHandler::GenerateDocument()" );

    return KErrNone;

    }

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

// CSConConMLHandler::WBXMLDocument()

// Returns the generated WBXML -document

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

//  

TPtrC8 CSConConMLHandler::WBXMLDocument()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::WBXMLDocument()" );

    LOGGER_LEAVEFN( "CSConConMLHandler::WBXMLDocument()" );

    return iGenerator->WBXMLDocument();

    }

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

// CSConConMLHandler::XMLDocument()

// Returns the generated XML -document

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

//  

TPtrC8 CSConConMLHandler::XMLDocument()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::XMLDocument()" );

    LOGGER_LEAVEFN( "CSConConMLHandler::XMLDocument()" );

    return iGenerator->XMLDocument();

    }

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

// CSConConMLHandler::ParseL()

// Parses the next document tag / header if not parsed yet

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

//  

TInt CSConConMLHandler::ParseL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ParseL()" );

    if( !iHeaderParsed )

        {

        TConMLParserError result(KWBXMLParserErrorOk);

        TRAPD(err,  result = DoParseDocumentHeaderL());

        if( err == KErrEof )

            {

            LOGGER_WRITE( "CSConConMLHandler::ParseL() : KWBXMLParserErrorEofTooEarly " );

            return KWBXMLParserErrorEofTooEarly;

            }

        return result;

        }

    LOGGER_LEAVEFN( "CSConConMLHandler::ParseL()" );

    return DoParseDocumentBodyL();

    }

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

// CSConConMLHandler::DoParseDocumentHeaderL()

// Parses the document header

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

//  

TConMLParserError CSConConMLHandler::DoParseDocumentHeaderL()

    {

    LOGGER_ENTERFN( "CSConConMLParser::DoParseDocumentHeaderL()" );

    iHeaderParsed = ETrue;

    // Version

    TUint8 version = ReadUint8L();

    // PublicId

    TInt32 publicId = ReadMUint32L();

    if( publicId == 0 )

        {

        publicId = ReadMUint32L();

        }

    else

        {

        publicId = -publicId;

        }

    // Charset

    TUint32 charSet = ReadMUint32L();

    // String table

    ReadStringTableL();

    // Document begins now

    if( publicId < 0 )

        {

        iGenerator->StartDocument(version, -publicId, charSet);

        }

    else

        {

        iGenerator->StartDocument(version, 

            StringTableString(publicId), charSet);

        }

    LOGGER_LEAVEFN( "CSConConMLHandler::DoParseDocumentHeaderL()" );

    return KWBXMLParserErrorOk;

    }

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

// CSConConMLHandler::DoParseDocumentBodyL()

// Parses the next element of the document

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

//  

TConMLParserError CSConConMLHandler::DoParseDocumentBodyL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::DoParseDocumentBodyL()" );

    TUint8 id(0);

    TRAPD(err, id = ReadUint8L());

    if( err != KErrNone )

        {

        if( err == KErrEof )

            {

            iGenerator->EndDocument();

            if( iElemStack.Count() > 0 )

                {

                LOGGER_WRITE( "CSConConMLHandler::DoParseDocumentBodyL() : KWBXMLParserErrorEofTooEarly " );

                return KWBXMLParserErrorEofTooEarly;

                }

            return KWBXMLParserErrorEof;

            }

        User::Leave(err);

        }

    switch (id) 

        {

        case END:

            {

            if( !iElemStack.Count() )

                {

                LOGGER_WRITE( "CSConConMLHandler::DoParseDocumentBodyL() : KWBXMLParserErrorinvalidDocument " );

                User::Leave( KWBXMLParserErrorinvalidDocument );

                }

            TUint8 tag( iElemStack.operator[](iElemStack.Count() - 1 ));

            iGenerator->EndElementL( tag );

            iElemStack.Remove(iElemStack.Count() - 1);

            }

            break;

        case STR_I: 

            iGenerator->CharactersL(ReadStrIL());

            break;

        case OPAQUE:

            iGenerator->CharactersL(ReadOpaqueL());

            break;

        default: 

            HandleElementL(id);

            break;

        }

    LOGGER_LEAVEFN( "CSConConMLHandler::DoParseDocumentBodyL()" );

    return KWBXMLParserErrorOk;

    }

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

// CSConConMLHandler::ReadUint8L()

// Reads one byte from the document

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

//  

TUint8 CSConConMLHandler::ReadUint8L()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ReadUint8L()" );

    if ( iPos == iParseBuffer->Size()) 

        {

        User::Leave ( KErrEof );

        }

    TUint8 value;

    HBufC8* data = HBufC8::NewLC( sizeof(TUint8) );

    TPtr8 ptr = data->Des();

    iParseBuffer->Read(iPos, ptr, sizeof(TUint8));

    iPos+= sizeof(TUint8);

    value = ptr[0];

    CleanupStack::PopAndDestroy(1); //data 

    LOGGER_WRITE_1( "CSConConMLHandler::ReadUint8L()\

     : returned %d ", value );

    return value;

    }

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

// CSConConMLHandler::ReadMUint32L()

// Reads multibyte coding from the document

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

//  

TUint32 CSConConMLHandler::ReadMUint32L()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ReadMUint32L()" );

    TUint32 result = 0;

    TUint8 c;

    do  {

        c = ReadUint8L();

        result = (result << 7) | (c & 0x7f);

        } while ( c & 0x80 );

    LOGGER_WRITE_1( "CSConConMLHandler::ReadMUint32L()\

     : returned %d ", result );

    return result;

    }

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

// CSConConMLHandler::ReadStrIL()

// Reads string data from the document

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

//  

TPtrC8 CSConConMLHandler::ReadStrIL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ReadStrIL()" );

    iBuffer->Reset();

    RBufWriteStream bws(*iBuffer);

    TUint8 c;

    while( (c = ReadUint8L()) != 0 )

        {

        bws.WriteUint8L(c);

        }

    bws.CommitL();

    LOGGER_LEAVEFN( "CSConConMLParser::ReadStrIL()" );

    return iBuffer->Ptr(0);

    }

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

// CSConConMLHandler::ReadStringTableL()

// Handles the document's string table

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

//  

void CSConConMLHandler::ReadStringTableL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ReadStringTableL()" );

    delete iStringTable;

    iStringTable = NULL;

    TUint32 strTblLen = ReadMUint32L();

    if( strTblLen > 0 )

        {

        if( iPos+strTblLen > iParseBuffer->Size()) 

            {

            LOGGER_WRITE( "CSConConMLHandler::ReadStringTableL() : LEAVE KErrEof " );

            User::Leave ( KErrEof );

            }

        iStringTable = HBufC8::NewL(strTblLen);

        TPtr8 ptr = iStringTable->Des();

        iParseBuffer->Read(iPos, ptr, strTblLen);

        iPos+=strTblLen;

        }

    LOGGER_LEAVEFN( "CSConConMLHandler::ReadStringTableL()" );

    }

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

// CSConConMLHandler::StringTableString()

// Returns a value from the string table according to the given index

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

//  

TPtrC8 CSConConMLHandler::StringTableString( TUint32 aIndex )

    {

    LOGGER_ENTERFN( "CSConConMLHandler::StringTableString()" );

    TPtrC8 temp(iStringTable->Mid(aIndex));

    TInt pos = temp.Find(KWBXMLNull());

    if( pos != KErrNotFound )

        {

        temp.Set(temp.Left(pos));

        }

    LOGGER_LEAVEFN( "CSConConMLHandler::StringTableString()" );

    return temp;

    }

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

// CSConConMLHandler::HandleElementL()

// Starts a new element in the document

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

//  

void CSConConMLHandler::HandleElementL( TUint8 aId )

    {

    LOGGER_ENTERFN( "CSConConMLHandler::HandleElementL()" );

    TUint8 tag(TUint8(aId & 0x3f));

    iGenerator->StartElementL( tag );

    if( aId & 0x40 ) 

        {

        iElemStack.Append( tag );

        }

    else 

        {

        iGenerator->EndElementL(tag);

        }

    LOGGER_LEAVEFN( "CSConConMLHandler::HandleElementL()" );

    }

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

// CSConConMLHandler::ReadOpaqueL()

// Reads opaque data from the document

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

//  

TPtrC8 CSConConMLHandler::ReadOpaqueL()

    {

    LOGGER_ENTERFN( "CSConConMLHandler::ReadOpaqueL()" );

    iBuffer->Reset();

    RBufWriteStream bws(*iBuffer);

    TUint32 length = ReadMUint32L();

    if( iPos+length > iParseBuffer->Size()) 

        {

        LOGGER_WRITE( "CSConConMLHandler::ReadOpaqueL() : LEAVE KErrEof " );

        User::Leave ( KErrEof );

        }

    HBufC8* data = HBufC8::NewLC( length );

    TPtr8 ptr = data->Des();

    iParseBuffer->Read( iPos, ptr, length );

    iPos+= length;

    bws.WriteL(ptr, length);

    bws.CommitL();

    CleanupStack::PopAndDestroy(1); // data

    LOGGER_LEAVEFN( "CSConConMLHandler::ReadOpaqueL()" );

    return iBuffer->Ptr(0);

    }