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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
XMLDOMUtil.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：25k
源码类别：

词法分析

开发平台：

Visual C++

XMLDOMUtil.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: XMLDOMUtil.cpp,v 1.1.1.1 2002/02/01 22:21:42 peiyongz Exp $
  59.  */
  61. #include "stdafx.h"
  62. #include "xml4com.h"
  63. #include "XMLDOMElement.h"
  64. #include "XMLDOMAttribute.h"
  65. #include "XMLDOMText.h"
  66. #include "XMLDOMCDATASection.h"
  67. #include "XMLDOMEntityReference.h"
  68. #include "XMLDOMEntity.h"
  69. #include "XMLDOMProcessingInstruction.h"
  70. #include "XMLDOMComment.h"
  71. #include "XMLDOMDocument.h"
  72. #include "XMLDOMDocumentType.h"
  73. #include "XMLDOMDocumentFragment.h"
  74. #include "XMLDOMNotation.h"
  75. #include "XMLDOMXMLDecl.h"
  76. #include "XMLDOMUtil.h"
  77. #include <xercesc/util/PlatformUtils.hpp>
  78. #include <xercesc/util/XMLUniDefs.hpp>
  81. const OLECHAR* g_DomNodeName[] =
  82. {
  83. OLESTR("invalid"),
  84. OLESTR("element"),
  85. OLESTR("attribute"),
  86. OLESTR("text"),
  87. OLESTR("cdatasection"),
  88. OLESTR("entityreference"),
  89. OLESTR("entity"),
  90. OLESTR("processinginstruction"),
  91. OLESTR("comment"),
  92. OLESTR("document"),
  93. OLESTR("documenttype"),
  94. OLESTR("documentfragment"),
  95. OLESTR("notation")
  96. };
  98. const int g_DomNodeNameSize = sizeof(g_DomNodeName) / sizeof(OLECHAR*);
  100. DOMString GetText(const DOM_Node& node)
  101. {
  102. DOM_Node::NodeType type = static_cast<DOM_Node::NodeType> (node.getNodeType());
  103. DOMString val;
  105. if (DOM_Node::DOCUMENT_TYPE_NODE   == type ||
  106. DOM_Node::NOTATION_NODE   == type)
  107. return val;
  109. if (DOM_Node::CDATA_SECTION_NODE   == type ||
  110. DOM_Node::COMMENT_NODE   == type ||
  111. DOM_Node::PROCESSING_INSTRUCTION_NODE == type ||
  112. DOM_Node::TEXT_NODE   == type) {
  113. val = node.getNodeValue();
  114. return val;
  115. }
  117. DOM_NodeList l =  node.getChildNodes();
  118. int length = l.getLength();
  119. if (length > 0) {
  120. for (int i = 0; i < length; ++i)
  121. val.appendData(GetText(l.item(i)));
  122. }
  123. else {
  124. val = node.getNodeValue();
  125. }
  126. return val;
  127. }
  131. template <class Base>
  132. class CComObjectPool
  133. {
  134. public:
  135. CComObjectPool(unsigned long poolSize);
  137. virtual ~CComObjectPool();
  139. HRESULT WINAPI CreateInstance(Base** pp);
  141. HRESULT Deactivate(Base* obj);
  143. private:
  144. Base** m_pool;
  145. unsigned long m_size;
  146. unsigned long m_hit;
  147. unsigned long m_attempt;
  148. HRESULT Activate(Base* obj);
  149. };
  154. template <class Base>
  155. class CPooledComObject : public Base
  156. {
  157. public:
  158. typedef Base _BaseClass;
  159. CPooledComObject(void* = NULL)
  160. {
  161. _Module.Lock();
  162. }
  163. // Set refcount to 1 to protect destruction
  164. ~CPooledComObject()
  165. {
  166. m_dwRef = 1L;
  167. FinalRelease();
  168. #ifdef _ATL_DEBUG_INTERFACES
  169. _Module.DeleteNonAddRefThunk(_GetRawUnknown());
  170. #endif
  171. _Module.Unlock();
  172. }
  173. //If InternalAddRef or InternalRelease is undefined then your class
  174. //doesn't derive from CComObjectRoot
  175. STDMETHOD_(ULONG, AddRef)() {return InternalAddRef();}
  176. STDMETHOD_(ULONG, Release)()
  177. {
  178. ULONG l = InternalRelease();
  179. if (l == 0) {
  180. if(SUCCEEDED(m_pool.Deactivate(this))) {
  181. FinalRelease();
  182. }
  183. else
  184. delete this;
  185. }
  186. return l;
  187. }
  188. //if _InternalQueryInterface is undefined then you forgot BEGIN_COM_MAP
  189. STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject)
  190. {return _InternalQueryInterface(iid, ppvObject);}
  191. template <class Q>
  192. HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)
  193. {
  194. return QueryInterface(__uuidof(Q), (void**)pp);
  195. }
  197. static HRESULT WINAPI CreateInstance(Base** pp) {
  198. return m_pool.CreateInstance(pp);
  199. }
  201. private:
  202. static CComObjectPool<Base> m_pool;
  203. };
  208. template <class Base>
  209. CComObjectPool<Base>::CComObjectPool<Base>(unsigned long poolSize) {
  210. m_pool = NULL;
  211. m_size = poolSize;
  212. m_pool = new Base*[m_size];
  213. for(unsigned long i = 0; i < m_size; i++)
  214. m_pool[i] = NULL;
  215. m_hit= 0;
  216. m_attempt = 0;
  217. }
  219. template <class Base>
  220. CComObjectPool<Base>::~CComObjectPool<Base>() {
  221. for(unsigned long i = 0; i < m_size; i++) {
  222. if(m_pool[i]) delete m_pool[i];
  223. }
  224. delete [] m_pool;
  225. }
  227. template <class Base>
  228. HRESULT CComObjectPool<Base>::Deactivate(Base* obj) {
  229. for(unsigned long i = 0; i < m_size; i++) {
  230. if(m_pool[i] == NULL) {
  231. m_pool[i] = obj;
  232. return S_OK;
  233. }
  234. }
  235. return E_FAIL;
  236. }
  238. template <class Base>
  239. HRESULT CComObjectPool<Base>::Activate(Base* p)
  240. {
  241. p->SetVoid(NULL);
  242. p->InternalFinalConstructAddRef();
  243. HRESULT hRes = p->FinalConstruct();
  244. p->InternalFinalConstructRelease();
  245. return hRes;
  246. }
  249. template <class Base>
  250. HRESULT WINAPI CComObjectPool<Base>::CreateInstance(Base** pp) {
  251. ATLASSERT(pp != NULL);
  252. HRESULT hRes = E_OUTOFMEMORY;
  253. Base* p = NULL;
  255. m_attempt++;
  257. for(unsigned long i = 0; i < m_size; i++) {
  258. if(m_pool[i]) {
  259. p = m_pool[i];
  260. m_pool[i] = NULL;
  261. hRes = Activate(p);
  262. if (SUCCEEDED(hRes)) {
  263. m_hit++;
  264. break;
  265. }
  266. else {
  267. delete p;
  268. p = NULL;
  269. }
  270. }
  271. }
  273. if(FAILED(hRes)) {
  274. ATLTRY(p = new CPooledComObject<Base>())
  275. if (p != NULL) {
  276. hRes = Activate(p);
  277. if (hRes != S_OK) {
  278. delete p;
  279. p = NULL;
  280. }
  281. }
  282. }
  283. *pp = p;
  284. return hRes;
  285. }
  288. CComObjectPool<CXMLDOMElement> CPooledComObject<CXMLDOMElement>::m_pool(6);
  289. typedef CPooledComObject<CXMLDOMElement> CPooledXMLDOMElementObj;
  291. CComObjectPool<CXMLDOMAttribute> CPooledComObject<CXMLDOMAttribute>::m_pool(6);
  292. typedef CPooledComObject<CXMLDOMAttribute> CPooledXMLDOMAttributeObj;
  294. CComObjectPool<CXMLDOMText> CPooledComObject<CXMLDOMText>::m_pool(6);
  295. typedef CPooledComObject<CXMLDOMText> CPooledXMLDOMTextObj;
  297. CComObjectPool<CXMLDOMCDATASection> CPooledComObject<CXMLDOMCDATASection>::m_pool(6);
  298. typedef CPooledComObject<CXMLDOMCDATASection> CPooledXMLDOMCDATASectionObj;
  300. CComObjectPool<CXMLDOMEntityReference> CPooledComObject<CXMLDOMEntityReference>::m_pool(6);
  301. typedef CPooledComObject<CXMLDOMEntityReference> CPooledXMLDOMEntityReferenceObj;
  303. CComObjectPool<CXMLDOMEntity> CPooledComObject<CXMLDOMEntity>::m_pool(6);
  304. typedef CPooledComObject<CXMLDOMEntity> CPooledXMLDOMEntityObj;
  306. CComObjectPool<CXMLDOMProcessingInstruction> CPooledComObject<CXMLDOMProcessingInstruction>::m_pool(6);
  307. typedef CPooledComObject<CXMLDOMProcessingInstruction> CPooledXMLDOMProcessingInstructionObj;
  309. CComObjectPool<CXMLDOMComment> CPooledComObject<CXMLDOMComment>::m_pool(6);
  310. typedef CPooledComObject<CXMLDOMComment> CPooledXMLDOMCommentObj;
  313. HRESULT wrapNode(IXMLDOMDocument *pDoc, DOM_Node& node, REFIID iid, LPVOID *pVal)
  314. {
  315. HRESULT hr = S_OK;
  316. if (NULL == pVal)
  317. return E_POINTER;
  319. *pVal = NULL;
  320. short type = node.getNodeType();
  322. // the way we are constructing the wrappers is kind of fishy but oh well...
  323. // the various IBM DOM wrapper classes don't ever add any members or have
  324. // any v-tables so what we are doing should be safe.  There isn't any other
  325. // way as far as I can tell to do this....
  327. switch(type)
  328. {
  329. case DOM_Node::ELEMENT_NODE:
  330. {
  331. CXMLDOMElement *pObj = NULL;
  332. hr = CPooledXMLDOMElementObj::CreateInstance(&pObj);
  333. if (S_OK != hr)
  334. return hr;
  336. pObj->AddRef();
  337. pObj->SetOwnerDoc(pDoc);
  339. try
  340. {
  341. pObj->element = *(static_cast<DOM_Element*> (&node));
  342. }
  343. catch(DOM_DOMException& ex)
  344. {
  345. pObj->Release();
  346. return MakeHRESULT(ex);
  347. }
  348. catch(...)
  349. {
  350. pObj->Release();
  351. return E_FAIL;
  352. }
  354. hr = pObj->QueryInterface(iid, pVal);
  355. if (S_OK != hr)
  356. *pVal = NULL;
  358. pObj->Release();
  359. break;
  360. }
  361. case DOM_Node::ATTRIBUTE_NODE:
  362. {
  363. CXMLDOMAttribute *pObj = NULL;
  364. hr = CPooledXMLDOMAttributeObj::CreateInstance(&pObj);
  365. if (S_OK != hr)
  366. return hr;
  368. pObj->AddRef();
  369. pObj->SetOwnerDoc(pDoc);
  371. try
  372. {
  373. pObj->attr = *(static_cast<DOM_Attr*> (&node));
  374. }
  375. catch(DOM_DOMException& ex)
  376. {
  377. pObj->Release();
  378. return MakeHRESULT(ex);
  379. }
  380. catch(...)
  381. {
  382. pObj->Release();
  383. return E_FAIL;
  384. }
  386. hr = pObj->QueryInterface(iid, pVal);
  387. if (S_OK != hr)
  388. *pVal = NULL;
  390. pObj->Release();
  391. break;
  392. }
  393. case DOM_Node::TEXT_NODE:
  394. {
  395. CXMLDOMText *pObj = NULL;
  396. hr = CPooledXMLDOMTextObj::CreateInstance(&pObj);
  397. if (S_OK != hr)
  398. return hr;
  400. pObj->AddRef();
  401. pObj->SetOwnerDoc(pDoc);
  403. try
  404. {
  405. pObj->text = *(static_cast<DOM_Text*> (&node));
  406. }
  407. catch(DOM_DOMException& ex)
  408. {
  409. pObj->Release();
  410. return MakeHRESULT(ex);
  411. }
  412. catch(...)
  413. {
  414. pObj->Release();
  415. return E_FAIL;
  416. }
  418. hr = pObj->QueryInterface(iid, pVal);
  419. if (S_OK != hr)
  420. *pVal = NULL;
  422. pObj->Release();
  423. break;
  424. }
  425. case DOM_Node::CDATA_SECTION_NODE:
  426. {
  427. CXMLDOMCDATASection *pObj = NULL;
  428. hr = CPooledXMLDOMCDATASectionObj::CreateInstance(&pObj);
  429. if (S_OK != hr)
  430. return hr;
  432. pObj->AddRef();
  433. pObj->SetOwnerDoc(pDoc);
  435. try
  436. {
  437. pObj->cdataSection = *(static_cast<DOM_CDATASection*> (&node));
  438. }
  439. catch(DOM_DOMException& ex)
  440. {
  441. pObj->Release();
  442. return MakeHRESULT(ex);
  443. }
  444. catch(...)
  445. {
  446. pObj->Release();
  447. return E_FAIL;
  448. }
  450. hr = pObj->QueryInterface(iid, pVal);
  451. if (S_OK != hr)
  452. *pVal = NULL;
  454. pObj->Release();
  455. break;
  456. }
  457. case DOM_Node::ENTITY_REFERENCE_NODE:
  458. {
  459. CXMLDOMEntityReference *pObj = NULL;
  460. hr = CPooledXMLDOMEntityReferenceObj::CreateInstance(&pObj);
  461. if (S_OK != hr)
  462. return hr;
  464. pObj->AddRef();
  465. pObj->SetOwnerDoc(pDoc);
  467. try
  468. {
  469. pObj->entityReference = *(static_cast<DOM_EntityReference*> (&node));
  470. }
  471. catch(DOM_DOMException& ex)
  472. {
  473. pObj->Release();
  474. return MakeHRESULT(ex);
  475. }
  476. catch(...)
  477. {
  478. pObj->Release();
  479. return E_FAIL;
  480. }
  482. hr = pObj->QueryInterface(iid, pVal);
  483. if (S_OK != hr)
  484. *pVal = NULL;
  486. pObj->Release();
  487. break;
  488. }
  489. case DOM_Node::ENTITY_NODE:
  490. {
  491. CXMLDOMEntity *pObj = NULL;
  492. hr = CPooledXMLDOMEntityObj::CreateInstance(&pObj);
  493. if (S_OK != hr)
  494. return hr;
  496. pObj->AddRef();
  497. pObj->SetOwnerDoc(pDoc);
  499. try
  500. {
  501. pObj->entity = *(static_cast<DOM_Entity*> (&node));
  502. }
  503. catch(DOM_DOMException& ex)
  504. {
  505. pObj->Release();
  506. return MakeHRESULT(ex);
  507. }
  508. catch(...)
  509. {
  510. pObj->Release();
  511. return E_FAIL;
  512. }
  514. hr = pObj->QueryInterface(iid, pVal);
  515. if (S_OK != hr)
  516. *pVal = NULL;
  518. pObj->Release();
  519. break;
  520. }
  521. case DOM_Node::PROCESSING_INSTRUCTION_NODE:
  522. {
  523. CXMLDOMProcessingInstruction *pObj = NULL;
  524. hr = CPooledXMLDOMProcessingInstructionObj::CreateInstance(&pObj);
  525. if (S_OK != hr)
  526. return hr;
  528. pObj->AddRef();
  529. pObj->SetOwnerDoc(pDoc);
  531. try
  532. {
  533. pObj->processingInstruction = *(static_cast<DOM_ProcessingInstruction*> (&node));
  534. }
  535. catch(DOM_DOMException& ex)
  536. {
  537. pObj->Release();
  538. return MakeHRESULT(ex);
  539. }
  540. catch(...)
  541. {
  542. pObj->Release();
  543. return E_FAIL;
  544. }
  546. hr = pObj->QueryInterface(iid, pVal);
  547. if (S_OK != hr)
  548. *pVal = NULL;
  550. pObj->Release();
  551. break;
  552. }
  553. case DOM_Node::COMMENT_NODE:
  554. {
  555. CXMLDOMComment *pObj = NULL;
  556. hr = CPooledXMLDOMCommentObj::CreateInstance(&pObj);
  557. if (S_OK != hr)
  558. return hr;
  560. pObj->AddRef();
  561. pObj->SetOwnerDoc(pDoc);
  563. try
  564. {
  565. pObj->comment = *(static_cast<DOM_Comment*> (&node));
  566. }
  567. catch(DOM_DOMException& ex)
  568. {
  569. pObj->Release();
  570. return MakeHRESULT(ex);
  571. }
  572. catch(...)
  573. {
  574. pObj->Release();
  575. return E_FAIL;
  576. }
  578. hr = pObj->QueryInterface(iid, pVal);
  579. if (S_OK != hr)
  580. *pVal = NULL;
  582. pObj->Release();
  583. break;
  584. }
  585. case DOM_Node::DOCUMENT_NODE:
  586. {
  587. CXMLDOMDocumentObj *pObj = NULL;
  588. hr = CXMLDOMDocumentObj::CreateInstance(&pObj);
  589. if (S_OK != hr)
  590. return hr;
  592. pObj->AddRef();
  593. pObj->SetOwnerDoc(pDoc);
  595. try
  596. {
  597. pObj->m_Document = *(static_cast<DOM_Document*> (&node));
  598. }
  599. catch(DOM_DOMException& ex)
  600. {
  601. pObj->Release();
  602. return MakeHRESULT(ex);
  603. }
  604. catch(...)
  605. {
  606. pObj->Release();
  607. return E_FAIL;
  608. }
  610. hr = pObj->QueryInterface(iid, pVal);
  611. if (S_OK != hr)
  612. *pVal = NULL;
  614. pObj->Release();
  615. break;
  616. }
  617. case DOM_Node::DOCUMENT_TYPE_NODE:
  618. {
  619. CXMLDOMDocumentTypeObj *pObj = NULL;
  620. hr = CXMLDOMDocumentTypeObj::CreateInstance(&pObj);
  621. if (S_OK != hr)
  622. return hr;
  624. pObj->AddRef();
  625. pObj->SetOwnerDoc(pDoc);
  627. try
  628. {
  629. pObj->documentType = *(static_cast<DOM_DocumentType*> (&node));
  630. }
  631. catch(DOM_DOMException& ex)
  632. {
  633. pObj->Release();
  634. return MakeHRESULT(ex);
  635. }
  636. catch(...)
  637. {
  638. pObj->Release();
  639. return E_FAIL;
  640. }
  642. hr = pObj->QueryInterface(iid, pVal);
  643. if (S_OK != hr)
  644. *pVal = NULL;
  646. pObj->Release();
  647. break;
  648. }
  649. case DOM_Node::DOCUMENT_FRAGMENT_NODE:
  650. {
  651. CXMLDOMDocumentFragmentObj *pObj = NULL;
  652. hr = CXMLDOMDocumentFragmentObj::CreateInstance(&pObj);
  653. if (S_OK != hr)
  654. return hr;
  656. pObj->AddRef();
  657. pObj->SetOwnerDoc(pDoc);
  659. try
  660. {
  661. pObj->documentFragment = *(static_cast<DOM_DocumentFragment*> (&node));
  662. }
  663. catch(DOM_DOMException& ex)
  664. {
  665. pObj->Release();
  666. return MakeHRESULT(ex);
  667. }
  668. catch(...)
  669. {
  670. pObj->Release();
  671. return E_FAIL;
  672. }
  674. hr = pObj->QueryInterface(iid, pVal);
  675. if (S_OK != hr)
  676. *pVal = NULL;
  678. pObj->Release();
  679. break;
  680. }
  681. case DOM_Node::NOTATION_NODE:
  682. {
  683. CXMLDOMNotationObj *pObj = NULL;
  684. hr = CXMLDOMNotationObj::CreateInstance(&pObj);
  685. if (S_OK != hr)
  686. return hr;
  688. pObj->AddRef();
  689. pObj->SetOwnerDoc(pDoc);
  691. try
  692. {
  693. pObj->notation = *(static_cast<DOM_Notation*> (&node));
  694. }
  695. catch(DOM_DOMException& ex)
  696. {
  697. pObj->Release();
  698. return MakeHRESULT(ex);
  699. }
  700. catch(...)
  701. {
  702. pObj->Release();
  703. return E_FAIL;
  704. }
  706. hr = pObj->QueryInterface(iid, pVal);
  707. if (S_OK != hr)
  708. *pVal = NULL;
  710. pObj->Release();
  711. break;
  712. }
  714. case DOM_Node::XML_DECL_NODE:
  715. {
  716. CXMLDOMXMLDeclObj *pObj = NULL;
  717. hr = CXMLDOMXMLDeclObj::CreateInstance(&pObj);
  718. if (S_OK != hr)
  719. return hr;
  721. pObj->AddRef();
  722. pObj->SetOwnerDoc(pDoc);
  724. try
  725. {
  726. pObj->xmlDecl = *(static_cast<DOM_XMLDecl*> (&node));
  727. }
  728. catch(DOM_DOMException& ex)
  729. {
  730. pObj->Release();
  731. return MakeHRESULT(ex);
  732. }
  733. catch(...)
  734. {
  735. pObj->Release();
  736. return E_FAIL;
  737. }
  739. hr = pObj->QueryInterface(iid, pVal);
  740. if (S_OK != hr)
  741. *pVal = NULL;
  743. pObj->Release();
  744. break;
  745. }
  746. default:
  747. hr = E_NOTIMPL;
  748. break;
  749. }
  751. return hr;
  752. }
  755. class xmlstream {
  756. public:
  757. xmlstream() {
  758. m_length = 0;
  759. m_alloc = 0;
  760. m_buffer = 0;
  761. m_next = 0;
  762. }
  764. ~xmlstream() {
  765. delete [] m_buffer;
  766. }
  768. xmlstream& operator<<(const XMLCh* other) {
  769. //
  770. //   get length of string
  771. //
  772. unsigned long len = 0;
  773. for(const XMLCh* source = other; *source; source++,len++);
  775. //
  776. //    append to stream
  777. //
  778. append(other,len);
  779. return *this;
  780. }
  782. xmlstream& operator<<(const DOMString& other) {
  783. append(other.rawBuffer(),other.length());
  784. return *this;
  785. }
  787. xmlstream& operator<<(const XMLCh other) {
  788. append(&other,1);
  789. return *this;
  790. }
  792. BSTR SysAllocString() {
  793. if(m_length > 0)
  794. return SysAllocStringLen(m_buffer,m_length);
  795. return 0;
  796. }
  798. private:
  799. void append(const XMLCh* other,unsigned long length) {
  800. const XMLCh* source = NULL;
  802. if(m_length + length > m_alloc) {
  803. unsigned long chunk = 4096;
  804. if(length > chunk) chunk += length;
  805. XMLCh* newbuf = new XMLCh[m_alloc+ chunk];
  806. m_alloc += chunk;
  807. m_next = newbuf + m_length;
  809. //
  810. //    copy old content into new buffer
  811. //
  812. XMLCh* dest = newbuf;
  813. source = m_buffer;
  814. for(unsigned long i = 0; i < m_length; i++,dest++,source++) {
  815. *dest = *source;
  816. }
  817. delete [] m_buffer;
  818. m_buffer = newbuf;
  819. }
  821. source = other;
  822. for(unsigned long i = 0; i < length; i++,source++,m_next++) {
  823. *m_next = *source;
  824. }
  825. m_length += length;
  826. }
  828. unsigned long m_length;
  829. unsigned long m_alloc;
  830. XMLCh* m_buffer;
  831. XMLCh* m_next;
  832. };
  837. // ---------------------------------------------------------------------------
  838. //  outputContent
  839. //
  840. //  Write document content from a DOMString to a C++ ostream. Escape the
  841. //  XML special characters (<, &, etc.) unless this is suppressed by the
  842. //  command line option.
  843. // ---------------------------------------------------------------------------
  844. void outputContent(xmlstream& target, const DOMString &toWrite)
  845. {
  847.         int            length = toWrite.length();
  848.         const XMLCh*   chars  = toWrite.rawBuffer();
  850.         int index;
  851.         for (index = 0; index < length; index++)
  852.         {
  853.             switch (chars[index])
  854.             {
  855.             case chAmpersand :
  856.                 target << XMLStrL("&amp;");
  857.                 break;
  859.             case chOpenAngle :
  860.                 target << XMLStrL("&lt;");
  861.                 break;
  863.             case chCloseAngle:
  864.                 target << XMLStrL("&gt;");
  865.                 break;
  867.             case chDoubleQuote :
  868.                 target << XMLStrL("&quot;");
  869.                 break;
  871.             default:
  872.                 // If it is none of the special characters, print it as such
  873.                 target << toWrite.substringData(index, 1);
  874.                 break;
  875.             }
  876.         }
  878.     return;
  879. }
  881. xmlstream& operator<<(xmlstream& target, const DOM_Node& toWrite)
  882. {
  883.     // Get the name and value out for convenience
  884.     DOMString   nodeName = toWrite.getNodeName();
  885.     DOMString   nodeValue = toWrite.getNodeValue();
  888. switch (toWrite.getNodeType())
  889.     {
  890. case DOM_Node::TEXT_NODE:
  891.         {
  892.             outputContent(target, nodeValue);
  893.             break;
  894.         }
  896.         case DOM_Node::PROCESSING_INSTRUCTION_NODE :
  897.         {
  898.             target  << XMLStrL("<?")
  899.                     << nodeName
  900.                     << XMLStrL(' ')
  901.                     << nodeValue
  902.                     << XMLStrL("?>");
  903.             break;
  904.         }
  906.         case DOM_Node::DOCUMENT_NODE :
  907.         {
  908.             //
  909.             //  Bug here:  we need to find a way to get the encoding name
  910.             //  for the default code page on the system where the program
  911.             //  is running, and plug that in for the encoding name.
  912.             //
  913.             //target << "<?xml version='1.0' encoding='ISO-8859-1' ?>n";
  914.             DOM_Node child = toWrite.getFirstChild();
  915.             while( child != 0)
  916.             {
  917.                 target << child;
  918.                 child = child.getNextSibling();
  919.             }
  920.             break;
  921.         }
  923.         case DOM_Node::ELEMENT_NODE :
  924.         {
  925.             // Output the element start tag.
  926.             target << XMLStrL('<') << nodeName;
  928.             // Output any attributes on this element
  929.             DOM_NamedNodeMap attributes = toWrite.getAttributes();
  930.             int attrCount = attributes.getLength();
  931.             for (int i = 0; i < attrCount; i++)
  932.             {
  933.                 DOM_Node  attribute = attributes.item(i);
  935.                 target  << XMLStrL(' ') << attribute.getNodeName()
  936.                         << XMLStrL(" = "");
  937.                         //  Note that "<" must be escaped in attribute values.
  938.                         outputContent(target, attribute.getNodeValue());
  939.                         target << XMLStrL('"');
  940.             }
  942.             //
  943.             //  Test for the presence of children, which includes both
  944.             //  text content and nested elements.
  945.             //
  946.             DOM_Node child = toWrite.getFirstChild();
  947.             if (child != 0)
  948.             {
  949.                 // There are children. Close start-tag, and output children.
  950.                 target << XMLStrL(">");
  951.                 while( child != 0)
  952.                 {
  953.                     target << child;
  954.                     child = child.getNextSibling();
  955.                 }
  957.                 // Done with children.  Output the end tag.
  958.                 target << XMLStrL("</") << nodeName << XMLStrL(">");
  959.             }
  960.             else
  961.             {
  962.                 //
  963.                 //  There were no children. Output the short form close of
  964.                 //  the element start tag, making it an empty-element tag.
  965.                 //
  966.                 target << XMLStrL("/>");
  967.             }
  968.             break;
  969.         }
  971.         case DOM_Node::ENTITY_REFERENCE_NODE:
  972.         {
  973.             DOM_Node child;
  974.             for (child = toWrite.getFirstChild(); child != 0; child = child.getNextSibling())
  975.                 target << child;
  976.             break;
  977.         }
  979.         case DOM_Node::CDATA_SECTION_NODE:
  980.         {
  981.             target << XMLStrL("<![CDATA[") << nodeValue << XMLStrL("]]>");
  982.             break;
  983.         }
  985.         case DOM_Node::COMMENT_NODE:
  986.         {
  987.             target << XMLStrL("<!--") << nodeValue << XMLStrL("-->");
  988.             break;
  989.         }
  991.         case DOM_Node::DOCUMENT_TYPE_NODE:
  992.         {
  993. DOM_DocumentType doctype = (DOM_DocumentType &)toWrite;;
  995. target << XMLStrL("<!DOCTYPE ") << nodeName ;
  996. DOMString id = doctype.getPublicId();
  997. if (id != 0)
  998. target << XMLStrL(" PUBLIC "") << id << XMLStrL(""");
  999. id = doctype.getSystemId();
  1000. if (id != 0)
  1001. target << XMLStrL(" SYSTEM "") << id << XMLStrL(""");
  1002. id = doctype.getInternalSubset();
  1003. if (id !=0)
  1004. target << XMLStrL(" [ ") << id  << XMLStrL("]");
  1005. target  << XMLStrL(">");
  1006.             break;
  1007.         }
  1008. case DOM_Node::ENTITY_NODE:
  1009.         {
  1010. target << XMLStrL("<!ENTITY ") << nodeName;
  1011. DOMString id = ((DOM_Entity &)toWrite).getPublicId();
  1012. if (id != 0)
  1013. target << XMLStrL("PUBLIC "") << id << XMLStrL(""");
  1014. id = ((DOM_Entity &)toWrite).getSystemId();
  1015. if (id != 0)
  1016. target << XMLStrL("SYSTEM "") << id << XMLStrL(""");
  1017. id = ((DOM_Entity &)toWrite).getNotationName();
  1018. if (id != 0)
  1019. target << XMLStrL("NDATA "") << id << XMLStrL(""");
  1021.             break;
  1022.         }
  1023.         case DOM_Node::XML_DECL_NODE:
  1024.         {
  1025.             target << XMLStrL("<?xml version=") << ((DOM_XMLDecl &)toWrite).getVersion();
  1026.             DOMString str = ((DOM_XMLDecl &)toWrite).getEncoding();
  1027.             if (str != 0)
  1028.                 target << XMLStrL(" encoding=") << str;
  1029.             str = ((DOM_XMLDecl &)toWrite).getStandalone();
  1030.             if (str != 0)
  1031.                 target << XMLStrL(" standalone=") << str;
  1032.             target << XMLStrL("?>");
  1033.             break;
  1034.         }
  1035.         default:
  1036.             target << XMLStrL("<!-- Unrecognized node type -->");
  1037.     }
  1038. return target;
  1039. }
  1041. void GetXML(const DOM_Node &node, _bstr_t &text)
  1042. {
  1043. xmlstream stream;
  1044. stream << node;
  1045. text.Assign(stream.SysAllocString());
  1046. }