// Copyright (c) 2000-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:

//

// header

#include <cdtdmodel.h>

#include <attrlut.h>

// debug macros

#ifdef DEBUG_DTD

#include <e32svr.h>

_LIT(KDebugInvalidStream, "Stream is INVALID - Unmatched: %S\n");

_LIT(KDebugValidStream, "Stream is VALID!"));

_LIT(KDebugMatchedText, "Matched \"%S\"\n");

#define DEBUG_MATCHED(A) { HBufC* matched = aParser.MarkedL(); CleanupStack::PushL(matched); RDebug::Print(KDebugMatchedText, &_L(A)); CleanupStack::PopAndDelete(); }

#define DEBUG_MARK()	 { aParser.Mark(); } // Mark can leave

#define DEBUG_UNMARK()	 { aParser.DeleteMark(); }

#else

#define DEBUG_MATCHED(A) {}

#define DEBUG_MARK()	 {}

#define DEBUG_UNMARK()	 {}

#endif

// constants

const TInt KValidCharMatchStartStingLength=2;

// parser strings

#define _STRING(X) _LIT(K ## X, #X)

_STRING(Match0Plus);

_STRING(Rules);

_STRING(Rule);

_STRING(Comment);

_STRING(optS);

_STRING(Space);

_STRING(Optional);

_STRING(Match1Plus);

_STRING(Or);

_STRING(And);

_STRING(GroupStart);

_STRING(GroupEnd);

_STRING(SStringStart);

_STRING(SStringEnd);

_STRING(DStringStart);

_STRING(DStringEnd);

_STRING(Pop);

_STRING(Letter);

_STRING(Digit);

_STRING(HexNumber);

_STRING(DecNumber);

_STRING(HexChar);

_STRING(DecChar);

_STRING(ValidHexChar);

_STRING(BaseChar);

_STRING(ValidChar);

_STRING(SStringChar);

_STRING(DStringChar);

_STRING(Identifier);

_STRING(SString);

_STRING(DString);

_STRING(String);

_STRING(Primary);

_STRING(Factor);

_STRING(Definition);

_STRING(Definitions);

_STRING(DataReference);

_STRING(AttlistLine);

_STRING(EntityDefinition);

_STRING(CharRefStream);

_STRING(EntityDef);

_STRING(ReferenceName);

_STRING(EntityDeclName);

_STRING(ElementDeclName);

_STRING(NameChar);

_STRING(AttlistDeclName);

_STRING(EntityDecl);

_STRING(ElementDecl);

_STRING(AttDefRequired);

_STRING(AttDefImplied);

_STRING(AttDefFixed);

_STRING(AttDefault);

_STRING(Reference);

_STRING(AttlistReference);

_STRING(AttlistDef);

_STRING(AttlistDecl);

_STRING(CommentChar);

_STRING(AttfieldName);

_STRING(AttfieldTypeName);

_STRING(AttValue);

_STRING(GEContentS);

_STRING(GEContentD);

_STRING(GEDecl);

_STRING(PEDecl);

_LIT(KRefNameInitialChar,	"%");

_LIT(KRefNameEndChar,		";");

_LIT(KEntityInitialChar,	"%");

_LIT(KWhiteSpaceString,		" \n\r\t");

_LIT(KQMark,				"?");

_LIT(KStar,					"*");

_LIT(KPlus,					"+");

_LIT(KSpaceChar,			" ");

_LIT(KOrCharacter,			"|");

_LIT(KAndCharacter,			",");

_LIT(KGroupStartChar,		"(");

_LIT(KGroupEndChar,			")");

_LIT(KStringStartCharacter,	"'");

_LIT(KStringEndCharacter,	"'");

_LIT(KStringStartCharacter2,"\"");

_LIT(KStringEndCharacter2,	"\"");

_LIT(KHexCharacterStart,	"&#");

_LIT(KHexCharacterEnd,		";");

_LIT(KDecCharacterStart,	"#");

_LIT(KBaseCharacters,		"-()+,./:=?;!*#@$_%^&<>|");

_LIT(KOtherValidCharacters,	"'\"");

_LIT(KStringCharacters,		"\"[]");

_LIT(KStringCharacters2,	"'[]");

_LIT(KCharRefStreamAmpersand, "&");

_LIT(KNameOtherCharacters,	".-_:");

_LIT(KGEContentCharacters,	"^<&'");

_LIT(KGEContentDCharacters, "^<&\"");

_LIT(KEntityDeclStart,		"<!ENTITY");

_LIT(KEntityDeclEnd,		">");

_LIT(KElementDeclStart,		"<!ELEMENT");

_LIT(KElementDeclEnd,		">");

_LIT(KRequired,				"#REQUIRED");

_LIT(KImplied,				"#IMPLIED");

_LIT(KFixed,				"#FIXED");

_LIT(KCData,				"CDATA");

_LIT(KPCData,				"#PCDATA");

_LIT(KNMToken,				"NMTOKEN");

_LIT(KID,					"ID");

_LIT(KAttributeListStart,	"<!ATTLIST");

_LIT(KAttlistDeclNameCharacters,"AttlistDeclName");

_LIT(KAttributeListEnd,		">");

_LIT(KCommentStart,			"<!--");

_LIT(KCommentCharacter,		"-");

_LIT(KCommentEnd,			"-->");

_LIT(KCharRefMatchingPattern, "*&#*;*");

/** Allocates and constructs a new DTD parser.

@return New parser

@param aLUT Attribute lookup table in which to store attributes for the rule tree

*/

EXPORT_C CDTDModel* CDTDModel::NewL(CAttributeLookupTable& aLUT)

	{ // static

	CDTDModel* model = new (ELeave) CDTDModel(aLUT);

	return (model);

	}

/** Constructor.

@param aLUT Attribute lookup table in which to store attributes for the rule tree

*/

EXPORT_C CDTDModel::CDTDModel(CAttributeLookupTable& aLUT)

: CBNFParser(aLUT)

	{

	}

/** Destructor. */

EXPORT_C CDTDModel::~CDTDModel()

	{

	DoClear();

	}

EXPORT_C void CDTDModel::ResetL()

/** Reset the parser to a state where it can accept and parse new input.

	Any existing state of parsing and input data is destroyed. */

	{

	CBNFParser::ResetL();

	DoClear();

	}

void CDTDModel::DoClear()

	{

	delete iNewAttfieldName;

	iNewAttfieldName = NULL;

	delete iNewElementAttribute;

	iNewElementAttribute = NULL;

	delete iNewTree;

	iNewTree = NULL;

	iNewRuleStack.Clear();

	iInPEDecl = EFalse;

	iCharRefCheck = EFalse;

	delete iGEContent;

	iGEContent = NULL;

	}

/** Called when the parser starts a conditional point (i.e. And/Or rules) in the BNF grammar.

This overrides CBNFParser::StartConditional().

@param aRuleType Rule type

*/

EXPORT_C void CDTDModel::StartConditional(TParserNodeTypes aRuleType)

	{

	if (aRuleType == EOr)

		iNewRuleStack.MarkL(EConditionalMark);

	}

/** Called when the parser ends a conditional point (i.e. And/Or rules) in the BNF grammar.

This overrides CBNFParser::EndConditional().

@param aRuleType Rule type

@param aSuccess True if processing was sucessful, otherwise false

*/

EXPORT_C void  CDTDModel::EndConditional(TParserNodeTypes aRuleType, TBool aSuccess)

	{

	if (aRuleType == EOr)

		{

		if (aSuccess)

			iNewRuleStack.RemoveMark(EConditionalMark);

		else

			iNewRuleStack.DeleteToMark(EConditionalMark);

		}

	}

void CDTDModel::PreRulesL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	me.iNewTree = me.NewBNFL();

	}

#ifdef DEBUG_DTD

const TInt KMaxMatchTextDebugOuput=100;

void CDTDModel::PostRulesL(CBNFParser& aParser)

	{ // static

	if (aParser.RuleMatched())

		{

		if (!aParser.Valid())

			{

			HBufC* unmatched = aParser.StringL();

			RDebug::Print(KDebugInvalidStream, unmatched->Left(Min(KMaxMatchTextDebugOuput, unmatched->Length())));

			delete unmatched;

			}

		else

			RDebug::Print(KDebugValidStream);

		}

	}

#else

void CDTDModel::PostRulesL(CBNFParser& /*aParser*/)

	{ // static

	}

#endif // DEBUG_DTD

void CDTDModel::PreElementDeclL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	DEBUG_MARK(); // Mark can leave

	me.iNewRuleStack.MarkL(ERuleStartMark);

	}

void CDTDModel::PostElementDeclL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postElementDecl");

		me.iNewRuleStack.MergeToMarkL(ERuleStartMark);

		CBNFNode* currentRule=me.iNewRuleStack.Pop();

		CleanupStack::PushL(currentRule);

		currentRule->ReparentL(me.iNewRule);

		CleanupStack::Pop(); // currentRule

		}

	else

		me.iNewRuleStack.DeleteToMark(ERuleStartMark);

	DEBUG_UNMARK();

	}

void CDTDModel::PreEntityDeclL(CBNFParser& aParser)

	{ // static

	DEBUG_MARK(); // Mark can leave

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);	

	me.iNewRuleStack.MarkL(ERuleStartMark);

	}

void CDTDModel::PostEntityDeclL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postEntityDecl");

		if (!me.iNewRuleStack.IsEmpty())

			{

			me.iNewRuleStack.MergeToMarkL(ERuleStartMark);

			CBNFNode* currentRule = me.iNewRuleStack.Pop();

			CleanupStack::PushL(currentRule);

			currentRule->ReparentL(me.iNewRule);

			CleanupStack::Pop(); // currentRule

			me.iNewRule->SetType(EAnd);

			}

		}

	else

		me.iNewRuleStack.DeleteToMark(ERuleStartMark);

	DEBUG_UNMARK();

	}

void CDTDModel::PreAttlistLineL(CBNFParser& aParser)

	{ // static

	DEBUG_MARK(); // Mark can leave

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	me.iNewRuleStack.MarkL(ERuleStartMark);

	if (me.iNewElementAttribute == NULL)

		me.iNewElementAttribute = new (ELeave) CDTDElementAttribute();

	}

void CDTDModel::PostAttlistLineL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postAttlistLine");

		me.iNewRuleStack.MergeToMarkL(ERuleStartMark);

		CBNFNode *currentRule = me.iNewRuleStack.Pop();

		if (currentRule)

			me.iNewElementAttribute->iType = currentRule;

		const HBufC* attNameId = me.AttributeLUT().Des2IDL(*me.iNewAttfieldName);

		delete me.iNewAttfieldName;

		me.iNewAttfieldName = NULL;

		me.iNewRule->AddAttributeL(attNameId, me.iNewElementAttribute);

		me.iNewElementAttribute = NULL;

		}

	else

		me.iNewRuleStack.DeleteToMark(ERuleStartMark);

	DEBUG_UNMARK();

	}

void CDTDModel::PostIdentifierL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postIdentifier");

		HBufC* matched=me.MarkedL();

		CleanupStack::PushL(matched);

		CBNFNode* newRule = me.NewComponentL(me.iNewTree, *matched);

		me.iNewRuleStack.PushL(newRule);

		CleanupStack::PopAndDestroy(); // matched

		}

	me.DeleteMark();

	}

void CDTDModel::PostReferenceNameL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postReferenceName");

		HBufC* matched = me.MarkedWithInitialTextL(KRefNameInitialChar);

		CleanupStack::PushL(matched);

		CBNFNode* newRule = me.NewComponentL(me.iNewTree, *matched);

		me.iNewRuleStack.PushL(newRule);

		CleanupStack::PopAndDestroy(); // matched

		}

	me.DeleteMark();

	}

void 

CDTDModel::PostAttlistReferenceL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		me.iNewRuleStack.MergeToMarkL(ERuleStartMark);

		CBNFNode *currentRule = me.iNewRuleStack.Pop();

		if (currentRule)

			me.iNewElementAttribute->iType = currentRule;

        me.iNewElementAttribute->iValueType = CDTDElementAttribute::EReference;

        const TDesC* unique = REINTERPRET_CAST(const TDesC*, me.iNewElementAttribute);

		me.iNewRule->AddAttributeL(unique, me.iNewElementAttribute);

		me.iNewElementAttribute = NULL;

		}

	else

		me.iNewRuleStack.DeleteToMark(ERuleStartMark);

	}

void CDTDModel::PostEntityDeclNameL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postEntityDeclName");

		HBufC* matched=NULL;

		if(me.iInPEDecl)

			matched=me.MarkedWithInitialTextL(KEntityInitialChar);

		else

			matched=me.MarkedL();

		CleanupStack::PushL(matched);

		CBNFNode& newRule = me.NewRuleL(me.iNewTree, *matched, EIncomplete, NULL, NULL, NULL);

		me.iNewRule = &newRule;

		CleanupStack::PopAndDestroy(); // matched	

		}

	me.DeleteMark();

	}

void CDTDModel::PostElementDeclNameL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postElementDeclName");

		HBufC* matched = me.MarkedL();

		CleanupStack::PushL(matched);

		CBNFNode& newRule = me.NewRuleL(me.iNewTree, *matched, EAnd, NULL, NULL, NULL);

		me.iNewRule = &newRule;

		CleanupStack::PopAndDestroy(); // matched		

		}

	me.DeleteMark();

	}

void CDTDModel::PostAttlistDeclNameL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		DEBUG_MATCHED("postAttlistDeclName");

	me.DeleteMark();

	}

void CDTDModel::PostAttfieldNameL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		DEBUG_MATCHED("postAttfieldName");

		HBufC* matched=me.MarkedL();

		delete me.iNewAttfieldName;

		me.iNewAttfieldName = matched;

		}

	me.DeleteMark();

	}

void CDTDModel::PreAttValueL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	me.iNewRuleStack.MarkL(ERuleStartMark);

	}

void  CDTDModel::PostAttValueL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		me.iNewRuleStack.MergeToMarkL(ERuleStartMark);

		CBNFNode *currentRule = me.iNewRuleStack.Pop();

        // ASSUME me.iNewElementAttribute != NULL

		if (currentRule)

			me.iNewElementAttribute->iValue = currentRule;

		}

	else

		me.iNewRuleStack.DeleteToMark(ERuleStartMark);

	}

void CDTDModel::PostRequiredL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

        // ASSUME me.iNewElementAttribute != NULL

        me.iNewElementAttribute->iValueType = CDTDElementAttribute::ERequired;

		}

	}

void CDTDModel::PostImpliedL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

        // ASSUME me.iNewElementAttribute != NULL

        me.iNewElementAttribute->iValueType = CDTDElementAttribute::EImplied;

		}

	}

void 

CDTDModel::PostFixedL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

        // ASSUME me.iNewElementAttribute != NULL

        me.iNewElementAttribute->iValueType = CDTDElementAttribute::EFixed;

		}

	}

void CDTDModel::PostAndL(CBNFParser& aParser)

	{ // static

	CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser);

	if (me.RuleMatched())

		{

		CBNFNode *currentRule = me.iNewRuleStack.Head();

		if (currentRule->Type() != EAnd)