diff -r 000000000000 -r b16258d2340f applayerprotocols/wapbase/dtdmdl/CDTDModel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applayerprotocols/wapbase/dtdmdl/CDTDModel.cpp Tue Feb 02 01:09:52 2010 +0200 @@ -0,0 +1,2086 @@ +// 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 + +#include + +// debug macros +#ifdef DEBUG_DTD +#include +_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, ""); +_LIT(KElementDeclStart, ""); +_LIT(KRequired, "#REQUIRED"); +_LIT(KImplied, "#IMPLIED"); +_LIT(KFixed, "#FIXED"); +_LIT(KCData, "CDATA"); +_LIT(KPCData, "#PCDATA"); +_LIT(KNMToken, "NMTOKEN"); +_LIT(KID, "ID"); +_LIT(KAttributeListStart, ""); +_LIT(KCommentStart, ""); + +_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) + { + CBNFNode* newRule = me.NewComponentL(EAnd); + CleanupStack::PushL(newRule); + CBNFNode* currentRule = me.iNewRuleStack.Pop(); + CleanupStack::PushL(currentRule); + currentRule->ReparentL(newRule); + CleanupStack::Pop(2); // currentRule, newRule + me.iNewRuleStack.PushL(newRule); + } + } + } + + + +void CDTDModel::PostRuleL(CBNFParser& aParser, TParserNodeTypes aType, const TDesC* aAttribute) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + if (me.RuleMatched()) + { + CBNFNode *currentRule = me.iNewRuleStack.Head(); + if (currentRule->Type()!=aType) + { + CBNFNode* newRule = me.NewComponentL(aType); + CleanupStack::PushL(newRule); + + if (aAttribute) + me.AddComponentAttributeL(*newRule, aAttribute, 1); + + CBNFNode* currentRule = me.iNewRuleStack.Pop(); + CleanupStack::PushL(currentRule); + currentRule->ReparentL(newRule); + CleanupStack::Pop(2); // currentRule, newRule + me.iNewRuleStack.PushL(newRule); + } + } + } + + +void CDTDModel::PostOrL(CBNFParser& aParser) + { // static + PostRuleL(aParser, EOr, NULL); + } + +void CDTDModel::PostOptionalL(CBNFParser& aParser) + { // static + PostRuleL(aParser, EOptional, NULL); + } + +void CDTDModel::PostMatch0PlusL(CBNFParser& aParser) + { // static + PostRuleL(aParser, ENMore, NULL); + } + +void CDTDModel::PostMatch1PlusL(CBNFParser& aParser) + { // static + PostRuleL(aParser, ENMore, CBNFNode::KNMoreMinimum()); + } + +void CDTDModel::PreGroupL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + me.iNewRuleStack.MarkL(EGroupMark); + } + +void CDTDModel::PostGroupL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + if (aParser.RuleMatched()) + me.iNewRuleStack.MergeToMarkL(EGroupMark); + else + me.iNewRuleStack.RemoveMark(EGroupMark); + } + + +void CDTDModel::PostStringL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + if (me.RuleMatched() && !me.iCharRefCheck) + { + DEBUG_MATCHED("postString"); + HBufC* matched = me.MarkedL(); + CBNFNode* newRule = me.NewComponentL(EExact, matched); + me.iNewRuleStack.PushL(newRule); + } + + me.DeleteMark(); + } + + +void CDTDModel::PostValidCharL(CBNFParser& aParser, TRadix aRadix) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + if (me.RuleMatched()) + { + DEBUG_MATCHED("postValidChar"); + HBufC* matched = me.MarkedL(); + CleanupStack::PushL(matched); + TLex lex(matched->Mid(KValidCharMatchStartStingLength)); + TUint32 value; + lex.Val(value, aRadix); + HBufC* hexChar = HBufC::NewL(1); + hexChar->Des().Append(TChar(value)); + CBNFNode* newRule = me.NewComponentL(EExact, hexChar); + me.iNewRuleStack.PushL(newRule); + CleanupStack::PopAndDestroy(); // matched + } + + me.DeleteMark(); + } + +void CDTDModel::PostValidHexCharL(CBNFParser& aParser) + { // static + PostValidCharL(aParser, EHex); + } + +void CDTDModel::PostValidDecCharL(CBNFParser& aParser) + { // static + PostValidCharL(aParser, EDecimal); + } + + +void CDTDModel::PreGEContentL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + me.iCharRefCheck = ETrue; + me.Mark(); // Mark can leave + } + +void CDTDModel::PostGEContentL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + if (me.RuleMatched()) + { + HBufC* matched=me.MarkedL(); + delete me.iGEContent; + me.iGEContent=matched; + TPtr string=me.iGEContent->Des(); + me.CharRefReplacement(string); + } + me.iCharRefCheck=EFalse; + me.DeleteMark(); + } + +void CDTDModel::PostGEDeclL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + if (me.RuleMatched()) + { + CBNFNode* newRule = me.NewComponentL(EExact, me.iGEContent); + me.iGEContent=NULL; + me.iNewRuleStack.PushL(newRule); + } + } + +void CDTDModel::PrePEDeclL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + me.iInPEDecl = ETrue; + } + +void CDTDModel::PostPEDeclL(CBNFParser& aParser) + { // static + CDTDModel& me = REINTERPRET_CAST(CDTDModel&, aParser); + + me.iInPEDecl = EFalse; + } + +/** Creates a BNF rule tree to parse the input stream. + +This overrides CBNFParser::TreeL(). + +@return BNF rule tree +*/ +EXPORT_C CBNFNode* CDTDModel::TreeL() + { + CBNFNode* root = NewBNFL(); + CleanupStack::PushL(root); + + NewComponentL(root, *root, KRules); + + // Rules ::= ((S? Comment) | Rule )+ S? +//#pragma message(__FILE__ " note : Parameter entity references in the document body") +// It is possible, that there is a parameter entity reference in +// document body. This should be replaced with its corresponding replacement +// text and then processed. + CBNFNode& Rules = NewRuleL(root, KRules, EAnd, NULL, PreRulesL, PostRulesL); + CBNFNode& Rules1 = NewComponentL(Rules, ENMore); + CBNFNode& Rules2 = NewComponentL(Rules1, EOr); + CBNFNode& Rules3 = NewComponentL(Rules2, EAnd); + NewComponentL(root, Rules3, KoptS); + NewComponentL(root, Rules3, KComment); + NewComponentL(root, Rules2, KRule); + AddComponentAttributeL(Rules1, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(root, Rules, KoptS); + + // Space ::= #x20 | #x9 | #x d | #xa + NewRuleL(root, KSpace, ESelect, KWhiteSpaceString, NULL, NULL); + // OptionalSpace ::= Space* + CBNFNode& optSpace = NewRuleL(root, KoptS, ENMore, NULL, NULL, NULL); + NewComponentL(root, optSpace, KSpace); + + // Optional ::= '?' + NewRuleL(root, KOptional, EExact, KQMark, NULL, PostOptionalL); + // Match 0 or More := '*' + NewRuleL(root, KMatch0Plus, EExact, KStar, NULL, PostMatch0PlusL); + // Match 1 or More := '+' + NewRuleL(root, KMatch1Plus, EExact, KPlus, NULL, PostMatch1PlusL); + // Or ::= '|' + NewRuleL(root, KOr, EExact, KOrCharacter, NULL, PostOrL); + // And ::= ',' + NewRuleL(root, KAnd, EExact, KAndCharacter, NULL, PostAndL); + // GroupStart ::= '(' + NewRuleL(root, KGroupStart, EExact, KGroupStartChar, PreGroupL, NULL); + // GroupEnd ::= ')' + NewRuleL(root, KGroupEnd, EExact, KGroupEndChar, PostGroupL, NULL); + // SStringStart ::= ''' + NewRuleL(root, KSStringStart, EExact, KStringStartCharacter, NULL, NULL); + // SStringEnd ::= ''' + NewRuleL(root, KSStringEnd, EExact, KStringEndCharacter, NULL, NULL); + // DStringStart ::= '"' + NewRuleL(root, KDStringStart, EExact, KStringStartCharacter2, NULL, NULL); + // DStringEnd ::= '"' + NewRuleL(root, KDStringEnd, EExact, KStringEndCharacter2, NULL, NULL); + + // PostOp ::= Optional | Macth0Plus | Match1Plus + CBNFNode& Pop = NewRuleL(root, KPop, EOr, NULL, NULL, NULL); + NewComponentL(root, Pop, KOptional); + NewComponentL(root, Pop, KMatch0Plus); + NewComponentL(root, Pop, KMatch1Plus); + + // Letter ::= [A-Za-z] + CBNFNode& letter = NewRuleL(root, KLetter, EOr, NULL, NULL, NULL); + CBNFNode& letter1 = NewComponentL(letter, ERange); + AddComponentAttributeL(letter1, CBNFNode::KRangeStart(), 'A'); + AddComponentAttributeL(letter1, CBNFNode::KRangeEnd(), 'Z'); + CBNFNode& letter2 = NewComponentL(letter, ERange); + AddComponentAttributeL(letter2, CBNFNode::KRangeStart(), 'a'); + AddComponentAttributeL(letter2, CBNFNode::KRangeEnd(), 'z'); + + // Digit ::= [0-9] + CBNFNode& Digit = NewRuleL(root, KDigit, ERange, NULL, NULL, NULL); + AddComponentAttributeL(Digit, CBNFNode::KRangeStart(), '0'); + AddComponentAttributeL(Digit, CBNFNode::KRangeEnd(), '9'); + + // HexNumber ::= (Digit | [a-fA-f])+ + CBNFNode& HexNumber = NewRuleL(root, KHexNumber, ENMore, NULL, NULL, NULL); + AddComponentAttributeL(HexNumber, CBNFNode::KNMoreMinimum(), 1); + CBNFNode& HexNumber1 = NewComponentL(HexNumber, EOr); + NewComponentL(root, HexNumber1, KDigit); + CBNFNode& HexNumber2 = NewComponentL(HexNumber1, ERange); + AddComponentAttributeL(HexNumber2, CBNFNode::KRangeStart(), 'a'); + AddComponentAttributeL(HexNumber2, CBNFNode::KRangeEnd(), 'f'); + CBNFNode& HexNumber3 = NewComponentL(HexNumber1, ERange); + AddComponentAttributeL(HexNumber3, CBNFNode::KRangeStart(), 'A'); + AddComponentAttributeL(HexNumber3, CBNFNode::KRangeEnd(), 'F'); + + // DecNumber ::= Digit+ + CBNFNode& DecNumber = NewRuleL(root, KDecNumber, ENMore, NULL, NULL, NULL); + AddComponentAttributeL(DecNumber, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(root, DecNumber, KDigit); + + // HexChar ::= "#x" HexNumber ";" + CBNFNode& HexChar = NewRuleL(root, KHexChar, EAnd, NULL, NULL, NULL); + NewComponentL(HexChar, EExact, KHexCharacterStart); + NewComponentL(root, HexChar, KHexNumber); + NewComponentL(HexChar, EExact, KHexCharacterEnd); + + // DecChar ::= "#" DecNumber ";" + CBNFNode& DecChar = NewRuleL(root, KDecChar, EAnd, NULL, NULL, NULL); + NewComponentL(DecChar, EExact, KDecCharacterStart); + NewComponentL(root, DecChar, KDecNumber); + NewComponentL(DecChar, EExact, KHexCharacterEnd); + + // ValidHexChar ::= HexChar + CBNFNode& ValidHexChar = NewRuleL(root, KValidHexChar, EAnd, NULL, MarkCallback, PostValidHexCharL); + NewComponentL(root, ValidHexChar, KHexChar); + + // BaseChar ::= ' ' | Letter | Digit | [-()+,./:=?;!*#@$_%^&<>|] + CBNFNode& BaseChar = NewRuleL(root, KBaseChar, EOr, NULL, NULL, NULL); + NewComponentL(BaseChar, EExact, KSpaceChar); + NewComponentL(root, BaseChar, KLetter); + NewComponentL(root, BaseChar, KDigit); + NewComponentL(BaseChar, ESelect, KBaseCharacters); + + // ValidChar ::= BaseChar | ValidHexChar | ['"] + CBNFNode& ValidChar = NewRuleL(root, KValidChar, EOr, NULL, NULL, NULL); + NewComponentL(root, ValidChar, KBaseChar); + NewComponentL(root, ValidChar, KValidHexChar); + NewComponentL(ValidChar, ESelect, KOtherValidCharacters); + + // SStringChar ::= BaseChar | ["[]] | S + CBNFNode& SStringChar = NewRuleL(root, KSStringChar, EOr, NULL, NULL, NULL); + NewComponentL(root, SStringChar, KBaseChar); + NewComponentL(SStringChar, ESelect, KStringCharacters); + NewComponentL(root, SStringChar, KSpace); + + // DStringChar ::= BaseChar | ['[]] | S + CBNFNode& DStringChar = NewRuleL(root, KDStringChar, EOr, NULL, NULL, NULL); + NewComponentL(root, DStringChar, KBaseChar); + NewComponentL(DStringChar, ESelect, KStringCharacters2); + NewComponentL(root, DStringChar, KSpace); + + // Identifier ::= Letter (Letter | Digit)* + CBNFNode& identifier = NewRuleL(root, KIdentifier, EAnd, NULL, MarkCallback, PostIdentifierL); + NewComponentL(root, identifier, KLetter); + CBNFNode& identifier1 = NewComponentL(identifier, ENMore); + CBNFNode& identifier2 = NewComponentL(identifier1, EOr); + NewComponentL(root, identifier2, KLetter); + NewComponentL(root, identifier2, KDigit); + + // SString ::= SStringChar+ + CBNFNode& sstring = NewRuleL(root, KSString, ENMore, NULL, MarkCallback, PostStringL); + AddComponentAttributeL(sstring, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(root, sstring, KSStringChar); + + // DString ::= DStringChar+ + CBNFNode& dstring = NewRuleL(root, KDString, ENMore, NULL, MarkCallback, PostStringL); + AddComponentAttributeL(dstring, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(root, dstring, KDStringChar); + + // String ::= SStringStart SString SStringEnd + // | DStringStart DString DStringEnd + // | ValidHexChar + CBNFNode& string = NewRuleL(root, KString, EOr, NULL, NULL, NULL); + CBNFNode& string1 = NewComponentL(string, EAnd); + NewComponentL(root, string1, KSStringStart); + NewComponentL(root, string1, KSString); + NewComponentL(root, string1, KSStringEnd); + CBNFNode& string2 = NewComponentL(string, EAnd); + NewComponentL(root, string2, KDStringStart); + NewComponentL(root, string2, KDString); + NewComponentL(root, string2, KDStringEnd); + NewComponentL(root, string, KValidHexChar); + + // Primary ::= S? (GroupStart Definitions S? GroupEnd + // | DataReference + // | Identifier + // | String) + CBNFNode& Primary = NewRuleL(root, KPrimary, EAnd, NULL, NULL, NULL); + NewComponentL(root, Primary, KoptS); + CBNFNode& Primary0 = NewComponentL(Primary, EOr); + + CBNFNode& Primary4 = NewComponentL(Primary0, EAnd); + NewComponentL(root, Primary4, KGroupStart); + NewComponentL(root, Primary4, KDefinitions); + NewComponentL(root, Primary4, KoptS); + NewComponentL(root, Primary4, KGroupEnd); + + NewComponentL(root, Primary0, KDataReference); + NewComponentL(root, Primary0, KIdentifier); + NewComponentL(root, Primary0, KString); + + // Factor ::= Primary Pop? + CBNFNode& Factor = NewRuleL(root, KFactor, EAnd, NULL, NULL, NULL); + NewComponentL(root, Factor, KPrimary); + CBNFNode& Factor1 = NewComponentL(Factor, EOptional); + NewComponentL(root, Factor1, KPop); + + // Definition ::= Factor (S? And Factor)* + CBNFNode& Definition = NewRuleL(root, KDefinition, EAnd, NULL, NULL, NULL); + NewComponentL(root, Definition, KFactor); + CBNFNode& Definition1 = NewComponentL(Definition, ENMore); + CBNFNode& Definition2 = NewComponentL(Definition1, EAnd); + NewComponentL(root, Definition2, KoptS); + NewComponentL(root, Definition2, KAnd); + NewComponentL(root, Definition2, KFactor); + + // Definitions ::= Definition (S? Or Definition)* + CBNFNode& Definitions = NewRuleL(root, KDefinitions, EAnd, NULL, NULL, NULL); + NewComponentL(root, Definitions, KDefinition); + CBNFNode& Definitions1 = NewComponentL(Definitions, ENMore); + CBNFNode& Definitions2 = NewComponentL(Definitions1, EAnd); + NewComponentL(root, Definitions2, KoptS); + NewComponentL(root, Definitions2, KOr); + NewComponentL(root, Definitions2, KDefinition); + + // EntityDefinition ::= (S? AttlistLine)+ | Definition + CBNFNode& EntityDefinition = NewRuleL(root, KEntityDefinition, EOr, NULL, NULL, NULL); + CBNFNode& EntityDefinition1 = NewComponentL(EntityDefinition, ENMore); + CBNFNode& EntityDefinition11 = NewComponentL(EntityDefinition1, EAnd); + NewComponentL(root, EntityDefinition11, KoptS); + NewComponentL(root, EntityDefinition11, KAttlistLine); + AddComponentAttributeL(EntityDefinition1, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(root, EntityDefinition, KDefinitions); + + // CharRefStream ::= "&" (DecChar | HexChar)+ + CBNFNode& CharRefStream = NewRuleL(root, KCharRefStream, EAnd, NULL, MarkCallback, PostStringL); + NewComponentL(CharRefStream, EExact, KCharRefStreamAmpersand); + CBNFNode& CharRefStream1 = NewComponentL(CharRefStream, ENMore); + AddComponentAttributeL(CharRefStream1, CBNFNode::KNMoreMinimum(), 1); + CBNFNode& CharRefStream2 = NewComponentL(CharRefStream1, EOr); + NewComponentL(root, CharRefStream2, KDecChar); + NewComponentL(root, CharRefStream2, KHexChar); + + // EntityDef ::= DStringStart (CharRefStream | EntityDefinition) DStringEnd +//#pragma message(__FILE__ " note : An entity (also a Parameter entity) can be surrounded with single quotes, too") + CBNFNode& EntityDef = NewRuleL(root, KEntityDef, EAnd, NULL, NULL, NULL); + NewComponentL(root, EntityDef, KDStringStart); + CBNFNode& EntityDef1 = NewComponentL(EntityDef, EOr); + NewComponentL(root, EntityDef1, KCharRefStream); + NewComponentL(root, EntityDef1, KEntityDefinition); + NewComponentL(root, EntityDef, KDStringEnd); + + // ReferenceName ::= Identifier + CBNFNode& ReferenceName = NewRuleL(root, KReferenceName, EAnd, NULL, MarkCallback, PostReferenceNameL); + NewComponentL(root, ReferenceName, KLetter); + CBNFNode& ReferenceName1 = NewComponentL(ReferenceName, ENMore); + CBNFNode& ReferenceName2 = NewComponentL(ReferenceName1, EOr); + NewComponentL(root, ReferenceName2, KLetter); + NewComponentL(root, ReferenceName2, KDigit); + + // EntityDeclName ::= Identifier + CBNFNode& EntityDeclName = NewRuleL(root, KEntityDeclName, EAnd, NULL, MarkCallback, PostEntityDeclNameL); + NewComponentL(root, EntityDeclName, KLetter); + CBNFNode& EntityDeclName1 = NewComponentL(EntityDeclName, ENMore); + CBNFNode& EntityDeclName2 = NewComponentL(EntityDeclName1, EOr); + NewComponentL(root, EntityDeclName2, KLetter); + NewComponentL(root, EntityDeclName2, KDigit); + + // ElementDeclName ::= Letter (Letter | Digit)* + CBNFNode& ElementDeclName = NewRuleL(root, KElementDeclName, EAnd, NULL, MarkCallback, PostElementDeclNameL); + NewComponentL(root, ElementDeclName, KLetter); + CBNFNode& ElementDeclName1 = NewComponentL(ElementDeclName, ENMore); + CBNFNode& ElementDeclName2 = NewComponentL(ElementDeclName1, EOr); + NewComponentL(root, ElementDeclName2, KLetter); + NewComponentL(root, ElementDeclName2, KDigit); + + // NameChar ::= Letter | Digit | [.-_:] + CBNFNode& NameChar = NewRuleL(root, KNameChar, EOr, NULL, NULL, NULL); + NewComponentL(root, NameChar, KLetter); + NewComponentL(root, NameChar, KDigit); + NewComponentL(NameChar, ESelect, KNameOtherCharacters); + + // AttlistDeclName ::= Letter (Letter | Digit)* + CBNFNode& AttlistDeclName = NewRuleL(root, KAttlistDeclName, EAnd, NULL, MarkCallback, PostAttlistDeclNameL); + NewComponentL(root, AttlistDeclName, KLetter); + CBNFNode& AttlistDeclName1 = NewComponentL(AttlistDeclName, ENMore); + CBNFNode& AttlistDeclName2 = NewComponentL(AttlistDeclName1, EOr); + NewComponentL(root, AttlistDeclName2, KLetter); + NewComponentL(root, AttlistDeclName2, KDigit); + + // AttfieldName ::= NameChar (NameChar | Digit)* + CBNFNode& AttfieldName = NewRuleL(root, KAttfieldName, EAnd, NULL, MarkCallback, PostAttfieldNameL); + NewComponentL(root, AttfieldName, KNameChar); + CBNFNode& AttfieldName1 = NewComponentL(AttfieldName, ENMore); + CBNFNode& AttfieldName2 = NewComponentL(AttfieldName1, EOr); + NewComponentL(root, AttfieldName2, KNameChar); + NewComponentL(root, AttfieldName2, KDigit); + + // AttfieldTypeName ::= Letter (Letter | Digit)* + CBNFNode& AttfieldTypeName = NewRuleL(root, KAttfieldTypeName, EAnd, NULL, NULL, NULL); + NewComponentL(root, AttfieldTypeName, KLetter); + CBNFNode& AttfieldTypeName1 = NewComponentL(AttfieldTypeName, ENMore); + CBNFNode& AttfieldTypeName2 = NewComponentL(AttfieldTypeName1, EOr); + NewComponentL(root, AttfieldTypeName2, KLetter); + NewComponentL(root, AttfieldTypeName2, KDigit); + + // AttValue ::= SStringStart (CharRefStream | ReferenceName) SStringEnd + // | DStringStart (CharRefStream | ReferenceName) DStringEnd +//#pragma message(__FILE__ " note : AttValue may contain several references") +// It is possible for the attribute value to contain several character +// references and parameter references, too. The complete attribute value +// should be stored as whole string, so that it can be used in the actual +// parser + CBNFNode& AttValue = NewRuleL(root, KAttValue, EOr, NULL, PreAttValueL, PostAttValueL); + CBNFNode& AttValue1 = NewComponentL(AttValue, EAnd); + NewComponentL(root, AttValue1, KSStringStart); + CBNFNode& AttValue11 = NewComponentL(AttValue1, EOr); + NewComponentL(root, AttValue11, KCharRefStream); + NewComponentL(root, AttValue11, KReferenceName); + NewComponentL(root, AttValue11, KSString); + NewComponentL(root, AttValue1, KSStringEnd); + CBNFNode& AttValue2 = NewComponentL(AttValue, EAnd); + NewComponentL(root, AttValue2, KDStringStart); + CBNFNode& AttValue21 = NewComponentL(AttValue2, EOr); + NewComponentL(root, AttValue21, KCharRefStream); + NewComponentL(root, AttValue11, KReferenceName); + NewComponentL(root, AttValue21, KDString); + NewComponentL(root, AttValue2, KDStringEnd); + + CBNFNode& GEContentS = NewRuleL(root, KGEContentS, ENMore, NULL, PreGEContentL, PostGEContentL); + CBNFNode& GEContentS1 = NewComponentL(GEContentS, EOr); + NewComponentL(GEContentS1, ESelect, KGEContentCharacters); + NewComponentL(root, GEContentS1, KCharRefStream); +// NewComponentL(root, GEContent, PEReference); + + CBNFNode& GEContentD = NewRuleL(root, KGEContentD, ENMore, NULL, PreGEContentL, PostGEContentL); + CBNFNode& GEContentD1 = NewComponentL(GEContentD, EOr); + NewComponentL(GEContentD1, ESelect, KGEContentDCharacters); + NewComponentL(root, GEContentD1, KCharRefStream); + + // GEDecl ::= EntityDeclName S? + CBNFNode& GEDecl = NewRuleL(root, KGEDecl, EAnd, NULL, NULL, PostGEDeclL); + NewComponentL(root, GEDecl, KEntityDeclName); + NewComponentL(root, GEDecl, KoptS); + CBNFNode& GEDecl3 = NewComponentL(GEDecl, EOr); + CBNFNode& GEDecl31 = NewComponentL(GEDecl3, EAnd); + NewComponentL(root, GEDecl31, KSStringStart); + NewComponentL(root, GEDecl31, KGEContentS); + NewComponentL(root, GEDecl31, KSStringEnd); + CBNFNode& GEDecl32 = NewComponentL(GEDecl3, EAnd); + NewComponentL(root, GEDecl32, KDStringStart); + NewComponentL(root, GEDecl32, KGEContentD); + NewComponentL(root, GEDecl32, KDStringEnd); + + // PEDecl ::= "%" S? GEDecl --- old --- + // PEDecl ::= "%" S? EntityDeclName S? EntityDef + CBNFNode& PEDecl = NewRuleL(root, KPEDecl, EAnd, NULL, PrePEDeclL, PostPEDeclL); + NewComponentL(PEDecl, EExact, KEntityInitialChar); + NewComponentL(root, PEDecl, KoptS); + NewComponentL(root, PEDecl, KEntityDeclName); + NewComponentL(root, PEDecl, KoptS); + NewComponentL(root, PEDecl, KEntityDef); + + // EntityDecl ::= "" + CBNFNode& EntityDecl = NewRuleL(root, KEntityDecl, EAnd, NULL, PreEntityDeclL, PostEntityDeclL); + NewComponentL(EntityDecl, EExact, KEntityDeclStart); + NewComponentL(root, EntityDecl, KoptS); + CBNFNode& EntityDecl1 = NewComponentL(EntityDecl, EOr); + NewComponentL(root, EntityDecl1, KPEDecl); + NewComponentL(root, EntityDecl1, KGEDecl); + NewComponentL(root, EntityDecl, KoptS); + NewComponentL(EntityDecl, EExact, KEntityDeclEnd); + + // ElementDecl ::= "" + CBNFNode& ElementDecl = NewRuleL(root, KElementDecl, EAnd, NULL, PreElementDeclL, PostElementDeclL); + NewComponentL(ElementDecl, EExact, KElementDeclStart); + NewComponentL(root, ElementDecl, KoptS); + NewComponentL(root, ElementDecl, KElementDeclName); + NewComponentL(root, ElementDecl, KoptS); + NewComponentL(root, ElementDecl, KDefinitions); + NewComponentL(root, ElementDecl, KoptS); + NewComponentL(ElementDecl, EExact, KElementDeclEnd); + + // AttDefRequired ::= "#REQUIRED" + NewRuleL(root, KAttDefRequired, EExact, KRequired, NULL, PostRequiredL); + // AttDefImplied ::= "#IMPLIED" + NewRuleL(root, KAttDefImplied, EExact, KImplied, NULL, PostImpliedL); + // AttDefFixed ::= "#FIXED" + NewRuleL(root, KAttDefFixed, EExact, KFixed, NULL, PostFixedL); + + // AttDefault ::= AttDefRequired | AttDefImplied | (AttDefFixed S?)? AttValue + CBNFNode& AttDefault = NewRuleL(root, KAttDefault, EOr, NULL, NULL, NULL); + NewComponentL(root, AttDefault, KAttDefRequired); + NewComponentL(root, AttDefault, KAttDefImplied); + CBNFNode& AttDefault1 = NewComponentL(AttDefault, EAnd); + CBNFNode& AttDefault11 = NewComponentL(AttDefault1, EOptional); + CBNFNode& AttDefault111 = NewComponentL(AttDefault11, EAnd); + NewComponentL(root, AttDefault111, KAttDefFixed); + NewComponentL(root, AttDefault111, KoptS); + NewComponentL(root, AttDefault1, KAttValue); + + // CDATA ::= "CDATA" + NewRuleL(root, KCData, EExact, KCData, MarkCallback, PostIdentifierL); + // PCDATA ::= "#PCDATA" + NewRuleL(root, KPCData, EExact, KPCData, MarkCallback, PostIdentifierL); + // NMTOKEN ::= "NMTOKEN" + NewRuleL(root, KNMToken, EExact, KNMToken, MarkCallback, PostIdentifierL); + // ID ::= "ID" + NewRuleL(root, KID, EExact, KID, MarkCallback, PostIdentifierL); + + // Reference ::= "%" ReferenceName ";" + CBNFNode& Reference = NewRuleL(root, KReference, EAnd, NULL, NULL, NULL); + NewComponentL(Reference, EExact, KRefNameInitialChar); + NewComponentL(root, Reference, KReferenceName); + NewComponentL(Reference, EExact, KRefNameEndChar); + + // AttlistReference ::= Reference + CBNFNode& AttlistReference = NewRuleL(root, KAttlistReference, EAnd, NULL, PreAttlistLineL, PostAttlistReferenceL); + NewComponentL(root, AttlistReference, KReference); + + // DataReference ::= CDATA | NMTOKEN | #PCDATA | ID | Reference + CBNFNode& DataReference = NewRuleL(root, KDataReference, EOr, NULL, NULL, NULL); + NewComponentL(root, DataReference, KCData); + NewComponentL(root, DataReference, KNMToken); + NewComponentL(root, DataReference, KPCData); + NewComponentL(root, DataReference, KID); + NewComponentL(root, DataReference, KReference); + + // AttlistLine ::= (AttfieldName S? Definition S? AttDefault) + CBNFNode& AttlistLine = NewRuleL(root, KAttlistLine, EOr, NULL, PreAttlistLineL, PostAttlistLineL); + CBNFNode& AttlistLine1 = NewComponentL(AttlistLine, EAnd); + NewComponentL(root, AttlistLine1, KAttfieldName); + NewComponentL(root, AttlistLine1, KoptS); + NewComponentL(root, AttlistLine1, KDefinition); + NewComponentL(root, AttlistLine1, KoptS); + NewComponentL(root, AttlistLine1, KAttDefault); + + // AttlistDef ::= AttlistLine | Reference + CBNFNode& AttlistDef = NewRuleL(root, KAttlistDef, EOr, NULL, NULL, NULL); + NewComponentL(root, AttlistDef, KAttlistLine); + NewComponentL(root, AttlistDef, KAttlistReference); + + // AttlistDecl ::= "" + CBNFNode& AttlistDecl = NewRuleL(root, KAttlistDecl, EAnd, NULL, NULL, NULL); + NewComponentL(AttlistDecl, EExact, KAttributeListStart); + NewComponentL(root, AttlistDecl, KoptS); + NewComponentL(root, AttlistDecl, KAttlistDeclNameCharacters); + NewComponentL(root, AttlistDecl, KoptS); + CBNFNode& AttlistDecl1 = NewComponentL(AttlistDecl, ENMore); + CBNFNode& AttlistDecl11 = NewComponentL(AttlistDecl1, EAnd); + NewComponentL(root, AttlistDecl11, KAttlistDef); + NewComponentL(root, AttlistDecl11, KoptS); + NewComponentL(AttlistDecl, EExact, KAttributeListEnd); + + // CommentChar ::= S | [#x20-#xD7FF] + CBNFNode& CommentChar = NewRuleL(root, KCommentChar, EOr, NULL, NULL, NULL); + NewComponentL(root, CommentChar, KSpace); + CBNFNode& CommentChar1 = NewComponentL(CommentChar, ERange); + AddComponentAttributeL(CommentChar1, CBNFNode::KRangeStart(), 0x20); + AddComponentAttributeL(CommentChar1, CBNFNode::KRangeEnd(), 0xD7FF); + + // Comment ::= "" + CBNFNode& Comment = NewRuleL(root, KComment, EAnd, NULL, NULL, NULL); + NewComponentL(Comment, EExact, KCommentStart); + CBNFNode& Comment0 = NewComponentL(Comment, ENMore); + CBNFNode& Comment1 = NewComponentL(Comment0, EOr); + + CBNFNode& Comment11 = NewComponentL(Comment1, EWithout); + NewComponentL(root, Comment11, KCommentChar); + NewComponentL(Comment11, EExact, KCommentCharacter); + CBNFNode& Comment12 = NewComponentL(Comment1, EAnd); + NewComponentL(Comment12, EExact, KCommentCharacter); + CBNFNode& Comment13 = NewComponentL(Comment12, EWithout); + NewComponentL(root, Comment13, KCommentChar); + NewComponentL(Comment13, EExact, KCommentCharacter); + NewComponentL(Comment, EExact, KCommentEnd); + + // Rule ::= S? Comment? S? (EntityDecl | ElementDecl | AttlistDecl) + CBNFNode& Rule = NewRuleL(root, KRule, EAnd, NULL, NULL, NULL); + NewComponentL(root, Rule, KoptS); + CBNFNode& Rule1 = NewComponentL(Rule, EOptional); + NewComponentL(root, Rule1, KComment); + NewComponentL(root, Rule, KoptS); + CBNFNode& Rule2 = NewComponentL(Rule, EOr); + NewComponentL(root, Rule2, KEntityDecl); + NewComponentL(root, Rule2, KElementDecl); + NewComponentL(root, Rule2, KAttlistDecl); + + CleanupStack::Pop(); // root + return (root); + } + +void CDTDModel::CharRefReplacement(TPtr& aString) +// A method to replace character references to the given string with the referenced character +// This method does minimal set of checks since when this method is called the string has +// already been parsed and hence the references it contains are valid (this is ensured by the +// reference parsing rules). Therefore, this method should be called just before the data +// is being attached as an attribute value or as CDATA to a node. The reason why we don't replace +// the values during the parsing (i.e. when the values are checked) is that if the rule would +// later fail and the string would be re-parsed then the replaced characters might cause +// errorneous situations and unintended references to appear. + { + TPtrC examinable = aString; + TInt examinableOffset = 0; + TInt referenceOffset = examinable.Match(KCharRefMatchingPattern); + while( referenceOffset != KErrNotFound ) + { + TPtrC reference = examinable.Mid(referenceOffset); + TInt referenceValueOffset = 2; + TRadix system = EDecimal; + if( reference[2] == 'x' ) + { + referenceValueOffset++; + system = EHex; + } + TLex valueString(reference.Mid(referenceValueOffset, reference.Locate(';')-referenceValueOffset) ); + TUint16 referenceValue = 32; // just in case something fails, we shall insert space + valueString.Val(referenceValue, system); + aString.Delete(examinableOffset+referenceOffset, reference.Locate(';') ); + aString[examinableOffset+referenceOffset] = referenceValue; + + examinable.Set(aString.Mid(examinableOffset+referenceOffset+1)); + examinableOffset += referenceOffset+1; + referenceOffset = examinable.Match(KCharRefMatchingPattern); + } + } + + +/** Gets the root node of the tree generated to process the DTD. + +It transfers ownership of the tree to the caller. + +@return Root node of the tree +*/ +EXPORT_C CBNFNode* CDTDModel::GeneratedTree() + { + CBNFNode* tree=iNewTree; + iNewTree=NULL; + return tree; + } + +void CDTDModel::AddNewAttributeL(CBNFNode& aNode, const TDesC* aAttributeId, const TDesC& aAttributeType, CDTDElementAttribute::KValueType aAttributeValueType, CBNFNode* aRootNode) + { + CDTDElementAttribute* newAttribute = new(ELeave)CDTDElementAttribute(); + CleanupStack::PushL(newAttribute); + newAttribute->iValueType = aAttributeValueType; + newAttribute->iType = NewComponentL(aRootNode, aAttributeType); + aNode.AddAttributeL(aAttributeId, newAttribute); + CleanupStack::Pop(); // newAttribute + } + +void CDTDModel::AddNewReferenceAttributeL(CBNFNode& aNode, const TDesC& aAttributeType, CBNFNode* aRootNode) + { + CDTDElementAttribute* newAttribute = new(ELeave)CDTDElementAttribute(); + CleanupStack::PushL(newAttribute); + newAttribute->iValueType = CDTDElementAttribute::EReference; + newAttribute->iType = NewComponentL(aRootNode, aAttributeType); + aNode.AddAttributeL(REINTERPRET_CAST(const TDesC*, newAttribute), newAttribute); + CleanupStack::Pop(); // newAttribute + } + +void CDTDModel::AddNewAttributeWithValueL(CBNFNode& aNode, const TDesC* aAttributeId, const TDesC& aAttributeType, const TDesC& aAttributeDefaultValue, CBNFNode* aRootNode) + { + CDTDElementAttribute* newAttribute = new(ELeave)CDTDElementAttribute(); + CleanupStack::PushL(newAttribute); + newAttribute->iType = NewComponentL(aRootNode, aAttributeType); + newAttribute->iValue = NewComponentL(EExact, aAttributeDefaultValue); + aNode.AddAttributeL(aAttributeId, newAttribute); + CleanupStack::Pop(); // newAttribute, + } + +/** Builds a parser tree for the WML1.1 DTD. + +@param aPackageRootNode A root node to which the generated tree is attached +*/ +EXPORT_C void CDTDModel::BuildWml11DTDL(CBNFNode& aPackageRootNode) +{ + CBNFNode* dtdRoot = NewBNFL(); + dtdRoot->ReparentL(&aPackageRootNode); + + _LIT(KCDATA,"CDATA"); + _LIT(Klength,"%length"); + _LIT(Kvdata,"%vdata"); + _LIT(KHREF,"%HREF"); + _LIT(Ktrue,"true"); + _LIT(Kfalse,"false"); + _LIT(Kboolean,"%boolean"); + _LIT(KNMTOKEN,"NMTOKEN"); + _LIT(Knumber,"%number"); + _LIT(Kcoreattrs,"%coreattrs"); + _LIT(Kem,"em"); + _LIT(Kstrong,"strong"); + _LIT(Kb,"b"); + _LIT(Ki,"i"); + _LIT(Ku,"u"); + _LIT(Kbig,"big"); + _LIT(Ksmall,"small"); + _LIT(Kemph,"%emph"); + _LIT(Kbr,"br"); + _LIT(Klayout,"%layout"); + _LIT(KPCDATA,"#PCDATA"); + _LIT(Ktext,"%text"); + _LIT(Kimg,"img"); + _LIT(Kanchor,"anchor"); + _LIT(Ka,"a"); + _LIT(Ktable,"table"); + _LIT(Knoop,"noop"); + _LIT(Ktask,"%task"); + _LIT(Kdo,"do"); + _LIT(Knavelmts,"%navelmts"); + _LIT(Konevent,"onevent"); + _LIT(Kflow,"%flow"); + _LIT(KEMPTY,"EMPTY"); + _LIT(Kbottom,"bottom"); + _LIT(KIAlign,"%IAlign"); + _LIT(Kgo,"go"); + _LIT(Kprev,"prev"); + _LIT(Krefresh,"refresh"); + _LIT(Ktr,"tr"); + _LIT(Kpostfield,"postfield"); + _LIT(Ksetvar,"setvar"); + _LIT(Khead,"head"); + _LIT(Ktemplate,"template"); + _LIT(Kcard,"card"); + _LIT(Kwml,"wml"); + _LIT(Kaccess,"access"); + _LIT(Kmeta,"meta"); + _LIT(Kcardev,"%cardev"); + _LIT(Kp,"p"); + _LIT(Ktimer,"timer"); + _LIT(Kinput,"input"); + _LIT(Kselect,"select"); + _LIT(Kfieldset,"fieldset"); + _LIT(Kfields,"%fields"); + _LIT(Koption,"option"); + _LIT(Koptgroup,"optgroup"); + _LIT(KTAlign,"%TAlign"); + _LIT(KWrapMode,"%WrapMode"); + _LIT(Ktd,"td"); + + _LIT(Kleft,"left"); + _LIT(Ktop,"top"); + _LIT(Kmiddle,"middle"); + _LIT(Kright,"right"); + _LIT(Kcenter,"center"); + _LIT(Kwrap,"wrap"); + _LIT(Knowrap,"nowrap"); + + + _LIT(Kxmllang, "xml:lang"); + const TDesC* xmllangAttributeId = iLUT.Des2IDL(Kxmllang); + _LIT(Ktitle, "title"); + const TDesC* titleAttributeId = iLUT.Des2IDL(Ktitle); + _LIT(Khref, "href"); + const TDesC* hrefAttributeId = iLUT.Des2IDL(Khref); + _LIT(Kvalue, "value"); + const TDesC* valueAttributeId = iLUT.Des2IDL(Kvalue); + _LIT(Ktabindex, "tabindex"); + const TDesC* tabindexAttributeId = iLUT.Des2IDL(Ktabindex); + _LIT(Ktype, "type"); + const TDesC* typeAttributeId = iLUT.Des2IDL(Ktype); + _LIT(Kname, "name"); + const TDesC* nameAttributeId = iLUT.Des2IDL(Kname); + _LIT(Kalign, "align"); + const TDesC* alignAttributeId = iLUT.Des2IDL(Kalign); + + + // + CBNFNode& length = NewRuleL(dtdRoot, Klength, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, length,KCDATA); + + + // + CBNFNode& vdata = NewRuleL(dtdRoot, Kvdata, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, vdata,KCDATA); + + + // + CBNFNode& href = NewRuleL(dtdRoot, KHREF, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, href,Kvdata); + + + // + CBNFNode& boolean = NewRuleL(dtdRoot, Kboolean, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, boolean, Ktrue); + NewComponentL(dtdRoot, boolean, Kfalse); + + + // + CBNFNode& number = NewRuleL(dtdRoot, Knumber, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, number, KNMTOKEN); + + CDTDElementAttribute* newAttribute = NULL; + + + // !ENTITY % coreattrs "id ID #IMPLIED class CDATA #IMPLIED"> + CBNFNode& coreattrs = NewRuleL(dtdRoot, Kcoreattrs, EIncomplete, NULL, NULL, NULL); + // Attributes + // id ID #IMPLIED + _LIT(KidAttrName, "id"); + _LIT(KID, "ID"); + AddNewAttributeL(coreattrs, iLUT.Des2IDL(KidAttrName), KID, CDTDElementAttribute::EImplied, dtdRoot); + // class CDATA #IMPLIED + _LIT(Kclass, "class"); + AddNewAttributeL(coreattrs, iLUT.Des2IDL(Kclass), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + + + // + CBNFNode& emph = NewRuleL(dtdRoot, Kemph, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, emph, Kem); + NewComponentL(dtdRoot, emph, Kstrong); + NewComponentL(dtdRoot, emph, Kb); + NewComponentL(dtdRoot, emph, Ki); + NewComponentL(dtdRoot, emph, Ku); + NewComponentL(dtdRoot, emph, Kbig); + NewComponentL(dtdRoot, emph, Ksmall); + + // + CBNFNode& layout = NewRuleL(dtdRoot, Klayout, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, layout, Kbr); + + + // + CBNFNode& text = NewRuleL(dtdRoot, Ktext, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, text, KPCDATA); + NewComponentL(dtdRoot, text, Kemph); + + + // + CBNFNode& flow = NewRuleL(dtdRoot, Kflow, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, flow, Ktext); + NewComponentL(dtdRoot, flow, Klayout); + NewComponentL(dtdRoot, flow, Kimg); + NewComponentL(dtdRoot, flow, Kanchor); + NewComponentL(dtdRoot, flow, Ka); + NewComponentL(dtdRoot, flow, Ktable); + + // + CBNFNode& task = NewRuleL(dtdRoot, Ktask, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, task, Kgo); + NewComponentL(dtdRoot, task, Kprev); + NewComponentL(dtdRoot, task, Knoop); + NewComponentL(dtdRoot, task, Krefresh); + + + // + CBNFNode& navelmts = NewRuleL(dtdRoot, Knavelmts, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, navelmts, Kdo); + NewComponentL(dtdRoot, navelmts, Konevent); + + + // + CBNFNode& wml = NewRuleL(dtdRoot, Kwml, EAnd, NULL, NULL, NULL); + CBNFNode& wml1 = NewComponentL( wml, EOptional); + NewComponentL(dtdRoot, wml1,Khead); + CBNFNode& wml2 = NewComponentL( wml, EOptional); + NewComponentL(dtdRoot, wml2, Ktemplate); + CBNFNode& wml3 = NewComponentL( wml, ENMore); + AddComponentAttributeL( wml3, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(dtdRoot, wml3, Kcard); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(wml, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(wml, Kcoreattrs, dtdRoot); + + + // + CBNFNode& fields = NewRuleL(dtdRoot, Kfields, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, fields, Kflow); + NewComponentL(dtdRoot, fields, Kinput); + NewComponentL(dtdRoot, fields, Kselect); + NewComponentL(dtdRoot, fields, Kfieldset); + + + // + CBNFNode& card = NewRuleL(dtdRoot, Kcard, EAnd, NULL, NULL, NULL); + CBNFNode& card1 = NewComponentL( card, ENMore); + NewComponentL(dtdRoot, card1, Konevent); + CBNFNode& card2 = NewComponentL( card, EOptional); + NewComponentL(dtdRoot, card2, Ktimer); + CBNFNode& card3 = NewComponentL( card, ENMore); + CBNFNode& card31 = NewComponentL( card3, EOr); + NewComponentL(dtdRoot, card31, Kdo); + NewComponentL(dtdRoot, card31, Kp); + // Attributes + // title %vdata #IMPLIED + AddNewAttributeL(card, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // newcontext %boolean "false" + _LIT(Knewcontext, "newcontext"); + AddNewAttributeWithValueL(card, iLUT.Des2IDL(Knewcontext), Kboolean, Kfalse, dtdRoot); + // ordered %boolean "true" + _LIT(Kordered, "ordered"); + AddNewAttributeWithValueL(card, iLUT.Des2IDL(Kordered), Kboolean, Ktrue, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(card, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %cardev + AddNewReferenceAttributeL(card, Kcardev, dtdRoot ); + // %coreattrs + AddNewReferenceAttributeL(card, Kcoreattrs, dtdRoot); + + + // + CBNFNode& doElement = NewRuleL(dtdRoot, Kdo, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, doElement, Ktask); + // Attributes + // type CDATA #REQUIRED + AddNewAttributeL(doElement, typeAttributeId, KCDATA, CDTDElementAttribute::ERequired, dtdRoot); + // label %vdata #IMPLIED + _LIT(Klabel, "label"); + AddNewAttributeL(doElement, iLUT.Des2IDL(Klabel), Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // name NMTOKEN #IMPLIED + AddNewAttributeL(doElement, nameAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // optional %boolean "false" + _LIT(Koptional, "optional"); + AddNewAttributeWithValueL(doElement, iLUT.Des2IDL(Koptional), Kboolean, Kfalse, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(doElement, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(doElement, Kcoreattrs, dtdRoot); + + + // + CBNFNode& onevent = NewRuleL(dtdRoot, Konevent, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, onevent, Ktask); + // Attributes + // type CDATA #REQUIRED + AddNewAttributeL(onevent, typeAttributeId, KCDATA, CDTDElementAttribute::ERequired, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(onevent, Kcoreattrs, dtdRoot); + + + // + CBNFNode& head = NewRuleL(dtdRoot, Khead, EAnd, NULL, NULL, NULL); + CBNFNode& head1 = NewComponentL( head, ENMore); + AddComponentAttributeL( head1, CBNFNode::KNMoreMinimum(), 1); + CBNFNode& head11 = NewComponentL( head1, EOr); + NewComponentL(dtdRoot, head11, Kaccess); + NewComponentL(dtdRoot, head11, Kmeta); + // Attributes + // %coreattrs + AddNewReferenceAttributeL(head, Kcoreattrs, dtdRoot); + + + // + CBNFNode& templateElement = NewRuleL(dtdRoot, Ktemplate, EAnd, NULL, NULL, NULL); + CBNFNode& templateElement1 = NewComponentL( templateElement, ENMore); + NewComponentL(dtdRoot, templateElement1, Knavelmts); + // Attributes + // %cardev + AddNewReferenceAttributeL(templateElement, Kcardev, dtdRoot ); + // %coreattrs + AddNewReferenceAttributeL(templateElement, Kcoreattrs, dtdRoot); + + + // + CBNFNode& access = NewRuleL(dtdRoot, Kaccess, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, access, KEMPTY); + // Attributes + // domain CDATA #IMPLIED + _LIT(Kdomain, "domain"); + AddNewAttributeL(access, iLUT.Des2IDL(Kdomain), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // path CDATA #IMPLIED + _LIT(Kpath, "path"); + AddNewAttributeL(access, iLUT.Des2IDL(Kpath), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(access, Kcoreattrs, dtdRoot); + + + // + CBNFNode& meta = NewRuleL(dtdRoot, Kmeta, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, meta, KEMPTY); + // Attributes + // http-equiv CDATA #IMPLIED + _LIT(Khttpequiv, "http-equiv"); + AddNewAttributeL(meta, iLUT.Des2IDL(Khttpequiv), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // name CDATA #IMPLIED + AddNewAttributeL(meta, nameAttributeId, KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // forua %boolean #IMPLIED + _LIT(Kforua, "forua"); + AddNewAttributeL(meta, iLUT.Des2IDL(Kforua), Kboolean, CDTDElementAttribute::EImplied, dtdRoot); + // content CDATA #REQUIRED + _LIT(Kcontent, "content"); + AddNewAttributeL(meta, iLUT.Des2IDL(Kcontent), KCDATA, CDTDElementAttribute::ERequired, dtdRoot); + // scheme CDATA #IMPLIED + _LIT(Kscheme, "scheme"); + AddNewAttributeL(meta, iLUT.Des2IDL(Kscheme), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(meta, Kcoreattrs, dtdRoot); + + + // + CBNFNode& go = NewRuleL(dtdRoot, Kgo, EAnd, NULL, NULL, NULL); + CBNFNode& go1 = NewComponentL( go, ENMore); + CBNFNode& go11 = NewComponentL( go1, EOr); + NewComponentL(dtdRoot, go11, Kpostfield); + NewComponentL(dtdRoot, go11, Ksetvar); + // Attributes + // href %HREF #REQUIRED + AddNewAttributeL(go, hrefAttributeId, KHREF, CDTDElementAttribute::ERequired, dtdRoot); + // sendreferer %boolean "false" + _LIT(Ksendreferer, "sendreferer"); + AddNewAttributeWithValueL(go, iLUT.Des2IDL(Ksendreferer), Kboolean, Kfalse, dtdRoot); + // method post | get "get" + newAttribute = new(ELeave) CDTDElementAttribute(); + CleanupStack::PushL(newAttribute); + _LIT(Kpost, "post"); + _LIT(Kget, "get"); + CBNFNode* methodTypeTree = NewComponentL(EOr); + newAttribute->iType = methodTypeTree; + NewComponentL(dtdRoot, *methodTypeTree, Kpost); + NewComponentL(dtdRoot, *methodTypeTree, Kget); + newAttribute->iValue = NewComponentL(EExact, Kget); + _LIT(Kmethod, "method"); + go.AddAttributeL(iLUT.Des2IDL(Kmethod), newAttribute); + CleanupStack::Pop(); // newAttribute + // accept-charset CDATA #IMPLIED + _LIT(Kacceptcharset, "accept-charset"); + AddNewAttributeL(go, iLUT.Des2IDL(Kacceptcharset), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(go, Kcoreattrs, dtdRoot); + + + // + CBNFNode& prev = NewRuleL(dtdRoot, Kprev, EAnd, NULL, NULL, NULL); + CBNFNode& prev1 = NewComponentL( prev, ENMore); + NewComponentL(dtdRoot, prev1, Ksetvar); + // Attributes + // %coreattrs + AddNewReferenceAttributeL(prev, Kcoreattrs, dtdRoot); + + + // + CBNFNode& refresh = NewRuleL(dtdRoot, Krefresh, EAnd, NULL, NULL, NULL); + CBNFNode& refresh1 = NewComponentL( refresh, ENMore); + NewComponentL(dtdRoot, refresh1,Ksetvar); + // Attributes + // %coreattrs + AddNewReferenceAttributeL(refresh, Kcoreattrs, dtdRoot); + + + // + CBNFNode& noop = NewRuleL(dtdRoot, Knoop, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, noop, KEMPTY); + // Attributes + // %coreattrs + AddNewReferenceAttributeL(noop, Kcoreattrs, dtdRoot); + + + // + CBNFNode& postfield = NewRuleL(dtdRoot, Kpostfield, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, postfield, KEMPTY); + // Attributes + // name %vdata #REQUIRED + AddNewAttributeL(postfield, nameAttributeId, Kvdata, CDTDElementAttribute::ERequired, dtdRoot); + // value %vdata #REQUIRED + AddNewAttributeL(postfield, valueAttributeId, Kvdata, CDTDElementAttribute::ERequired, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(postfield, Kcoreattrs, dtdRoot); + + + // + CBNFNode& setvar = NewRuleL(dtdRoot, Ksetvar, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, setvar, KEMPTY); + // Attributes + // name %vdata #REQUIRED + AddNewAttributeL(setvar, nameAttributeId, Kvdata, CDTDElementAttribute::ERequired, dtdRoot); + // value %vdata #REQUIRED + AddNewAttributeL(setvar, valueAttributeId, Kvdata, CDTDElementAttribute::ERequired, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(setvar, Kcoreattrs, dtdRoot); + + + // + CBNFNode& select = NewRuleL(dtdRoot, Kselect, EAnd, NULL, NULL, NULL); + CBNFNode& select1 = NewComponentL( select, ENMore); + AddComponentAttributeL( select1, CBNFNode::KNMoreMinimum(), 1); + CBNFNode& select12 = NewComponentL( select1, EOr); + NewComponentL(dtdRoot, select12, Koptgroup); + NewComponentL(dtdRoot, select12, Koption); + // Attributes + // title %vdata #IMPLIED + AddNewAttributeL(select, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // name NMTOKEN #IMPLIED + AddNewAttributeL(select, nameAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // value %vdata #IMPLIED + AddNewAttributeL(select, valueAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // iname NMTOKEN #IMPLIED + _LIT(Kiname, "iname"); + AddNewAttributeL(select, iLUT.Des2IDL(Kiname), KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // ivalue %vdata #IMPLIED + _LIT(Kivalue, "ivalue"); + AddNewAttributeL(select, iLUT.Des2IDL(Kivalue), Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // multiple %boolean "false" + _LIT(Kmultiple, "multiple"); + AddNewAttributeWithValueL(select, iLUT.Des2IDL(Kmultiple), Kboolean, Kfalse, dtdRoot); + // tabindex %number #IMPLIED + AddNewAttributeL(select, tabindexAttributeId, Knumber, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(select, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(select, Kcoreattrs, dtdRoot); + + + // + CBNFNode& optgroup = NewRuleL(dtdRoot, Koptgroup, EAnd, NULL, NULL, NULL); + CBNFNode& optgroup1 = NewComponentL( optgroup, ENMore); + AddComponentAttributeL( optgroup1, CBNFNode::KNMoreMinimum(), 1); + CBNFNode& optgroup11 = NewComponentL( optgroup1, EOr); + NewComponentL(dtdRoot, optgroup11, Koptgroup); + NewComponentL(dtdRoot, optgroup11, Koption); + // Attributes + // title %vdata #IMPLIED + AddNewAttributeL(optgroup, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(optgroup, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(optgroup, Kcoreattrs, dtdRoot); + + + // + CBNFNode& option = NewRuleL(dtdRoot, Koption, EAnd, NULL, NULL, NULL); + CBNFNode& option1 = NewComponentL( option, ENMore); + CBNFNode& option11 = NewComponentL( option1, EOr); + NewComponentL(dtdRoot, option11, KPCDATA); + NewComponentL(dtdRoot, option11, Konevent); + // Attributes + // value %vdata #IMPLIED + AddNewAttributeL(option, valueAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // title %vdata #IMPLIED + AddNewAttributeL(option, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // onpick %HREF #IMPLIED + _LIT(Konpick, "onpick"); + AddNewAttributeL(option, iLUT.Des2IDL(Konpick), KHREF, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(option, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(option, Kcoreattrs, dtdRoot); + + + // + CBNFNode& input = NewRuleL(dtdRoot, Kinput, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, input,KEMPTY); + // Attributes + // name NMTOKEN #REQUIRED + AddNewAttributeL(input, nameAttributeId, KNMTOKEN, CDTDElementAttribute::ERequired, dtdRoot); + // type text | password "text" + newAttribute = new(ELeave) CDTDElementAttribute(); + CleanupStack::PushL(newAttribute); + _LIT(KtextLit, "text"); + _LIT(Kpassword, "password"); + CBNFNode* inputtypeTypeTree = NewComponentL(EOr); + newAttribute->iType = inputtypeTypeTree; + NewComponentL(dtdRoot, *inputtypeTypeTree, KtextLit); + NewComponentL(dtdRoot, *inputtypeTypeTree, Kpassword); + newAttribute->iValue = NewComponentL(EExact, KtextLit); + input.AddAttributeL(typeAttributeId, newAttribute); + CleanupStack::Pop(); // newAttribute + // value %vdata #IMPLIED + AddNewAttributeL(input, valueAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // format CDATA #IMPLIED + _LIT(Kformat, "format"); + AddNewAttributeL(input, iLUT.Des2IDL(Kformat), KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // emptyok %boolean "false" + _LIT(Kemptyok, "emptyok"); + AddNewAttributeWithValueL(input, iLUT.Des2IDL(Kemptyok), Kboolean, Kfalse, dtdRoot); + // size %number #IMPLIED + _LIT(Ksize, "size"); + AddNewAttributeL(input, iLUT.Des2IDL(Ksize), Knumber, CDTDElementAttribute::EImplied, dtdRoot); + // maxlength %number #IMPLIED + _LIT(Kmaxlength, "maxlength"); + AddNewAttributeL(input, iLUT.Des2IDL(Kmaxlength), Knumber, CDTDElementAttribute::EImplied, dtdRoot); + // tabindex %number #IMPLIED + AddNewAttributeL(input, tabindexAttributeId, Knumber, CDTDElementAttribute::EImplied, dtdRoot); + // title %vdata #IMPLIED + AddNewAttributeL(input, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(input, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(input, Kcoreattrs, dtdRoot); + + + // + CBNFNode& fieldset = NewRuleL(dtdRoot, Kfieldset, EAnd, NULL, NULL, NULL); + CBNFNode& fieldset1 = NewComponentL( fieldset, ENMore); + CBNFNode& fieldset11 = NewComponentL( fieldset1, EOr); + NewComponentL(dtdRoot, fieldset11, Kfields); + NewComponentL(dtdRoot, fieldset11, Kdo); + // Attributes + // title %vdata #IMPLIED + AddNewAttributeL(fieldset, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(fieldset, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(fieldset, Kcoreattrs, dtdRoot); + + + // + CBNFNode& timer = NewRuleL(dtdRoot, Ktimer, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, timer, KEMPTY); + // Attributes + // name NMTOKEN #IMPLIED + AddNewAttributeL(timer, nameAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // value %vdata #REQUIRED + AddNewAttributeL(timer, valueAttributeId, Kvdata, CDTDElementAttribute::ERequired, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(timer, Kcoreattrs, dtdRoot); + + + // + CBNFNode& ialign = NewRuleL(dtdRoot, KIAlign, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, ialign,Ktop); + NewComponentL(dtdRoot, ialign, Kmiddle); + NewComponentL(dtdRoot, ialign, Kbottom); + + + // + CBNFNode& img = NewRuleL(dtdRoot, Kimg, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, img, KEMPTY); + // Attributes + // alt %vdata #REQUIRED + _LIT(Kalt, "alt"); + AddNewAttributeL(img, iLUT.Des2IDL(Kalt), Kvdata, CDTDElementAttribute::ERequired, dtdRoot); + // src %HREF #REQUIRED + _LIT(Ksrc, "src"); + AddNewAttributeL(img, iLUT.Des2IDL(Ksrc), KHREF, CDTDElementAttribute::ERequired, dtdRoot); + // localsrc %vdata #IMPLIED + _LIT(Klocalsrc, "localsrc"); + AddNewAttributeL(img, iLUT.Des2IDL(Klocalsrc), Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // vspace %length "0" + _LIT(KNILL, "0"); + _LIT(Kvspace, "vspace"); + AddNewAttributeWithValueL(img, iLUT.Des2IDL(Kvspace), Klength, KNILL, dtdRoot); + // hspace %length "0" + _LIT(Khspace, "hspace"); + AddNewAttributeWithValueL(img, iLUT.Des2IDL(Khspace), Klength, KNILL, dtdRoot); + // align %IAlign "bottom" + AddNewAttributeWithValueL(img, alignAttributeId, KIAlign, Kbottom, dtdRoot); + // height %length #IMPLIED + _LIT(Kheight , "height"); + AddNewAttributeL(img, iLUT.Des2IDL(Kheight), Klength, CDTDElementAttribute::EImplied, dtdRoot); + // width %length #IMPLIED + _LIT(Kwidth, "width"); + AddNewAttributeL(img, iLUT.Des2IDL(Kwidth), Klength, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(img, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(img, Kcoreattrs, dtdRoot); + + + // + CBNFNode& anchor = NewRuleL(dtdRoot, Kanchor, EAnd, NULL, NULL, NULL); + CBNFNode& anchor1 = NewComponentL( anchor, ENMore); + CBNFNode& anchor11 = NewComponentL( anchor1, EOr); + NewComponentL(dtdRoot, anchor11, KPCDATA); + NewComponentL(dtdRoot, anchor11, Kbr); + NewComponentL(dtdRoot, anchor11, Kimg); + NewComponentL(dtdRoot, anchor11, Kgo); + NewComponentL(dtdRoot, anchor11, Kprev); + NewComponentL(dtdRoot, anchor11,Krefresh); + // Attributes + // title %vdata #IMPLIED + AddNewAttributeL(anchor, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(anchor, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(anchor, Kcoreattrs, dtdRoot); + + + // + CBNFNode& a = NewRuleL(dtdRoot, Ka, EAnd, NULL, NULL, NULL); + CBNFNode& a1 = NewComponentL( a, ENMore); + CBNFNode& a11 = NewComponentL( a1, EOr); + NewComponentL(dtdRoot, a11, KPCDATA); + NewComponentL(dtdRoot, a11, Kbr); + NewComponentL(dtdRoot, a11, Kimg); + // Attributes + // href %HREF #REQUIRED + AddNewAttributeL(a, hrefAttributeId, KHREF, CDTDElementAttribute::ERequired, dtdRoot); + // title %vdata #IMPLIED + AddNewAttributeL(a, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(a, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(a, Kcoreattrs, dtdRoot); + + + // + CBNFNode& table = NewRuleL(dtdRoot, Ktable, EAnd, NULL, NULL, NULL); + CBNFNode& table1 = NewComponentL( table, ENMore); + AddComponentAttributeL( table1, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(dtdRoot, table1, Ktr); + // Attributes + // title %vdata #IMPLIED + AddNewAttributeL(table, titleAttributeId, Kvdata, CDTDElementAttribute::EImplied, dtdRoot); + // align CDATA #IMPLIED + AddNewAttributeL(table, alignAttributeId, KCDATA, CDTDElementAttribute::EImplied, dtdRoot); + // columns %number #REQUIRED + _LIT(Kcolumns, "columns"); + AddNewAttributeL(table, iLUT.Des2IDL(Kcolumns), Knumber, CDTDElementAttribute::ERequired, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(table, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(table, Kcoreattrs, dtdRoot); + + + // + CBNFNode& tr = NewRuleL(dtdRoot, Ktr, EAnd, NULL, NULL, NULL); + CBNFNode& tr1 = NewComponentL( tr, ENMore); + AddComponentAttributeL( tr1, CBNFNode::KNMoreMinimum(), 1); + NewComponentL(dtdRoot, tr1, Ktd); + // Attributes + // %coreattrs + AddNewReferenceAttributeL(tr, Kcoreattrs, dtdRoot); + + + // + CBNFNode& td = NewRuleL(dtdRoot, Ktd, EAnd, NULL, NULL, NULL); + CBNFNode& td1 = NewComponentL( td, ENMore); + CBNFNode& td11 = NewComponentL( td1, EOr); + NewComponentL(dtdRoot, td11, Ktext); + NewComponentL(dtdRoot, td11, Klayout); + NewComponentL(dtdRoot, td11, Kimg); + NewComponentL(dtdRoot, td11, Kanchor); + NewComponentL(dtdRoot, td11, Ka); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(td, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(td, Kcoreattrs, dtdRoot); + + + // + CBNFNode& em = NewRuleL(dtdRoot, Kem, EAnd, NULL, NULL, NULL); + CBNFNode& em1 = NewComponentL( em, ENMore); + NewComponentL(dtdRoot, em1, Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(em, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(em, Kcoreattrs, dtdRoot); + + + // + CBNFNode& strong = NewRuleL(dtdRoot, Kstrong, EAnd, NULL, NULL, NULL); + CBNFNode& strong1 = NewComponentL( strong, ENMore); + NewComponentL(dtdRoot, strong1, Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(strong, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(strong, Kcoreattrs, dtdRoot); + + + // + CBNFNode& b = NewRuleL(dtdRoot, Kb, EAnd, NULL, NULL, NULL); + CBNFNode& b1 = NewComponentL( b, ENMore); + NewComponentL(dtdRoot, b1, Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(b, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(b, Kcoreattrs, dtdRoot); + + + // + CBNFNode& i = NewRuleL(dtdRoot, Ki, EAnd, NULL, NULL, NULL); + CBNFNode& i1 = NewComponentL( i, ENMore); + NewComponentL(dtdRoot, i1, Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(i, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(i, Kcoreattrs, dtdRoot); + + + // + CBNFNode& u = NewRuleL(dtdRoot, Ku, EAnd, NULL, NULL, NULL); + CBNFNode& u1 = NewComponentL( u, ENMore); + NewComponentL(dtdRoot, u1, Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(u, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(u, Kcoreattrs, dtdRoot); + + + // + CBNFNode& big = NewRuleL(dtdRoot, Kbig, EAnd, NULL, NULL, NULL); + CBNFNode& big1 = NewComponentL( big, ENMore); + NewComponentL(dtdRoot, big1,Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(big, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(big, Kcoreattrs, dtdRoot); + + + // + CBNFNode& small = NewRuleL(dtdRoot, Ksmall, EAnd, NULL, NULL, NULL); + CBNFNode& small1 = NewComponentL( small, ENMore); + NewComponentL(dtdRoot, small1,Kflow); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(small, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(small, Kcoreattrs, dtdRoot); + + + // + CBNFNode& talign = NewRuleL(dtdRoot, KTAlign, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, talign,Kleft); + NewComponentL(dtdRoot, talign, Kright); + NewComponentL(dtdRoot, talign, Kcenter); + + + // + CBNFNode& wrapmode = NewRuleL(dtdRoot, KWrapMode, EOr, NULL, NULL, NULL); + NewComponentL(dtdRoot, wrapmode, Kwrap); + NewComponentL(dtdRoot, wrapmode, Knowrap); + + + // + CBNFNode& p = NewRuleL(dtdRoot, Kp, EAnd, NULL, NULL, NULL); + CBNFNode& p1 = NewComponentL( p, ENMore); + CBNFNode& p11 = NewComponentL( p1, EOr); + NewComponentL(dtdRoot, p11, Kfields); + NewComponentL(dtdRoot, p11,Kdo); + // Attributes + // align %TAlign "left" + AddNewAttributeWithValueL(p, alignAttributeId, KTAlign, Kleft, dtdRoot); + // mode %WrapMode #IMPLIED + _LIT(Kmode, "mode"); + AddNewAttributeL(p, iLUT.Des2IDL(Kmode), KWrapMode, CDTDElementAttribute::EImplied, dtdRoot); + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(p, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(p, Kcoreattrs, dtdRoot); + + + // + CBNFNode& br = NewRuleL(dtdRoot, Kbr, EAnd, NULL, NULL, NULL); + NewComponentL(dtdRoot, br, KEMPTY); + // Attributes + // xml:lang NMTOKEN #IMPLIED + AddNewAttributeL(br, xmllangAttributeId, KNMTOKEN, CDTDElementAttribute::EImplied, dtdRoot); + // %coreattrs + AddNewReferenceAttributeL(br, Kcoreattrs, dtdRoot); + + + _LIT(Kquot,"quot"); + CBNFNode& quot = NewRuleL(dtdRoot, Kquot, EAnd, NULL, NULL, NULL); + _LIT(Kquote , "\""); + NewComponentL( quot, EExact, Kquote ); + + + _LIT(Kamp,"amp"); + CBNFNode& amp = NewRuleL(dtdRoot, Kamp, EAnd, NULL, NULL, NULL); + _LIT(Kampersand , "&"); + NewComponentL( amp, EExact, Kampersand ); + + _LIT(Kapos,"apos"); + CBNFNode& apos = NewRuleL(dtdRoot, Kapos, EAnd, NULL, NULL, NULL); + _LIT(Kapostrophe , "'"); + NewComponentL( apos, EExact, Kapostrophe ); + + _LIT(Klt,"lt"); + CBNFNode& lt = NewRuleL(dtdRoot, Klt, EAnd, NULL, NULL, NULL); + _LIT(Klessthan , "<"); + NewComponentL( lt, EExact, Klessthan ); + + _LIT(Kgt,"gt"); + CBNFNode& gt = NewRuleL(dtdRoot, Kgt, EAnd, NULL, NULL, NULL); + _LIT(Kgreaterthan , ">"); + NewComponentL( gt, EExact, Kgreaterthan ); + + _LIT(Knbsp,"nbsp"); + CBNFNode& nbsp = NewRuleL(dtdRoot, Knbsp, EAnd, NULL, NULL, NULL); + _LIT(Knonbreakingspace , "\xA0"); + NewComponentL( nbsp, EExact, Knonbreakingspace ); + + _LIT(Kshy,"shy"); + CBNFNode& shy = NewRuleL(dtdRoot, Kshy, EAnd, NULL, NULL, NULL); + _LIT(Kshorthyphen , "\xad"); + NewComponentL( shy, EExact, Kshorthyphen ); +}