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

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

词法分析

开发平台：

Visual C++

DOMDocumentImpl.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2003 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) 2001, 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: DOMDocumentImpl.cpp,v 1.43 2003/05/23 17:07:41 knoaman Exp $
  59.  */
  60. #include "DOMDocumentImpl.hpp"
  61. #include "DOMCasts.hpp"
  62. #include "DOMConfigurationImpl.hpp"
  63. #include "DOMDocumentTypeImpl.hpp"
  64. #include "DOMAttrImpl.hpp"
  65. #include "DOMAttrNSImpl.hpp"
  66. #include "DOMCDATASectionImpl.hpp"
  67. #include "DOMCommentImpl.hpp"
  68. #include "DOMDeepNodeListImpl.hpp"
  69. #include "DOMDocumentFragmentImpl.hpp"
  70. #include "DOMElementImpl.hpp"
  71. #include "XSDElementNSImpl.hpp"
  72. #include "DOMEntityImpl.hpp"
  73. #include "DOMEntityReferenceImpl.hpp"
  74. #include "DOMNamedNodeMapImpl.hpp"
  75. #include "DOMNormalizer.hpp"
  76. #include "DOMNotationImpl.hpp"
  77. #include "DOMProcessingInstructionImpl.hpp"
  78. #include "DOMTextImpl.hpp"
  79. #include "DOMStringPool.hpp"
  80. #include "DOMTreeWalkerImpl.hpp"
  81. #include "DOMNodeIteratorImpl.hpp"
  82. #include "DOMNodeIDMap.hpp"
  83. #include "DOMRangeImpl.hpp"
  85. #include <xercesc/dom/DOMImplementation.hpp>
  86. #include <xercesc/util/XMLChar.hpp>
  87. #include <xercesc/framework/MemoryManager.hpp>
  90. XERCES_CPP_NAMESPACE_BEGIN
  93. //
  94. //   Constructors.   Warning - be very careful with the ordering of initialization
  95. //                             of the heap.  Ordering depends on the order of declaration
  96. //                             in the .hpp file, not on the order of initializers here
  97. //                             in the constructor.  The heap declaration can not be
  98. //                             first - fNode and fParent must be first for the casting
  99. //                             functions in DOMCasts to work correctly.  This means that
  100. //                             fNode and fParent constructors used here can not
  101. //                             allocate.
  102. //
  103. DOMDocumentImpl::DOMDocumentImpl(MemoryManager* const manager)
  104.     : fNode(this),
  105.       fParent(this),
  106.       fCurrentBlock(0),
  107.       fDOMConfiguration(0),
  108.       fFreePtr(0),
  109.       fFreeBytesRemaining(0),
  110.       fDocType(0),
  111.       fDocElement(0),
  112.       fNamePool(0),
  113.       fNormalizer(0),
  114.       fNodeIDMap(0),
  115.       fRanges(0),
  116.       fNodeIterators(0),
  117.       fChanges(0),
  118.       fNodeListPool(0),
  119.       fActualEncoding(0),
  120.       fEncoding(0),
  121.       fVersion(0),
  122.       fStandalone(false),
  123.       fDocumentURI(0),
  124.       fUserDataTable(0),
  125.       fRecycleNodePtr(0),
  126.       fRecycleBufferPtr(0),
  127.       fMemoryManager(manager),
  128.       errorChecking(true)
  129. {
  130.     fNamePool    = new (this) DOMStringPool(257, this);
  131. };
  134. //DOM Level 2
  135. DOMDocumentImpl::DOMDocumentImpl(const XMLCh *fNamespaceURI,
  136.                                const XMLCh *qualifiedName,
  137.                                DOMDocumentType *doctype,
  138.                                MemoryManager* const manager)
  139.     : fNode(this),
  140.       fParent(this),
  141.       fCurrentBlock(0),
  142.       fDOMConfiguration(0),
  143.       fFreePtr(0),
  144.       fFreeBytesRemaining(0),
  145.       fDocType(0),
  146.       fDocElement(0),
  147.       fNamePool(0),
  148.       fNormalizer(0),
  149.       fNodeIDMap(0),
  150.       fRanges(0),
  151.       fNodeIterators(0),
  152.       fChanges(0),
  153.       fNodeListPool(0),
  154.       fActualEncoding(0),
  155.       fEncoding(0),
  156.       fVersion(0),
  157.       fStandalone(false),
  158.       fDocumentURI(0),
  159.       fUserDataTable(0),
  160.       fRecycleNodePtr(0),
  161.       fRecycleBufferPtr(0),
  162.       fMemoryManager(manager),
  163.       errorChecking(true)
  164. {
  165.     fNamePool    = new (this) DOMStringPool(257, this);
  166.     try {
  167.         setDocumentType(doctype);
  169.         if (qualifiedName)
  170.             appendChild(createElementNS(fNamespaceURI, qualifiedName));  //root element
  171.         else if (fNamespaceURI)
  172.             throw DOMException(DOMException::NAMESPACE_ERR, 0);
  173.     }
  174.     catch (...) {
  175.         this->deleteHeap();
  176.         throw;
  177.     }
  178. }
  180. void DOMDocumentImpl::setDocumentType(DOMDocumentType *doctype)
  181. {
  182.     if (!doctype)
  183.         return;
  185.     // New doctypes can be created either with the factory methods on DOMImplementation, in
  186.     //   which case ownerDocument will be 0, or with methods on DocumentImpl, in which case
  187.     //   ownerDocument will be set, but the DocType won't yet be a child of the document.
  188.     if (doctype->getOwnerDocument() != 0 && doctype->getOwnerDocument() != this)
  189.         throw DOMException(    //one doctype can belong to only one DOMDocumentImpl
  190.         DOMException::WRONG_DOCUMENT_ERR, 0);
  192.     DOMDocumentTypeImpl* doctypeImpl = (DOMDocumentTypeImpl*) doctype;
  193.     doctypeImpl->setOwnerDocument(this);
  195.     // The doctype can not have any Entities or Notations yet, because they can not
  196.     //   be created except through factory methods on a document.
  198.     // revisit.  What if this doctype is already a child of the document?
  199.     appendChild(doctype);
  201. }
  203. DOMDocumentImpl::~DOMDocumentImpl()
  204. {
  205.     //  Clean up the fNodeListPool
  206.     if (fNodeListPool)
  207.         fNodeListPool->cleanup();
  209.     if (fRanges)
  210.         delete fRanges; //fRanges->cleanup();
  212.     if (fNodeIterators)
  213.         delete fNodeIterators;//fNodeIterators->cleanup();
  215.     if (fUserDataTable)
  216.         delete fUserDataTable;//fUserDataTable->cleanup();
  218.     if (fRecycleNodePtr) {
  219.         fRecycleNodePtr->deleteAllElements();
  220.         delete fRecycleNodePtr;
  221.     }
  223.     if (fRecycleBufferPtr) {
  224.         delete fRecycleBufferPtr;
  225.     }
  227.     delete fNormalizer;
  229.     //  Delete the heap for this document.  This uncerimoniously yanks the storage
  230.     //      out from under all of the nodes in the document.  Destructors are NOT called.
  231.     this->deleteHeap();
  232. };
  235. DOMNode *DOMDocumentImpl::cloneNode(bool deep) const {
  237.     // Note:  the cloned document node goes on the system heap.  All other
  238.     //   nodes added to the new document will go on that document's heap,
  239.     //   but we need to construct the document first, before its heap exists.
  240.     DOMDocumentImpl *newdoc = new (fMemoryManager) DOMDocumentImpl(fMemoryManager);
  242.     // then the children by _importing_ them
  243.     if (deep)
  244.         for (DOMNode *n = this->getFirstChild(); n != 0; n = n->getNextSibling()) {
  245.             newdoc->appendChild(newdoc->importNode(n, true, true));
  246.     }
  248.     fNode.callUserDataHandlers(DOMUserDataHandler::NODE_CLONED, this, newdoc);
  249.     return newdoc;
  250. };
  253. const XMLCh * DOMDocumentImpl::getNodeName() const {
  254.     static const XMLCh nam[] =  // "#document"
  255.         {chPound, chLatin_d, chLatin_o, chLatin_c, chLatin_u, chLatin_m, chLatin_e, chLatin_n, chLatin_t, 0};
  256.     return nam;
  257. }
  260. short DOMDocumentImpl::getNodeType() const {
  261.     return DOMNode::DOCUMENT_NODE;
  262. };
  265. // even though ownerDocument refers to this in this implementation
  266. // the DOM Level 2 spec says it must be 0, so make it appear so
  267. DOMDocument * DOMDocumentImpl::getOwnerDocument() const {
  268.     return 0;
  269. }
  272. DOMAttr *DOMDocumentImpl::createAttribute(const XMLCh *nam)
  273. {
  274.     if(!nam || !isXMLName(nam))
  275.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  276.     return new (this, DOMDocumentImpl::ATTR_OBJECT) DOMAttrImpl(this,nam);
  277. };
  281. DOMCDATASection *DOMDocumentImpl::createCDATASection(const XMLCh *data) {
  282.     return new (this, DOMDocumentImpl::CDATA_SECTION_OBJECT) DOMCDATASectionImpl(this,data);
  283. };
  287. DOMComment *DOMDocumentImpl::createComment(const XMLCh *data)
  288. {
  289.     return new (this, DOMDocumentImpl::COMMENT_OBJECT) DOMCommentImpl(this, data);
  290. };
  294. DOMDocumentFragment *DOMDocumentImpl::createDocumentFragment()
  295. {
  296.     return new (this, DOMDocumentImpl::DOCUMENT_FRAGMENT_OBJECT) DOMDocumentFragmentImpl(this);
  297. };
  301. DOMDocumentType *DOMDocumentImpl::createDocumentType(const XMLCh *nam)
  302. {
  303.     if (!nam || !isXMLName(nam))
  304.         throw DOMException(
  305.         DOMException::INVALID_CHARACTER_ERR, 0);
  307.     return new (this, DOMDocumentImpl::DOCUMENT_TYPE_OBJECT) DOMDocumentTypeImpl(this, nam, false);
  308. };
  312. DOMDocumentType *
  313.     DOMDocumentImpl::createDocumentType(const XMLCh *qualifiedName,
  314.                                      const XMLCh *publicId,
  315.                                      const XMLCh *systemId)
  316. {
  317.     if (!qualifiedName || !isXMLName(qualifiedName))
  318.         throw DOMException(
  319.         DOMException::INVALID_CHARACTER_ERR, 0);
  321.     return new (this, DOMDocumentImpl::DOCUMENT_TYPE_OBJECT) DOMDocumentTypeImpl(this, qualifiedName, publicId, systemId, false);
  322. };
  326. DOMElement *DOMDocumentImpl::createElement(const XMLCh *tagName)
  327. {
  328.     if(!tagName || !isXMLName(tagName))
  329.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  331.     return new (this, DOMDocumentImpl::ELEMENT_OBJECT) DOMElementImpl(this,tagName);
  332. };
  335. DOMElement *DOMDocumentImpl::createElementNoCheck(const XMLCh *tagName)
  336. {
  337.     return new (this, DOMDocumentImpl::ELEMENT_OBJECT) DOMElementImpl(this, tagName);
  338. };
  343. DOMEntity *DOMDocumentImpl::createEntity(const XMLCh *nam)
  344. {
  345.     if (!nam || !isXMLName(nam))
  346.         throw DOMException(
  347.         DOMException::INVALID_CHARACTER_ERR, 0);
  349.     return new (this, DOMDocumentImpl::ENTITY_OBJECT) DOMEntityImpl(this, nam);
  350. };
  354. DOMEntityReference *DOMDocumentImpl::createEntityReference(const XMLCh *nam)
  355. {
  356.     if (!nam || !isXMLName(nam))
  357.         throw DOMException(
  358.         DOMException::INVALID_CHARACTER_ERR, 0);
  360.     return new (this, DOMDocumentImpl::ENTITY_REFERENCE_OBJECT) DOMEntityReferenceImpl(this, nam);
  361. };
  363. DOMEntityReference *DOMDocumentImpl::createEntityReferenceByParser(const XMLCh *nam)
  364. {
  365.     if (!nam || !isXMLName(nam))
  366.         throw DOMException(
  367.         DOMException::INVALID_CHARACTER_ERR, 0);
  369.     return new (this, DOMDocumentImpl::ENTITY_REFERENCE_OBJECT) DOMEntityReferenceImpl(this, nam, false);
  370. };
  372. DOMNotation *DOMDocumentImpl::createNotation(const XMLCh *nam)
  373. {
  374.     if (!nam || !isXMLName(nam))
  375.         throw DOMException(
  376.         DOMException::INVALID_CHARACTER_ERR, 0);
  378.     return new (this, DOMDocumentImpl::NOTATION_OBJECT) DOMNotationImpl(this, nam);
  379. };
  383. DOMProcessingInstruction *DOMDocumentImpl::createProcessingInstruction(
  384.                                           const XMLCh *target, const XMLCh *data)
  385. {
  386.     if(!target || !isXMLName(target))
  387.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  388.     return new (this, DOMDocumentImpl::PROCESSING_INSTRUCTION_OBJECT) DOMProcessingInstructionImpl(this,target,data);
  389. };
  394. DOMText *DOMDocumentImpl::createTextNode(const XMLCh *data)
  395. {
  396.     return new (this, DOMDocumentImpl::TEXT_OBJECT) DOMTextImpl(this,data);
  397. };
  400. DOMNodeIterator* DOMDocumentImpl::createNodeIterator (
  401.           DOMNode *root, unsigned long whatToShow, DOMNodeFilter* filter, bool entityReferenceExpansion)
  402. {
  403.     if (!root) {
  404.         throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  405.         return 0;
  406.     }
  408.     DOMNodeIteratorImpl* nodeIterator = new (this) DOMNodeIteratorImpl(this, root, whatToShow, filter, entityReferenceExpansion);
  410.     if (fNodeIterators == 0L) {
  411.         //fNodeIterators = new (this) NodeIterators(1, false);
  412.         fNodeIterators = new (fMemoryManager) NodeIterators(1, false, fMemoryManager);
  413.     }
  414.     fNodeIterators->addElement(nodeIterator);
  416.     return nodeIterator;
  417. }
  420. NodeIterators* DOMDocumentImpl::getNodeIterators() const
  421. {
  422.     return fNodeIterators;
  423. }
  425. void DOMDocumentImpl::removeNodeIterator(DOMNodeIteratorImpl* nodeIterator)
  426. {
  427.     if (fNodeIterators != 0) {
  428.         XMLSize_t sz = fNodeIterators->size();
  429.         if (sz !=0) {
  430.             for (XMLSize_t i =0; i<sz; i++) {
  431.                 if (fNodeIterators->elementAt(i) == nodeIterator) {
  432.                     fNodeIterators->removeElementAt(i);
  433.                     break;
  434.                 }
  435.             }
  436.         }
  437.     }
  438. }
  440. DOMTreeWalker* DOMDocumentImpl::createTreeWalker (DOMNode *root, unsigned long whatToShow, DOMNodeFilter* filter, bool entityReferenceExpansion)
  441. {
  442.     if (!root) {
  443.         throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  444.         return 0;
  445.     }
  447.     return new (this) DOMTreeWalkerImpl(root, whatToShow, filter, entityReferenceExpansion);
  448. }
  453. DOMDocumentType *DOMDocumentImpl::getDoctype() const
  454. {
  455.     return fDocType;
  456. };
  460. DOMElement *DOMDocumentImpl::getDocumentElement() const
  461. {
  462.     return fDocElement;
  463. };
  467. DOMNodeList *DOMDocumentImpl::getElementsByTagName(const XMLCh *tagname) const
  468. {
  469.     // cast off the const of this because we will update the fNodeListPool
  470.     return ((DOMDocumentImpl*)this)->getDeepNodeList(this,tagname);
  471. };
  474. DOMImplementation   *DOMDocumentImpl::getImplementation() const {
  475.     return DOMImplementation::getImplementation();
  476. }
  479. DOMNode *DOMDocumentImpl::insertBefore(DOMNode *newChild, DOMNode *refChild)
  480. {
  481.     // Only one such child permitted
  482.     if(
  483.         (newChild->getNodeType() == DOMNode::ELEMENT_NODE  && fDocElement!=0)
  484.         ||
  485.         (newChild->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE  && fDocType!=0)
  486.         )
  487.         throw DOMException(DOMException::HIERARCHY_REQUEST_ERR,0);
  489.     // if the newChild is a documenttype node created from domimplementation, set the ownerDoc first
  490.     if ((newChild->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE) && !newChild->getOwnerDocument())
  491.         ((DOMDocumentTypeImpl*)newChild)->setOwnerDocument(this);
  493.     fParent.insertBefore(newChild,refChild);
  495.     // If insert succeeded, cache the kid appropriately
  496.     if(newChild->getNodeType() == DOMNode::ELEMENT_NODE)
  497.         fDocElement=(DOMElement *)newChild;
  498.     else if(newChild->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE)
  499.         fDocType=(DOMDocumentType *)newChild;
  501.     return newChild;
  502. };
  505. DOMNode* DOMDocumentImpl::replaceChild(DOMNode *newChild, DOMNode *oldChild) {
  506.     DOMDocumentType* tempDocType = fDocType;
  507.     DOMElement* tempDocElement = fDocElement;
  509.     if(oldChild->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE)
  510.         fDocType=0;
  511.     else if(oldChild->getNodeType() == DOMNode::ELEMENT_NODE)
  512.         fDocElement=0;
  514.     try {
  515.         insertBefore(newChild, oldChild);
  516.         // changed() already done.
  518.         if((oldChild->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE)
  519.         || (oldChild->getNodeType() == DOMNode::ELEMENT_NODE))
  520.             return fParent.removeChild(oldChild);
  521.         else
  522.             return removeChild(oldChild);
  523.     }
  524.     catch(...) {
  525.         fDocType = tempDocType;
  526.         fDocElement = tempDocElement;
  527.         throw;
  528.     }
  529. }
  531. bool DOMDocumentImpl::isXMLName(const XMLCh *s)
  532. {
  533.     if (XMLString::equals(fVersion, XMLUni::fgVersion1_1))
  534.         return XMLChar1_1::isValidName(s, XMLString::stringLen(s));
  535.     else
  536.         return XMLChar1_0::isValidName(s, XMLString::stringLen(s));
  537. };
  542. DOMNode *DOMDocumentImpl::removeChild(DOMNode *oldChild)
  543. {
  544.     fParent.removeChild(oldChild);
  546.     // If remove succeeded, un-cache the kid appropriately
  547.     if(oldChild->getNodeType() == DOMNode::ELEMENT_NODE)
  548.         fDocElement=0;
  549.     else if(oldChild->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE)
  550.         fDocType=0;
  552.     return oldChild;
  553. };
  557. void DOMDocumentImpl::setNodeValue(const XMLCh *x)
  558. {
  559.     fNode.setNodeValue(x);
  560. };
  563. //Introduced in DOM Level 2
  564. DOMNode *DOMDocumentImpl::importNode(DOMNode *source, bool deep)
  565. {
  566.     return importNode(source, deep, false);
  567. }
  570. DOMElement *DOMDocumentImpl::createElementNS(const XMLCh *fNamespaceURI,
  571.     const XMLCh *qualifiedName)
  572. {
  573.     if(!qualifiedName || !isXMLName(qualifiedName))
  574.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  575.     //XMLCh * pooledTagName = this->fNamePool->getPooledString(qualifiedName);
  576.     return new (this, DOMDocumentImpl::ELEMENT_NS_OBJECT) DOMElementNSImpl(this, fNamespaceURI, qualifiedName);
  577. }
  579. DOMElement *DOMDocumentImpl::createElementNS(const XMLCh *fNamespaceURI,
  580.                                               const XMLCh *qualifiedName,
  581.                                               const XMLSSize_t lineNo,
  582.                                               const XMLSSize_t columnNo)
  583. {
  584.     if(!qualifiedName || !isXMLName(qualifiedName))
  585.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  587.     return new (this) XSDElementNSImpl(this, fNamespaceURI, qualifiedName, lineNo, columnNo);
  588. }
  591. DOMAttr *DOMDocumentImpl::createAttributeNS(const XMLCh *fNamespaceURI,
  592.     const XMLCh *qualifiedName)
  593. {
  594.     if(!qualifiedName || !isXMLName(qualifiedName))
  595.         throw DOMException(DOMException::INVALID_CHARACTER_ERR,0);
  596.     return new (this, DOMDocumentImpl::ATTR_NS_OBJECT) DOMAttrNSImpl(this, fNamespaceURI, qualifiedName);
  597. }
  600. DOMNodeList *DOMDocumentImpl::getElementsByTagNameNS(const XMLCh *fNamespaceURI,
  601.     const XMLCh *fLocalName)  const
  602. {
  603.     // cast off the const of this because we will update the fNodeListPool
  604.     return ((DOMDocumentImpl*)this)->getDeepNodeList(this, fNamespaceURI, fLocalName);
  605. }
  608. DOMElement *DOMDocumentImpl::getElementById(const XMLCh *elementId) const
  609. {
  610.     if (fNodeIDMap == 0)
  611.         return 0;
  613.     DOMAttr *theAttr = fNodeIDMap->find(elementId);
  614.     if (theAttr == 0)
  615.         return 0;
  617.     return theAttr->getOwnerElement();
  618. }
  621. //Return the index > 0 of ':' in the given qualified name qName="prefix:localName".
  622. //Return 0 if there is no ':', or -1 if qName is malformed such as ":abcd" or "abcd:".
  623. int DOMDocumentImpl::indexofQualifiedName(const XMLCh * qName)
  624. {
  625.     int qNameLen = XMLString::stringLen(qName);
  626.     int index = -1, count = 0;
  627.     for (int i = 0; i < qNameLen; ++i) {
  628.         if (qName[i] == chColon) {
  629.             index = i;
  630.             ++count;    //number of ':' found
  631.         }
  632.     }
  634.     if (qNameLen == 0 || count > 1 || index == 0 || index == qNameLen-1)
  635.         return -1;
  636.     return count == 0 ? 0 : index;
  637. }
  640. const XMLCh*     DOMDocumentImpl::getBaseURI() const
  641. {
  642.   return fDocumentURI;
  643. };
  646. DOMRange* DOMDocumentImpl::createRange()
  647. {
  649.     DOMRangeImpl* range = new (this) DOMRangeImpl(this);
  651.     if (fRanges == 0L) {
  652.         //fRanges = new (this) Ranges(1, false);
  653.         fRanges = new (fMemoryManager) Ranges(1, false, fMemoryManager); // XMemory
  654.     }
  655.     fRanges->addElement(range);
  656.     return range;
  657. }
  659. Ranges* DOMDocumentImpl::getRanges() const
  660. {
  661.     return fRanges;
  662. }
  664. void DOMDocumentImpl::removeRange(DOMRangeImpl* range)
  665. {
  666.     if (fRanges != 0) {
  667.         XMLSize_t sz = fRanges->size();
  668.         if (sz !=0) {
  669.             for (XMLSize_t i =0; i<sz; i++) {
  670.                 if (fRanges->elementAt(i) == range) {
  671.                     fRanges->removeElementAt(i);
  672.                     break;
  673.                 }
  674.             }
  675.         }
  676.     }
  677. }
  679. /** Uses the kidOK lookup table to check whether the proposed
  680.     tree structure is legal.
  682.     ????? It feels like there must be a more efficient solution,
  683.     but for the life of me I can't think what it would be.
  684. */
  685. bool DOMDocumentImpl::isKidOK(DOMNode *parent, DOMNode *child)
  686. {
  687.       static int kidOK[14];
  689.       if (kidOK[DOMNode::ATTRIBUTE_NODE] == 0)
  690.       {
  691.           kidOK[DOMNode::DOCUMENT_NODE] =
  692.               1 << DOMNode::ELEMENT_NODE |
  693.               1 << DOMNode::PROCESSING_INSTRUCTION_NODE |
  694.               1 << DOMNode::COMMENT_NODE |
  695.               1 << DOMNode::DOCUMENT_TYPE_NODE;
  697.           kidOK[DOMNode::DOCUMENT_FRAGMENT_NODE] =
  698.               kidOK[DOMNode::ENTITY_NODE] =
  699.               kidOK[DOMNode::ENTITY_REFERENCE_NODE] =
  700.               kidOK[DOMNode::ELEMENT_NODE] =
  701.               1 << DOMNode::ELEMENT_NODE |
  702.               1 << DOMNode::PROCESSING_INSTRUCTION_NODE |
  703.               1 << DOMNode::COMMENT_NODE |
  704.               1 << DOMNode::TEXT_NODE |
  705.               1 << DOMNode::CDATA_SECTION_NODE |
  706.               1 << DOMNode::ENTITY_REFERENCE_NODE;
  708.           kidOK[DOMNode::ATTRIBUTE_NODE] =
  709.               1 << DOMNode::TEXT_NODE |
  710.               1 << DOMNode::ENTITY_REFERENCE_NODE;
  712.           kidOK[DOMNode::PROCESSING_INSTRUCTION_NODE] =
  713.               kidOK[DOMNode::COMMENT_NODE] =
  714.               kidOK[DOMNode::TEXT_NODE] =
  715.               kidOK[DOMNode::CDATA_SECTION_NODE] =
  716.               kidOK[DOMNode::NOTATION_NODE] =
  717.               0;
  718.       };
  719.       int p=parent->getNodeType();
  720.       int ch = child->getNodeType();
  721.       return (kidOK[p] & 1<<ch) != 0;
  722. }
  724. void            DOMDocumentImpl::changed()
  725. {
  726.     fChanges++;
  727. }
  730. int             DOMDocumentImpl::changes() const{
  731.     return fChanges;
  732. };
  736. //
  737. //    Delegation for functions inherited from DOMNode
  738. //
  739.            DOMNode*         DOMDocumentImpl::appendChild(DOMNode *newChild)          {return insertBefore(newChild, 0); };
  740.            DOMNamedNodeMap* DOMDocumentImpl::getAttributes() const                   {return fNode.getAttributes (); };
  741.            DOMNodeList*     DOMDocumentImpl::getChildNodes() const                   {return fParent.getChildNodes (); };
  742.            DOMNode*         DOMDocumentImpl::getFirstChild() const                   {return fParent.getFirstChild (); };
  743.            DOMNode*         DOMDocumentImpl::getLastChild() const                    {return fParent.getLastChild (); };
  744.      const XMLCh*           DOMDocumentImpl::getLocalName() const                    {return fNode.getLocalName (); };
  745.      const XMLCh*           DOMDocumentImpl::getNamespaceURI() const                 {return fNode.getNamespaceURI (); };
  746.            DOMNode*         DOMDocumentImpl::getNextSibling() const                  {return fNode.getNextSibling (); };
  747.      const XMLCh*           DOMDocumentImpl::getNodeValue() const                    {return fNode.getNodeValue (); };
  748.      const XMLCh*           DOMDocumentImpl::getPrefix() const                       {return fNode.getPrefix (); };
  749.            DOMNode*         DOMDocumentImpl::getParentNode() const                   {return fNode.getParentNode (); };
  750.            DOMNode*         DOMDocumentImpl::getPreviousSibling() const              {return fNode.getPreviousSibling (); };
  751.            bool             DOMDocumentImpl::hasChildNodes() const                   {return fParent.hasChildNodes (); };
  752.            void             DOMDocumentImpl::normalize()                             {fParent.normalize (); };
  753.            bool             DOMDocumentImpl::isSupported(const XMLCh *feature, const XMLCh *version) const
  754.                                                                                      {return fNode.isSupported (feature, version); };
  755.            void             DOMDocumentImpl::setPrefix(const XMLCh  *prefix)         {fNode.setPrefix(prefix); };
  756.            bool             DOMDocumentImpl::hasAttributes() const                   {return fNode.hasAttributes(); };
  757.            bool             DOMDocumentImpl::isSameNode(const DOMNode* other) const  {return fNode.isSameNode(other);};
  758.            bool             DOMDocumentImpl::isEqualNode(const DOMNode* arg) const   {return fParent.isEqualNode(arg);};
  759.            void*            DOMDocumentImpl::setUserData(const XMLCh* key, void* data, DOMUserDataHandler* handler)
  760.                                                                                      {return fNode.setUserData(key, data, handler); };
  761.            void*            DOMDocumentImpl::getUserData(const XMLCh* key) const     {return fNode.getUserData(key); };
  762.            short            DOMDocumentImpl::compareTreePosition(const DOMNode* other) const {return fNode.compareTreePosition(other); };
  763.            const XMLCh*     DOMDocumentImpl::getTextContent() const                  {return fNode.getTextContent(); };
  764.            void             DOMDocumentImpl::setTextContent(const XMLCh* textContent){fNode.setTextContent(textContent); };
  765.            const XMLCh*     DOMDocumentImpl::lookupNamespacePrefix(const XMLCh* namespaceURI, bool useDefault) const  {return fNode.lookupNamespacePrefix(namespaceURI, useDefault); };
  766.            bool             DOMDocumentImpl::isDefaultNamespace(const XMLCh* namespaceURI) const {return fNode.isDefaultNamespace(namespaceURI); };
  767.            const XMLCh*     DOMDocumentImpl::lookupNamespaceURI(const XMLCh* prefix) const  {return fNode.lookupNamespaceURI(prefix); };
  768.            DOMNode*         DOMDocumentImpl::getInterface(const XMLCh* feature)      {return fNode.getInterface(feature); };
  773. //-----------------------------------------------------------------------
  774. //
  775. //  Per Document Heap and Heap Helper functions
  776. //
  777. //        revisit - this stuff should be a class of its own, rather than
  778. //                       just lying around naked in DocumentImpl.
  779. //
  780. //-----------------------------------------------------------------------
  782. XMLCh * DOMDocumentImpl::cloneString(const XMLCh *src)
  783. {
  784.     if (!src) return 0;
  785.     size_t   len = XMLString::stringLen(src);
  786.     len = (len + 1) * sizeof(XMLCh);
  787.     len = (len % 4) + len;
  788.     XMLCh *newStr = (XMLCh *)this->allocate(len);
  789.     XMLString::copyString(newStr, src);
  790.     return newStr;
  791. }
  794. const XMLCh *  DOMDocumentImpl::getPooledString(const XMLCh *src)
  795. {
  796.     if (!src) return 0;
  797.     else return this->fNamePool->getPooledString(src);
  798. }
  800. static const int kHeapAllocSize = 0x10000;    // The chunk size to allocate from the
  801.                                               //   system allocator.
  803. static const int kMaxSubAllocationSize = 4096;   // Any request for more bytes
  804.                                                  //  than this will be handled by
  805.                                                  //  allocating directly with system.
  807. void *         DOMDocumentImpl::allocate(size_t amount)
  808. {
  809. // Align the request size so that suballocated blocks
  810. // beyond this one will be maintained at the same alignment.
  811. amount = XMLPlatformUtils::alignPointerForNewBlockAllocation(amount);
  813.     // If the request is for a largish block, hand it off to the system
  814.     //   allocator.  The block still must be linked into the list of
  815.     //   allocated blocks so that it will be deleted when the time comes.
  816.     if (amount > kMaxSubAllocationSize)
  817.     {
  818. // The size of the header we add to our raw blocks
  819. size_t sizeOfHeader = XMLPlatformUtils::alignPointerForNewBlockAllocation(sizeof(void *));
  821. // Try to allocate the block
  822.         void* newBlock = 0;
  823.         try {
  824.             newBlock = fMemoryManager->allocate((sizeOfHeader + amount) * sizeof(char)); //new char[amount + sizeOfHeader];
  825.         }
  826.         catch (...) {
  827.             ThrowXML(RuntimeException, XMLExcepts::Out_Of_Memory);
  828.         }
  829.         if (!newBlock)
  830.            ThrowXML(RuntimeException, XMLExcepts::Out_Of_Memory);
  832. // Link it into the list beyond current block, as current block
  833. // is still being subdivided. If there is no current block
  834. // then track that we have no bytes to further divide.
  835.         if (fCurrentBlock)
  836.         {
  837.             *(void **)newBlock = *(void **)fCurrentBlock;
  838.             *(void **)fCurrentBlock = newBlock;
  839.         }
  840.         else
  841.         {
  842.             fCurrentBlock = newBlock;
  843.             fFreePtr = 0;
  844.             fFreeBytesRemaining = 0;
  845.         }
  847.         void *retPtr = (char *)newBlock + sizeOfHeader;
  848.         return retPtr;
  849.     }
  851.     // It's a normal (sub-allocatable) request.
  852. // Are we out of room in our current block?
  853. if (amount > fFreeBytesRemaining)
  854.     {
  855.         // Request doesn't fit in the current block.
  857. // The size of the header we add to our raw blocks
  858. size_t sizeOfHeader = XMLPlatformUtils::alignPointerForNewBlockAllocation(sizeof(void *));
  860.         // Get a new block from the system allocator.
  861.         void* newBlock = 0;
  862.         try {
  863.             newBlock = fMemoryManager->allocate(kHeapAllocSize * sizeof(char)); //new char[kHeapAllocSize];
  864.         }
  865.         catch (...) {
  866.             ThrowXML(RuntimeException, XMLExcepts::Out_Of_Memory);
  867.         }
  868.         if (!newBlock)
  869.            ThrowXML(RuntimeException, XMLExcepts::Out_Of_Memory);
  871.         *(void **)newBlock = fCurrentBlock;
  872.         fCurrentBlock = newBlock;
  873.         fFreePtr = (char *)newBlock + sizeOfHeader;
  874.         fFreeBytesRemaining = kHeapAllocSize - sizeOfHeader;
  875.     }
  877. // Subdivide the request off current block
  878.     void *retPtr = fFreePtr;
  879.     fFreePtr += amount;
  880.     fFreeBytesRemaining -= amount;
  882.     return retPtr;
  883. }
  886. void    DOMDocumentImpl::deleteHeap()
  887. {
  888.     while (fCurrentBlock != 0)
  889.     {
  890.         void *nextBlock = *(void **)fCurrentBlock;
  891.         fMemoryManager->deallocate(fCurrentBlock); //delete [] (char*) fCurrentBlock;
  892.         fCurrentBlock = nextBlock;
  893.     }
  894. }
  897. DOMNodeList *DOMDocumentImpl::getDeepNodeList(const DOMNode *rootNode, const XMLCh *tagName)
  898. {
  899.     if(!fNodeListPool) {
  900.         fNodeListPool = new (this) DOMDeepNodeListPool<DOMDeepNodeListImpl>(109, false);
  901.     }
  903.     DOMDeepNodeListImpl* retList = fNodeListPool->getByKey(rootNode, tagName, 0);
  904.     if (!retList) {
  905.         int id = fNodeListPool->put((void*) rootNode, (XMLCh*) tagName, 0, new (this) DOMDeepNodeListImpl(rootNode, tagName));
  906.         retList = fNodeListPool->getById(id);
  907.     }
  909.     return retList;
  910. }
  913. DOMNodeList *DOMDocumentImpl::getDeepNodeList(const DOMNode *rootNode,     //DOM Level 2
  914.                                                    const XMLCh *namespaceURI,
  915.                                                    const XMLCh *localName)
  916. {
  917.     if(!fNodeListPool) {
  918.         fNodeListPool = new (this) DOMDeepNodeListPool<DOMDeepNodeListImpl>(109, false);
  919.     }
  921.     DOMDeepNodeListImpl* retList = fNodeListPool->getByKey(rootNode, localName, namespaceURI);
  922.     if (!retList) {
  923.         // the pool will adopt the DOMDeepNodeListImpl
  924.         int id = fNodeListPool->put((void*) rootNode, (XMLCh*) localName, (XMLCh*) namespaceURI, new (this) DOMDeepNodeListImpl(rootNode, namespaceURI, localName));
  925.         retList = fNodeListPool->getById(id);
  926.     }
  928.     return retList;
  929. }
  932. //Introduced in DOM Level 3
  933. const XMLCh* DOMDocumentImpl::getActualEncoding() const {
  934.     return fActualEncoding;
  935. }
  937. void DOMDocumentImpl::setActualEncoding(const XMLCh* actualEncoding){
  938.     fActualEncoding = cloneString(actualEncoding);
  939. }
  941. const XMLCh* DOMDocumentImpl::getEncoding() const {
  942.     return fEncoding;
  943. }
  945. void DOMDocumentImpl::setEncoding(const XMLCh* encoding){
  946.     fEncoding = cloneString(encoding);
  947. }
  949. bool DOMDocumentImpl::getStandalone() const{
  950.     return fStandalone;
  951. }
  953. void DOMDocumentImpl::setStandalone(bool standalone){
  954.     fStandalone = standalone;
  955. }
  957. const XMLCh* DOMDocumentImpl::getVersion() const {
  958.     return fVersion;
  959. }
  961. void DOMDocumentImpl::setVersion(const XMLCh* version){
  962.     if ((version && *version) &&
  963.         !XMLString::equals(version, XMLUni::fgVersion1_0) &&
  964.         !XMLString::equals(version, XMLUni::fgVersion1_1))
  965.         throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  967.     fVersion = cloneString(version);
  968. }
  970. const XMLCh* DOMDocumentImpl::getDocumentURI() const
  971. {
  972.     return fDocumentURI;
  973. }
  975. void DOMDocumentImpl::setDocumentURI(const XMLCh* documentURI){
  976.     if (documentURI && *documentURI) {
  977.         XMLCh* temp = (XMLCh*) this->allocate((XMLString::stringLen(documentURI) + 9)*sizeof(XMLCh));
  978.         XMLString::fixURI(documentURI, temp);
  979.         fDocumentURI = temp;
  980.     }
  981.     else
  982.         fDocumentURI = 0;
  983. }
  985. bool DOMDocumentImpl::getStrictErrorChecking() const {
  986.     return getErrorChecking();
  987. }
  989. void DOMDocumentImpl::setStrictErrorChecking(bool strictErrorChecking) {
  990.     setErrorChecking(strictErrorChecking);
  991. }
  993. DOMNode* DOMDocumentImpl::adoptNode(DOMNode* source) {
  994.     throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  995.     return 0;
  996. }
  998. void DOMDocumentImpl::normalizeDocument() {
  1000.     if(!fNormalizer) 
  1001.         fNormalizer = new (fMemoryManager) DOMNormalizer(fMemoryManager);
  1003.     fNormalizer->normalizeDocument(this);
  1004. }
  1006. DOMConfiguration* DOMDocumentImpl::getDOMConfiguration() const {
  1007.     if(!fDOMConfiguration)
  1008.         ((DOMDocumentImpl*)this)->fDOMConfiguration = new ((DOMDocumentImpl*)this) DOMConfigurationImpl();
  1010.     return fDOMConfiguration;
  1011. }
  1013. void DOMDocumentImpl::setDOMConfiguration(DOMConfiguration *config) {
  1014.     fDOMConfiguration = config;
  1015. }
  1017. DOMNode *DOMDocumentImpl::importNode(DOMNode *source, bool deep, bool cloningDoc)
  1018. {
  1019.     DOMNode *newnode=0;
  1020.     bool oldErrorCheckingFlag = errorChecking;
  1022.     switch (source->getNodeType())
  1023.     {
  1024.     case DOMNode::ELEMENT_NODE :
  1025.         {
  1026.             DOMElement *newelement;
  1027.             if (source->getLocalName() == 0)
  1028.                 newelement = createElement(source->getNodeName());
  1029.             else
  1030.                 newelement = createElementNS(source->getNamespaceURI(),
  1032.             source->getNodeName());
  1033.             DOMNamedNodeMap *srcattr=source->getAttributes();
  1034.             if(srcattr!=0)
  1035.                 for(XMLSize_t i=0;i<srcattr->getLength();++i)
  1036.                 {
  1037.                     DOMAttr *attr = (DOMAttr *) srcattr->item(i);
  1038.                     if (attr -> getSpecified()) { // not a default attribute
  1039.                         DOMAttr *nattr = (DOMAttr *) importNode(attr, true, false);
  1040.                         if (attr -> getLocalName() == 0)
  1041.                             newelement->setAttributeNode(nattr);
  1042.                         else
  1043.                             newelement->setAttributeNodeNS(nattr);
  1045.                         // if the imported attribute is of ID type, register the new node in fNodeIDMap
  1046.                         if (castToNodeImpl(attr)->isIdAttr()) {
  1047.                             castToNodeImpl(nattr)->isIdAttr(true);
  1048.                             if (!fNodeIDMap)
  1049.                                  fNodeIDMap = new (this) DOMNodeIDMap(500, this);
  1050.                             fNodeIDMap->add((DOMAttr*)nattr);
  1051.                         }
  1052.                     }
  1053.                 }
  1054.             newnode=newelement;
  1056.         }
  1057.         break;
  1058.     case DOMNode::ATTRIBUTE_NODE :
  1059.         if (source->getLocalName() == 0)
  1060.             newnode = createAttribute(source->getNodeName());
  1061.         else
  1062.             newnode = createAttributeNS(source->getNamespaceURI(),
  1063.             source->getNodeName());
  1064.         deep = true;
  1065.         // Kids carry value
  1067.         break;
  1068.     case DOMNode::TEXT_NODE :
  1069.         newnode = createTextNode(source->getNodeValue());
  1070.         break;
  1071.     case DOMNode::CDATA_SECTION_NODE :
  1072.         newnode = createCDATASection(source->getNodeValue());
  1073.         break;
  1074.     case DOMNode::ENTITY_REFERENCE_NODE :
  1075.         {
  1076.             DOMEntityReferenceImpl* newentityRef = (DOMEntityReferenceImpl*)createEntityReference(source->getNodeName());
  1077.             newnode=newentityRef;
  1078.             errorChecking = false;
  1079.             newentityRef->setReadOnly(false, true); //allow deep import temporarily
  1080.         }
  1081.         break;
  1082.     case DOMNode::ENTITY_NODE :
  1083.         {
  1084.             DOMEntity *srcentity=(DOMEntity *)source;
  1085.             DOMEntityImpl *newentity = (DOMEntityImpl *)createEntity(source->getNodeName());
  1086.             newentity->setPublicId(srcentity->getPublicId());
  1087.             newentity->setSystemId(srcentity->getSystemId());
  1088.             newentity->setNotationName(srcentity->getNotationName());
  1089.             // Kids carry additional value
  1090.             newnode=newentity;
  1091.             castToNodeImpl(newentity)->setReadOnly(false, true);// allow deep import temporarily
  1092.         }
  1093.         break;
  1094.     case DOMNode::PROCESSING_INSTRUCTION_NODE :
  1095.         newnode = createProcessingInstruction(source->getNodeName(),
  1096.             source->getNodeValue());
  1097.         break;
  1098.     case DOMNode::COMMENT_NODE :
  1099.         newnode = createComment(source->getNodeValue());
  1100.         break;
  1101.     case DOMNode::DOCUMENT_TYPE_NODE :
  1102.         {
  1103.             // unless this is used as part of cloning a Document
  1104.             // forbid it for the sake of being compliant to the DOM spec
  1105.             if (!cloningDoc)
  1106.                 throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  1108.             DOMDocumentType *srcdoctype = (DOMDocumentType *)source;
  1109.             DOMDocumentType *newdoctype = (DOMDocumentType *)
  1110.                 createDocumentType(srcdoctype->getNodeName(),
  1111.                 srcdoctype->getPublicId(),
  1112.                 srcdoctype->getSystemId());
  1113.             // Values are on NamedNodeMaps
  1114.             DOMNamedNodeMap *smap = srcdoctype->getEntities();
  1115.             DOMNamedNodeMap *tmap = newdoctype->getEntities();
  1116.             if(smap != 0) {
  1117.                 for(XMLSize_t i = 0; i < smap->getLength(); i++) {
  1118.                     tmap->setNamedItem(importNode(smap->item(i), true, false));
  1119.                 }
  1120.             }
  1121.             smap = srcdoctype->getNotations();
  1122.             tmap = newdoctype->getNotations();
  1123.             if (smap != 0) {
  1124.                 for(XMLSize_t i = 0; i < smap->getLength(); i++) {
  1125.                     tmap->setNamedItem(importNode(smap->item(i), true, false));
  1126.                 }
  1127.             }
  1128.             // NOTE: At this time, the DOM definition of DocumentType
  1129.             // doesn't cover Elements and their Attributes. domimpl's
  1130.             // extentions in that area will not be preserved, even if
  1131.             // copying from domimpl to domimpl. We could special-case
  1132.             // that here. Arguably we should. Consider. ?????
  1133.             newnode = newdoctype;
  1134.         }
  1135.         break;
  1136.     case DOMNode::DOCUMENT_FRAGMENT_NODE :
  1137.         newnode = createDocumentFragment();
  1138.         // No name, kids carry value
  1139.         break;
  1140.     case DOMNode::NOTATION_NODE :
  1141.         {
  1142.             DOMNotation *srcnotation=(DOMNotation *)source;
  1143.             DOMNotationImpl *newnotation = (DOMNotationImpl *)createNotation(source->getNodeName());
  1144.             newnotation->setPublicId(srcnotation->getPublicId());
  1145.             newnotation->setSystemId(srcnotation->getSystemId());
  1146.             // Kids carry additional value
  1147.             newnode=newnotation;
  1148.             // No name, no value
  1149.             break;
  1150.         }
  1152.     case DOMNode::DOCUMENT_NODE : // Document can't be child of Document
  1153.     default:                       // Unknown node type
  1154.         throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  1155.     }
  1157.     // If deep, replicate and attach the kids.
  1158.     if (deep)
  1159.         for (DOMNode *srckid = source->getFirstChild();
  1160.              srckid != 0;
  1161.              srckid = srckid->getNextSibling())
  1162.         {
  1163.             newnode->appendChild(importNode(srckid, true, false));
  1164.         }
  1166.     if (newnode->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE
  1167.         || newnode->getNodeType() == DOMNode::ENTITY_NODE) {
  1168.         castToNodeImpl(newnode)->setReadOnly(true, true);
  1169.         errorChecking = oldErrorCheckingFlag;
  1170.     }
  1172.     if (!cloningDoc)
  1173.         fNode.callUserDataHandlers(DOMUserDataHandler::NODE_IMPORTED, source, newnode);
  1175.     return newnode;
  1176. }
  1178. // user data utility
  1179. void* DOMDocumentImpl::setUserData(DOMNodeImpl* n, const XMLCh* key, void* data, DOMUserDataHandler* handler)
  1180. {
  1181.     void* oldData = 0;
  1182.     DOMNodeUserDataTable* node_userDataTable = 0;
  1184.     if (!fUserDataTable) {
  1185.         // create the table on heap so that it can be cleaned in destructor
  1186.         //fUserDataTable = new (this) RefHashTableOf<DOMNodeUserDataTable>(29, true, new HashPtr());
  1187.         fUserDataTable = new (fMemoryManager) RefHashTableOf<DOMNodeUserDataTable>
  1188.         (
  1189.             29
  1190.             , true
  1191.             , new (fMemoryManager) HashPtr()
  1192.             , fMemoryManager
  1193.         );
  1194.     }
  1195.     else {
  1196.         node_userDataTable = fUserDataTable->get((void*)n);
  1197.         DOMUserDataRecord* oldDataRecord = 0;
  1199.         if (node_userDataTable) {
  1200.             oldDataRecord = node_userDataTable->get((void*)key);
  1202.             if (oldDataRecord) {
  1203.                 oldData = oldDataRecord->getKey();
  1204.                 node_userDataTable->removeKey((void*)key);
  1205.             }
  1206.         }
  1207.     }
  1209.     if (data) {
  1211.         // create the DOMNodeUserDataTable if not exists
  1212.         // create on the heap and adopted by the hashtable which will delete it upon removal.
  1213.         if (!node_userDataTable) {
  1214.             node_userDataTable  = new (fMemoryManager) RefHashTableOf<DOMUserDataRecord>(29, true, fMemoryManager);
  1215.             fUserDataTable->put(n, node_userDataTable);
  1216.         }
  1218.         // clone the key first, and create the DOMUserDataRecord
  1219.         // create on the heap and adopted by the hashtable which will delete it upon removal.
  1220.         node_userDataTable->put((void*)getPooledString(key), new (fMemoryManager) DOMUserDataRecord(data, handler));
  1221.     }
  1222.     else {
  1223.         if (node_userDataTable->isEmpty())
  1224.             n->hasUserData(false);
  1225.     }
  1227.     return oldData;
  1228. }
  1230. void* DOMDocumentImpl::getUserData(const DOMNodeImpl* n, const XMLCh* key) const
  1231. {
  1232.     if (fUserDataTable) {
  1233.         DOMNodeUserDataTable*  node_userDataTable = fUserDataTable->get((void*)n);
  1235.         if (node_userDataTable) {
  1236.             DOMUserDataRecord* dataRecord = node_userDataTable->get((void*)key);
  1237.             if (dataRecord)
  1238.                 return dataRecord->getKey();
  1239.         }
  1240.     }
  1242.     return 0;
  1243. }
  1245. void DOMDocumentImpl::callUserDataHandlers(const DOMNodeImpl* n, DOMUserDataHandler::DOMOperationType operation, const DOMNode* src, const DOMNode* dst) const
  1246. {
  1247.     if (fUserDataTable) {
  1248.         DOMNodeUserDataTable*  node_userDataTable = fUserDataTable->get((void*)n);
  1250.         if (node_userDataTable) {
  1251.             RefHashTableOfEnumerator<DOMUserDataRecord> userDataEnum(node_userDataTable);
  1253.             // walk through the entire node_userDataTable table
  1254.             while (userDataEnum.hasMoreElements()) {
  1255.                 // get the key
  1256.                 XMLCh* key = (XMLCh*) userDataEnum.nextElementKey();
  1258.                 // get the DOMUserDataRecord
  1259.                 DOMUserDataRecord* userDataRecord = node_userDataTable->get((void*)key);
  1261.                 // get the handler
  1262.                 DOMUserDataHandler* handler = userDataRecord->getValue();
  1264.                 if (handler) {
  1265.                     // get the data
  1266.                     void* data = userDataRecord->getKey();
  1267.                     handler->handle(operation, key, data, src, dst);
  1268.                 }
  1270.                 // if the operation is deleted, we in fact should remove the data from the table
  1271.                 if (operation == DOMUserDataHandler::NODE_DELETED)
  1272.                     node_userDataTable->removeKey((void*)key);
  1273.             }
  1274.         }
  1275.     }
  1276. }
  1279. void DOMDocumentImpl::transferUserData(DOMNodeImpl* n1, DOMNodeImpl* n2)
  1280. {
  1281.     if (fUserDataTable) {
  1282.         fUserDataTable->transferElement((void*)n1, (void*)n2);
  1283.         n1->hasUserData(false);
  1284.         n2->hasUserData(true);
  1285.     }
  1286. }
  1289. DOMNode* DOMDocumentImpl::renameNode(DOMNode* n, const XMLCh* namespaceURI, const XMLCh* name)
  1290. {
  1291.     if (n->getOwnerDocument() != this)
  1292.         if (n->getNodeType() == DOCUMENT_NODE)
  1293.             throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  1294.         else
  1295.             throw DOMException(DOMException::WRONG_DOCUMENT_ERR, 0);
  1297.     switch (n->getNodeType()) {
  1298.         case ELEMENT_NODE:
  1299.             return ((DOMElementImpl*)n)->rename(namespaceURI, name);
  1300.         case ATTRIBUTE_NODE:
  1301.             return ((DOMAttrImpl*)n)->rename(namespaceURI, name);
  1302.         default:
  1303.             throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  1304.     }
  1306.     return 0;
  1307. }
  1309. void DOMDocumentImpl::release()
  1310. {
  1311.     DOMDocument* doc = (DOMDocument*) this;
  1312.     fNode.callUserDataHandlers(DOMUserDataHandler::NODE_DELETED, 0, 0);
  1314.     // notify userdatahandler first
  1315.     releaseDocNotifyUserData(this);
  1317.     // release the docType in case it was created from heap
  1318.     if (fDocType) {
  1319.         castToNodeImpl(fDocType)->isToBeReleased(true);
  1320.         fDocType->release();
  1321.     }
  1323.     // delete the document memory pool
  1324.     delete doc;
  1325. };
  1327. void DOMDocumentImpl::releaseDocNotifyUserData(DOMNode* object)
  1328. {
  1329.     DOMNode *child = object->getFirstChild();
  1330.     if (child != 0)
  1331.     {
  1332.         while( child != 0)
  1333.         {
  1334.             releaseDocNotifyUserData(child);
  1335.             child = child->getNextSibling();
  1336.         }
  1337.     }
  1338.     else
  1339.         castToNodeImpl(object)->callUserDataHandlers(DOMUserDataHandler::NODE_DELETED, 0, 0);
  1340. }
  1342. void DOMDocumentImpl::release(DOMNode* object, NodeObjectType type)
  1343. {
  1344.     if (!fRecycleNodePtr)
  1345.         fRecycleNodePtr = new (fMemoryManager) RefArrayOf<DOMNodePtr> (15, fMemoryManager);
  1347.     if (!fRecycleNodePtr->operator[](type))
  1348.         fRecycleNodePtr->operator[](type) = new (fMemoryManager) RefStackOf<DOMNode> (15, false, fMemoryManager);
  1350.     fRecycleNodePtr->operator[](type)->push(object);
  1351. }
  1353. void DOMDocumentImpl::releaseBuffer(DOMBuffer* buffer)
  1354. {
  1355.     if (!fRecycleBufferPtr)
  1356.         fRecycleBufferPtr = new (fMemoryManager) RefStackOf<DOMBuffer> (15, false, fMemoryManager);
  1358.     fRecycleBufferPtr->push(buffer);
  1359. }
  1361. DOMBuffer* DOMDocumentImpl::popBuffer()
  1362. {
  1363.     if (!fRecycleBufferPtr || fRecycleBufferPtr->empty())
  1364.         return 0;
  1366.     return fRecycleBufferPtr->pop();
  1367. }
  1370. void * DOMDocumentImpl::allocate(size_t amount, NodeObjectType type)
  1371. {
  1372.     if (!fRecycleNodePtr)
  1373.         return allocate(amount);
  1375.     DOMNodePtr* ptr = fRecycleNodePtr->operator[](type);
  1376.     if (!ptr || ptr->empty())
  1377.         return allocate(amount);
  1379.     return (void*) ptr->pop();
  1381. }
  1383. XERCES_CPP_NAMESPACE_END