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

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

Symbian

开发平台：

C/C++

expatprs.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 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 RealNetworks Community Source License 
  8.  * Version 1.0 (the "License"). You may not use this file except in 
  9.  * compliance with the License executed by both you and RealNetworks.  You 
  10.  * may obtain a copy of the License at  
  11.  * http://www.helixcommunity.org/content/rcsl.  You may also obtain a 
  12.  * copy of the License by contacting RealNetworks directly.  Please see the 
  13.  * License for the rights, obligations and limitations governing use of the 
  14.  * contents of the file. 
  15.  *  
  16.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  17.  * developer of the Original Code and owns the copyrights in the portions 
  18.  * it created. 
  19.  *  
  20.  * This file, and the files included with this file, is distributed and made 
  21.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  22.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  23.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  24.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.  
  25.  * 
  26.  * Technology Compatibility Kit Test Suite(s) Location: 
  27.  *    http://www.helixcommunity.org/content/tck 
  28.  * 
  29.  * Contributor(s): 
  30.  *  
  31.  * ***** END LICENSE BLOCK ***** */ 
  32. //  $Id: expatprs.cpp,v 1.6 2003/09/02 21:20:38 ehyche Exp $
  34. #include "hlxclib/string.h"
  35. #include "hxtypes.h"
  36. #include "hxresult.h"
  37. #include "hxassert.h"
  38. #include "hxheap.h"
  40. #include "hxcom.h"
  41. #include "hxcomm.h"
  42. #include "hxfiles.h"
  43. #include "ihxpckts.h"
  44. #include "hxxml.h"
  45. #include "hxplugn.h"
  46. #include "xmlreslt.h"
  48. #include "hxxres.h"
  49. #include "hxxrsmg.h"
  51. #include "hxxml.ver"
  52. #include "xmlparse.h"
  53. #include "expatprs.h"
  54. #include "expatapi.h"
  55. #include "ctype.h"
  57. #include "hxperf.h"
  59. #ifdef _DEBUG
  60. #undef HX_THIS_FILE
  61. static const char HX_THIS_FILE[] = __FILE__;
  62. #endif
  64. #define MAX_ATTRIBUTE_SIZE 255
  67. HXExpatXMLParser::HXExpatXMLParser(IUnknown* pContext)
  68. : m_lRefCount(0)
  69. , m_pParser(NULL)
  70. , m_pResponse(NULL)
  71. , m_pContext(pContext)
  72. , m_pClassFactory(NULL)
  73. , m_pCurrentBuffer(NULL)
  74. , m_ulCurrentOffset(0)
  75. , m_pNSResp(NULL)
  76. , m_bInited(FALSE)
  77. {
  78.     m_pContext->AddRef();
  79.     m_pContext->QueryInterface(IID_IHXCommonClassFactory, 
  80. (void**)&m_pClassFactory);
  81. }
  83. HXExpatXMLParser::~HXExpatXMLParser()
  84. {
  85.     Close();
  86.     HX_RELEASE(m_pContext);
  87.     HX_RELEASE(m_pClassFactory);
  88. }
  90. /************************************************************************
  91.  *  IUnknown COM Interface Methods                          ref:  hxcom.h
  92.  */
  93. STDMETHODIMP 
  94. HXExpatXMLParser::QueryInterface(REFIID riid, void** ppvObj)
  95. {
  96.     if (IsEqualIID(riid, IID_IUnknown))
  97.     {
  98. AddRef();
  99. *ppvObj = this;
  100. return HXR_OK;
  101.     }
  102.     else if (IsEqualIID(riid, IID_IHXXMLParser))
  103.     {
  104. AddRef();
  105. *ppvObj = (IHXXMLParser*)this;
  106. return HXR_OK;
  107.     }
  108.     else if (IsEqualIID(riid, IID_IHXXMLNamespaceParser))
  109.     {
  110. AddRef();
  111. *ppvObj = (IHXXMLNamespaceParser*)this;
  112. return HXR_OK;
  113.     }
  115.     *ppvObj = NULL;
  116.     return HXR_NOINTERFACE;
  117. }
  119. STDMETHODIMP_(UINT32)
  120. HXExpatXMLParser::AddRef()
  121. {
  122.     return InterlockedIncrement(&m_lRefCount);
  123. }
  125. STDMETHODIMP_(UINT32)
  126. HXExpatXMLParser::Release()
  127. {
  128.     if (InterlockedDecrement(&m_lRefCount) > 0)
  129.     {
  130. return m_lRefCount;
  131.     }
  132.     delete this;
  133.     return 0;
  134. }
  136. /*
  137.  * IHXXMLNamespaceParser methods
  138.  */
  139. STDMETHODIMP
  140. HXExpatXMLParser::InitNamespaceParser(
  141.        IHXXMLParserResponse* /*IN*/  pResponse,
  142.        IHXXMLNamespaceResponse*      pNSResp,
  143.        const char*     /*IN*/    pEncoding,
  144.        const char       sepChar)
  145. {
  146.     HX_LOG_BLOCK( "HXExpatXMLParser::InitNamespaceParser" );
  148.     if (m_bInited)
  149.     {
  150. return HXR_UNEXPECTED;
  151.     }
  152.     HX_RESULT rc = HXR_OK;
  153.     if (pResponse)
  154.     {
  155. m_pResponse = pResponse;
  156. m_pResponse->AddRef();
  157.     }
  159.     if (pNSResp)
  160.     {
  161. m_pNSResp = pNSResp;
  162. m_pNSResp->AddRef();
  163.     }
  165.     m_cSepChar = sepChar;
  166.     if (pEncoding)
  167.     {
  168. m_pParser = XML_ParserCreateNS(pEncoding, sepChar);
  169.     }
  170.     else
  171.     {
  172. /* use iso-8859-1 by default */
  173. m_pParser = XML_ParserCreateNS("iso-8859-1", sepChar);
  174.     }
  176.     if (m_pParser == NULL)
  177.     {
  178. rc = HXR_OUTOFMEMORY;
  179.     }
  180.     if (SUCCEEDED(rc))
  181.     {
  182. XML_SetUserData(m_pParser, this);
  183. XML_SetElementHandler(m_pParser, ::handleStartElement, 
  184.     ::handleEndElement);
  185. XML_SetCharacterDataHandler(m_pParser, ::handleCharacterData);
  186. XML_SetProcessingInstructionHandler(m_pParser, 
  187.     ::handleProcessingInstruction);
  188. XML_SetCommentHandler(m_pParser, ::handleComment);
  189.     
  190. //XML_SetCdataSectionHandler(m_pParser, ::handleStartCdataSection,  
  191. //    ::handleEndCdataSection);
  192.     
  193. XML_SetCharacterDataHandler(m_pParser, ::handleCharacterData);
  194. XML_SetUnparsedEntityDeclHandler(m_pParser, ::handleUnparsedEntityDecl);
  195. XML_SetNotationDeclHandler(m_pParser, ::handleNotationDecl);
  196. XML_SetDefaultHandler(m_pParser, ::handleDefault);
  198. XML_SetNamespaceDeclHandler(m_pParser, ::handleStartNamespaceDecl,
  199. ::handleEndNamespaceDecl);
  200.     }
  202.     m_bInited = TRUE;
  203.     return rc;
  204. }
  206. STDMETHODIMP_(char)
  207. HXExpatXMLParser::GetSepChar()
  208. {
  209.     return m_cSepChar;
  210. }
  213. /*
  214.  * IHXXMLParser methods
  215.  */
  216. STDMETHODIMP
  217. HXExpatXMLParser::Init(IHXXMLParserResponse* /*IN*/  pResponse,
  218.        const char*     /*IN*/ pEncoding,
  219.        BOOL     /*IN*/ bStrict)
  220. {
  221.     HX_LOG_BLOCK( "HXExpatXMLParser::Init" );
  223.     if (m_bInited)
  224.     {
  225. return HXR_UNEXPECTED;
  226.     }
  227.     HX_RESULT rc = HXR_OK;
  228.     if (pResponse)
  229.     {
  230. m_pResponse = pResponse;
  231. m_pResponse->AddRef();
  232.     }
  234.     if (pEncoding)
  235.     {
  236. m_pParser = XML_ParserCreate(pEncoding);
  237.     }
  238.     else
  239.     {
  240. /* use iso-8859-1 by default */
  241. m_pParser = XML_ParserCreate("iso-8859-1");
  242.     }
  244.     if (m_pParser == NULL)
  245.     {
  246. rc = HXR_OUTOFMEMORY;
  247.     }
  248.     if (SUCCEEDED(rc))
  249.     {
  250. XML_SetUserData(m_pParser, this);
  251. XML_SetElementHandler(m_pParser, ::handleStartElement, 
  252.     ::handleEndElement);
  253. XML_SetCharacterDataHandler(m_pParser, ::handleCharacterData);
  254. XML_SetProcessingInstructionHandler(m_pParser, 
  255.     ::handleProcessingInstruction);
  256. XML_SetCommentHandler(m_pParser, ::handleComment);
  257.     
  258. //XML_SetCdataSectionHandler(m_pParser, ::handleStartCdataSection,  
  259. //    ::handleEndCdataSection);
  260.     
  261. XML_SetCharacterDataHandler(m_pParser, ::handleCharacterData);
  262. XML_SetUnparsedEntityDeclHandler(m_pParser, ::handleUnparsedEntityDecl);
  263. XML_SetNotationDeclHandler(m_pParser, ::handleNotationDecl);
  264. XML_SetDefaultHandler(m_pParser, ::handleDefault);
  265.     }
  266.     m_bInited = TRUE;
  267.     return rc;
  268. }
  270. STDMETHODIMP
  271. HXExpatXMLParser::Close()
  272. {
  273.     HX_RELEASE(m_pResponse);
  274.     HX_RELEASE(m_pNSResp);
  275.     HX_RELEASE(m_pCurrentBuffer);
  276.     m_ulCurrentOffset = 0;
  277.     m_bInited = FALSE;
  278.     if (m_pParser)
  279.     {
  280. XML_ParserFree(m_pParser);
  281. m_pParser = NULL;
  282.     }
  283.     return HXR_OK;
  284. }
  287. STDMETHODIMP
  288. HXExpatXMLParser::Parse(IHXBuffer* /*IN*/     pBuffer,
  289.  BOOL /*IN*/     bIsFinal)
  290. {
  291.     HX_LOG_BLOCK( "HXExpatXMLParser::Parse" );
  293.     if (m_pParser)
  294.     {
  295. if (m_pCurrentBuffer)
  296. {
  297.     m_ulCurrentOffset += m_pCurrentBuffer->GetSize();
  298.     HX_RELEASE(m_pCurrentBuffer);
  299. }
  300. m_pCurrentBuffer = pBuffer;
  301. m_pCurrentBuffer->AddRef();
  302. if (!XML_Parse(m_pParser, (const XML_Char*)m_pCurrentBuffer->GetBuffer(), 
  303. m_pCurrentBuffer->GetSize(), bIsFinal))
  304. {
  305.     XML_Error code = XML_GetErrorCode(m_pParser);
  306.     switch (code)
  307.     {
  308.     case XML_ERROR_NONE:
  309. return HXR_FAIL;
  310.     case XML_ERROR_NO_MEMORY:
  311. return HXR_OUTOFMEMORY;
  312.     case XML_ERROR_SYNTAX:
  313. return HXR_XML_SYNTAX;
  314.     case XML_ERROR_NO_ELEMENTS:
  315. return HXR_XML_NO_ELEMENTS;
  316. // we removed this error in favor of more specific errors
  317. //     case XML_ERROR_INVALID_TOKEN:
  318. // return HXR_XML_INVALID_TOKEN;
  319.     case XML_ERROR_UNCLOSED_TOKEN:
  320. return HXR_XML_UNCLOSED_TOKEN;
  321.     case XML_ERROR_PARTIAL_CHAR:
  322. return HXR_XML_PARTIAL_CHAR;
  323.     case XML_ERROR_TAG_MISMATCH:
  324. return HXR_XML_TAG_MISMATCH;
  325.     case XML_ERROR_DUPLICATE_ATTRIBUTE:
  326. // HXR_XML_DUPLICATE_ATTRIBUTE;
  327. return HXR_XML_DUPATTRIBUTE;
  328.     case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
  329. return HXR_XML_JUNK_AFTER_DOC_ELEMENT;
  330.     case XML_ERROR_PARAM_ENTITY_REF:
  331. return HXR_XML_PARAM_ENTITY_REF;
  332.     case XML_ERROR_UNDEFINED_ENTITY:
  333. return HXR_XML_UNDEFINED_ENTITY;
  334.     case XML_ERROR_RECURSIVE_ENTITY_REF:
  335. return HXR_XML_RECURSIVE_ENTITY_REF;
  336.     case XML_ERROR_ASYNC_ENTITY:
  337. return HXR_XML_ASYNC_ENTITY;
  338.     case XML_ERROR_BAD_CHAR_REF:
  339. return HXR_XML_BAD_CHAR_REF;
  340.     case XML_ERROR_BINARY_ENTITY_REF:
  341. return HXR_XML_BINARY_ENTITY_REF;
  342.     case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
  343. return PNR_XML_ATTRIBUTE_EXTEHXAL_ENTITY_REF;
  344.     case XML_ERROR_MISPLACED_XML_PI:
  345. return HXR_XML_MISPLACED_XML_PI;
  346.     case XML_ERROR_UNKNOWN_ENCODING:
  347. return HXR_XML_UNKNOWN_ENCODING;
  348.     case XML_ERROR_INCORRECT_ENCODING:
  349. return HXR_XML_INCORRECT_ENCODING;
  350.     case XML_ERROR_UNCLOSED_CDATA_SECTION:
  351. return HXR_XML_UNCLOSED_CDATA_SECTION;
  352.     case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
  353. return PNR_XML_EXTEHXAL_ENTITY_HANDLING;
  354.     case XML_ERROR_NOT_STANDALONE:
  355. return HXR_XML_NOT_STANDALONE;
  356.             case XML_ERROR_INVALID_NAME:
  357. return HXR_XML_INVALID_NAME;
  358.             case XML_ERROR_INVALID_CHAR_IN_DOC:
  359. return HXR_XML_INVALID_CHAR_IN_DOC;
  360.             case XML_ERROR_TWO_DASHES_NOT_ALLOWED_IN_COMMENT:
  361. return HXR_XML_TWO_DASHES_NOT_ALLOWED_IN_COMMENT;
  362.             case XML_ERROR_INVALID_DECL:
  363. return HXR_XML_INVALID_DECL;
  364.             case XML_ERROR_INVALID_PI: 
  365. return HXR_XML_INVALID_PI;
  366.             case XML_ERROR_INVALID_PI_TARGET: 
  367. return HXR_XML_INVALID_PI_TARGET;
  368.             case XML_ERROR_INVALID_CDATA: 
  369. return HXR_XML_INVALID_CDATA;
  370.             case XML_ERROR_NO_CLOSING_GT: 
  371. return HXR_XML_NO_CLOSING_GT;
  372.             case XML_ERROR_INVALID_HEX_CHAR_REF: 
  373. return HXR_XML_INVALID_HEX_CHAR_REF;
  374.             case XML_ERROR_INVALID_CHAR_REF: 
  375. return HXR_XML_INVALID_CHAR_REF;
  376.             case XML_ERROR_INVALID_REF: 
  377. return HXR_XML_INVALID_REF;
  378.             case XML_ERROR_MISSING_EQUALS: 
  379. return HXR_XML_MISSING_EQUALS;
  380.             case XML_ERROR_MISSING_QUOT_APOS: 
  381. // HXR_XML_MISSING_QUOT_APOS;
  382. return HXR_XML_MISSINGQUOTE;
  383.             case XML_ERROR_MISSING_REQ_SPACE: 
  384. return HXR_XML_MISSING_REQ_SPACE;
  385.             case XML_ERROR_LT_NOT_ALLOWED: 
  386. return HXR_XML_LT_NOT_ALLOWED;
  387.             case XML_ERROR_EXPECTED_GT: 
  388. return HXR_XML_EXPECTED_GT;
  389.             case XML_ERROR_INVALID_GT_AFFT_2_RSQB_IN_CONTENT: 
  390. return HXR_XML_INVALID_GT_AFFT_2_RSQB_IN_CONTENT;
  391.             case XML_ERROR_INVALID_COMMENT: 
  392. return HXR_XML_INVALID_COMMENT;
  393.     default:
  394. return HXR_XML_GENERALERROR;
  395.     }
  396. }
  397.     }
  398.     else
  399.     {
  400. return HXR_NOT_INITIALIZED;
  401.     }
  402.     return HXR_OK;
  403. }
  405. STDMETHODIMP
  406. HXExpatXMLParser::GetCurrentLineNumber(REF(ULONG32) /*OUT*/ ulLineNumber)
  407. {
  408.     if ( m_pParser )
  409.     {
  410. ulLineNumber = XML_GetCurrentLineNumber(m_pParser);
  411. return HXR_OK;
  412.     }
  413.     else
  414.     {
  415. return HXR_NOT_INITIALIZED;
  416.     }
  417. }
  419. STDMETHODIMP
  420. HXExpatXMLParser::GetCurrentColumnNumber(REF(ULONG32) /*OUT*/ ulColumnNumber)
  421. {
  422.     if ( m_pParser )
  423.     {
  424. ulColumnNumber = XML_GetCurrentLineNumber(m_pParser);
  425. return HXR_OK;
  426.     }
  427.     else
  428.     {
  429. return HXR_NOT_INITIALIZED;
  430.     }
  431. }
  433. STDMETHODIMP
  434. HXExpatXMLParser::GetCurrentByteIndex(REF(ULONG32) /*OUT*/ ulByteIndex)
  435. {
  436.     if ( m_pParser )
  437.     {
  438. ulByteIndex = XML_GetCurrentByteIndex(m_pParser);
  439. return HXR_OK;
  440.     }
  441.     else
  442.     {
  443. return HXR_NOT_INITIALIZED;
  444.     }
  445. }
  448. STDMETHODIMP
  449. HXExpatXMLParser::GetCurrentErrorText(REF(IHXBuffer*) /*OUT*/ pBuffer)
  450. {
  451.     XML_Error code = XML_GetErrorCode(m_pParser);
  452.     /* Returns a string describing the error. */
  453.     UINT32 ulByteIndex = XML_GetCurrentByteIndex(m_pParser);
  454.     UINT32 ulColumnNumber = XML_GetCurrentLineNumber(m_pParser);
  456.     
  457.     const UCHAR* pPos = m_pCurrentBuffer->GetBuffer();
  458.     if ( SUCCEEDED(m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pBuffer)) )
  459.     {
  460. const char p[] = "No error context";
  461. if (m_pCurrentBuffer)
  462. {
  463.     if (ulByteIndex >= m_ulCurrentOffset && 
  464. ulByteIndex < m_ulCurrentOffset + m_pCurrentBuffer->GetSize())
  465.     {
  466. int i;
  467. int offset = ulByteIndex - m_ulCurrentOffset;
  468. int startPos = offset;
  469. // first we will back the startPos up to the begining of the 
  470. // line or 0
  471. for (; startPos > 0 && pPos[startPos-1] != 'n' &&
  472.     pPos[startPos-1] != 'r'; --startPos);
  474. // if the beginning of the line number is > 40 characters 
  475. // ahead, we want to jump ahead so the error text is not too long.
  476. if (offset - startPos >= 40)
  477. {
  478.     startPos = offset - 40;
  479. }
  481. // now we will find the end of the line.
  482. for (i=startPos;  pPos[i] && pPos[i] != 'n' && 
  483. pPos[i] != 'r'; ++i);
  485. if (SUCCEEDED(pBuffer->Set(&pPos[startPos], i-startPos+1)))
  486. {
  487.     pBuffer->GetBuffer()[i-startPos] = '';
  488.     return HXR_OK;
  489. }
  490. else
  491. {
  492.     return HXR_OUTOFMEMORY;
  493. }
  494.     }
  495.     else
  496.     {
  497. return pBuffer->Set((const UCHAR*)p, sizeof(p));
  498.     }
  499. }
  500. else
  501. {
  502.     return pBuffer->Set((const UCHAR*)p, sizeof(p));
  503. }
  504.     }
  505.     else
  506.     {
  507. return HXR_FAIL;
  508.     }
  509. }
  512. void HXExpatXMLParser::handleStartElement(const XML_Char *name, const XML_Char **atts)
  513. {
  514.     HX_LOG_BLOCK( "HXExpatXMLParser::handleStartElement" );
  515.     
  516.     if (m_pResponse)
  517.     {
  518. IHXValues* pAtt = NULL;
  519. {
  520.     HX_LOG_BLOCK( "HXExpatXMLParser::handleStartElement::createIHXValues" );
  521.     IUnknown* pUnkAtt = NULL;
  522.     m_pClassFactory->CreateInstance(CLSID_IHXValues, (void**)&pUnkAtt);
  523.     pUnkAtt->QueryInterface(IID_IHXValues, (void**)&pAtt);
  524.     HX_RELEASE(pUnkAtt);
  525. }
  526. if (*atts && **atts) 
  527. {
  528.     HX_LOG_BLOCK( "HXExpatXMLParser::handleStartElement::createIHXBuffer" );
  530.     do
  531.     {
  532. IHXBuffer* pBuf = NULL;
  533. m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pBuf);
  534. pBuf->Set((const UCHAR*)atts[1], strlen(atts[1])+1);
  535. pAtt->SetPropertyCString(atts[0], pBuf);
  536. HX_RELEASE(pBuf);
  537.     }
  538.     while (*(atts+=2));
  539. }
  541. {
  542.     int ulLine;
  543.     int ulCol;
  544.     {
  545.         HX_LOG_BLOCK( "HXExpatXMLParser::handleStartElement::XML_GetCurrentLineNumber" );
  546. ulLine = XML_GetCurrentLineNumber(m_pParser);
  547.     }
  548.     {
  549.         HX_LOG_BLOCK( "HXExpatXMLParser::handleStartElement::XML_GetCurrentColumnNumber" );
  550. ulCol = XML_GetCurrentColumnNumber(m_pParser);
  551.     }
  552.     m_pResponse->HandleStartElement((const char*)name, pAtt, ulLine,ulCol);
  553. }
  554. HX_RELEASE(pAtt);
  555.     }
  556. }
  558. void HXExpatXMLParser::handleEndElement(const XML_Char *name)
  559. {
  560.     HX_LOG_BLOCK( "HXExpatXMLParser::handleEndElement" );
  561.     
  562.     if (m_pResponse)
  563.     {
  564. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  565. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  566. m_pResponse->HandleEndElement((const char*)name, ulLine,ulCol);
  567.     }
  568. }
  570. void HXExpatXMLParser::handleCharacterData(const XML_Char *s, int len)
  571. {
  572.     if (m_pResponse)
  573.     {
  574. IHXBuffer* pBuf = NULL;
  575. m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pBuf);
  576. pBuf->Set((UCHAR*)s, len);
  577. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  578. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  579. m_pResponse->HandleCharacterData(pBuf, ulLine,ulCol);
  580. HX_RELEASE(pBuf);
  581.     }
  582. }
  584. void HXExpatXMLParser::handleProcessingInstruction(
  585. const XML_Char *target, const XML_Char *data)
  586. {
  587.     if (m_pResponse)
  588.     {
  589. IHXValues* pAtt = NULL;
  590. IUnknown* pUnkAtt = NULL;
  591. m_pClassFactory->CreateInstance(CLSID_IHXValues, (void**)&pUnkAtt);
  592. pUnkAtt->QueryInterface(IID_IHXValues, (void**)&pAtt);
  593. HX_RELEASE(pUnkAtt);
  594. const char* pos = data;
  596. const char* pStartName = NULL;
  597. const char* pEndName = NULL;
  598. const char* pStartAtt = NULL;
  599. char cQuote = '"';
  600. const char* pEndAtt = NULL;
  602. for (;;)
  603. {
  604.     // eat white space
  605.     for(;*pos && isspace(*pos); ++pos);
  607.             // if we've reached the end, break out
  608.             if (*pos == '') break;
  610.     // get attribute name
  611.     for(pStartName = pos; *pos && !isspace(*pos) && 
  612.      *pos != '='; ++pos);
  613.     
  614.     // eat white space
  615.     for(pEndName = pos;*pos && isspace(*pos); ++pos);
  617.     // require equals sign
  618.     if (*pos++ != '=')
  619.      break;
  621.     // eat white space
  622.     for(;*pos && isspace(*pos); ++pos);
  624.     // get attribute value
  625.     if (*pos == ''' || *pos == '"')
  626.     {
  627.      cQuote = *pos++;
  628.     }
  629.     else
  630.     {
  631. break;
  632.     }
  633.     
  634.     for(pStartAtt = pos; *pos && *pos != cQuote;++pos);
  635.     pEndAtt = pos;
  637.             // Advance past the quote
  638.             ++pos;
  639.     // require a single whitespace or termination...
  640.     if (*pos != '' && !isspace(*pos))
  641.     {
  642.      break;
  643.     }
  645.     char* name = new char[pEndName-pStartName+1];
  646.     if (!name)
  647.     {
  648. break;
  649.     }
  651.     strncpy(name, pStartName, pEndName - pStartName); /* Flawfinder: ignore */
  652.     name[pEndName-pStartName] = '';
  654.     IHXBuffer* pBuf = NULL;
  655.     m_pClassFactory->CreateInstance(CLSID_IHXBuffer, 
  656.      (void**)&pBuf);
  657.     
  658.     if (!pBuf)
  659.     {
  660.      HX_VECTOR_DELETE(name);
  661. break;
  662.     }
  664.     if (FAILED(pBuf->Set((UCHAR*)pStartAtt,
  665.      pEndAtt-pStartAtt+1)))
  666.     {
  667.      HX_VECTOR_DELETE(name);
  668. HX_RELEASE(pBuf);
  669. break;
  670.     }
  671.     
  672.     pBuf->GetBuffer()[pEndAtt-pStartAtt] = '';
  673.     
  674.     if (FAILED(pAtt->SetPropertyCString(name, pBuf)))
  675.     {
  676.      HX_VECTOR_DELETE(name);
  677. HX_RELEASE(pBuf);
  678. break;
  679.     }
  680.     HX_RELEASE(pBuf);
  681.     HX_VECTOR_DELETE(name);
  682. }
  684. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  685. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  686. m_pResponse->HandleProcessingInstruction(target, pAtt, ulLine,ulCol);
  687.         HX_RELEASE(pAtt);
  688.     }
  689. }
  691. void HXExpatXMLParser::handleComment(const XML_Char *data)
  692. {
  693.     if (m_pResponse)
  694.     {
  695. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  696. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  697. m_pResponse->HandleComment((const char*) data, ulLine, ulCol);
  698.     }
  699. }
  701. void HXExpatXMLParser::handleStartCDataSection()
  702. {
  703. }
  705. void HXExpatXMLParser::handleEndCDataSection()
  706. {
  707. }
  710. void HXExpatXMLParser::handleDefault(const XML_Char *s, int len)
  711. {
  712.     if (m_pResponse)
  713.     {
  714. IHXBuffer* pBuf = NULL;
  715. m_pClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)&pBuf);
  716. pBuf->Set((UCHAR*)s, len);
  718. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  719. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  720. m_pResponse->HandleDefault(pBuf, ulLine, ulCol);
  721. HX_RELEASE (pBuf);
  722.     }
  723. }
  725. void HXExpatXMLParser::handleUnparsedEntityDecl(
  726.     const XML_Char *entityName,
  727.     const XML_Char *base,
  728.     const XML_Char *systemId,
  729.     const XML_Char *publicId,
  730.     const XML_Char *notationName)
  731. {
  732.     if (m_pResponse)
  733.     {
  734. // note ... call back interface missing *base
  735. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  736. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  737. m_pResponse->HandleUnparsedEntityDecl(entityName,systemId, publicId,
  738.     notationName, ulLine, ulCol);
  739.     }
  740. }
  742. void HXExpatXMLParser::handleNotationDecl(
  743.       const XML_Char *notationName,
  744.       const XML_Char *base,
  745.       const XML_Char *systemId,
  746.       const XML_Char *publicId)
  747. {
  748.     if (m_pResponse)
  749.     {
  750. // note ... call back interface missing *base
  751. int ulLine = XML_GetCurrentLineNumber(m_pParser);
  752. int ulCol = XML_GetCurrentColumnNumber(m_pParser);
  753. m_pResponse->HandleNotationDecl(notationName, systemId, publicId,
  754.     ulLine, ulCol);
  755.     }
  756. }
  758. void HXExpatXMLParser::handleStartNamespaceDecl(
  759.       const XML_Char *prefix,
  760.       const XML_Char *uri)
  761. {
  762.     if (m_pNSResp)
  763.     {
  764. m_pNSResp->HandleStartNamespaceDecl(prefix, uri);
  765.     }
  766. }
  768. void HXExpatXMLParser::handleEndNamespaceDecl(const XML_Char *prefix)
  769. {
  770.     if (m_pNSResp)
  771.     {
  772. m_pNSResp->HandleEndNamespaceDecl(prefix);
  773.     }
  774. }
  777. int HXExpatXMLParser::handleNotStandalone()
  778. {
  779.     /* This is called if the document is not standalone (it has an
  780.      * external subset or a reference to a parameter entity, but does not
  781.      * have standalone="yes"). If this handler returns 0, then processing
  782.      * will not continue, and the parser will return a
  783.      * XML_ERROR_NOT_STANDALONE error.
  784.      */
  785.     return 1;
  786. }
  788. void HXExpatXMLParser::handleStartDoctypeDecl(const XML_Char *doctypeName)
  789. {
  790.     // note... no DTD callbacks...
  791. }
  793. void HXExpatXMLParser::handleEndDoctypeDecl()
  794. {
  795.     // note... no DTD callbacks...
  796. }