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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxxmlprs.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：23k
源码类别：

Symbian

开发平台：

Visual C++

hxxmlprs.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: hxxmlprs.cpp,v 1.3.36.3 2004/07/09 01:44:10 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  51. #include "hxresult.h"
  52. #include "hxassert.h"
  53. #include "hxheap.h"
  55. #include "hxcom.h"
  56. #include "hxcomm.h"
  57. #include "hxfiles.h"
  58. #include "ihxpckts.h"
  59. #include "hxxml.h"
  60. #include "xmlreslt.h"
  62. #include "cbbqueue.h"
  63. #include "hxbuffer.h"
  64. #include "chxpckts.h"
  65. #include "looseprs.h"
  67. #include "hxxmlprs.h"
  69. #ifdef _DEBUG
  70. #undef HX_THIS_FILE
  71. static const char HX_THIS_FILE[] = __FILE__;
  72. #endif
  74. #ifndef _VXWORKS
  75. static const UINT32 BUFSIZE = 1024;
  76. #endif
  78. HXXMLParser::HXXMLParser(BOOL bAllowNonXMLComments):
  79.     m_lRefCount(0),
  80.     m_pParser(NULL),
  81.     m_pResponse(NULL),
  82.     m_bAllowNonXMLComments(bAllowNonXMLComments)
  83. {
  84. }
  86. HXXMLParser::~HXXMLParser()
  87. {
  88.     Close();
  89. }
  92. /*
  93.  * IUnknown methods
  94.  */
  96. STDMETHODIMP 
  97. HXXMLParser::QueryInterface(REFIID riid, void** ppvObj)
  98. {
  99.     if (IsEqualIID(riid, IID_IUnknown))
  100.     {
  101. AddRef();
  102. *ppvObj = this;
  103. return HXR_OK;
  104.     }
  105.     else if (IsEqualIID(riid, IID_IHXXMLParser))
  106.     {
  107. AddRef();
  108. *ppvObj = (IHXXMLParser*)this;
  109. return HXR_OK;
  110.     }
  111.     *ppvObj = NULL;
  112.     return HXR_NOINTERFACE;
  113. }
  115. STDMETHODIMP_(ULONG32) 
  116. HXXMLParser::AddRef()
  117. {
  118.     return InterlockedIncrement(&m_lRefCount);
  119. }
  121. STDMETHODIMP_(ULONG32) 
  122. HXXMLParser::Release()
  123. {
  124.     if (InterlockedDecrement(&m_lRefCount) > 0)
  125.     {
  126.         return m_lRefCount;
  127.     }
  129.     delete this;
  130.     return 0;
  131. }
  134. /*
  135.  * IHXXMLParser methods
  136.  */
  138. STDMETHODIMP
  139. HXXMLParser::Init(IHXXMLParserResponse* /*IN*/  pResponse,
  140.    const char*     /*IN*/ pEncoding,
  141.    BOOL     /*IN*/ bStrict)
  142. {
  143.     HX_RESULT rc = HXR_OK;
  145.     m_pResponse = pResponse;
  146.     m_pResponse->AddRef(); 
  148.     if(bStrict)
  149.     {
  150. m_pParser = new HXStrictXMLParser();
  151.     }
  152.     else
  153.     {
  154. m_pParser = new HXLooseXMLParser(m_bAllowNonXMLComments);
  155.     }
  157.     rc = m_pParser->Init(pResponse, pEncoding);
  159.     return rc;
  160. }
  162. STDMETHODIMP
  163. HXXMLParser::Close()
  164. {
  165.     HX_RESULT rc = HXR_OK;
  167.     HX_RELEASE(m_pResponse);
  168.     HX_DELETE(m_pParser);
  170.     return rc;
  171. }
  174. STDMETHODIMP
  175. HXXMLParser::Parse(IHXBuffer* /*IN*/     pBuffer,
  176.   BOOL /*IN*/     bIsFinal)
  177. {
  178.     HX_RESULT rc = HXR_OK;
  180.     rc = m_pParser->Parse(pBuffer, bIsFinal);    
  182.     return rc;
  183. }
  185. STDMETHODIMP
  186. HXXMLParser::GetCurrentLineNumber(REF(ULONG32) /*OUT*/ ulLineNumber)
  187. {
  188.     HX_RESULT rc = HXR_OK;
  190.     rc = m_pParser->GetCurrentLineNumber(ulLineNumber);
  192.     return rc;
  193. }
  195. STDMETHODIMP
  196. HXXMLParser::GetCurrentColumnNumber(REF(ULONG32) /*OUT*/ ulColumnNumber)
  197. {
  198.     HX_RESULT rc = HXR_OK;
  200.     rc = m_pParser->GetCurrentColumnNumber(ulColumnNumber);
  202.     return rc;
  203. }
  205. STDMETHODIMP
  206. HXXMLParser::GetCurrentByteIndex(REF(ULONG32) /*OUT*/ ulByteIndex)
  207. {
  208.     HX_RESULT rc = HXR_OK;
  210.     rc = m_pParser->GetCurrentByteIndex(ulByteIndex);
  212.     return rc;
  213. }
  215. STDMETHODIMP
  216. HXXMLParser::GetCurrentErrorText(REF(IHXBuffer*) /*OUT*/ pBuffer)
  217. {
  218.     HX_RESULT rc = HXR_OK;
  220.     rc = m_pParser->GetCurrentErrorText(pBuffer);
  222.     return rc;
  223. }
  225. HX_RESULT
  226. HXXMLParser::InitErrorNotifier(ErrorNotifier* /*OUT*/ pNotifier)
  227. {
  228.     return m_pParser->InitErrorNotifier(pNotifier);
  229. }
  232. /*
  233.  * virtual base class methods
  234.  */
  236. HXActualXMLParser::HXActualXMLParser():
  237.     m_pResponse(NULL)
  238. {
  239. }
  241. HXActualXMLParser::~HXActualXMLParser()
  242. {
  243. }
  245. void HXActualXMLParser::CheckEncoding(XMLParser* pParser, IHXBuffer* pBuffer)
  246. {
  247.     if (pParser && pBuffer)
  248.     {
  249.         // Check if this buffer has any prolog info
  250.         char* pszVersion  = NULL;
  251.         char* pszEncoding = NULL;
  252.         HX_RESULT rv = pParser->GetPrologInfo((const char*) pBuffer->GetBuffer(),
  253.                                               pBuffer->GetSize(),
  254.                                               pszVersion,
  255.                                               pszEncoding);
  256.         if (SUCCEEDED(rv) && pszEncoding && strlen(pszEncoding) > 0)
  257.         {
  258.             // Get the encoding from the parser
  259.             char* pszParserEncoding = NULL;
  260.             HX_RESULT rv = pParser->GetEncoding(pszParserEncoding);
  261.             if (SUCCEEDED(rv) &&
  262.                 strcmp(pszEncoding, pszParserEncoding) != 0)
  263.             {
  264.                 pParser->SetEncoding(pszEncoding);
  265.             }
  266.             HX_VECTOR_DELETE(pszParserEncoding);
  267.         }
  268.         HX_VECTOR_DELETE(pszVersion);
  269.         HX_VECTOR_DELETE(pszEncoding);
  270.     }
  271. }
  273. /* 
  274.  * HXLooseXMLParser methods
  275.  */
  277. HXLooseXMLParser::HXLooseXMLParser(BOOL bAllowNonXMLComments):
  278.     m_pParser(NULL),
  279.     m_pByteQueue(NULL),
  280.     m_bAllowNonXMLComments(bAllowNonXMLComments)
  281. {
  282. }
  284. HXLooseXMLParser::~HXLooseXMLParser()
  285. {
  286.     HX_DELETE(m_pParser);
  287.     HX_DELETE(m_pByteQueue);
  288. }
  290. HX_RESULT
  291. HXLooseXMLParser::Init(IHXXMLParserResponse* pResponse,
  292.        const char* pEncoding)
  293. {
  294.     m_pResponse = pResponse;
  295.     m_pParser = new XMLParser(FALSE, pEncoding, m_bAllowNonXMLComments);
  296.     m_pByteQueue = new CBigByteQueue(BUFSIZE);
  298.     return HXR_OK;
  299. }
  301. HX_RESULT
  302. HXLooseXMLParser::Parse(IHXBuffer* pBuffer,
  303. BOOL bIsFinal)
  304. {
  305.     HX_RESULT rc = HXR_OK;
  307.     // Check the encoding
  308.     CheckEncoding(m_pParser, pBuffer);
  310.     UINT32 ulBufLen = pBuffer->GetSize();
  312.     if(m_pByteQueue->GetAvailableElements() < ulBufLen)
  313.     {
  314. m_pByteQueue->Grow(ulBufLen);
  315.     }
  316.     m_pByteQueue->EnQueue(pBuffer->GetBuffer(), ulBufLen);
  317.     rc = DoParse(bIsFinal);
  319.     return rc;
  320. }
  322. HX_RESULT
  323. HXLooseXMLParser::GetCurrentLineNumber(REF(ULONG32) ulLineNumber)
  324. {
  325.     HX_RESULT rc = HXR_OK;
  327.     ulLineNumber = (UINT32)m_pParser->GetCurrentLineNumber();
  329.     return rc;
  330. }
  332. HX_RESULT
  333. HXLooseXMLParser::GetCurrentColumnNumber(REF(ULONG32) ulColumnNumber)
  334. {
  335.     HX_RESULT rc = HXR_OK;
  337.     ulColumnNumber = (UINT32)m_pParser->GetCurrentColumnNumber();
  339.     return rc;
  340. }
  342. HX_RESULT
  343. HXLooseXMLParser::GetCurrentByteIndex(REF(ULONG32) ulByteIndex)
  344. {
  345.     HX_RESULT rc = HXR_OK;
  347.     return rc;
  348. }
  350. HX_RESULT
  351. HXLooseXMLParser::GetCurrentErrorText(REF(IHXBuffer*) pBuffer)
  352. {
  353.     HX_RESULT rc = HXR_FAIL;
  355.     XMLError* pLastError = m_pParser->GetLastError();
  356.     if(pLastError &&
  357. pLastError->m_pErrorString)
  358.     {
  359. pBuffer = new CHXBuffer;
  360. pBuffer->AddRef();
  361. pBuffer->Set((BYTE*)pLastError->m_pErrorString,
  362.  strlen(pLastError->m_pErrorString) + 1);
  363. rc = HXR_OK;
  364.     }
  366.     return rc;
  367. }
  369. HX_RESULT
  370. HXLooseXMLParser::DoParse(BOOL bIsFinal)
  371. {
  372.     HX_RESULT rc = HXR_OK;
  374.     XMLTag* pTag = NULL;
  376.     BOOL bDone = FALSE;
  377.     while(!bDone && SUCCEEDED(rc))
  378.     {
  379. UINT32 bytesUsed;
  380. UINT32 bytesAvail = m_pByteQueue->GetQueuedItemCount();
  381. if(bytesAvail <= 0)
  382. {
  383.     break;
  384. }
  386. BYTE* pBuf = new BYTE[bytesAvail];
  387. BYTE* p = pBuf;
  388. m_pByteQueue->DeQueue(pBuf, bytesAvail);
  389. bytesUsed = bytesAvail;
  391. if(pTag)
  392. {
  393.     delete pTag;
  394.     pTag = 0;
  395. }
  397. XMLParseResult pResult = 
  398.     m_pParser->Parse((const char*&)p, bytesAvail, pTag, bIsFinal);
  399. m_pByteQueue->EnQueue(p, (UINT32)(bytesAvail - (p - pBuf)));
  401. // pBuf is not needed anymore, so delete
  402. HX_VECTOR_DELETE(pBuf);
  403. p = NULL;
  405. switch(pResult)
  406. {
  407.     case XMLPNotDone:
  408.     {
  409. goto exit;
  410.     }
  412.     case XMLPNoClose:
  413.     {
  414. rc = HXR_XML_NOCLOSE;
  415. goto exit;
  416.     }
  418.     case XMLPBadAttribute:
  419.     {
  420. rc = HXR_XML_NOTAGTYPE;
  421. goto exit;
  422.     }
  424.     case XMLPBadEndTag:
  425.     {
  426. rc = HXR_XML_BADENDTAG;
  427. goto exit;
  428.     }
  429.     
  430.     case XMLPAttributeValueNotQuoted:
  431.     {
  432. rc = HXR_XML_MISSINGQUOTE;
  433. goto exit;
  434.     }
  436.     case XMLPBadDirective:
  437.     {
  438. rc = HXR_XML_GENERALERROR;
  439. goto exit;
  440.     }
  442.     case XMLPDupAttribute:
  443.     {
  444. rc = HXR_XML_DUPATTRIBUTE;
  445. goto exit;
  446.     }
  448.     case XMLPComment:
  449.     {
  450. const char* pValue = pTag->m_cur_attribute->value;
  451. rc = m_pResponse->HandleComment(pValue,0,0);
  452.     }
  453.     break;
  455.     case XMLPPlainText:
  456.     {
  457. const char* pValue = pTag->m_cur_attribute->value;
  458. CHXBuffer* pBuffer = new CHXBuffer;
  459. pBuffer->AddRef();
  460. pBuffer->Set((const BYTE*)pValue, strlen(pValue)+1);
  461. rc = m_pResponse->HandleCharacterData(pBuffer,0,0);
  462. HX_RELEASE(pBuffer);
  463.     }
  464.     break;
  466.     case XMLPDirective:
  467.     {
  468. const char* pValue = pTag->m_name;
  469. if(strcmp(pValue, "DOCTYPE") == 0)
  470. {
  471.     // m_bExternalDoctype = TRUE;
  472. }
  473.     }
  474.     break;
  476.     case XMLPProcInst:
  477.     // handle processing instruction
  478.     {
  479. const char* pTarget = pTag->m_name;
  481. CHXHeader* pValues = new CHXHeader;
  482. pValues->AddRef();
  484. for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  485. {
  486.     XMLAttribute* pAttr = pTag->attribute(i);
  487.     // the XMLParser class supports what it calls attributes
  488.     // without names.  It's used to communicate processing
  489.     // instructions and things like that. We just ignore attributes
  490.     // without names here.
  491.     if (pAttr->name != NULL)
  492.     {
  493. CHXBuffer* pBuf = new CHXBuffer;
  494. pBuf->AddRef();
  495. pBuf->Set((const BYTE*)pAttr->value,
  496.     strlen(pAttr->value)+1);
  497. pValues->SetPropertyCString(
  498.     pAttr->name, pBuf);
  499. pBuf->Release();
  500.     }
  501. }
  502. rc = m_pResponse->HandleProcessingInstruction(pTarget,
  503.       pValues,0,0);
  504. HX_RELEASE(pValues);
  505.     }
  506.     break;
  508.     case XMLPTag:
  509.     {
  510. const char* pName = pTag->m_name;
  511. if(pTag->m_type != XMLEndTag)
  512. {
  513.     CHXHeader* pValues = new CHXHeader;
  514.     pValues->AddRef();
  516.     for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  517.     {
  518. XMLAttribute* pAttr = pTag->attribute(i);
  519. // the XMLParser class supports what it calls attributes
  520. // without names.  It's used to communicate processing
  521. // instructions and things like that. We just ignore attributes
  522. // without names here.
  523. if (pAttr->name != NULL)
  524. {
  525.     CHXBuffer* pBuf = new CHXBuffer;
  526.     pBuf->AddRef();
  527.     pBuf->Set((const BYTE*)pAttr->value,
  528. strlen(pAttr->value)+1);
  529.     pValues->SetPropertyCString(
  530. pAttr->name, pBuf);
  531.     pBuf->Release();
  532. }
  533.     }
  534.     rc = m_pResponse->HandleStartElement(pName, pValues,
  535.                                                          m_pParser->GetTagStartLineNumber(),
  536.                                                          m_pParser->GetTagStartColumnNumber());
  537.     HX_RELEASE(pValues);
  539.     if(!pTag->m_need_close && SUCCEEDED(rc))
  540.     {
  541. rc = m_pResponse->HandleEndElement(pName,0,0);
  542.     }
  543. }
  544. else
  545. {
  546.     rc = m_pResponse->HandleEndElement(pName,0,0);
  547. }
  548.     }
  549.     break;
  551.     default:
  552.     {
  553. bDone = TRUE;
  554.     }
  555.     break;
  556. }
  557.     }
  559. exit:
  560.     HX_DELETE(pTag);
  562.     return rc;
  563. }
  566. /* 
  567.  * HXStrictXMLParser methods
  568.  */
  570. HXStrictXMLParser::HXStrictXMLParser():
  571.     m_pParser(NULL),
  572.     m_pByteQueue(NULL)
  573.     , m_pErrorNotifier(NULL)
  574. {
  575. }
  577. HXStrictXMLParser::~HXStrictXMLParser()
  578. {
  579.     HX_DELETE(m_pParser);
  580.     HX_DELETE(m_pByteQueue);
  581. }
  583. HX_RESULT
  584. HXStrictXMLParser::Init(IHXXMLParserResponse* pResponse,
  585.        const char* pEncoding)
  586. {
  587.     m_pResponse = pResponse;
  589.     m_pResponse = pResponse;
  590.     m_pParser = new XMLParser(TRUE, pEncoding);
  591.     if (m_pErrorNotifier)
  592.     {
  593. m_pParser->StoreErrors();
  594.     }
  595.     m_pByteQueue = new CBigByteQueue(BUFSIZE);
  597.     return HXR_OK;
  598. }
  600. HX_RESULT
  601. HXStrictXMLParser::InitErrorNotifier(ErrorNotifier* /*OUT*/ pNotifier)
  602. {
  603.     m_pErrorNotifier = pNotifier; 
  604.     if (m_pParser)
  605.     {
  606. m_pParser->StoreErrors();
  607.     }
  608.     return HXR_OK; 
  609. }
  611. HX_RESULT
  612. HXStrictXMLParser::Parse(IHXBuffer* pBuffer,
  613. BOOL bIsFinal)
  614. {
  615.     HX_RESULT rc = HXR_OK;
  617.     // See if we have any encoding info
  618.     CheckEncoding(m_pParser, pBuffer);
  620.     UINT32 ulBufLen = pBuffer->GetSize();
  621.     if(m_pByteQueue->GetAvailableElements() < ulBufLen)
  622.     {
  623. m_pByteQueue->Grow(ulBufLen);
  624.     }
  625.     m_pByteQueue->EnQueue(pBuffer->GetBuffer(), ulBufLen);
  626.     rc = DoParse(bIsFinal);
  628.     return rc;
  629. }
  631. HX_RESULT
  632. HXStrictXMLParser::HandleErrors(CHXPtrArray* pErrs)
  633. {
  634.     if (m_pErrorNotifier && pErrs)
  635.     {
  636. int size = pErrs->GetSize();
  638. for(int i=0;i<size;++i)
  639. {
  640.     XMLError* pError = (XMLError*) (*pErrs)[i];
  641.     HX_RESULT code = ConvertToHX_RESULT(pError->m_errorTag);
  642.     m_pErrorNotifier->ErrorInLastTag(code, pError->m_pErrorString, 
  643. pError->m_pFrameString,  pError->m_lLineNumber, 
  644. pError->m_lLinePosition);
  645. }
  646.     }
  647.     return HXR_OK;
  648. }
  650. HX_RESULT
  651. HXStrictXMLParser::ConvertToHX_RESULT(UINT32 err)
  652. {
  653.     HX_RESULT ret = HXR_OK;
  654.     switch (err)
  655.     {
  656.     case XMLUnknownError:
  657. ret = HXR_XML_GENERALERROR;
  658. break;
  659.     case XMLErrorNoClose:
  660. ret = HXR_XML_NOCLOSE;
  661. break;
  662.     case XMLErrorBadAttribute:
  663. ret = HXR_XML_BADATTRIBUTE;
  664. break;
  665.     case XMLErrorNoValue:
  666. ret = HXR_XML_NOVALUE;
  667. break;
  668.     case XMLErrorMissingQuote:
  669. ret = HXR_XML_MISSINGQUOTE;
  670. break;
  671.     case XMLErrorBadEndTag:
  672. ret = HXR_XML_BADENDTAG;
  673. break;
  674.     case XMLErrorNoTagType:
  675. ret = HXR_XML_NOTAGTYPE;
  676. break;
  677.     case XMLErrorDupAttribute:
  678. ret = HXR_XML_DUPATTRIBUTE;
  679. break;
  680.     case XMLErrorCommentBeforeProcInst:
  681. ret = HXR_XML_COMMENT_B4_PROCINST;
  682. break;
  683.     case XMLErrorInvalidName:
  684. ret = HXR_XML_INVALID_NAME;
  685. break;
  686.     case XMLErrorInvalidCharInDoc:
  687. ret = HXR_XML_INVALID_CHAR_IN_DOC;
  688. break;
  689.     case XMLErrorTwoDashNotAllowed:
  690. ret = HXR_XML_TWO_DASHES_NOT_ALLOWED_IN_COMMENT;
  691. break;
  692.     case XMLErrorInvalidDecl:
  693. ret = HXR_XML_INVALID_DECL;
  694. break;
  695.     case XMLErrorInvalidPI:
  696. ret = HXR_XML_INVALID_PI;
  697. break;
  698.     case XMLErrorInvalidPITarget:
  699. ret = HXR_XML_INVALID_PI_TARGET;
  700. break;
  701.     case XMLErrorInvalidCDATA:
  702. ret = HXR_XML_INVALID_CDATA;
  703. break;
  704.     case XMLErrorInvalidRef:
  705. ret = HXR_XML_INVALID_REF;
  706. break;
  707.     case XMLErrorMissingEquals:
  708. ret = HXR_XML_MISSING_EQUALS;
  709. break;
  710.     case XMLErrorMissingReqSpace:
  711. ret = HXR_XML_MISSING_REQ_SPACE;
  712. break;
  713.     case XMLErrorLTnotAllowed:
  714. ret = HXR_XML_LT_NOT_ALLOWED;
  715. break;
  716.     case XMLErrorInvalidGTafter2RSQB:
  717. ret = HXR_XML_INVALID_GT_AFFT_2_RSQB_IN_CONTENT;
  718. break;
  719.     case XMLErrorInvalidComment:
  720. ret = HXR_XML_INVALID_COMMENT;
  721. break;
  722.     }
  723.     return ret;
  724. }
  727. HX_RESULT
  728. HXStrictXMLParser::DoParse(BOOL bIsFinal)
  729. {
  730.     HX_RESULT rc = HXR_OK;
  732.     XMLTag* pTag = NULL;
  734.     BOOL bDone = FALSE;
  735.     while(!bDone &&
  736. HXR_OK == rc)
  737.     {
  738. UINT32 bytesUsed;
  739. UINT32 bytesAvail = m_pByteQueue->GetQueuedItemCount();
  740. if(bytesAvail <= 0)
  741. {
  742.     break;
  743. }
  745. BYTE* pBuf = new BYTE[bytesAvail];
  746. BYTE* p = pBuf;
  747. m_pByteQueue->DeQueue(pBuf, bytesAvail);
  748. bytesUsed = bytesAvail;
  750. if(pTag)
  751. {
  752.     delete pTag;
  753.     pTag = 0;
  754. }
  756. XMLParseResult pResult = 
  757.     m_pParser->Parse((const char*&)p, bytesAvail, pTag, bIsFinal);
  758. m_pByteQueue->EnQueue(p, (UINT32)(bytesAvail - (p - pBuf)));
  760. // pBuf is not used anymore, so delete
  761. HX_VECTOR_DELETE(pBuf);
  762. p = NULL;
  764. UINT32 ulTagStartLine = m_pParser->GetTagStartLineNumber();
  765. UINT32 ulTagStartCol = m_pParser->GetTagStartColumnNumber();
  767. switch(pResult)
  768. {
  769.     case XMLPNotDone:
  770.     {
  771. goto exit;
  772.     }
  774.     case XMLPNoClose:
  775.     {
  776. rc = HXR_XML_NOCLOSE;
  777. goto exit;
  778.     }
  780.     case XMLPBadAttribute:
  781.     {
  782. rc = HXR_XML_NOTAGTYPE;
  783. goto exit;
  784.     }
  786.     case XMLPBadEndTag:
  787.     {
  788. rc = HXR_XML_BADENDTAG;
  789. goto exit;
  790.     }
  791.     
  792.     case XMLPAttributeValueNotQuoted:
  793.     {
  794. rc = HXR_XML_MISSINGQUOTE;
  795. goto exit;
  796.     }
  798.     case XMLPBadDirective:
  799.     {
  800. rc = HXR_XML_GENERALERROR;
  801. goto exit;
  802.     }
  804.     case XMLPDupAttribute:
  805.     {
  806. rc = HXR_XML_DUPATTRIBUTE;
  807. goto exit;
  808.     }
  810.     case XMLPCommentBeforeProcInst:
  811.     {
  812. rc = HXR_XML_COMMENT_B4_PROCINST;
  813. goto exit;
  814.     }
  815.     
  816.     case XMLPComment:
  817.     {
  818. const char* pValue = pTag->m_cur_attribute->value;
  819. rc = m_pResponse->HandleComment(pValue,ulTagStartLine,ulTagStartCol);
  820. HandleErrors(pTag->m_errs);
  821.     }
  822.     break;
  824.     case XMLPPlainText:
  825.     {
  826. const char* pValue = pTag->m_cur_attribute->value;
  827. CHXBuffer* pBuffer = new CHXBuffer;
  828. pBuffer->AddRef();
  829. pBuffer->Set((const BYTE*)pValue, strlen(pValue)+1);
  830. rc = m_pResponse->HandleCharacterData(pBuffer,ulTagStartLine,ulTagStartCol);
  831. HandleErrors(pTag->m_errs);
  832. HX_RELEASE(pBuffer);
  833.     }
  834.     break;
  836.     case XMLPDirective:
  837.     {
  838. const char* pName = NULL;
  839. const char* pPublicID = NULL;
  840. const char* pSystemID = NULL;
  841. CHXBuffer* pBuffer = NULL;
  842. UINT32 ulNumAttributes = pTag->m_numAttributes; 
  843. if(strcmp(pTag->m_name, "DOCTYPE") == 0 &&
  844.     ulNumAttributes > 0)
  845. {
  846.     UINT32 ulCurAttribute = 0;
  848.     while(ulCurAttribute < ulNumAttributes)
  849.     {
  850. XMLAttribute* pAttr = NULL;
  851. if(ulCurAttribute == 0)
  852. {
  853.     pAttr = pTag->attribute(ulCurAttribute);
  854.     if(pAttr)
  855.     {
  856. pName = pAttr->value;
  857.     }
  858. }
  859. else
  860. {
  861.     pAttr = pTag->attribute(ulCurAttribute);
  862.     if(strcmp(pAttr->value, "SYSTEM") == 0)
  863.     {
  864. ulCurAttribute++;
  865. if(ulCurAttribute < ulNumAttributes)
  866. {
  867.     pAttr = pTag->attribute(ulCurAttribute);
  868.     if(pAttr)
  869.     {
  870. pSystemID = pAttr->value;
  871.     }
  872. }
  873.     }
  874.     else if(strcmp(pAttr->value, "PUBLIC") == 0)
  875.     {
  876. ulCurAttribute++;
  877. if(ulCurAttribute < ulNumAttributes)
  878. {
  879.     pAttr = pTag->attribute(ulCurAttribute);
  880.     if(pAttr)
  881.     {
  882. pPublicID = pAttr->value;
  883. ulCurAttribute++;
  884. if(ulCurAttribute < ulNumAttributes)
  885. {
  886.     pAttr = pTag->attribute(ulCurAttribute);
  887.     if(pAttr)
  888.     {
  889. pSystemID = pAttr->value;
  890.     }
  891. }
  892.     }
  893. }
  894.     }
  895. }
  896. ulCurAttribute++;
  897.     }
  899.     rc = m_pResponse->HandleUnparsedDoctypeDecl(pName, pSystemID,
  900. pPublicID, ulTagStartLine,ulTagStartCol);
  901.     HX_RELEASE(pBuffer);
  902. }
  903.     }
  904.     break;
  906.     case XMLPProcInst:
  907.     // handle processing instruction
  908.     {
  909. const char* pTarget = pTag->m_name;
  911. CHXHeader* pValues = new CHXHeader;
  912. pValues->AddRef();
  913. pValues->PreserveCase(TRUE);
  915. for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  916. {
  917.     XMLAttribute* pAttr = pTag->attribute(i);
  918.     // the XMLParser class supports what it calls attributes
  919.     // without names.  It's used to communicate processing
  920.     // instructions and things like that. We just ignore attributes
  921.     // without names here.
  922.     if (pAttr->name != NULL)
  923.     {
  924. CHXBuffer* pBuf = new CHXBuffer;
  925. pBuf->AddRef();
  926. pBuf->Set((const BYTE*)pAttr->value,
  927.     strlen(pAttr->value)+1);
  928. pValues->SetPropertyCString(
  929.     pAttr->name, pBuf);
  930. pBuf->Release();
  931.     }
  932. }
  933. rc = m_pResponse->HandleProcessingInstruction(pTarget,
  934.       pValues,ulTagStartLine,ulTagStartCol);
  936. HandleErrors(pTag->m_errs);
  938. HX_RELEASE(pValues);
  939.     }
  940.     break;
  942.     case XMLPTag:
  943.     {
  944. const char* pName = pTag->m_name;
  945. if(pTag->m_type != XMLEndTag)
  946. {
  947.     CHXHeader* pValues = new CHXHeader;
  948.     pValues->AddRef();
  949.     pValues->PreserveCase(TRUE);
  951.     for(UINT32 i=0;i<pTag->m_numAttributes;++i)
  952.     {
  953. XMLAttribute* pAttr = pTag->attribute(i);
  954. // the XMLParser class supports what it calls attributes
  955. // without names.  It's used to communicate processing
  956. // instructions and things like that. We just ignore attributes
  957. // without names here.
  958. if (pAttr->name != NULL)
  959. {
  960.     CHXBuffer* pBuf = new CHXBuffer;
  961.     pBuf->AddRef();
  962.     pBuf->Set((const BYTE*)pAttr->value,
  963. strlen(pAttr->value)+1);
  964.     pValues->SetPropertyCString(
  965. pAttr->name, pBuf);
  966.     pBuf->Release();
  967. }
  968.     }
  969.     if(HXR_OK == rc)
  970.     {
  971. rc = m_pResponse->HandleStartElement(pName, 
  972.     pValues,ulTagStartLine,ulTagStartCol);
  974. HandleErrors(pTag->m_errs);
  975.     }
  976.     HX_RELEASE(pValues);
  978.     if(HXR_OK == rc &&
  979. !pTag->m_need_close)
  980.     {
  981. rc = m_pResponse->HandleEndElement(pName,ulTagStartLine,ulTagStartCol);
  982.     }
  983. }
  984. else
  985. {
  986.     rc = m_pResponse->HandleEndElement(pName,ulTagStartLine,ulTagStartCol);
  987.     HandleErrors(pTag->m_errs);
  988. }
  989.     }
  990.     break;
  992.     default:
  993.     {
  994. bDone = TRUE;
  995.     }
  996.     break;
  997. }
  998.     }
  1000. exit:
  1001.     HX_DELETE(pTag);
  1003.     return rc;
  1004. }
  1006. HX_RESULT
  1007. HXStrictXMLParser::GetCurrentLineNumber(REF(ULONG32) ulLineNumber)
  1008. {
  1009.     HX_RESULT rc = HXR_OK;
  1011.     ulLineNumber = (UINT32)m_pParser->GetCurrentLineNumber();
  1013.     return rc;
  1014. }
  1016. HX_RESULT
  1017. HXStrictXMLParser::GetCurrentColumnNumber(REF(ULONG32) ulColumnNumber)
  1018. {
  1019.     HX_RESULT rc = HXR_OK;
  1021.     ulColumnNumber = (UINT32)m_pParser->GetCurrentColumnNumber();
  1023.     return rc;
  1024. }
  1026. HX_RESULT
  1027. HXStrictXMLParser::GetCurrentByteIndex(REF(ULONG32) ulByteIndex)
  1028. {
  1029.     HX_RESULT rc = HXR_NOTIMPL;
  1031.     return rc;
  1032. }
  1034. HX_RESULT
  1035. HXStrictXMLParser::GetCurrentErrorText(REF(IHXBuffer*) pBuffer)
  1036. {
  1037.     HX_RESULT rc = HXR_FAIL;
  1039.     XMLError* pLastError = m_pParser->GetLastError();
  1040.     if(pLastError &&
  1041. pLastError->m_pErrorString)
  1042.     {
  1043. pBuffer = new CHXBuffer;
  1044. pBuffer->AddRef();
  1045. pBuffer->Set((BYTE*)pLastError->m_pErrorString,
  1046.  strlen(pLastError->m_pErrorString) + 1);
  1047. rc = HXR_OK;
  1048.     }
  1050.     return rc;
  1051. }