开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxxmlprs.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：23k
源码类别：

Symbian

开发平台：

C/C++

hxxmlprs.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxtypes.h"
  37. #include "hxresult.h"
  38. #include "hxassert.h"
  39. #include "hxheap.h"
  41. #include "hxcom.h"
  42. #include "hxcomm.h"
  43. #include "hxfiles.h"
  44. #include "ihxpckts.h"
  45. #include "hxxml.h"
  46. #include "xmlreslt.h"
  48. #include "cbbqueue.h"
  49. #include "hxbuffer.h"
  50. #include "chxpckts.h"
  51. #include "looseprs.h"
  53. #include "hxxmlprs.h"
  55. #ifdef _DEBUG
  56. #undef HX_THIS_FILE
  57. static const char HX_THIS_FILE[] = __FILE__;
  58. #endif
  60. #ifndef _VXWORKS
  61. static const UINT32 BUFSIZE = 1024;
  62. #endif
  64. HXXMLParser::HXXMLParser(BOOL bAllowNonXMLComments):
  65.     m_lRefCount(0),
  66.     m_pParser(NULL),
  67.     m_pResponse(NULL),
  68.     m_bAllowNonXMLComments(bAllowNonXMLComments)
  69. {
  70. }
  72. HXXMLParser::~HXXMLParser()
  73. {
  74.     Close();
  75. }
  78. /*
  79.  * IUnknown methods
  80.  */
  82. STDMETHODIMP 
  83. HXXMLParser::QueryInterface(REFIID riid, void** ppvObj)
  84. {
  85.     if (IsEqualIID(riid, IID_IUnknown))
  86.     {
  87. AddRef();
  88. *ppvObj = this;
  89. return HXR_OK;
  90.     }
  91.     else if (IsEqualIID(riid, IID_IHXXMLParser))
  92.     {
  93. AddRef();
  94. *ppvObj = (IHXXMLParser*)this;
  95. return HXR_OK;
  96.     }
  97.     *ppvObj = NULL;
  98.     return HXR_NOINTERFACE;
  99. }
  101. STDMETHODIMP_(ULONG32) 
  102. HXXMLParser::AddRef()
  103. {
  104.     return InterlockedIncrement(&m_lRefCount);
  105. }
  107. STDMETHODIMP_(ULONG32) 
  108. HXXMLParser::Release()
  109. {
  110.     if (InterlockedDecrement(&m_lRefCount) > 0)
  111.     {
  112.         return m_lRefCount;
  113.     }
  115.     delete this;
  116.     return 0;
  117. }
  120. /*
  121.  * IHXXMLParser methods
  122.  */
  124. STDMETHODIMP
  125. HXXMLParser::Init(IHXXMLParserResponse* /*IN*/  pResponse,
  126.    const char*     /*IN*/ pEncoding,
  127.    BOOL     /*IN*/ bStrict)
  128. {
  129.     HX_RESULT rc = HXR_OK;
  131.     m_pResponse = pResponse;
  132.     m_pResponse->AddRef(); 
  134.     if(bStrict)
  135.     {
  136. m_pParser = new HXStrictXMLParser();
  137.     }
  138.     else
  139.     {
  140. m_pParser = new HXLooseXMLParser(m_bAllowNonXMLComments);
  141.     }
  143.     rc = m_pParser->Init(pResponse, pEncoding);
  145.     return rc;
  146. }
  148. STDMETHODIMP
  149. HXXMLParser::Close()
  150. {
  151.     HX_RESULT rc = HXR_OK;
  153.     HX_RELEASE(m_pResponse);
  154.     HX_DELETE(m_pParser);
  156.     return rc;
  157. }
  160. STDMETHODIMP
  161. HXXMLParser::Parse(IHXBuffer* /*IN*/     pBuffer,
  162.   BOOL /*IN*/     bIsFinal)
  163. {
  164.     HX_RESULT rc = HXR_OK;
  166.     rc = m_pParser->Parse(pBuffer, bIsFinal);    
  168.     return rc;
  169. }
  171. STDMETHODIMP
  172. HXXMLParser::GetCurrentLineNumber(REF(ULONG32) /*OUT*/ ulLineNumber)
  173. {
  174.     HX_RESULT rc = HXR_OK;
  176.     rc = m_pParser->GetCurrentLineNumber(ulLineNumber);
  178.     return rc;
  179. }
  181. STDMETHODIMP
  182. HXXMLParser::GetCurrentColumnNumber(REF(ULONG32) /*OUT*/ ulColumnNumber)
  183. {
  184.     HX_RESULT rc = HXR_OK;
  186.     rc = m_pParser->GetCurrentColumnNumber(ulColumnNumber);
  188.     return rc;
  189. }
  191. STDMETHODIMP
  192. HXXMLParser::GetCurrentByteIndex(REF(ULONG32) /*OUT*/ ulByteIndex)
  193. {
  194.     HX_RESULT rc = HXR_OK;
  196.     rc = m_pParser->GetCurrentByteIndex(ulByteIndex);
  198.     return rc;
  199. }
  201. STDMETHODIMP
  202. HXXMLParser::GetCurrentErrorText(REF(IHXBuffer*) /*OUT*/ pBuffer)
  203. {
  204.     HX_RESULT rc = HXR_OK;
  206.     rc = m_pParser->GetCurrentErrorText(pBuffer);
  208.     return rc;
  209. }
  211. HX_RESULT
  212. HXXMLParser::InitErrorNotifier(ErrorNotifier* /*OUT*/ pNotifier)
  213. {
  214.     return m_pParser->InitErrorNotifier(pNotifier);
  215. }
  218. /*
  219.  * virtual base class methods
  220.  */
  222. HXActualXMLParser::HXActualXMLParser():
  223.     m_pResponse(NULL)
  224. {
  225. }
  227. HXActualXMLParser::~HXActualXMLParser()
  228. {
  229. }
  231. void HXActualXMLParser::CheckEncoding(XMLParser* pParser, IHXBuffer* pBuffer)
  232. {
  233.     if (pParser && pBuffer)
  234.     {
  235.         // Check if this buffer has any prolog info
  236.         char* pszVersion  = NULL;
  237.         char* pszEncoding = NULL;
  238.         HX_RESULT rv = pParser->GetPrologInfo((const char*) pBuffer->GetBuffer(),
  239.                                               pBuffer->GetSize(),
  240.                                               pszVersion,
  241.                                               pszEncoding);
  242.         if (SUCCEEDED(rv) && pszEncoding && strlen(pszEncoding) > 0)
  243.         {
  244.             // Get the encoding from the parser
  245.             char* pszParserEncoding = NULL;
  246.             HX_RESULT rv = pParser->GetEncoding(pszParserEncoding);
  247.             if (SUCCEEDED(rv) &&
  248.                 strcmp(pszEncoding, pszParserEncoding) != 0)
  249.             {
  250.                 pParser->SetEncoding(pszEncoding);
  251.             }
  252.             HX_VECTOR_DELETE(pszParserEncoding);
  253.         }
  254.         HX_VECTOR_DELETE(pszVersion);
  255.         HX_VECTOR_DELETE(pszEncoding);
  256.     }
  257. }
  259. /* 
  260.  * HXLooseXMLParser methods
  261.  */
  263. HXLooseXMLParser::HXLooseXMLParser(BOOL bAllowNonXMLComments):
  264.     m_pParser(NULL),
  265.     m_pByteQueue(NULL),
  266.     m_bAllowNonXMLComments(bAllowNonXMLComments)
  267. {
  268. }
  270. HXLooseXMLParser::~HXLooseXMLParser()
  271. {
  272.     HX_DELETE(m_pParser);
  273.     HX_DELETE(m_pByteQueue);
  274. }
  276. HX_RESULT
  277. HXLooseXMLParser::Init(IHXXMLParserResponse* pResponse,
  278.        const char* pEncoding)
  279. {
  280.     m_pResponse = pResponse;
  281.     m_pParser = new XMLParser(FALSE, pEncoding, m_bAllowNonXMLComments);
  282.     m_pByteQueue = new CBigByteQueue(BUFSIZE);
  284.     return HXR_OK;
  285. }
  287. HX_RESULT
  288. HXLooseXMLParser::Parse(IHXBuffer* pBuffer,
  289. BOOL bIsFinal)
  290. {
  291.     HX_RESULT rc = HXR_OK;
  293.     // Check the encoding
  294.     CheckEncoding(m_pParser, pBuffer);
  296.     UINT32 ulBufLen = pBuffer->GetSize();
  298.     if(m_pByteQueue->GetAvailableElements() < ulBufLen)
  299.     {
  300. m_pByteQueue->Grow(ulBufLen);
  301.     }
  302.     m_pByteQueue->EnQueue(pBuffer->GetBuffer(), ulBufLen);
  303.     rc = DoParse(bIsFinal);
  305.     return rc;
  306. }
  308. HX_RESULT
  309. HXLooseXMLParser::GetCurrentLineNumber(REF(ULONG32) ulLineNumber)
  310. {
  311.     HX_RESULT rc = HXR_OK;
  313.     ulLineNumber = (UINT32)m_pParser->GetCurrentLineNumber();
  315.     return rc;
  316. }
  318. HX_RESULT
  319. HXLooseXMLParser::GetCurrentColumnNumber(REF(ULONG32) ulColumnNumber)
  320. {
  321.     HX_RESULT rc = HXR_OK;
  323.     ulColumnNumber = (UINT32)m_pParser->GetCurrentColumnNumber();
  325.     return rc;
  326. }
  328. HX_RESULT
  329. HXLooseXMLParser::GetCurrentByteIndex(REF(ULONG32) ulByteIndex)
  330. {
  331.     HX_RESULT rc = HXR_OK;
  333.     return rc;
  334. }
  336. HX_RESULT
  337. HXLooseXMLParser::GetCurrentErrorText(REF(IHXBuffer*) pBuffer)
  338. {
  339.     HX_RESULT rc = HXR_FAIL;
  341.     XMLError* pLastError = m_pParser->GetLastError();
  342.     if(pLastError &&
  343. pLastError->m_pErrorString)
  344.     {
  345. pBuffer = new CHXBuffer;
  346. pBuffer->AddRef();
  347. pBuffer->Set((BYTE*)pLastError->m_pErrorString,
  348.  strlen(pLastError->m_pErrorString) + 1);
  349. rc = HXR_OK;
  350.     }
  352.     return rc;
  353. }
  355. HX_RESULT
  356. HXLooseXMLParser::DoParse(BOOL bIsFinal)
  357. {
  358.     HX_RESULT rc = HXR_OK;
  360.     XMLTag* pTag = NULL;
  362.     BOOL bDone = FALSE;
  363.     while(!bDone && SUCCEEDED(rc))
  364.     {
  365. UINT32 bytesUsed;
  366. UINT32 bytesAvail = m_pByteQueue->GetQueuedItemCount();
  367. if(bytesAvail <= 0)
  368. {
  369.     break;
  370. }
  372. BYTE* pBuf = new BYTE[bytesAvail];
  373. BYTE* p = pBuf;
  374. m_pByteQueue->DeQueue(pBuf, bytesAvail);
  375. bytesUsed = bytesAvail;
  377. if(pTag)
  378. {
  379.     delete pTag;
  380.     pTag = 0;
  381. }
  383. XMLParseResult pResult = 
  384.     m_pParser->Parse((const char*&)p, bytesAvail, pTag, bIsFinal);
  385. m_pByteQueue->EnQueue(p, (UINT32)(bytesAvail - (p - pBuf)));
  387. // pBuf is not needed anymore, so delete
  388. HX_VECTOR_DELETE(pBuf);
  389. p = NULL;
  391. switch(pResult)
  392. {
  393.     case XMLPNotDone:
  394.     {
  395. goto exit;
  396.     }
  398.     case XMLPNoClose:
  399.     {
  400. rc = HXR_XML_NOCLOSE;
  401. goto exit;
  402.     }
  404.     case XMLPBadAttribute:
  405.     {
  406. rc = HXR_XML_NOTAGTYPE;
  407. goto exit;
  408.     }
  410.     case XMLPBadEndTag:
  411.     {
  412. rc = HXR_XML_BADENDTAG;
  413. goto exit;
  414.     }
  415.     
  416.     case XMLPAttributeValueNotQuoted:
  417.     {
  418. rc = HXR_XML_MISSINGQUOTE;
  419. goto exit;
  420.     }
  422.     case XMLPBadDirective:
  423.     {
  424. rc = HXR_XML_GENERALERROR;
  425. goto exit;
  426.     }
  428.     case XMLPDupAttribute:
  429.     {
  430. rc = HXR_XML_DUPATTRIBUTE;
  431. goto exit;
  432.     }
  434.     case XMLPComment:
  435.     {
  436. const char* pValue = pTag->m_cur_attribute->value;
  437. rc = m_pResponse->HandleComment(pValue,0,0);
  438.     }
  439.     break;
  441.     case XMLPPlainText:
  442.     {
  443. const char* pValue = pTag->m_cur_attribute->value;
  444. CHXBuffer* pBuffer = new CHXBuffer;
  445. pBuffer->AddRef();
  446. pBuffer->Set((const BYTE*)pValue, strlen(pValue)+1);
  447. rc = m_pResponse->HandleCharacterData(pBuffer,0,0);
  448. HX_RELEASE(pBuffer);
  449.     }
  450.     break;
  452.     case XMLPDirective:
  453.     {
  454. const char* pValue = pTag->m_name;
  455. if(strcmp(pValue, "DOCTYPE") == 0)
  456. {
  457.     // m_bExternalDoctype = TRUE;
  458. }
  459.     }
  460.     break;
  462.     case XMLPProcInst:
  463.     // handle processing instruction
  464.     {
  465. const char* pTarget = pTag->m_name;
  467. CHXHeader* pValues = new CHXHeader;
  468. pValues->AddRef();
  470. for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  471. {
  472.     XMLAttribute* pAttr = pTag->attribute(i);
  473.     // the XMLParser class supports what it calls attributes
  474.     // without names.  It's used to communicate processing
  475.     // instructions and things like that. We just ignore attributes
  476.     // without names here.
  477.     if (pAttr->name != NULL)
  478.     {
  479. CHXBuffer* pBuf = new CHXBuffer;
  480. pBuf->AddRef();
  481. pBuf->Set((const BYTE*)pAttr->value,
  482.     strlen(pAttr->value)+1);
  483. pValues->SetPropertyCString(
  484.     pAttr->name, pBuf);
  485. pBuf->Release();
  486.     }
  487. }
  488. rc = m_pResponse->HandleProcessingInstruction(pTarget,
  489.       pValues,0,0);
  490. HX_RELEASE(pValues);
  491.     }
  492.     break;
  494.     case XMLPTag:
  495.     {
  496. const char* pName = pTag->m_name;
  497. if(pTag->m_type != XMLEndTag)
  498. {
  499.     CHXHeader* pValues = new CHXHeader;
  500.     pValues->AddRef();
  502.     for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  503.     {
  504. XMLAttribute* pAttr = pTag->attribute(i);
  505. // the XMLParser class supports what it calls attributes
  506. // without names.  It's used to communicate processing
  507. // instructions and things like that. We just ignore attributes
  508. // without names here.
  509. if (pAttr->name != NULL)
  510. {
  511.     CHXBuffer* pBuf = new CHXBuffer;
  512.     pBuf->AddRef();
  513.     pBuf->Set((const BYTE*)pAttr->value,
  514. strlen(pAttr->value)+1);
  515.     pValues->SetPropertyCString(
  516. pAttr->name, pBuf);
  517.     pBuf->Release();
  518. }
  519.     }
  520.     rc = m_pResponse->HandleStartElement(pName, pValues,
  521.                                                          m_pParser->GetTagStartLineNumber(),
  522.                                                          m_pParser->GetTagStartColumnNumber());
  523.     HX_RELEASE(pValues);
  525.     if(!pTag->m_need_close && SUCCEEDED(rc))
  526.     {
  527. rc = m_pResponse->HandleEndElement(pName,0,0);
  528.     }
  529. }
  530. else
  531. {
  532.     rc = m_pResponse->HandleEndElement(pName,0,0);
  533. }
  534.     }
  535.     break;
  537.     default:
  538.     {
  539. bDone = TRUE;
  540.     }
  541.     break;
  542. }
  543.     }
  545. exit:
  546.     HX_DELETE(pTag);
  548.     return rc;
  549. }
  552. /* 
  553.  * HXStrictXMLParser methods
  554.  */
  556. HXStrictXMLParser::HXStrictXMLParser():
  557.     m_pParser(NULL),
  558.     m_pByteQueue(NULL)
  559.     , m_pErrorNotifier(NULL)
  560. {
  561. }
  563. HXStrictXMLParser::~HXStrictXMLParser()
  564. {
  565.     HX_DELETE(m_pParser);
  566.     HX_DELETE(m_pByteQueue);
  567. }
  569. HX_RESULT
  570. HXStrictXMLParser::Init(IHXXMLParserResponse* pResponse,
  571.        const char* pEncoding)
  572. {
  573.     m_pResponse = pResponse;
  575.     m_pResponse = pResponse;
  576.     m_pParser = new XMLParser(TRUE, pEncoding);
  577.     if (m_pErrorNotifier)
  578.     {
  579. m_pParser->StoreErrors();
  580.     }
  581.     m_pByteQueue = new CBigByteQueue(BUFSIZE);
  583.     return HXR_OK;
  584. }
  586. HX_RESULT
  587. HXStrictXMLParser::InitErrorNotifier(ErrorNotifier* /*OUT*/ pNotifier)
  588. {
  589.     m_pErrorNotifier = pNotifier; 
  590.     if (m_pParser)
  591.     {
  592. m_pParser->StoreErrors();
  593.     }
  594.     return HXR_OK; 
  595. }
  597. HX_RESULT
  598. HXStrictXMLParser::Parse(IHXBuffer* pBuffer,
  599. BOOL bIsFinal)
  600. {
  601.     HX_RESULT rc = HXR_OK;
  603.     // See if we have any encoding info
  604.     CheckEncoding(m_pParser, pBuffer);
  606.     UINT32 ulBufLen = pBuffer->GetSize();
  607.     if(m_pByteQueue->GetAvailableElements() < ulBufLen)
  608.     {
  609. m_pByteQueue->Grow(ulBufLen);
  610.     }
  611.     m_pByteQueue->EnQueue(pBuffer->GetBuffer(), ulBufLen);
  612.     rc = DoParse(bIsFinal);
  614.     return rc;
  615. }
  617. HX_RESULT
  618. HXStrictXMLParser::HandleErrors(CHXPtrArray* pErrs)
  619. {
  620.     if (m_pErrorNotifier && pErrs)
  621.     {
  622. int size = pErrs->GetSize();
  624. for(int i=0;i<size;++i)
  625. {
  626.     XMLError* pError = (XMLError*) (*pErrs)[i];
  627.     HX_RESULT code = ConvertToHX_RESULT(pError->m_errorTag);
  628.     m_pErrorNotifier->ErrorInLastTag(code, pError->m_pErrorString, 
  629. pError->m_pFrameString,  pError->m_lLineNumber, 
  630. pError->m_lLinePosition);
  631. }
  632.     }
  633.     return HXR_OK;
  634. }
  636. HX_RESULT
  637. HXStrictXMLParser::ConvertToHX_RESULT(UINT32 err)
  638. {
  639.     HX_RESULT ret = HXR_OK;
  640.     switch (err)
  641.     {
  642.     case XMLUnknownError:
  643. ret = HXR_XML_GENERALERROR;
  644. break;
  645.     case XMLErrorNoClose:
  646. ret = HXR_XML_NOCLOSE;
  647. break;
  648.     case XMLErrorBadAttribute:
  649. ret = HXR_XML_BADATTRIBUTE;
  650. break;
  651.     case XMLErrorNoValue:
  652. ret = HXR_XML_NOVALUE;
  653. break;
  654.     case XMLErrorMissingQuote:
  655. ret = HXR_XML_MISSINGQUOTE;
  656. break;
  657.     case XMLErrorBadEndTag:
  658. ret = HXR_XML_BADENDTAG;
  659. break;
  660.     case XMLErrorNoTagType:
  661. ret = HXR_XML_NOTAGTYPE;
  662. break;
  663.     case XMLErrorDupAttribute:
  664. ret = HXR_XML_DUPATTRIBUTE;
  665. break;
  666.     case XMLErrorCommentBeforeProcInst:
  667. ret = HXR_XML_COMMENT_B4_PROCINST;
  668. break;
  669.     case XMLErrorInvalidName:
  670. ret = HXR_XML_INVALID_NAME;
  671. break;
  672.     case XMLErrorInvalidCharInDoc:
  673. ret = HXR_XML_INVALID_CHAR_IN_DOC;
  674. break;
  675.     case XMLErrorTwoDashNotAllowed:
  676. ret = HXR_XML_TWO_DASHES_NOT_ALLOWED_IN_COMMENT;
  677. break;
  678.     case XMLErrorInvalidDecl:
  679. ret = HXR_XML_INVALID_DECL;
  680. break;
  681.     case XMLErrorInvalidPI:
  682. ret = HXR_XML_INVALID_PI;
  683. break;
  684.     case XMLErrorInvalidPITarget:
  685. ret = HXR_XML_INVALID_PI_TARGET;
  686. break;
  687.     case XMLErrorInvalidCDATA:
  688. ret = HXR_XML_INVALID_CDATA;
  689. break;
  690.     case XMLErrorInvalidRef:
  691. ret = HXR_XML_INVALID_REF;
  692. break;
  693.     case XMLErrorMissingEquals:
  694. ret = HXR_XML_MISSING_EQUALS;
  695. break;
  696.     case XMLErrorMissingReqSpace:
  697. ret = HXR_XML_MISSING_REQ_SPACE;
  698. break;
  699.     case XMLErrorLTnotAllowed:
  700. ret = HXR_XML_LT_NOT_ALLOWED;
  701. break;
  702.     case XMLErrorInvalidGTafter2RSQB:
  703. ret = HXR_XML_INVALID_GT_AFFT_2_RSQB_IN_CONTENT;
  704. break;
  705.     case XMLErrorInvalidComment:
  706. ret = HXR_XML_INVALID_COMMENT;
  707. break;
  708.     }
  709.     return ret;
  710. }
  713. HX_RESULT
  714. HXStrictXMLParser::DoParse(BOOL bIsFinal)
  715. {
  716.     HX_RESULT rc = HXR_OK;
  718.     XMLTag* pTag = NULL;
  720.     BOOL bDone = FALSE;
  721.     while(!bDone &&
  722. HXR_OK == rc)
  723.     {
  724. UINT32 bytesUsed;
  725. UINT32 bytesAvail = m_pByteQueue->GetQueuedItemCount();
  726. if(bytesAvail <= 0)
  727. {
  728.     break;
  729. }
  731. BYTE* pBuf = new BYTE[bytesAvail];
  732. BYTE* p = pBuf;
  733. m_pByteQueue->DeQueue(pBuf, bytesAvail);
  734. bytesUsed = bytesAvail;
  736. if(pTag)
  737. {
  738.     delete pTag;
  739.     pTag = 0;
  740. }
  742. XMLParseResult pResult = 
  743.     m_pParser->Parse((const char*&)p, bytesAvail, pTag, bIsFinal);
  744. m_pByteQueue->EnQueue(p, (UINT32)(bytesAvail - (p - pBuf)));
  746. // pBuf is not used anymore, so delete
  747. HX_VECTOR_DELETE(pBuf);
  748. p = NULL;
  750. UINT32 ulTagStartLine = m_pParser->GetTagStartLineNumber();
  751. UINT32 ulTagStartCol = m_pParser->GetTagStartColumnNumber();
  753. switch(pResult)
  754. {
  755.     case XMLPNotDone:
  756.     {
  757. goto exit;
  758.     }
  760.     case XMLPNoClose:
  761.     {
  762. rc = HXR_XML_NOCLOSE;
  763. goto exit;
  764.     }
  766.     case XMLPBadAttribute:
  767.     {
  768. rc = HXR_XML_NOTAGTYPE;
  769. goto exit;
  770.     }
  772.     case XMLPBadEndTag:
  773.     {
  774. rc = HXR_XML_BADENDTAG;
  775. goto exit;
  776.     }
  777.     
  778.     case XMLPAttributeValueNotQuoted:
  779.     {
  780. rc = HXR_XML_MISSINGQUOTE;
  781. goto exit;
  782.     }
  784.     case XMLPBadDirective:
  785.     {
  786. rc = HXR_XML_GENERALERROR;
  787. goto exit;
  788.     }
  790.     case XMLPDupAttribute:
  791.     {
  792. rc = HXR_XML_DUPATTRIBUTE;
  793. goto exit;
  794.     }
  796.     case XMLPCommentBeforeProcInst:
  797.     {
  798. rc = HXR_XML_COMMENT_B4_PROCINST;
  799. goto exit;
  800.     }
  801.     
  802.     case XMLPComment:
  803.     {
  804. const char* pValue = pTag->m_cur_attribute->value;
  805. rc = m_pResponse->HandleComment(pValue,ulTagStartLine,ulTagStartCol);
  806. HandleErrors(pTag->m_errs);
  807.     }
  808.     break;
  810.     case XMLPPlainText:
  811.     {
  812. const char* pValue = pTag->m_cur_attribute->value;
  813. CHXBuffer* pBuffer = new CHXBuffer;
  814. pBuffer->AddRef();
  815. pBuffer->Set((const BYTE*)pValue, strlen(pValue)+1);
  816. rc = m_pResponse->HandleCharacterData(pBuffer,ulTagStartLine,ulTagStartCol);
  817. HandleErrors(pTag->m_errs);
  818. HX_RELEASE(pBuffer);
  819.     }
  820.     break;
  822.     case XMLPDirective:
  823.     {
  824. const char* pName = NULL;
  825. const char* pPublicID = NULL;
  826. const char* pSystemID = NULL;
  827. CHXBuffer* pBuffer = NULL;
  828. UINT32 ulNumAttributes = pTag->m_numAttributes; 
  829. if(strcmp(pTag->m_name, "DOCTYPE") == 0 &&
  830.     ulNumAttributes > 0)
  831. {
  832.     UINT32 ulCurAttribute = 0;
  834.     while(ulCurAttribute < ulNumAttributes)
  835.     {
  836. XMLAttribute* pAttr = NULL;
  837. if(ulCurAttribute == 0)
  838. {
  839.     pAttr = pTag->attribute(ulCurAttribute);
  840.     if(pAttr)
  841.     {
  842. pName = pAttr->value;
  843.     }
  844. }
  845. else
  846. {
  847.     pAttr = pTag->attribute(ulCurAttribute);
  848.     if(strcmp(pAttr->value, "SYSTEM") == 0)
  849.     {
  850. ulCurAttribute++;
  851. if(ulCurAttribute < ulNumAttributes)
  852. {
  853.     pAttr = pTag->attribute(ulCurAttribute);
  854.     if(pAttr)
  855.     {
  856. pSystemID = pAttr->value;
  857.     }
  858. }
  859.     }
  860.     else if(strcmp(pAttr->value, "PUBLIC") == 0)
  861.     {
  862. ulCurAttribute++;
  863. if(ulCurAttribute < ulNumAttributes)
  864. {
  865.     pAttr = pTag->attribute(ulCurAttribute);
  866.     if(pAttr)
  867.     {
  868. pPublicID = pAttr->value;
  869. ulCurAttribute++;
  870. if(ulCurAttribute < ulNumAttributes)
  871. {
  872.     pAttr = pTag->attribute(ulCurAttribute);
  873.     if(pAttr)
  874.     {
  875. pSystemID = pAttr->value;
  876.     }
  877. }
  878.     }
  879. }
  880.     }
  881. }
  882. ulCurAttribute++;
  883.     }
  885.     rc = m_pResponse->HandleUnparsedDoctypeDecl(pName, pSystemID,
  886. pPublicID, ulTagStartLine,ulTagStartCol);
  887.     HX_RELEASE(pBuffer);
  888. }
  889.     }
  890.     break;
  892.     case XMLPProcInst:
  893.     // handle processing instruction
  894.     {
  895. const char* pTarget = pTag->m_name;
  897. CHXHeader* pValues = new CHXHeader;
  898. pValues->AddRef();
  899. pValues->PreserveCase(TRUE);
  901. for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  902. {
  903.     XMLAttribute* pAttr = pTag->attribute(i);
  904.     // the XMLParser class supports what it calls attributes
  905.     // without names.  It's used to communicate processing
  906.     // instructions and things like that. We just ignore attributes
  907.     // without names here.
  908.     if (pAttr->name != NULL)
  909.     {
  910. CHXBuffer* pBuf = new CHXBuffer;
  911. pBuf->AddRef();
  912. pBuf->Set((const BYTE*)pAttr->value,
  913.     strlen(pAttr->value)+1);
  914. pValues->SetPropertyCString(
  915.     pAttr->name, pBuf);
  916. pBuf->Release();
  917.     }
  918. }
  919. rc = m_pResponse->HandleProcessingInstruction(pTarget,
  920.       pValues,ulTagStartLine,ulTagStartCol);
  922. HandleErrors(pTag->m_errs);
  924. HX_RELEASE(pValues);
  925.     }
  926.     break;
  928.     case XMLPTag:
  929.     {
  930. const char* pName = pTag->m_name;
  931. if(pTag->m_type != XMLEndTag)
  932. {
  933.     CHXHeader* pValues = new CHXHeader;
  934.     pValues->AddRef();
  935.     pValues->PreserveCase(TRUE);
  937.     for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  938.     {
  939. XMLAttribute* pAttr = pTag->attribute(i);
  940. // the XMLParser class supports what it calls attributes
  941. // without names.  It's used to communicate processing
  942. // instructions and things like that. We just ignore attributes
  943. // without names here.
  944. if (pAttr->name != NULL)
  945. {
  946.     CHXBuffer* pBuf = new CHXBuffer;
  947.     pBuf->AddRef();
  948.     pBuf->Set((const BYTE*)pAttr->value,
  949. strlen(pAttr->value)+1);
  950.     pValues->SetPropertyCString(
  951. pAttr->name, pBuf);
  952.     pBuf->Release();
  953. }
  954.     }
  955.     if(HXR_OK == rc)
  956.     {
  957. rc = m_pResponse->HandleStartElement(pName, 
  958.     pValues,ulTagStartLine,ulTagStartCol);
  960. HandleErrors(pTag->m_errs);
  961.     }
  962.     HX_RELEASE(pValues);
  964.     if(HXR_OK == rc &&
  965. !pTag->m_need_close)
  966.     {
  967. rc = m_pResponse->HandleEndElement(pName,ulTagStartLine,ulTagStartCol);
  968.     }
  969. }
  970. else
  971. {
  972.     rc = m_pResponse->HandleEndElement(pName,ulTagStartLine,ulTagStartCol);
  973.     HandleErrors(pTag->m_errs);
  974. }
  975.     }
  976.     break;
  978.     default:
  979.     {
  980. bDone = TRUE;
  981.     }
  982.     break;
  983. }
  984.     }
  986. exit:
  987.     HX_DELETE(pTag);
  989.     return rc;
  990. }
  992. HX_RESULT
  993. HXStrictXMLParser::GetCurrentLineNumber(REF(ULONG32) ulLineNumber)
  994. {
  995.     HX_RESULT rc = HXR_OK;
  997.     ulLineNumber = (UINT32)m_pParser->GetCurrentLineNumber();
  999.     return rc;
  1000. }
  1002. HX_RESULT
  1003. HXStrictXMLParser::GetCurrentColumnNumber(REF(ULONG32) ulColumnNumber)
  1004. {
  1005.     HX_RESULT rc = HXR_OK;
  1007.     ulColumnNumber = (UINT32)m_pParser->GetCurrentColumnNumber();
  1009.     return rc;
  1010. }
  1012. HX_RESULT
  1013. HXStrictXMLParser::GetCurrentByteIndex(REF(ULONG32) ulByteIndex)
  1014. {
  1015.     HX_RESULT rc = HXR_NOTIMPL;
  1017.     return rc;
  1018. }
  1020. HX_RESULT
  1021. HXStrictXMLParser::GetCurrentErrorText(REF(IHXBuffer*) pBuffer)
  1022. {
  1023.     HX_RESULT rc = HXR_FAIL;
  1025.     XMLError* pLastError = m_pParser->GetLastError();
  1026.     if(pLastError &&
  1027. pLastError->m_pErrorString)
  1028.     {
  1029. pBuffer = new CHXBuffer;
  1030. pBuffer->AddRef();
  1031. pBuffer->Set((BYTE*)pLastError->m_pErrorString,
  1032.  strlen(pLastError->m_pErrorString) + 1);
  1033. rc = HXR_OK;
  1034.     }
  1036.     return rc;
  1037. }