/*
* 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 "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:  Generic WBXML parser class implementation.
*
*/


// ------------------------------------------------------------------------------------------------
// Includes
// ------------------------------------------------------------------------------------------------
#include <s32mem.h>

#include "WBXMLParser.h"
#include "WBXMLAttributes.h"

// ------------------------------------------------------------------------------------------------
// Constants
// ------------------------------------------------------------------------------------------------
const TInt KNSmlBufferGranularity( 32 );

// ------------------------------------------------------------------------------------------------
// Local functions
// ------------------------------------------------------------------------------------------------
LOCAL_D void doPanic( const TDesC& aMsg, TInt aReason )
	{
	User::Panic(aMsg, aReason);
	}

// ------------------------------------------------------------------------------------------------
// CWBXMLParser
// ------------------------------------------------------------------------------------------------
EXPORT_C CWBXMLParser* CWBXMLParser::NewL()
	{
	CWBXMLParser* self = new (ELeave) CWBXMLParser();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(); // self
	return self;
	}

// ------------------------------------------------------------------------------------------------
void CWBXMLParser::ConstructL()
	{
	iBuffer = CBufFlat::NewL(KNSmlBufferGranularity);
	}

// ------------------------------------------------------------------------------------------------
EXPORT_C CWBXMLParser::~CWBXMLParser()
	{
	delete iBuffer;
	delete iStringTable;
	iStack.Reset();
	}

// ------------------------------------------------------------------------------------------------
EXPORT_C void CWBXMLParser::SetDocumentHandler( MWBXMLDocumentHandler* aHandler )
	{
	iDocHandler = aHandler;
	}

// ------------------------------------------------------------------------------------------------
EXPORT_C void CWBXMLParser::SetExtensionHandler( MWBXMLExtensionHandler* aHandler )
	{
	iExtHandler = aHandler;
	}

// ------------------------------------------------------------------------------------------------
EXPORT_C void CWBXMLParser::SetDocumentL( RReadStream& aInput )
	{
	iInput = aInput;
	iStack.Reset();
	iDocHdrParsed = EFalse;
	if( iDocHandler )
		{
		iDocHandler->DocumentChangedL();
		}
	}

// ------------------------------------------------------------------------------------------------
EXPORT_C TWBXMLParserError CWBXMLParser::ParseL()
	{
	__ASSERT_ALWAYS(iDocHandler, doPanic(KWBXMLNoDocHandler, KErrGeneral));
	__ASSERT_ALWAYS(iExtHandler, doPanic(KWBXMLNoExtHandler, KErrGeneral));
	if( !iDocHdrParsed )
		{
		TWBXMLParserError result(KWBXMLParserErrorOk);
		TRAPD(err, 	result = DoParseDocumentHeaderL());
		if( err == KErrEof )
			{
			return KWBXMLParserErrorEofTooEarly;
			}
		return result;
		}
	return DoParseDocumentBodyL();
	}

// ------------------------------------------------------------------------------------------------
TWBXMLParserError CWBXMLParser::DoParseDocumentHeaderL()
	{
	iDocHdrParsed = 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 begings now
	if( publicId < 0 )
		{
		iDocHandler->StartDocumentL(version, -publicId, charSet);
		}
	else
		{
		iDocHandler->StartDocumentL(version, StringTableString(publicId), charSet);
		}

	return KWBXMLParserErrorOk;
	}

// ------------------------------------------------------------------------------------------------
TWBXMLParserError CWBXMLParser::DoParseDocumentBodyL()
	{
	TUint8 id(0);
	
	TRAPD(err, id = ReadUint8L());

	if( err != KErrNone )
		{
		if( err == KErrEof )
			{
			iDocHandler->EndDocumentL();
			if( iStack.Count() > 0 )
				{
				return KWBXMLParserErrorEofTooEarly;
				}
			return KWBXMLParserErrorEof;
			}
		User::Leave(err);
		}
	
	switch (id) 
		{
		case SWITCH_PAGE: 
			{
			TUint8 cp = ReadUint8L();
			if( cp != iCodePage )
				{
				iDocHandler->CodePageSwitchL(cp);
				iCodePage = cp;
				}
			}
			break;
	
		case END:
			{
			if( !iStack.Count() )
				{
				User::Leave(KErrParserErrorInvalidDocument);
				}
			TWBXMLStackItem si(iStack.operator[](iStack.Count() - 1));
			if( si.CodePage() != iCodePage )
				{
				iDocHandler->CodePageSwitchL(si.CodePage());
				iCodePage = si.CodePage();
				}
			iDocHandler->EndElementL(si.Tag());
			iStack.Remove(iStack.Count() - 1);
			}
			break;
	
		case ENTITY:
			{
			TUint8 b = ReadUint8L();
			iDocHandler->CharactersL(TPtrC8(&b, 1));
			}
			break;

		case STR_I: 
			{
			iDocHandler->CharactersL(ReadStrIL());
			}
			break;

		case EXT_I_0: 
		case EXT_I_1: 
		case EXT_I_2:
		case EXT_T_0: 
		case EXT_T_1: 
		case EXT_T_2:
		case EXT_0:   
		case EXT_1:   
		case EXT_2:
		case OPAQUE:
			HandleExtensionsL(id);
			break;

		case STR_T: 
			iDocHandler->CharactersL(StringTableString(ReadMUint32L()));
			break;

		case PI:
			User::Leave(KErrNotSupported);
			break;

		default: 
			HandleElementL(id);
			break;
	    }

	return KWBXMLParserErrorOk;
	}

// ------------------------------------------------------------------------------------------------
TUint32 CWBXMLParser::ReadMUint32L()
	{
	TUint32 result = 0;
	TUint8 c;
	
	do 	{
		c = ReadUint8L();
		result = (result << 7) | (c & 0x7f);
		} while ( c & 0x80 );

	return result;
	}

// ------------------------------------------------------------------------------------------------
TUint8 CWBXMLParser::ReadUint8L()
	{
	return iInput.ReadUint8L();
	}

// ------------------------------------------------------------------------------------------------
TPtrC8 CWBXMLParser::ReadStrIL()
	{
	iBuffer->Reset();
	RBufWriteStream bws(*iBuffer);
	TUint8 c;
	while( (c = ReadUint8L()) != 0 )
		{
		bws.WriteUint8L(c);
		}
	bws.CommitL();
	return iBuffer->Ptr(0);
	}

// ------------------------------------------------------------------------------------------------
TPtrC8 CWBXMLParser::ReadOpaqueL()
	{
	iBuffer->Reset();
	RBufWriteStream bws(*iBuffer);
	bws.WriteL(iInput, ReadMUint32L());
	bws.CommitL();
	return iBuffer->Ptr(0);
	}

// ------------------------------------------------------------------------------------------------
TPtrC8 CWBXMLParser::StringTableString( TUint32 aIndex )
	{
	TPtrC8 temp(iStringTable->Mid(aIndex));
	TInt pos = temp.Find(KWBXMLNull());
	if( pos != KErrNotFound )
		{
		temp.Set(temp.Left(pos));
		}
	return temp;
	}

// ------------------------------------------------------------------------------------------------
void CWBXMLParser::ReadStringTableL()
	{
	delete iStringTable;
	iStringTable = 0;
	TUint32 strTblLen = ReadMUint32L();
	if( strTblLen > 0 )
		{
		iStringTable = HBufC8::NewL(strTblLen);
		TPtr8 ptr = iStringTable->Des();
		iInput.ReadL(ptr, strTblLen);
		}
	}

// ------------------------------------------------------------------------------------------------
void CWBXMLParser::HandleExtensionsL( TUint8 aId )
	{
	switch( aId ) 
		{
		case EXT_I_0: 
		case EXT_I_1: 
		case EXT_I_2:     
			iExtHandler->Ext_IL(TUint8(aId - EXT_I_0), ReadStrIL());
			break;
			
		case EXT_T_0: 
		case EXT_T_1: 
		case EXT_T_2:
			iExtHandler->Ext_TL(TUint8(aId - EXT_T_0), ReadMUint32L());
			break;
			
		case EXT_0:   
		case EXT_1: 
		case EXT_2:
			iExtHandler->ExtL(TUint8(aId - EXT_0));
			break;
			
		case OPAQUE: 
			iExtHandler->OpaqueL(ReadOpaqueL());
			break;

		default:
			User::Leave( KWBXMLParserErrorInvalidTag );
		}
	}

// ------------------------------------- -----------------------------------------------------------
void CWBXMLParser::HandleElementL( TUint8 aId )
	{
	TUint8 aTag = TUint8(aId & 0x3f);

	CWBXMLAttributes* attr = CWBXMLAttributes::NewLC();
	
	if( aId & 0x80 )
		{
		ReadAttributesL(attr);
		}

	iDocHandler->StartElementL(aTag, *attr);

	if( aId & 0x40 ) 
		{
		TWBXMLStackItem si(aTag, iCodePage);
	    iStack.Append(si);
		}
	else 
		{
	    iDocHandler->EndElementL(aTag);
		}

	CleanupStack::PopAndDestroy(); // attr
	}

// ------------------------------------------------------------------------------------------------
void CWBXMLParser::ReadAttributesL( CWBXMLAttributes* aAttributes )
	{
	TUint8 id = ReadUint8L();
	while( id != END ) 
		{	    
		iBuffer->Reset();
		RBufWriteStream bws(*iBuffer);
		TUint8 name = id;
	    id = ReadUint8L();
	    while( id > 0x80 || id == ENTITY || id == STR_I || id == STR_T || (id >= EXT_I_0 && id <= EXT_I_2) || (id >= EXT_T_0 && id <= EXT_T_2) ) 
			{		
			switch (id) 
				{
				case ENTITY: 
					bws.WriteUint8L(ReadUint8L());
					break;

				case STR_I: 
					bws.WriteL(ReadStrIL());
					break;
			
				case EXT_I_0: 
				case EXT_I_1: 
				case EXT_I_2:     
				case EXT_T_0: 
				case EXT_T_1: 
				case EXT_T_2:
				case EXT_0:   
				case EXT_1: 
				case EXT_2:
				case OPAQUE: 
					HandleExtensionsL(id);
					break;
 
				case STR_T: 
					bws.WriteL(StringTableString(ReadUint8L()));
					break;
			   
				default:
					bws.WriteUint8L(id);
					break;
				}
			id = ReadUint8L();
			}
		bws.CommitL();
		aAttributes->AddAttributeL(name, iBuffer->Ptr(0));
		}
	}

//End of File