1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // @file

    15 // This file contains the definition of the generic CMDXMLParser class

    16 // which is responsible for creating a DOM structure

    17 // from a given XML file.

    18 // 

    19 //

    20 

    21 #include <f32file.h>

    22 #include <utf.h>

    23 #include <bautils.h>

    24 

    25 #include <gmxmlconstants.h>

    26 #include <gmxmlcomposer.h>

    27 #include <gmxmlentityconverter.h>

    28 #include <gmxmlnode.h>

    29 #include <gmxmldocument.h>

    30 #include <gmxmlelement.h>

    31 #include <gmxmlparser.h>

    32 #include <gmxmlprocessinginstruction.h>

    33 #include <gmxmlcomment.h>

    34 #include <gmxmlcdatasection.h>

    35 #include <gmxmltext.h>

    36 

    37 #include "GMXMLFileDataSource.h"

    38 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

    39 #include "gmxmldummydtd.h"

    40 #endif

    41 

    42 const TInt KGMXMLDefaultTextBufferSize = 1024;

    43 const TInt KUTF8EdgeBufferLen = 6;

    44 

    45 //

    46 // Global functions					//

    47 //

    48 

    49 

    50 //==================================================================================

    51 

    52 //

    53 //CMDXParser						//

    54 //

    55 //==================================================================================

    56 

    57 void CMDXMLParser::Panic(TPanicCode aReason) const

    58 	{

    59 	_LIT(KClassName, "CMDXMLParser");

    60 	User::Panic(KClassName, aReason);

    61 	}

    62 

    63 EXPORT_C CMDXMLParser* CMDXMLParser::NewL(MMDXMLParserObserver* aParserObserver)

    64 //

    65 // Two phase static factory function constructor

    66 // @return Created CMDXMLParser

    67 // @leave can Leave due to OOM

    68 //

    69 	{

    70 	CMDXMLParser* self = NewLC(aParserObserver);

    71 	CleanupStack::Pop();

    72 	return self;

    73 	}

    74 

    75 EXPORT_C CMDXMLParser* CMDXMLParser::NewL(MMDXMLParserObserver* aParserObserver, MXMLDtd* aDtdRepresentation)

    76 //

    77 // Two phase static factory function constructor

    78 // @return Created CMDXMLParser

    79 // @param aDtdRepresentation specid DTD represention class to be used for validation

    80 // @leave can Leave due to OOM

    81 //

    82 	{

    83 	CMDXMLParser* self = NewLC(aParserObserver, aDtdRepresentation);

    84 	CleanupStack::Pop();

    85 	return self;

    86 	}

    87 

    88 

    89 //==================================================================================

    90 

    91 EXPORT_C CMDXMLParser* CMDXMLParser::NewLC(MMDXMLParserObserver* aParserObserver)

    92 //

    93 // Two phase static factory function constructor

    94 // @return Created CMDXMLParser

    95 // @leave can Leave due to OOM

    96 //

    97 	{

    98 	CMDXMLParser* self = new (ELeave) CMDXMLParser(aParserObserver);

    99 	CleanupStack::PushL(self);

   100 	// This overload of NewLC doesn't take a MXMLDtd*, but we need to provide one to

   101 	// ConstructL where ownership is taken if we do have one.  Just pass NULL.

   102 	self->ConstructL(NULL);

   103 	return self;

   104 	}

   105 

   106 EXPORT_C CMDXMLParser* CMDXMLParser::NewLC(MMDXMLParserObserver* aParserObserver, MXMLDtd* aDtdRepresentation)

   107 //

   108 // Two phase static factory function constructor

   109 // @return Created CMDXMLParser

   110 // @param aDtdRepresentation specid DTD represention class to be used for validation

   111 // @leave can Leave due to OOM

   112 //

   113 	{

   114 	CMDXMLParser* self = new (ELeave) CMDXMLParser(aParserObserver);

   115 	CleanupStack::PushL(self);

   116 	self->ConstructL(aDtdRepresentation);

   117 	return self;

   118 	}

   119 

   120 

   121 //==================================================================================

   122 

   123 void CMDXMLParser::ConstructL(MXMLDtd* aDtdRepresentation)

   124 //

   125 // Second stage constructor

   126 // @param aDtdRepresentation The DTD to be used for validation

   127 // @leave can Leave due to OOM

   128 //

   129 	{

   130 	CMDXMLEntityConverter* entityConverter = new(ELeave) CMDXMLEntityConverter();

   131 	SetEntityConverter(entityConverter);

   132 

   133 	// This doesn't leave, but if CMDXMLParser::NewLC() Leaves after taking ownership

   134 	// of this we'll get a double deletion as the caller will have pushed 

   135 	// aDtdRepresentation onto the CleanupStack.  As such we can only take ownership

   136 	// once we are sure we aren't going to leave.

   137 	iDtdRepresentation = aDtdRepresentation;

   138 	}

   139 

   140 CMDXMLParser::CMDXMLParser(MMDXMLParserObserver* aParserObserver)

   141 	: CActive(EPriorityNormal)

   142 //

   143 // Constructor

   144 //

   145 	{

   146 	iParserObserver = aParserObserver;

   147 	iStoreInvalid = ETrue;

   148 	CActiveScheduler::Add(this);

   149 	}

   150 

   151 //==================================================================================

   152 

   153 EXPORT_C CMDXMLParser::~CMDXMLParser()

   154 	{

   155 	Cancel();

   156 	delete iBomBuffer;

   157 	if( iFileSource == NULL )

   158 		{

   159 		// iFileSource has not been allocated yet, so the file path or file

   160 		// handle are still owned

   161 		if( iFileToParse!=NULL )

   162 			delete iFileToParse;

   163 		else

   164 			iFileHandleToParse.Close();

   165 		}

   166 	else

   167 		{

   168 		delete iFileSource;

   169 		}

   170 	delete iUTF8EdgeBuffer;

   171 	delete iXMLDoc;

   172 	delete iEntityConverter;

   173 	delete iElementTag;

   174 	delete iDtdRepresentation;

   175 	delete iText;

   176 	}

   177 

   178 //==================================================================================

   179 //Defect fix for INC036136- Enable the use of custom entity converters in GMXML

   180 EXPORT_C void CMDXMLParser::SetEntityConverter(CMDXMLEntityConverter* aEntityConverter)

   181 /*

   182 	 * Sets the entity converter to be used

   183 	 * and  take ownership of the passed entity converter

   184 	 * @param aEntityConverter The entity converter to be used

   185 	 */

   186 	{

   187 	delete iEntityConverter;

   188 	iEntityConverter = aEntityConverter;

   189 	}

   190 //End Defect fix for INC036136

   191 //==================================================================================

   192 

   193 EXPORT_C void CMDXMLParser::SetStoreInvalid(TBool aStoreInvalid)

   194 	{

   195 	iStoreInvalid = aStoreInvalid;

   196 	}

   197 	

   198 //==================================================================================

   199 // Defect fix for INC105134 - GmXML consumes whitespace characters 

   200 //==================================================================================	

   201 EXPORT_C void CMDXMLParser::SetWhiteSpaceHandlingMode(TBool aPreserve)

   202     {

   203     iPreserve = aPreserve;

   204     }

   205 

   206 // End Defect fix for INC105134

   207 //==================================================================================

   208 EXPORT_C CMDXMLDocument* CMDXMLParser::DetachXMLDoc()

   209 //

   210 // @return CMDXMLDocument* to the created DOM, should be called after the

   211 // conclusion of the parser process.  Note that internal variable pointing to

   212 // the document is set to NULL so this function can only be called once per file

   213 // parse.  Client application must take ownership of document for cleanup purposes.

   214 //

   215 	{

   216 	CMDXMLDocument* returnDoc = iXMLDoc;

   217 	iXMLDoc = NULL;

   218 	return returnDoc;

   219 	}

   220 

   221 //==================================================================================

   222 

   223 CMDXMLEntityConverter* CMDXMLParser::EntityConverter()

   224 //

   225 // @return the CMDXMLEntityConverter for use in converting built in entity

   226 // and character entities back to their original format

   227 //

   228 	{

   229 	return iEntityConverter;

   230 	}

   231 

   232 //==================================================================================

   233 

   234 EXPORT_C TInt CMDXMLParser::ParseFile(RFs aRFs, const TDesC& aFileToParse)

   235 //

   236 // ParseFile opens a file ready for parsing

   237 // @param aRFs a resource file session used for file I/O

   238 // @param aFileToParse the file name to parse

   239 // @return KErrNone if all OK or file read error code

   240 //

   241 	{

   242 	//Find out whether the file exists. If not dont start the active object

   243 	if(!BaflUtils::FileExists(aRFs,aFileToParse))

   244 		{

   245 		return KErrNotFound;

   246 		}

   247 	else

   248 		{	

   249 		//Check whether the file is locked by any other process				

   250 		RFile tempFile;

   251 		TInt err=tempFile.Open(aRFs, aFileToParse, EFileRead | EFileShareReadersOnly);		

   252 		if(err!=KErrNone)

   253 			{

   254 			return err;					

   255 			}

   256 		tempFile.Close();	

   257 		}	

   258 	Cancel();

   259 	iSuspiciousCharacter = KErrNotFound;

   260 	iError = KErrNone;

   261 	iSeverity = EXMLNone;

   262 	iDocTypeSet = EFalse;

   263 	iVersionSet = EFalse;

   264 

   265 	/* We need to open our file in a leave-safe place as it involves

   266 	   a heap alloc, and so we'll set up the AO to do that when it runs next.

   267 	*/

   268 	delete iFileToParse;

   269 	iFileToParse = aFileToParse.Alloc();

   270 	if(iFileToParse == NULL)

   271 		{

   272 		return KErrNoMemory;

   273 		}

   274 

   275 	iRFs = aRFs;

   276 	iState = KInitFromFile;

   277 

   278 	SetActive();

   279 	TRequestStatus* s=&iStatus;

   280 	User::RequestComplete(s, KErrNone);

   281 

   282 	return KErrNone;

   283 	}

   284 	

   285 /** 

   286 Parses a specified XML file into a DOM object tree.

   287 

   288 Parses a specified XML file into a DOM object tree using an open file handle. The 

   289 parser takes ownership of the open file handle and will close handle when completed.

   290 

   291 @param aFileHandleToParse An open file handle for the file to parse. Ownership of the

   292 	   file handle is passed.

   293 @return KErrNone if successful.

   294 */

   295 EXPORT_C TInt CMDXMLParser::ParseFile(RFile& aFileHandleToParse)

   296 	{	

   297 	iFileHandleToParse = aFileHandleToParse;

   298 

   299 	Cancel();

   300 	iSuspiciousCharacter = KErrNotFound;

   301 	iError = KErrNone;

   302 	iSeverity = EXMLNone;

   303 	iDocTypeSet = EFalse;

   304 	iVersionSet = EFalse;

   305 

   306 	iState = KInitFromFile;

   307 

   308 	iStatus = KRequestPending;

   309 	SetActive();

   310 	TRequestStatus* s=&iStatus;

   311 	User::RequestComplete(s, KErrNone);

   312 

   313 	return KErrNone;

   314 	}

   315 //==================================================================================

   316 

   317 EXPORT_C void CMDXMLParser::ParseSourceL(MMDXMLParserDataProvider *aSource)

   318 	{

   319 	iSuspiciousCharacter = KErrNotFound;

   320 	iError = KErrNone;

   321 	iSeverity = EXMLNone;

   322 	iDocTypeSet = EFalse;

   323 	iVersionSet = EFalse;

   324 

   325 	iDataSource = aSource;

   326 	PrepareForReuseL();

   327 	GetMoreData();

   328 	}

   329 

   330 //==================================================================================

   331 

   332 void CMDXMLParser::PrepareForReuseL()

   333 	{

   334 	Cancel();

   335 

   336 	iError = KErrNone;

   337 	iSeverity = EXMLNone;

   338 	iDocTypeSet = EFalse;

   339 	iVersionSet = EFalse;

   340 	iBytesPerChar = 0;

   341 	iNextChar = 0;

   342 	iInputBytesRemaining = 0;

   343 	iOpened = EFalse;

   344 	iClosed = EFalse;

   345 	iNewElement = NULL;

   346 	iParentElement = NULL;

   347 	delete iUTF8EdgeBuffer;

   348 	iUTF8EdgeBuffer = NULL;

   349 	delete iBomBuffer;

   350 	iBomBuffer = NULL;

   351 

   352 	CreateDocumentL();

   353 	iState = KDetermineCharset;

   354 	}

   355 

   356 //==================================================================================

   357 TBool CMDXMLParser::DetectFileType()

   358 //

   359 // Detects the type of a data source - can be Unicode, UTF-8 or ASCII (because ASCII is

   360 // a subset of UTF-8).

   361 // If the file is empty it is assumed to be Utf-8.

   362 	{

   363 	TBuf8<3> bom;

   364 

   365 	// Read the first 3 bytes of the file.  These contain any BOM present.  If it turns out

   366 	// there's not a bom we leave the pointer untouched so we can parse these bytes

   367 	// as usual.  

   368 	if(iInputBufferPtr.Length() < 3)

   369 		return EFalse;

   370 	else

   371 		bom.Copy(iInputBufferPtr.Left(3));

   372 

   373 	TInt hichar = (CEditableText::EByteOrderMark & 0xFF00)>>8;

   374 	TInt lochar = CEditableText::EByteOrderMark & 0xFF;

   375 

   376 	if((bom[0] == 0xEF) && (bom[1] == 0xBB) && (bom[2] == 0xBF))

   377 		{

   378 		// Utf-8 with a bom.  We don't want to parse the bom, so add 3 bytes offset to the read pos.

   379 		iBytesPerChar = 1;

   380 		iNextChar = 3;

   381 		}

   382 	else

   383 		{

   384 		if((bom[0] == lochar) && (bom[1] == hichar))

   385 			{

   386 			// Little Endian Unicode.  Move the read position on 2 bytes to ignore the bom.

   387 			iBytesPerChar = 2;

   388 			// would normally skip first 2 characters

   389 			iNextChar = 2;

   390 			}

   391 		else if((bom[0] == hichar) && (bom[1] == lochar))

   392 			{

   393 			// We have a bom, but it indicates endianess opposite to that of the platform.  We

   394 			// don't currently support this so set an error.

   395 			SetError(KErrNotSupported, EXMLFatal);

   396 			}

   397 		else

   398 			{

   399 			// Default to Utf-8

   400 			iBytesPerChar = 1;

   401 			}

   402 		}

   403 	return ETrue;

   404 	}

   405 

   406 //==================================================================================

   407 

   408 EXPORT_C void CMDXMLParser::DoCancel()

   409 //

   410 // DoCancel function inherited from CActive base class

   411 //

   412 	{

   413 	if (iDataSource)

   414 	  {

   415 	  iDataSource->Disconnect();

   416 	  iDataSource = NULL;

   417 	  }

   418 	}

   419 

   420 //==================================================================================

   421 

   422 EXPORT_C TInt CMDXMLParser::RunError(TInt aError)

   423 //

   424 // RunError function inherited from CActive base class - intercepts any Leave from

   425 // the RunL() function, sets an appropriate errorcode and calls ParseFileCompleteL

   426 //

   427 	{

   428 	if(iDataSource)

   429 		{

   430 		iDataSource->Disconnect();

   431 		iDataSource = NULL;

   432 		}

   433 

   434 	iSeverity = EXMLFatal;

   435 	iError = aError;

   436 	if (iFileToParse)

   437 		{

   438 		delete iFileToParse;

   439 		iFileToParse = NULL;

   440 		}

   441 	else if( iFileSource==NULL )

   442 		{

   443 		// iFileSource is not set so the ownership of the file handle has not been passed

   444 		iFileHandleToParse.Close();

   445 		}

   446 

   447 	__ASSERT_DEBUG(iParserObserver != NULL, Panic(ENullMemVarParserObserver));

   448 	TRAPD(err, iParserObserver->ParseFileCompleteL());

   449 	return err;

   450 	}

   451 

   452 //==================================================================================

   453 

   454 TBool CMDXMLParser::DoParseLoopL()

   455 //

   456 // RunL function inherited from CActive base class - carries out the actual parsing.

   457 // @leave can Leave due to OOM

   458 //

   459 	{

   460 	TBuf<1> singleChar;

   461 	TGetCharReturn getCharReturn = KError;

   462 	TInt error;

   463 

   464 	while(iSeverity != EXMLFatal && (getCharReturn = GetChar(singleChar), getCharReturn == KCharReturned) )

   465 		{

   466 

   467 #if 0	// THIS NEEDS TO BE REMOVED - IT'S A VERY HANDY DEBUGGING TOOL WHEN YOU'RE MANUALLY DOING 

   468 		// BYTE ORDERING ON MISALIGNED STREAMS THOUGH...

   469 		{

   470 #define DES_AS_8_BIT(str) (TPtrC8((TText8*)((str).Ptr()), (str).Size()))

   471 

   472 		RFs aRFs;

   473 		RFile aFile;

   474 		_LIT(KFileName, "c:\\documents\\SMIL_Test_Files\\echoOutput.txt");

   475 		TPtrC file;

   476 		TInt err;

   477 

   478 		file.Set(KFileName);

   479 

   480 		aRFs.Connect();

   481 

   482 		err = aFile.Open(aRFs, file, EFileWrite);

   483 		if(err != KErrNone)

   484 			err = aFile.Create(aRFs, file, EFileWrite);

   485 

   486 		err = 0;

   487 		aFile.Seek(ESeekEnd, err);

   488 		aFile.Write(DES_AS_8_BIT(singleChar));

   489 		aFile.Close();

   490 		aRFs.Close();

   491 		}

   492 #endif

   493 		if((!iOpened) && singleChar != KXMLStartTag)

   494 			{

   495 			HandleTextL(singleChar);

   496 			}

   497 

   498 		if((iOpened) || (singleChar == KXMLStartTag))			

   499 			{

   500 			if(singleChar == KXMLStartTag)

   501 				{

   502 				if(iOpened)

   503 					{

   504 					if((iSuspiciousCharacter == KErrNotFound))

   505 						{

   506 						iSuspiciousCharacter = iElementTag->Length();

   507 						}

   508 					}

   509 				else

   510 					{

   511 					AddTextL(iParentElement);

   512 					iOpened = ETrue;

   513 					}

   514 				}

   515 			else if(singleChar == KXMLEndTag)

   516 				{

   517 				if(iSuspiciousCharacter != KErrNotFound)

   518 					{

   519 					TPtrC suspiciousSection = iElementTag->Mid(iSuspiciousCharacter);

   520 					if( CheckForStartCData(suspiciousSection) == 0 )

   521 						{

   522 						TInt endCDataLen = TPtrC(KXMLEndCDataSection).Length();

   523 						// The suspicious character begins a CDataSection.  Check if

   524 						// this End Tag is closing it.

   525 						if( suspiciousSection.Right(endCDataLen - 1) 

   526 							== TPtrC(KXMLEndCDataSection).Left(endCDataLen - 1) )

   527 							{

   528 							// Any dodgy characters began the CDataSection or were in it

   529 							iSuspiciousCharacter = KErrNotFound;

   530 							}

   531 						}

   532 					else if( suspiciousSection.Find(KXMLStartComment) == 0 )

   533 						{

   534 						// The suspicious character begins a comment.  Check if

   535 						// this End Tag is closing it.

   536 						TInt endCommentLen = TPtrC(KXMLEndComment).Length();

   537 						if( suspiciousSection.Right(endCommentLen - 1) 

   538 							== TPtrC(KXMLEndComment).Left(endCommentLen - 1) )

   539 							{

   540 							// Any dodgy characters began the comment or were in it

   541 							iSuspiciousCharacter = KErrNotFound;

   542 							}

   543 						}

   544 					else if((CheckForStartCData(*iElementTag) == 0) || (iElementTag->Find(KXMLStartComment) == 0))

   545 						{

   546 						// this tag is a CDataSection or comment, we're allowed <

   547 						iSuspiciousCharacter = KErrNotFound;

   548 						iClosed = ETrue;

   549 						}

   550 					else

   551 						{

   552 						// The < was spurious, set an error and close the tag as normal

   553 						SetError(KErrXMLIllegalCharacter, EXMLWorkable);

   554 						iClosed = ETrue;

   555 						iSuspiciousCharacter = KErrNotFound;

   556 						}

   557 					}

   558 				else

   559 					{

   560 					iClosed = ETrue;

   561 					}

   562 				}

   563 

   564 			// ensure descriptor doesn't overflow end and panics

   565 			if(iElementTag->Length() == iElementTag->Des().MaxLength())

   566 				{

   567 				iElementTag = iElementTag->ReAllocL(iElementTag->Length() + KNominalTagLength);

   568 				}

   569 

   570 			iElementTag->Des().Append(singleChar);

   571 

   572 			// if tag is complete and needs adding to the DOM?

   573 			if(iClosed)

   574 				{

   575 				if(		!CommentL(iParentElement)

   576 					&&	!CDataSectionL(iParentElement)

   577 					&&	!VersionIDL()

   578 					&&	!DocTypeL()

   579 					&&	!ProcessingInstructionL(iParentElement) )

   580 					{

   581 					// is this a regular closing tag

   582 					if

   583 						(iElementTag->Left(2) == KXMLStartEndTag)

   584 						{

   585 						error = ParseElementEndTag(*iParentElement, iElementTag->Des());

   586 						if(error == KErrNone)

   587 							{

   588 							if(iParentElement->ParentNode() == NULL)

   589 								{

   590 								SetError(KErrXMLBadNesting, EXMLIndeterminate);

   591 								}

   592 							else

   593 								{

   594 								iParentElement = (CMDXMLElement*) iParentElement->ParentNode();

   595 								}

   596 							}

   597 						else if(error == KErrNotFound)

   598 							{

   599 							CMDXMLElement* tempElement = (CMDXMLElement*) iParentElement->ParentNode();

   600 							TInt searchResult = KErrNotFound;

   601 

   602 							while(tempElement != NULL &&

   603 									searchResult == KErrNotFound &&

   604 									tempElement->NodeName() != KXMLDocumentElementNodeName)

   605 								{

   606 								searchResult = ParseElementEndTag(*tempElement,iElementTag->Des());	

   607 								if(searchResult == KErrNone)

   608 									{

   609 									iParentElement = tempElement;

   610 									SetError(KErrXMLBadNesting, EXMLIndeterminate);

   611 									}

   612 								else

   613 									{

   614 									tempElement = (CMDXMLElement*) tempElement->ParentNode();

   615 									}

   616 								}

   617 							if(searchResult != KErrNone)

   618 								{

   619 								SetError(KErrXMLBadNesting, EXMLIndeterminate);

   620 								}

   621 							}

   622 						else

   623 							{

   624 							SetError(error, EXMLIndeterminate);

   625 							}

   626 						}

   627 					// if a new element start tag or start/end tag

   628 					else

   629 						{

   630 						// NOTE ParseStartTagL destroys iElementTag

   631 						// so following check must be done first

   632 

   633 						// if not single tag with close

   634 						if(!(iElementTag->Right(2) == KXMLEndStartTag))

   635 							{

   636 							iNewElement = ParseStartTagL();

   637 							CleanupStack::PushL(iNewElement);

   638 							error = iParentElement->AppendChild(iNewElement);

   639 

   640 							if(error == KErrNone)

   641 								{

   642 								CleanupStack::Pop(); // iNewElement

   643 								iParentElement = (CMDXMLElement*) iParentElement->LastChild();

   644 								}

   645 							else

   646 								{

   647 								SetError(error, EXMLWorkable);

   648 								CleanupStack::PopAndDestroy(iNewElement); // iNewElement

   649 								}

   650 							}

   651 						else

   652 							{

   653 							iNewElement = ParseStartTagL();

   654 							CleanupStack::PushL(iNewElement);

   655 							error = iParentElement->AppendChild(iNewElement);

   656 

   657 							if(error == KErrNone)

   658 								{

   659 								CleanupStack::Pop(iNewElement); // iNewElement

   660 								}

   661 							else

   662 								{

   663 								SetError(error, EXMLWorkable);

   664 								CleanupStack::PopAndDestroy(iNewElement); // iNewElement

   665 								}

   666 							}

   667 						}

   668 						iEndOfTag = ETrue;

   669 					}

   670 

   671 				if(iEndOfTag)

   672 					{

   673 					iEndOfTag = EFalse;

   674 					iOpened = iClosed = EFalse;

   675 					iElementTag->Des().Zero();

   676 

   677 					// reduce size of ElementTag if increased beyond normal limits on last pass

   678 					if(iElementTag->Des().MaxLength() > KNominalTagLength)

   679 						{

   680 						iElementTag = iElementTag->ReAllocL(KNominalTagLength);

   681 						}

   682 					}

   683 				}

   684 			}

   685 		}	// END OF WHILE LOOP

   686 

   687 	if(getCharReturn == KError)

   688 		{

   689 		return EFalse;

   690 		}

   691 	else

   692 		{

   693 		//	GetChar returned KWEaitForChar

   694 		// GetChar handles pushing the state and requesting more data for us, so we just go active.

   695 		return ETrue;

   696 		}

   697 	}

   698 

   699 

   700 

   701 

   702 //==================================================================================

   703 

   704 void CMDXMLParser::RunL()

   705 	{

   706 	TRequestStatus* s=&iStatus;

   707 	TInt err = s->Int();

   708 

   709 	switch(iState)

   710 		{

   711 	case KInitFromFile:

   712 		delete iFileSource;

   713 		iFileSource = NULL;

   714 		if( iFileToParse == NULL )

   715 			{

   716 			// iFileToParse is not set, file was passed by open file handle.

   717 			iFileSource = CMDXMLParserFileDataSource::NewL(iFileHandleToParse);			

   718 			}

   719 		else

   720 			{

   721 			iFileSource = CMDXMLParserFileDataSource::NewL(iRFs, *iFileToParse);

   722 

   723 			delete iFileToParse;

   724 			iFileToParse = NULL;

   725 			}

   726 

   727 		ParseSource(iFileSource);	// will go active itself 

   728 		break;

   729 

   730 	case KDetermineCharset:

   731 		if(!iBytesPerChar)

   732 			{

   733 			if(DetectFileType())

   734 				{

   735 				iState = KParseData;

   736 				SetActive();

   737 				User::RequestComplete(s, KErrNone);

   738 				}

   739 			else

   740 				{

   741 				if(!iBomBuffer)

   742 					{

   743 					iBomBuffer = HBufC8::NewL(KUTF8EdgeBufferLen);

   744 					}

   745 

   746 				TPtr8 bomDes(iBomBuffer->Des());

   747 				TInt newLength = bomDes.Length() + iCurrentInputBufferLen;

   748 				iBomBuffer->ReAlloc(newLength);

   749 				

   750 				bomDes.Append(iInputBufferPtr);

   751 				if(iBomBuffer->Length() >=3)

   752 					{

   753 					iInputBufferPtr.Set(bomDes);

   754 					iCurrentInputBufferLen = newLength;

   755 

   756 					SetActive();

   757 					User::RequestComplete(s, KErrNone);

   758 					}

   759 				else

   760 					{

   761 					GetMoreData();

   762 					}

   763 				}

   764 			}

   765 		else

   766 			{

   767 			iState = KParseData;

   768 			SetActive();

   769 			User::RequestComplete(s, KErrNone);

   770 			}

   771 		break;

   772 

   773 	case KWaitingForData:

   774 		switch(err)

   775 			{

   776 		case MMDXMLParserDataProvider::KMoreData:

   777 			// We got more data this time, make sure all the parameters are correct.

   778 			iCurrentInputBufferLen = iInputBufferPtr.Length();				

   779 

   780 			iState = iPreviousState;

   781 			SetActive();

   782 			User::RequestComplete(s, KErrNone);

   783 			break;

   784 

   785 		case MMDXMLParserDataProvider::KDataStreamEnd:

   786 			iState = KFinished;

   787 			SetActive();

   788 			User::RequestComplete(s, KErrNone);

   789 			break;

   790 

   791 		default:

   792 		case MMDXMLParserDataProvider::KDataStreamError:

   793 			User::Leave(KErrCorrupt);

   794 			break;

   795 			}

   796 

   797 		break;

   798 

   799 	case KParseData:

   800 		if(!iParentElement)	// initialise the parsing

   801 			{

   802 			iOpened = EFalse;

   803 			iClosed = EFalse;

   804 			// If we're going through the tag and find a < we don't know whether

   805 			// it will be valid (eg it starts a CDataSection) or whether it's an

   806 			// illegal character.  Store its index so that when we're a bit further

   807 			// along in the string we can check whether it was allowed and if not 

   808 			// set an Illegal Character error.

   809 			delete iNewElement;

   810 			iNewElement = NULL;

   811 			

   812 			__ASSERT_DEBUG(iXMLDoc != NULL, Panic(ENullMemVarXMLDoc));

   813 			iParentElement = iXMLDoc->DocumentElement();

   814 

   815 			delete iElementTag;

   816 			iElementTag = NULL;

   817 			iElementTag = HBufC::NewL(KNominalTagLength);

   818 			}

   819 

   820 		if(!iBytesPerChar)

   821 			{

   822 			// assume ascii/UTF8

   823 			iBytesPerChar = 1;

   824 			}

   825 

   826 		if(!DoParseLoopL())

   827 			iState = KFinished;

   828 

   829 			break;

   830 

   831 	case KFinished:

   832 		// Check for any errors that we can pick up now, like missing doctype, or incomplete content

   833 		CheckForErrors();

   834 

   835 		// we want to leave this instance in a safe state where it can be restarted again with a single call to ParseSource.

   836 		// cannot delete this element, as it belongs to the document...

   837 		iParentElement = NULL;

   838 		iState = KDetermineCharset;

   839 

   840 		iDataSource->Disconnect();

   841 		iDataSource=NULL;

   842 		__ASSERT_DEBUG(iParserObserver != NULL, Panic(ENullMemVarParserObserver));

   843 		iParserObserver->ParseFileCompleteL();

   844 		break;

   845 

   846 	default:

   847 		User::Leave(KErrUnknown);

   848 		break;

   849 		}

   850 	}

   851 

   852 void CMDXMLParser::CheckForErrors()

   853 	{

   854 	if(iError == KErrNone)

   855 		{

   856 		if(iParentElement)

   857 			{

   858 			// if iParentElement is not pointing to dummy root node, there has been a problem

   859 			if( (iParentElement == NULL) || (iParentElement->NodeName() != KXMLDocumentElementNodeName) )

   860 				{

   861 				SetError(KErrXMLIncomplete, EXMLWorkable);

   862 				}

   863 			else if(!iParentElement->CheckChildren())

   864 				{

   865 				SetError(KErrXMLInvalidChild, EXMLWorkable);

   866 				}

   867 			else if(iParentElement->FirstChild() != NULL)

   868 				{

   869 				// multiple real (not dummy) root elements

   870 				TInt count = 0;

   871 				CMDXMLNode* iterator = iParentElement->FirstChild();

   872 				do

   873 					{

   874 					if(iterator->NodeType() == CMDXMLNode::EElementNode)

   875 						{

   876 						count++;

   877 						}

   878 					iterator = iterator->NextSibling();

   879 					}

   880 				while(iterator != NULL);

   881 

   882 				if(count != 1)

   883 					{

   884 					SetError(KErrXMLMultipleRootElements, EXMLWorkable);

   885 					}

   886 				}

   887 			}

   888 		}

   889 	if(iError == KErrNone && !iDocTypeSet)

   890 		{

   891 		SetError(KErrXMLMissingDocTypeTag, EXMLWorkable);

   892 		}

   893 

   894 	if(iError == KErrNone && !iVersionSet)

   895 		{

   896 		SetError(KErrXMLMissingVersionTag, EXMLWorkable);

   897 		}

   898 	}

   899 

   900 

   901 void CMDXMLParser::CreateDocumentL()

   902 //

   903 // Creates a generic or DTD-specific document object

   904 // @leave can Leave due to OOM

   905 //

   906 	{

   907 	delete iXMLDoc;

   908 	iXMLDoc = NULL;

   909 

   910 	if (iDtdRepresentation != NULL)

   911 		iXMLDoc = CMDXMLDocument::NewL(*iDtdRepresentation);

   912 	else

   913 		iXMLDoc = CMDXMLDocument::NewL();

   914 	}

   915 

   916 

   917 //==================================================================================

   918 

   919 TBool CMDXMLParser::DocTypeL()

   920 //

   921 // @return Returns true if the current tag is a doctype tag and sets the

   922 // Document DocType member accordingly on the first pass of this function.

   923 //

   924 	{

   925 	TBool returnValue = EFalse;

   926 	TInt tagIdLen = TPtrC(KXMLDocumentTypes).Length();

   927 

   928 	__ASSERT_DEBUG(iElementTag != NULL, Panic(ENullMemVarElementTag));

   929 

   930 	if(iElementTag->Length() > tagIdLen

   931 			&& iElementTag->Left(tagIdLen) == KXMLDocumentTypes)

   932 		{

   933 		if(iDocTypeSet)

   934 			{

   935 			SetError(KErrXMLDuplicateDocTypeTags, EXMLWorkable);

   936 			}

   937 		else

   938 			{

   939 			iXMLDoc->SetDocTypeTagL(iElementTag->Des());

   940 			iDocTypeSet = ETrue;

   941 			}

   942 		returnValue = ETrue;

   943 		iEndOfTag = ETrue;

   944 		}

   945 

   946 	return returnValue;

   947 	}

   948 

   949 //==================================================================================

   950 

   951 TBool CMDXMLParser::ProcessingInstructionL(CMDXMLElement* aParentElement)

   952 //

   953 // creates a new processing instruction if necessary and adds to document

   954 // @return Returns true if the current tag is a processing instruction

   955 //

   956 	{

   957 	TBool returnValue = EFalse;

   958 	TInt startPILen = TPtrC(KXMLStartProcessingInstruction).Length();

   959 	TInt endPILen = TPtrC(KXMLEndProcessingInstruction).Length();

   960 

   961 	__ASSERT_DEBUG(iElementTag != NULL, Panic(ENullMemVarElementTag));

   962 

   963 	if((iElementTag->Left(startPILen) == KXMLStartProcessingInstruction) &&

   964 		(iElementTag->Right(endPILen) == KXMLEndProcessingInstruction))

   965 		{

   966 		if(aParentElement != NULL)

   967 			{

   968 			CMDXMLProcessingInstruction* inst = CMDXMLProcessingInstruction::NewLC(iXMLDoc);

   969 

   970 			TPtrC instStr = iElementTag->Des().Mid(startPILen,

   971 				iElementTag->Length() - (startPILen + endPILen));

   972 			inst->SetDataL(instStr);

   973 

   974 			__ASSERT_DEBUG(aParentElement != NULL, Panic(ENullParameterParentElement));

   975 			TInt error = aParentElement->AppendChild(inst);

   976 			CleanupStack::Pop(inst);

   977 

   978 			if(error != KErrNone)

   979 				{

   980 				SetError(error, EXMLWorkable);

   981 				}

   982 			}

   983 

   984 		returnValue = ETrue;

   985 		iEndOfTag = ETrue;

   986 		}

   987 

   988 	return returnValue;

   989 	}

   990 

   991 

   992 //==================================================================================

   993 

   994 TBool CMDXMLParser::CDataSectionL(CMDXMLElement* aParentElement)

   995 //

   996 // creates a new CDataSection if necessary and adds to document

   997 // @return Returns true if the current tag is a CDataSection

   998 //

   999 	{

  1000 	TBool returnValue = EFalse;

  1001 	TInt instLen = TPtrC(KXMLStartCDataSection).Length();

  1002 	TInt endCDataLen = TPtrC(KXMLEndCDataSection).Length();

  1003 

  1004 	__ASSERT_DEBUG(iElementTag != NULL, Panic(ENullMemVarElementTag));

  1005 

  1006 	if (iElementTag->Left(instLen) == KXMLStartCDataSection) 

  1007 		{

  1008 		returnValue = ETrue;

  1009 		if ((iElementTag->Right(endCDataLen) == KXMLEndCDataSection) && (aParentElement != NULL))

  1010 			{

  1011 			CMDXMLCDATASection* inst = CMDXMLCDATASection::NewLC(iXMLDoc);

  1012 

  1013 			TPtrC instStr = iElementTag->Des().Mid(instLen,

  1014 				iElementTag->Length() - (instLen + endCDataLen));

  1015 			inst->SetDataL(instStr);

  1016 

  1017 			__ASSERT_DEBUG(aParentElement != NULL, Panic(ENullParameterParentElement));

  1018 			TInt error = aParentElement->AppendChild(inst);

  1019 			CleanupStack::Pop(); // inst

  1020 

  1021 			if(error != KErrNone)

  1022 				{

  1023 				SetError(error, EXMLWorkable);

  1024 				}

  1025 			}

  1026 		iEndOfTag = ETrue;

  1027 		}

  1028 

  1029 	return returnValue;

  1030 	}

  1031 

  1032 

  1033 //==================================================================================

  1034 

  1035 TBool CMDXMLParser::VersionIDL()

  1036 //

  1037 // @return returns true if the current tag is a version id tag and sets the

  1038 // Document Version member accordingly on the first pass of this function.

  1039 //

  1040 	{

  1041 	TBool returnValue = EFalse;

  1042 	TInt tagIdLen = TPtrC(KXMLVersion).Length();

  1043 

  1044 	__ASSERT_DEBUG(iElementTag != NULL, Panic(ENullMemVarElementTag));

  1045 

  1046 	if(iElementTag->Length() > tagIdLen

  1047 			&& iElementTag->Left(tagIdLen) == KXMLVersion)

  1048 		{

  1049 		if(iVersionSet)

  1050 			{

  1051 			SetError(KErrXMLDuplicateVersionTags, EXMLWorkable);

  1052 			}

  1053 		else

  1054 			{

  1055 			iXMLDoc->SetVersionTagL(iElementTag->Des());

  1056 			iVersionSet = ETrue;

  1057 			}

  1058 		returnValue = ETrue;

  1059 		iEndOfTag = ETrue;

  1060 		}

  1061 

  1062 	return returnValue;

  1063 	}

  1064 

  1065 //==================================================================================

  1066 

  1067 TBool CMDXMLParser::CommentL(CMDXMLElement* aParentElement)

  1068 //

  1069 // creates a new comment if necessary and adds to document

  1070 // @return returns true if the current tag is a comment tag

  1071 //

  1072 	{

  1073 	TBool returnValue = EFalse;

  1074 	TInt commentLen = TPtrC(KXMLStartComment).Length();

  1075 	TInt endCommentLen = TPtrC(KXMLEndComment).Length();

  1076 

  1077 	__ASSERT_DEBUG(iElementTag != NULL, Panic(ENullMemVarElementTag));

  1078 

  1079 	if (iElementTag->Left(commentLen) == KXMLStartComment) 

  1080 		{

  1081 		returnValue = ETrue;

  1082 		if ((aParentElement != NULL) && (iElementTag->Right(endCommentLen) == KXMLEndComment))

  1083 			{

  1084 			CMDXMLComment* comment = CMDXMLComment::NewLC(iXMLDoc);

  1085 

  1086 			TPtrC commentStr = iElementTag->Des().Mid(commentLen,

  1087 				iElementTag->Length() - (commentLen + endCommentLen));

  1088 			comment->SetDataL(commentStr);

  1089 

  1090 			__ASSERT_DEBUG(aParentElement != NULL, Panic(ENullParameterParentElement));

  1091 			TInt error  = aParentElement->AppendChild(comment);

  1092 			CleanupStack::Pop(); // comment

  1093 

  1094 			if(error != KErrNone)

  1095 				{

  1096 				SetError(error, EXMLWorkable);

  1097 				}

  1098 			iEndOfTag = ETrue;

  1099 			}

  1100 		}

  1101 

  1102 	return returnValue;

  1103 	}

  1104 

  1105 //==================================================================================

  1106 

  1107 EXPORT_C void CMDXMLParser::SetSourceCharacterWidth(TMDXMLParserInputCharWidth aWidth)

  1108 	{

  1109 	iBytesPerChar = aWidth;

  1110 	}

  1111 

  1112 //==================================================================================

  1113 

  1114 void CMDXMLParser::GetMoreData()

  1115 	{

  1116 

  1117 	// Prepare these variables.

  1118 	iNextChar = 0;					// reading from the start of the buffer

  1119 	iCurrentInputBufferLen = 0;		// we have no characters in the buffer

  1120 	iUnicodeConversion.Zero();		// we have no characters in our UTF8->Unicode Conversion buffer.

  1121 	iUnicodeConversionLen = 0;

  1122 	iUnicodeReadPos = 0;

  1123 

  1124 	// Request more data from the data provider

  1125 	__ASSERT_DEBUG(iDataSource != NULL, Panic(ENullMemVarDataSource));

  1126 	iDataSource->GetData(iInputBufferPtr, iStatus);

  1127 	SetActive();

  1128 	iPreviousState = iState;

  1129 	iState = KWaitingForData;

  1130 	}

  1131 

  1132 //==================================================================================

  1133 

  1134 CMDXMLParser::TGetCharReturn CMDXMLParser::GetDoubleByteChar(TDes& aChar)

  1135 	// when inputing we have a pointer to an 8 bit buffer (iInputBufferPtr), for unicode