/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  ?Description

*

*/

// INCLUDE FILES

#include "CXMLReader.h"

/* Dictionar Public ID's */

#define WML_1_1_PUBLIC_ID         4      

#define WML_1_2_PUBLIC_ID         9     

#define WML_1_3_PUBLIC_ID        10    

#define XHTML_1_0_PUBLIC_ID      55    

#define SYNCML_1_0_PUBLIC_ID  0xFD1

#define WAP_PROV_1_0_PUBLIC_ID   11

#define SI_1_0_PUBLIC_ID          5

#define SL_1_0_PUBLIC_ID          6

#define PUSH_PROV_1_0_PUBLIC_ID   1    

extern "C" 

{ 

	extern NW_WBXML_Dictionary_t NW_Wml_1_0_WBXMLDictionary;

	extern NW_WBXML_Dictionary_t NW_Wml_1_1_WBXMLDictionary;

	extern NW_WBXML_Dictionary_t NW_Wml_1_2_WBXMLDictionary;

	extern NW_WBXML_Dictionary_t NW_Wml_1_3_WBXMLDictionary;

	extern NW_WBXML_Dictionary_t NW_XHTML_WBXMLDictionary;

	extern NW_WBXML_Dictionary_t NW_SyncML_1_0_WBXMLDictionary;

	extern NW_WBXML_Dictionary_t NW_SL_WBXMLDictionary;

//	extern NW_WBXML_Dictionary_t NW_wap_prov_doc_WBXMLDictionary;

//	extern NW_WBXML_Dictionary_t SI_dictionary;

//	extern NW_WBXML_Dictionary_t SL_dictionary;

//	extern NW_WBXML_Dictionary_t push_nokprov_dictionary;

}

#define DICTIONARY_COUNT 7

// ============================= LOCAL FUNCTIONS ===============================

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

// BeginElementCB

// BeginElement callback, stores elemntname in elemntlist

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

//

NW_Status_t BeginElementCB(NW_XML_Reader_t* aReader, 

						 const NW_XML_Reader_Interval_t* aName, 

						 void* aParser)

{

	CXMLObserver *wObserver = (CXMLObserver*)aParser;

	TPtrC wElementName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

	TRAPD(error, wObserver->SetElementL(wElementName));

	if(error)

	{

		(wObserver->GetAttributes())->Reset();

		return NW_STAT_FAILURE;

	}

	// New element, reset attributes list

	(wObserver->GetAttributes())->Reset();

	return NW_STAT_SUCCESS;

}

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

// EndElementCB. calls MXMLContentHandler::EndElement with elemntname, 

// removes closed element from elemntlist. 

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

//

NW_Status_t EndElementCB(NW_XML_Reader_t* aReader, 

					     const NW_XML_Reader_Interval_t* aName, 

					     NW_Uint32 /*aEmpFlag*/,

					     void* aParser)

{

	_LIT(KEmpty,"");

	TPtrC wEmpty(KEmpty);

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	wObserver->RemoveElement();

	MXMLContentHandler* aContentHandler = wObserver->GetContentHandler();

	TPtrC aElementName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

	TInt result = aContentHandler->EndElement(wEmpty, wEmpty, aElementName);

	aContentHandler->ReaderIndex( aReader->charIndex );

	return  result ? NW_STAT_SUCCESS:NW_STAT_FAILURE;		

}

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

// AttributesStartCB 

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

//

NW_Status_t AttributeStartCB (NW_XML_Reader_t*,

                               const NW_XML_Reader_Interval_t* /*pI_name*/,

                                void*)

{

	return NW_STAT_SUCCESS;	

}

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

// AttreibuteValueCB Adds new attribute to attributes list.

// Adds URI to URI list if namespaces is used

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

//

NW_Status_t AttributeValueCB(NW_XML_Reader_t* aReader, 

						   const NW_XML_Reader_Interval_t* aName,

                           const NW_XML_Reader_Interval_t* aValue,

                           void* aParser)

{

	_LIT(KNamespace,"xmlns:");

	TPtrC wNamespace(KNamespace);

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	CXMLAttributes* wAttr = wObserver->GetAttributes();

	// Append new attribute to attributes list

	TPtrC wAttributeName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

	TPtrC wAttributeValue( (TUint16*)aReader->pBuf + aValue->charStart, aValue->charStop - aValue->charStart );

	TRAPD(error,wAttr->AppendL(wAttributeName, wAttributeValue));

	if(error)

	{

		return NW_STAT_FAILURE;

	}

	// namespace declaration, store URI and extension

	if(wAttributeName.Left(6).Match(wNamespace)!=KErrNotFound)

	{

		TPtrC wExtension = wAttributeName.Right(wAttributeName.Length()-6);

		TRAP(error, wObserver->SetURIL(wAttributeValue, wExtension));

		if(error)

		{

			return NW_STAT_FAILURE;

		}

	}

	return NW_STAT_SUCCESS;		

}

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

// AttributesEndCB Calls MXMLContentHandler::StartElement with element name and

// attributes list.

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

//

NW_Status_t AttributesEndCB(NW_XML_Reader_t* /*aReader*/, 

						    NW_Uint32 /*aLength*/, 

						    void* aParser)

{

	_LIT(KLocalName,"");

	TPtrC wLocalName(KLocalName);

	_LIT(KURI,"");

	TPtrC wURI(KURI);

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	MXMLContentHandler* wContentHandler = wObserver->GetContentHandler();

	TPtrC wElementName = wObserver->GetElement();

	CXMLAttributes* wAttributes = wObserver->GetAttributes();

	// if using namespace, get URI and localname

	TInt wIndex = wElementName.Locate(':');

	if(wIndex > 0)

	{

		wLocalName.Set(wElementName.Right(wElementName.Length()-wIndex-1));

		TPtrC temp = wElementName.Left(wIndex);

		wURI.Set(wObserver->GetURI(temp));

	}

	// Call StartElement, now that we have all the attributes

	return wContentHandler->StartElement(wURI, wLocalName, wElementName, wAttributes) ? NW_STAT_SUCCESS:NW_STAT_FAILURE;	

}

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

// CDataCB Reports actual CData as MXMLContentHandler::Characters (between 

// MXMLContentHandler::StartCData and MXMLContentHandler::EndCData

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

//

NW_Status_t CdataCB (NW_XML_Reader_t* aReader,

                     const NW_XML_Reader_Interval_t* aName,

                     void* aParser)

{	

    CXMLObserver* wObserver = (CXMLObserver*)aParser;

	MXMLContentHandler* aContentHandler = wObserver->GetContentHandler();

	TPtrC wChar( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

	aContentHandler->StartCDATA();

	aContentHandler->Charecters( wChar, aName->charStart, (aName->charStop - aName->charStart) ); 

	return aContentHandler->EndCDATA()? NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// ContentCB Content reported as MXMLContentHandler::Characters

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

//

NW_Status_t ContentCB (NW_XML_Reader_t* aReader,

                             const NW_XML_Reader_Interval_t* aValue,

                             void* aParser)

{

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	TPtrC wChar( (TUint16*)aReader->pBuf + aValue->charStart, aValue->charStop - aValue->charStart );

	MXMLContentHandler* aContentHandler = wObserver->GetContentHandler();

	return (aContentHandler->Charecters(wChar, aValue->charStart, (aValue->charStop - aValue->charStart)))?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// AttrEntityVarValCB Adds new attribute to attributes list.

// Adds URI to URI list if namespaces is used

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

//

NW_Status_t AttrEntityVarValCB (NW_XML_Reader_t* aReader,

									const NW_XML_Reader_Interval_t* aName,

                                    NW_Uint8* aValue,

                                    NW_Uint32 aValueByteLength,

                                    void* aParser)

  {

        _LIT(KNamespace, "xmlns:");

        TPtrC wNamespace(KNamespace);

        CXMLObserver* wObserver = (CXMLObserver*)aParser;

        CXMLAttributes* wAttr = wObserver->GetAttributes();

        // Append new attribute to attributes list

        TPtrC wAttributeName( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

        TPtrC wAttributeValue( (TUint16*)aValue, aValueByteLength/2 );

        TRAPD(error,wAttr->AppendL(wAttributeName, wAttributeValue));

        if(error)

        {

                return NW_STAT_FAILURE;

        }

        // namespace declaration, store URI and extension

        if(wAttributeName.Left(6).Match(wNamespace)!=KErrNotFound)

        {

                TPtrC wExtension = wAttributeName.Right(wAttributeName.Length()-6);

                TRAP(error, wObserver->SetURIL(wAttributeValue, wExtension));

                if(error)

                {

                        return NW_STAT_FAILURE;

                }

        }

	return NW_STAT_SUCCESS;

  }

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

// EntityCB Entity reported as MXMLContentHandler::StartEntity

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

//

NW_Status_t EntityCB (NW_XML_Reader_t* aReader,

                             NW_Uint32 aNumEntity,

                             void* aParser, 

                             CXML_Uint8* aIntEntityValStr) 

{

	CXMLObserver *wObserver = (CXMLObserver*)aParser;

	NW_String_t *tempString = NW_String_new();

	// handle OOM

	if(tempString == NULL)

	{

		return NW_STAT_FAILURE;

	}

    if(aIntEntityValStr == NULL) 

    { 

     //It is character/predefined entities 

	NW_String_entityToString(aNumEntity, tempString, aReader->encoding);

    } 

    if(aIntEntityValStr != NULL) 

	{

     //It is the internal entity 

      tempString->storage = aIntEntityValStr; 

	}

    TPtrC wTmpEntityPtr((TUint16*)tempString->storage); 

        TInt result(wObserver->GetContentHandler()->StartEntity(wTmpEntityPtr)); 

	if (result == 0) 

	{

		NW_String_delete(tempString);

		return NW_STAT_FAILURE;

	}

        result = wObserver->GetContentHandler()->EndEntity(wTmpEntityPtr); 

		NW_String_delete(tempString);

	return (result?NW_STAT_SUCCESS:NW_STAT_FAILURE);

}

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

// CommentCB 

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

//

NW_Status_t CommentCB (NW_XML_Reader_t* aReader,

                       const NW_XML_Reader_Interval_t* aName,

                       void* aParser )

{

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	TPtrC wComment( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

	return (wObserver->GetContentHandler())->Comment(wComment)?NW_STAT_SUCCESS:NW_STAT_FAILURE;		

}

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

// StartDocumentCB 

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

//

NW_Status_t StartDocumentCB (NW_XML_Reader_t* /*aReader*/,

                             void* aParser )

{

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	return (wObserver->GetContentHandler())->StartDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE;		

}

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

// EndDocumentCB 

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

//

NW_Status_t EndDocumentCB (NW_XML_Reader_t* /*aReader*/,

                           void* aParser) 

{

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	return (wObserver->GetContentHandler())->EndDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE;		

}

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

// PiCB Report Processing Instruction with MXMLProcessingInstruction(Target, Data)

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

//

NW_Status_t PiCB (NW_XML_Reader_t* aReader,

                  NW_PiFormTypeTag_t aTag,

                  const NW_XML_Reader_Interval_t* aName,

                  const NW_XML_Reader_Interval_t* aVersion,

                  const NW_XML_Reader_Interval_t* /*aEncoding*/,

                  const NW_XML_Reader_Interval_t* /*aStandalone*/,

                  const NW_XML_Reader_Interval_t* aContent,

                  void* aParser)

{

	CXMLObserver* wObserver = (CXMLObserver*)aParser;

	TPtrC aTarget( (TUint16*)aReader->pBuf + aName->charStart, aName->charStop - aName->charStart );

	if(aTag==XMLDECL)

	{

		TPtrC aData( (TUint16*)aReader->pBuf + aVersion->charStart, aVersion->charStop - aVersion->charStart );

		return (wObserver->GetContentHandler())->ProcessingInstructions(aTarget, aData)?NW_STAT_SUCCESS:NW_STAT_FAILURE;	

	}

	else

	{

		TPtrC aData( (TUint16*)aReader->pBuf + aContent->charStart, aContent->charStop - aContent->charStart );

		return (wObserver->GetContentHandler())->ProcessingInstructions(aTarget, aData)?NW_STAT_SUCCESS:NW_STAT_FAILURE;

	}

}

// Binary Call backs

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

// Binary_StartDocument_CB 

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

//

NW_Status_t Binary_StartDocument_CB (NW_WBXML_Parser_t* /*aParser*/, 

                                   NW_WBXML_Document_t* /*aDocument*/, 

                                   void * aContext)

{

	CXMLObserver* wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->StartDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE;		

}

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

// Binary_EndDocument_CB 

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

// 

NW_Status_t Binary_EndDocument_CB(NW_WBXML_Parser_t* /*aParser*/, 

                                 void * aContext)

{

	CXMLObserver* wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->EndDocument()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Pi_CB ?description.

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

//

NW_Status_t Binary_Pi_CB (NW_WBXML_Parser_t* /*aParser*/, 

                        void * aContext)

{

	CXMLObserver* wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->ProcessingInstruction()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Pi_End_CB 

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

//

NW_Status_t Binary_Pi_End_CB (NW_WBXML_Parser_t* /*aParser*/, 

                            void* aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->ProcessingInstructionEnd()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Tag_Start_CB 

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

//

NW_Status_t Binary_Tag_Start_CB(NW_WBXML_Parser_t* /*aParser*/, 

                               void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->TagStart()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Tag_End_CB ?description.

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

//

NW_Status_t Binary_Tag_End_CB(NW_WBXML_Parser_t* /*aParser*/, 

                             void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;	

	return (wObserver->GetBinaryContentHandler())->TagEnd()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Attr_Start_CB 

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

//

NW_Status_t Binary_Attr_Start_CB(NW_WBXML_Parser_t* /*aParser*/, 

                                void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->AttributeStart()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Attr_Val_CB 

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

//

NW_Status_t Binary_Attr_Val_CB(NW_WBXML_Parser_t* /*aParser*/, 

                              void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->AttributeValue()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Content_CB 

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

//

NW_Status_t Binary_Content_CB(NW_WBXML_Parser_t* /*aParser*/, 

                             void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->Content()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_CodePage_CB 

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

//

NW_Status_t Binary_CodePage_CB(NW_WBXML_Parser_t* /*aParser*/, 

                              void* aContext)

{

	// Code page switch in WBXML doc

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->CodePageSwitch()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Extension_CB 

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

//

NW_Status_t Binary_Extension_CB(NW_WBXML_Parser_t* /*aParser*/, 

                               void* aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	return (wObserver->GetBinaryContentHandler())->Extension()?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_Token_CB 

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

//  

NW_Status_t Binary_Token_CB(NW_WBXML_Parser_t* /*aParser*/, 

                           NW_Uint8 aToken, 

                           void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	NW_String_UCS2Buff_t *wTemp = NW_WBXML_Dictionary_getTagByFqToken (aToken);

	TPtrC wString((TUint16*)wTemp);

	return (wObserver->GetBinaryContentHandler())->Token(aToken, wString)?NW_STAT_SUCCESS:NW_STAT_FAILURE;

}

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

// Binary_FQToken_CB 

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

//

NW_Status_t Binary_FQToken_CB(NW_WBXML_Parser_t* /*aParser*/, 

                            NW_Uint32 aFQToken, 

                            void *aContext)

{

	CXMLObserver *wObserver = (CXMLObserver*)aContext;

	NW_Byte aToken = (NW_Byte) (aFQToken & NW_WBXML_MASK_TOKEN);

	if( (aToken & NW_WBXML_MASK_TAG_ID) != NW_WBXML_LITERAL)

	{

		NW_String_UCS2Buff_t *wTemp = NW_WBXML_Dictionary_getTagByFqToken(aFQToken); 

		if(wTemp)

		{

			TPtrC wString((TUint16*)wTemp);

			return (wObserver->GetBinaryContentHandler())->Token(aToken, wString)?NW_STAT_SUCCESS:NW_STAT_FAILURE;

		}

		return NW_STAT_FAILURE;

	}

	return NW_STAT_SUCCESS;

}

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

// Binary_InlineString_CB 

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

//

NW_Status_t Binary_InlineString_CB(NW_WBXML_Parser_t *aParser,