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

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

词法分析

开发平台：

Visual C++

AbstractDOMParser.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2002,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. *  This file contains code to build the DOM tree. It registers a document
  59. *  handler with the scanner. In these handler methods, appropriate DOM nodes
  60. *  are created and added to the DOM tree.
  61. *
  62. * $Id: AbstractDOMParser.cpp,v 1.44 2003/05/21 21:18:14 peiyongz Exp $
  63. *
  64. */
  68. // ---------------------------------------------------------------------------
  69. //  Includes
  70. // ---------------------------------------------------------------------------
  71. #include <xercesc/parsers/AbstractDOMParser.hpp>
  72. #include <xercesc/internal/XMLScannerResolver.hpp>
  73. #include <xercesc/internal/ElemStack.hpp>
  74. #include <xercesc/sax/EntityResolver.hpp>
  75. #include <xercesc/util/XMLUniDefs.hpp>
  76. #include <xercesc/framework/XMLNotationDecl.hpp>
  77. #include <xercesc/framework/XMLValidator.hpp>
  78. #include <xercesc/util/IOException.hpp>
  79. #include <xercesc/dom/DOMImplementation.hpp>
  80. #include <xercesc/dom/DOMElement.hpp>
  81. #include <xercesc/dom/impl/DOMAttrImpl.hpp>
  82. #include <xercesc/dom/DOMCDATASection.hpp>
  83. #include <xercesc/dom/DOMComment.hpp>
  84. #include <xercesc/dom/impl/DOMTextImpl.hpp>
  85. #include <xercesc/dom/impl/DOMDocumentImpl.hpp>
  86. #include <xercesc/dom/impl/DOMDocumentTypeImpl.hpp>
  87. #include <xercesc/dom/DOMDocumentType.hpp>
  88. #include <xercesc/dom/impl/DOMElementImpl.hpp>
  89. #include <xercesc/dom/impl/DOMEntityImpl.hpp>
  90. #include <xercesc/dom/impl/DOMEntityReferenceImpl.hpp>
  91. #include <xercesc/dom/impl/DOMNotationImpl.hpp>
  92. #include <xercesc/dom/DOMNamedNodeMap.hpp>
  93. #include <xercesc/dom/DOMProcessingInstruction.hpp>
  94. #include <xercesc/dom/impl/DOMProcessingInstructionImpl.hpp>
  95. #include <xercesc/dom/impl/DOMNodeIDMap.hpp>
  96. #include <xercesc/validators/common/ContentSpecNode.hpp>
  97. #include <xercesc/validators/common/GrammarResolver.hpp>
  98. #include <xercesc/validators/schema/SchemaSymbols.hpp>
  99. XERCES_CPP_NAMESPACE_BEGIN
  102. // ---------------------------------------------------------------------------
  103. //  AbstractDOMParser: Constructors and Destructor
  104. // ---------------------------------------------------------------------------
  105. AbstractDOMParser::AbstractDOMParser( XMLValidator* const valToAdopt
  106.                                     , MemoryManager* const manager) :
  108.   fCreateEntityReferenceNodes(true)
  109. , fIncludeIgnorableWhitespace(true)
  110. , fWithinElement(false)
  111. , fParseInProgress(false)
  112. , fCreateCommentNodes(true)
  113. , fDocumentAdoptedByUser(false)
  114. , fScanner(0)
  115. , fCurrentParent(0)
  116. , fCurrentNode(0)
  117. , fCurrentEntity(0)
  118. , fDocument(0)
  119. , fNodeStack(0)
  120. , fDocumentType(0)
  121. , fDocumentVector(0)
  122. , fGrammarResolver(0)
  123. , fURIStringPool(0)
  124. , fValidator(valToAdopt)
  125. , fMemoryManager(manager)
  126. , fBufMgr(manager)
  127. , fInternalSubset(fBufMgr.bidOnBuffer())
  128. {
  129.     try
  130.     {
  131.         initialize();
  132.     }
  133.     catch(...)
  134.     {
  135.        cleanUp();
  136.        throw;
  137.     }
  138. }
  141. AbstractDOMParser::~AbstractDOMParser()
  142. {
  143.     cleanUp();
  144. }
  146. // ---------------------------------------------------------------------------
  147. //  AbstractDOMParser: Initialize/CleanUp methods
  148. // ---------------------------------------------------------------------------
  149. void AbstractDOMParser::initialize()
  150. {
  151.     //  Create grammar resolver and string pool to pass to the scanner
  152.     fGrammarResolver = new (fMemoryManager) GrammarResolver(fMemoryManager);
  153.     fURIStringPool = new (fMemoryManager) XMLStringPool(109, fMemoryManager);
  155.     //  Create a scanner and tell it what validator to use. Then set us
  156.     //  as the document event handler so we can fill the DOM document.
  157.     fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fMemoryManager);
  158.     fScanner->setDocHandler(this);
  159.     fScanner->setDocTypeHandler(this);
  160.     fScanner->setGrammarResolver(fGrammarResolver);
  161.     fScanner->setURIStringPool(fURIStringPool);
  163.     fNodeStack = new (fMemoryManager) ValueStackOf<DOMNode*>(64, fMemoryManager);
  164.     this->reset();
  165. }
  167. void AbstractDOMParser::cleanUp()
  168. {
  169.     if (fDocumentVector)
  170.         delete fDocumentVector;
  172.     if (!fDocumentAdoptedByUser && fDocument)
  173.         fDocument->release();
  175.     delete fNodeStack;
  176.     delete fScanner;
  177.     delete fGrammarResolver;
  178.     delete fURIStringPool;
  180.     if (fValidator)
  181.         delete fValidator;
  182. }
  184. // ---------------------------------------------------------------------------
  185. //  AbstractDOMParser: Utilities
  186. // ---------------------------------------------------------------------------
  187. void AbstractDOMParser::reset()
  188. {
  189.     // if fDocument exists already, store the old pointer in the vector for deletion later
  190.     if (fDocument && !fDocumentAdoptedByUser) {
  191.         if (!fDocumentVector) {
  192.             // allocate the vector if not exists yet
  193.             fDocumentVector  = new (fMemoryManager) RefVectorOf<DOMDocumentImpl>(10, true, fMemoryManager) ;
  194.         }
  195.         fDocumentVector->addElement(fDocument);
  196.     }
  198.     fDocument = 0;
  199.     resetDocType();
  201.     fCurrentParent   = 0;
  202.     fCurrentNode     = 0;
  203.     fCurrentEntity   = 0;
  204.     fParseInProgress = false;
  205.     fWithinElement   = false;
  206.     fDocumentAdoptedByUser = false;
  207.     fNodeStack->removeAllElements();
  208.     fInternalSubset.reset();
  209. };
  212. void AbstractDOMParser::resetPool()
  213. {
  214.     //  We cannot enter here while a regular parse is in progress.
  215.     if (fParseInProgress)
  216.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  218.     if (fDocumentVector)
  219.         fDocumentVector->removeAllElements();
  221.     if (!fDocumentAdoptedByUser && fDocument)
  222.         fDocument->release();
  224.     fDocument = 0;
  225. }
  227. bool AbstractDOMParser::isDocumentAdopted() const
  228. {
  229.     return fDocumentAdoptedByUser;
  230. }
  232. DOMDocument* AbstractDOMParser::adoptDocument()
  233. {
  234.     fDocumentAdoptedByUser = true;
  235.     return fDocument;
  236. }
  239. // ---------------------------------------------------------------------------
  240. //  AbstractDOMParser: Getter methods
  241. // ---------------------------------------------------------------------------
  242. DOMDocument* AbstractDOMParser::getDocument()
  243. {
  244.     return fDocument;
  245. }
  247. const XMLValidator& AbstractDOMParser::getValidator() const
  248. {
  249.     return *fScanner->getValidator();
  250. }
  252. bool AbstractDOMParser::getDoNamespaces() const
  253. {
  254.     return fScanner->getDoNamespaces();
  255. }
  257. bool AbstractDOMParser::getExitOnFirstFatalError() const
  258. {
  259.     return fScanner->getExitOnFirstFatal();
  260. }
  262. bool AbstractDOMParser::getValidationConstraintFatal() const
  263. {
  264.     return fScanner->getValidationConstraintFatal();
  265. }
  267. AbstractDOMParser::ValSchemes AbstractDOMParser::getValidationScheme() const
  268. {
  269.     const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
  271.     if (scheme == XMLScanner::Val_Always)
  272.         return Val_Always;
  273.     else if (scheme == XMLScanner::Val_Never)
  274.         return Val_Never;
  276.     return Val_Auto;
  277. }
  279. bool AbstractDOMParser::getDoSchema() const
  280. {
  281.     return fScanner->getDoSchema();
  282. }
  284. bool AbstractDOMParser::getValidationSchemaFullChecking() const
  285. {
  286.     return fScanner->getValidationSchemaFullChecking();
  287. }
  289. int AbstractDOMParser::getErrorCount() const
  290. {
  291.     return fScanner->getErrorCount();
  292. }
  294. XMLCh* AbstractDOMParser::getExternalSchemaLocation() const
  295. {
  296.     return fScanner->getExternalSchemaLocation();
  297. }
  299. XMLCh* AbstractDOMParser::getExternalNoNamespaceSchemaLocation() const
  300. {
  301.     return fScanner->getExternalNoNamespaceSchemaLocation();
  302. }
  304. SecurityManager* AbstractDOMParser::getSecurityManager() const
  305. {
  306.     return fScanner->getSecurityManager();
  307. }
  309. bool AbstractDOMParser::getLoadExternalDTD() const
  310. {
  311.     return fScanner->getLoadExternalDTD();
  312. }
  314. bool AbstractDOMParser::getCalculateSrcOfs() const
  315. {
  316.     return fScanner->getCalculateSrcOfs();
  317. }
  319. bool AbstractDOMParser::getStandardUriConformant() const
  320. {
  321.     return fScanner->getStandardUriConformant();
  322. }
  325. // ---------------------------------------------------------------------------
  326. //  AbstractDOMParser: Setter methods
  327. // ---------------------------------------------------------------------------
  328. void AbstractDOMParser::setDoNamespaces(const bool newState)
  329. {
  330.     fScanner->setDoNamespaces(newState);
  331. }
  333. void AbstractDOMParser::setExitOnFirstFatalError(const bool newState)
  334. {
  335.     fScanner->setExitOnFirstFatal(newState);
  336. }
  338. void AbstractDOMParser::setValidationConstraintFatal(const bool newState)
  339. {
  340.     fScanner->setValidationConstraintFatal(newState);
  341. }
  343. void AbstractDOMParser::setValidationScheme(const ValSchemes newScheme)
  344. {
  345.     if (newScheme == Val_Never)
  346.         fScanner->setValidationScheme(XMLScanner::Val_Never);
  347.     else if (newScheme == Val_Always)
  348.         fScanner->setValidationScheme(XMLScanner::Val_Always);
  349.     else
  350.         fScanner->setValidationScheme(XMLScanner::Val_Auto);
  351. }
  353. void AbstractDOMParser::setDoSchema(const bool newState)
  354. {
  355.     fScanner->setDoSchema(newState);
  356. }
  358. void AbstractDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
  359. {
  360.     fScanner->setValidationSchemaFullChecking(schemaFullChecking);
  361. }
  363. void AbstractDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
  364. {
  365.     fScanner->setExternalSchemaLocation(schemaLocation);
  366. }
  367. void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
  368. {
  369.     fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
  370. }
  372. void AbstractDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
  373. {
  374.     fScanner->setExternalSchemaLocation(schemaLocation);
  375. }
  376. void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
  377. {
  378.     fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
  379. }
  381. void AbstractDOMParser::setSecurityManager(SecurityManager* const securityManager)
  382. {
  383.     // since this could impact various components, don't permit it to change
  384.     // during a parse
  385.     if (fParseInProgress)
  386.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  388.     fScanner->setSecurityManager(securityManager);
  389. }
  391. void AbstractDOMParser::setLoadExternalDTD(const bool newState)
  392. {
  393.     fScanner->setLoadExternalDTD(newState);
  394. }
  396. void AbstractDOMParser::setCalculateSrcOfs(const bool newState)
  397. {
  398.     fScanner->setCalculateSrcOfs(newState);
  399. }
  401. void AbstractDOMParser::setStandardUriConformant(const bool newState)
  402. {
  403.     fScanner->setStandardUriConformant(newState);
  404. }
  406. void AbstractDOMParser::useScanner(const XMLCh* const scannerName)
  407. {
  408.     XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
  409.     (
  410.         scannerName
  411.         , fValidator
  412.         , fMemoryManager
  413.     );
  415.     if (tempScanner) {
  417.         tempScanner->setParseSettings(fScanner);
  418.         tempScanner->setGrammarResolver(fGrammarResolver);
  419.         tempScanner->setURIStringPool(fURIStringPool);
  420.         delete fScanner;
  421.         fScanner = tempScanner;
  422.     }
  423. }
  425. // ---------------------------------------------------------------------------
  426. //  AbstractDOMParser: Parsing methods
  427. // ---------------------------------------------------------------------------
  428. void AbstractDOMParser::parse(const InputSource& source)
  429. {
  430.     // Avoid multiple entrance
  431.     if (fParseInProgress)
  432.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  434.     try
  435.     {
  436.         fParseInProgress = true;
  437.         fScanner->scanDocument(source);
  438.         fParseInProgress = false;
  439.     }
  441.     catch(...)
  442.     {
  443.         fParseInProgress = false;
  444.         throw;
  445.     }
  446. }
  448. void AbstractDOMParser::parse(const XMLCh* const systemId)
  449. {
  450.     // Avoid multiple entrance
  451.     if (fParseInProgress)
  452.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  454.     try
  455.     {
  456.         fParseInProgress = true;
  457.         fScanner->scanDocument(systemId);
  458.         fParseInProgress = false;
  459.     }
  461.     catch(...)
  462.     {
  463.         fParseInProgress = false;
  464.         throw;
  465.     }
  466. }
  468. void AbstractDOMParser::parse(const char* const systemId)
  469. {
  470.     // Avoid multiple entrance
  471.     if (fParseInProgress)
  472.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  474.     try
  475.     {
  476.         fParseInProgress = true;
  477.         fScanner->scanDocument(systemId);
  478.         fParseInProgress = false;
  479.     }
  481.     catch(...)
  482.     {
  483.         fParseInProgress = false;
  484.         throw;
  485.     }
  486. }
  490. // ---------------------------------------------------------------------------
  491. //  AbstractDOMParser: Progressive parse methods
  492. // ---------------------------------------------------------------------------
  493. bool AbstractDOMParser::parseFirst( const XMLCh* const    systemId
  494.                                    ,       XMLPScanToken&  toFill)
  495. {
  496.     //
  497.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  498.     //  is in progress.
  499.     //
  500.     if (fParseInProgress)
  501.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  503.     return fScanner->scanFirst(systemId, toFill);
  504. }
  506. bool AbstractDOMParser::parseFirst( const char* const         systemId
  507.                                    ,       XMLPScanToken&      toFill)
  508. {
  509.     //
  510.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  511.     //  is in progress.
  512.     //
  513.     if (fParseInProgress)
  514.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  516.     return fScanner->scanFirst(systemId, toFill);
  517. }
  519. bool AbstractDOMParser::parseFirst( const InputSource& source
  520.                                    ,       XMLPScanToken&  toFill)
  521. {
  522.     //
  523.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  524.     //  is in progress.
  525.     //
  526.     if (fParseInProgress)
  527.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  529.     return fScanner->scanFirst(source, toFill);
  530. }
  532. bool AbstractDOMParser::parseNext(XMLPScanToken& token)
  533. {
  534.     return fScanner->scanNext(token);
  535. }
  537. void AbstractDOMParser::parseReset(XMLPScanToken& token)
  538. {
  539.     // Reset the scanner, and then reset the parser
  540.     fScanner->scanReset(token);
  541.     reset();
  542. }
  546. // ---------------------------------------------------------------------------
  547. //  AbstractDOMParser: Implementation of XMLDocumentHandler interface
  548. // ---------------------------------------------------------------------------
  549. void AbstractDOMParser::docCharacters(  const   XMLCh* const    chars
  550.                               , const unsigned int    length
  551.                               , const bool            cdataSection)
  552. {
  553.     // Ignore chars outside of content
  554.     if (!fWithinElement)
  555.         return;
  557.     // revisit.  Is it really safe to null-terminate here?
  558.     //                Does the scanner do it already?
  559.     //                If scanner goes up to the very end of an unterminated
  560.     //                buffer, we may be stepping on something bad here.
  561.     //           Probably best to modify the scanner to null terminate.
  562.     XMLCh savedChar = chars[length];
  563.     XMLCh *ncChars  = (XMLCh *)chars;   // cast off const
  564.     ncChars[length] = 0;
  565.     if (cdataSection == true)
  566.     {
  567.         DOMCDATASection *node = fDocument->createCDATASection(chars);
  568.         fCurrentParent->appendChild(node);
  569.         fCurrentNode = node;
  570.     }
  571.     else
  572.     {
  573.         if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
  574.         {
  575.             DOMText *node = (DOMText *)fCurrentNode;
  576.             node->appendData(chars);
  577.         }
  578.         else
  579.         {
  580.             DOMText *node = fDocument->createTextNode(chars);
  581.             fCurrentParent->appendChild(node);
  582.             fCurrentNode = node;
  583.         }
  584.     }
  585.     ncChars[length] = savedChar;
  586.     return;
  587. }
  590. void AbstractDOMParser::docComment(const XMLCh* const comment)
  591. {
  592.     if (fCreateCommentNodes) {
  593.         DOMComment *dcom = fDocument->createComment(comment);
  594.         fCurrentParent->appendChild(dcom);
  595.         fCurrentNode = dcom;
  596.     }
  597. }
  600. void AbstractDOMParser::docPI(  const   XMLCh* const    target
  601.                       , const XMLCh* const    data)
  602. {
  603.     DOMProcessingInstruction *pi = fDocument->createProcessingInstruction
  604.         (
  605.         target
  606.         , data
  607.         );
  608.     fCurrentParent->appendChild(pi);
  609.     fCurrentNode = pi;
  610. }
  613. void AbstractDOMParser::endEntityReference(const XMLEntityDecl& entDecl)
  614. {
  615.     DOMEntityReferenceImpl *erImpl = 0;
  616.     DOMNode* firstChild = 0;
  618.     if (fCurrentParent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
  619.         erImpl = (DOMEntityReferenceImpl *) fCurrentParent;
  620.         firstChild = erImpl->getFirstChild();
  621.     }
  623.     fCurrentParent = fNodeStack->pop();
  625.     if (!fCreateEntityReferenceNodes && erImpl && firstChild) {
  626.         DOMNode *kid, *next;
  627.         fCurrentNode   = fCurrentParent->getLastChild();
  629.         for (kid = firstChild; kid != 0; kid = next)
  630.         {
  631.             // If kid and fCurrentNode are both Text nodes (but _not_ CDATASection,
  632.             // which is a subclass of Text), they can be merged.
  633.             if (kid->getNodeType() == DOMNode::TEXT_NODE   &&
  634.                 fCurrentNode &&
  635.                 fCurrentNode->getNodeType() == DOMNode::TEXT_NODE )
  636.             {
  637.                 ((DOMTextImpl *) fCurrentNode)->appendData(((DOMTextImpl *) kid)->getData());
  638.             }
  639.             else {
  640.                 // append the child of erImpl to currentParent
  641.                 fCurrentNode = kid->cloneNode(true);
  642.                 fCurrentParent->appendChild(fCurrentNode);
  644.                 if (erImpl->getBaseURI()) {
  645.                     /**
  646.                      * Record baseURI information for the Element (by adding xml:base attribute)
  647.                      * or for the ProcessingInstruction (by setting a baseURI field)
  648.                      */
  649.                     if (fCurrentNode->getNodeType() == DOMNode::ELEMENT_NODE) {
  650.                         // if an element already has xml:base attribute
  651.                         // do nothing
  652.                         const XMLCh baseString[] =
  653.                         {
  654.                             chLatin_b, chLatin_a, chLatin_s, chLatin_e, chNull
  655.                         };
  656.                         const XMLCh xmlBaseString[] =
  657.                         {
  658.                             chLatin_x, chLatin_m, chLatin_l, chColon, chLatin_b, chLatin_a, chLatin_s, chLatin_e, chNull
  659.                         };
  661.                         if (fScanner -> getDoNamespaces() && (((DOMElement*)fCurrentNode)->getAttributeNodeNS(DOMNodeImpl::getXmlURIString(), baseString) != 0)) {
  662.                             return;
  663.                         } else if (((DOMElement*)fCurrentNode)->getAttributeNode(xmlBaseString) != 0) {
  664.                             return;
  665.                         }
  667.                         // retrive the baseURI from the entity decl
  668.                         const XMLCh* baseURI = erImpl->getBaseURI();
  669.                         if (baseURI != 0 && !XMLString::equals(baseURI,fDocument->getDocumentURI())) {
  670.                             if (fScanner -> getDoNamespaces()) {
  671.                                 ((DOMElement*)fCurrentNode)->setAttributeNS(DOMNodeImpl::getXmlURIString(), baseString, baseURI);
  672.                             } else {
  673.                                 ((DOMElement*)fCurrentNode)->setAttribute(xmlBaseString, baseURI);
  674.                             }
  675.                         }
  676.                     }
  677.                     else if (fCurrentNode->getNodeType() == DOMNode::PROCESSING_INSTRUCTION_NODE) {
  678.                         ((DOMProcessingInstructionImpl*)fCurrentNode)->setBaseURI(erImpl->getBaseURI());
  679.                     }
  680.                 }
  681.             }
  683.             next = kid->getNextSibling();
  684.         }
  685.     }
  686.     else
  687.         fCurrentNode   = fCurrentParent;
  689.     if (erImpl)
  690.         erImpl->setReadOnly(true, true);
  691. }
  694. void AbstractDOMParser::endElement( const   XMLElementDecl&     elemDecl
  695.                            , const unsigned int        urlId
  696.                            , const bool                isRoot
  697.                            , const XMLCh* const        elemPrefix)
  698. {
  699.     fCurrentNode   = fCurrentParent;
  700.     fCurrentParent = fNodeStack->pop();
  702.     //validation is performed after the startElement event so we have to associate the info here
  703.     ((DOMElementImpl *)(fCurrentNode))->setTypeInfo(elemDecl.getDOMTypeInfoName(), elemDecl.getDOMTypeInfoUri());
  706.     // If we've hit the end of content, clear the flag
  707.     if (fNodeStack->empty())
  708.         fWithinElement = false;
  709. }
  712. void AbstractDOMParser::ignorableWhitespace(const   XMLCh* const    chars
  713.                                     , const unsigned int    length
  714.                                     , const bool            cdataSection)
  715. {
  716.     // Ignore chars before the root element
  717.     if (!fWithinElement || !fIncludeIgnorableWhitespace)
  718.         return;
  720.     // revisit.  Not safe to slam in a null like this.
  721.     XMLCh savedChar = chars[length];
  722.     XMLCh *ncChars  = (XMLCh *)chars;   // cast off const
  723.     ncChars[length] = chNull;
  725.     if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
  726.     {
  727.         DOMText *node = (DOMText *)fCurrentNode;
  728.         node->appendData(chars);
  729.     }
  730.     else
  731.     {
  732.         DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(chars);
  733.         node->setIgnorableWhitespace(true);
  734.         fCurrentParent->appendChild(node);
  736.         fCurrentNode = node;
  737.     }
  738.     ncChars[length] = savedChar;
  739. }
  742. void AbstractDOMParser::resetDocument()
  743. {
  744.     //
  745.     //  The reset methods are called before a new parse event occurs.
  746.     //  Reset this parsers state to clear out anything that may be left
  747.     //  from a previous use, in particular the DOM document itself.
  748.     //
  749.     this->reset();
  750. }
  753. void AbstractDOMParser::startDocument()
  754. {
  755.     fDocument = (DOMDocumentImpl *)DOMImplementation::getImplementation()->createDocument();
  756.     // Just set the document as the current parent and current node
  757.     fCurrentParent = fDocument;
  758.     fCurrentNode   = fDocument;
  759.     // set DOM error checking off
  760.     fDocument->setErrorChecking(false);
  761.     fDocument->setDocumentURI(fScanner->getLocator()->getSystemId());
  762.     fDocument->setActualEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
  763. }
  766. void AbstractDOMParser::endDocument()
  767. {
  768.     // set DOM error checking back on
  769.     fDocument->setErrorChecking(true);
  771.     // DOM L2 does not support editing DocumentType nodes
  772.     if (fDocumentType && fScanner -> getDoNamespaces())
  773.         fDocumentType->setReadOnly(true, true);
  774. }
  777. void AbstractDOMParser::startElement(const  XMLElementDecl&         elemDecl
  778.                              , const unsigned int            urlId
  779.                              , const XMLCh* const            elemPrefix
  780.                              , const RefVectorOf<XMLAttr>&   attrList
  781.                              , const unsigned int            attrCount
  782.                              , const bool                    isEmpty
  783.                              , const bool                    isRoot)
  784. {
  785.     DOMElement     *elem;
  786.     DOMElementImpl *elemImpl;
  787.     static const XMLCh XMLNS[] = {
  788.     chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull
  789.     };
  791.     static const XMLCh XSI[] = {
  792.     chLatin_x, chLatin_s, chLatin_i, chNull
  793.     };
  795.     //get the list for use in the loop
  796.     XMLAttDefList* defAttrs = 0;
  797.     if(elemDecl.hasAttDefs()) {
  798.         defAttrs = &elemDecl.getAttDefList();
  799.     }
  801.     if (fScanner -> getDoNamespaces()) {    //DOM Level 2, doNamespaces on
  803.         const XMLCh* namespaceURI = 0;
  805.         if (urlId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
  807.             namespaceURI = fScanner->getURIText(urlId); //get namespaceURI
  809.             if (elemPrefix && *elemPrefix) {
  811.                 XMLBufBid elemQName(&fBufMgr);
  813.                 elemQName.set(elemPrefix);
  814.                 elemQName.append(chColon);
  815.                 elemQName.append(elemDecl.getBaseName());
  816.                 elem = createElementNSNode(namespaceURI, elemQName.getRawBuffer());
  817.             }
  818.             else { 
  819.                 elem = createElementNSNode(namespaceURI, elemDecl.getBaseName());
  820.             }
  821.         } 
  822.         else {
  823.             elem = createElementNSNode(namespaceURI, elemDecl.getBaseName());
  824.         }
  826.         elemImpl = (DOMElementImpl *) elem;
  828.         for (unsigned int index = 0; index < attrCount; ++index) {
  829.             const XMLAttr* oneAttrib = attrList.elementAt(index);
  830.             unsigned int attrURIId = oneAttrib -> getURIId();
  831.             namespaceURI = 0;
  832.             if (XMLString::equals(oneAttrib -> getName(), XMLNS))    //for xmlns=...
  833.                 attrURIId = fScanner->getXMLNSNamespaceId();
  834.             if (attrURIId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
  835.                 namespaceURI = fScanner->getURIText(attrURIId);   //get namespaceURI
  836.             }
  837.             //  revisit.  Optimize to init the named node map to the
  838.             //            right size up front.
  839.             DOMAttrImpl *attr = (DOMAttrImpl *)
  840.                 fDocument->createAttributeNS(namespaceURI, oneAttrib->getQName());
  841.             attr->setValue(oneAttrib -> getValue());
  842.             DOMNode* remAttr = elemImpl->setAttributeNodeNS(attr);
  843.             if (remAttr)
  844.                 remAttr->release();
  846.             //DOMAttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
  847.             //    oneAttrib -> getValue());
  849.             // Attributes of type ID.  If this is one, add it to the hashtable of IDs
  850.             //   that is constructed for use by GetElementByID().
  851.             //
  852.             if (oneAttrib->getType()==XMLAttDef::ID)
  853.             {
  854.                 if (fDocument->fNodeIDMap == 0)
  855.                     fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
  856.                 fDocument->fNodeIDMap->add(attr);
  857.                 attr->fNode.isIdAttr(true);
  858.             }
  860.             attr->setSpecified(oneAttrib->getSpecified());
  862.             XMLAttDef *attDef = 0;
  863.             if(defAttrs != 0)
  864.                 attDef = defAttrs->findAttDef(attrURIId, oneAttrib->getQName());
  866.             if(attDef != 0) {
  867.                 attr->setTypeInfo(attDef->getDOMTypeInfoName(), attDef->getDOMTypeInfoUri());
  868.                 attDef->reset();
  869.             }
  870.             else {
  871.                 const XMLCh *name = oneAttrib->getName();
  872.                 if (XMLString::equals(oneAttrib->getPrefix(), XSI)) {
  873.                     if(XMLString::equals(name, SchemaSymbols::fgXSI_TYPE)) {
  874.                         attr->setTypeInfo(SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  875.                     }
  876.                     else if(XMLString::equals(name, SchemaSymbols::fgATT_NILL)) {
  877.                         attr->setTypeInfo(SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  878.                     }
  879.                     else if(XMLString::equals(name, SchemaSymbols::fgXSI_NONAMESPACESCHEMALOCACTION)) {
  880.                         attr->setTypeInfo(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  881.                     }
  882.                 }
  883.                 else {
  884.                     //for normal ns attrs
  885.                     attr->setTypeInfo(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  886.                 }
  887.             }
  888.         }
  889.     }
  890.     else {    //DOM Level 1
  891.         elem = fDocument->createElement(elemDecl.getFullName());
  892.         elemImpl = (DOMElementImpl *) elem;
  893. for (unsigned int index = 0; index < attrCount; ++index) {
  894. const XMLAttr* oneAttrib = attrList.elementAt(index);
  895.             //AttrImpl *attr = elemImpl->setAttribute(oneAttrib->getName(), oneAttrib->getValue());
  896.             DOMAttrImpl *attr = (DOMAttrImpl *)
  897.                 fDocument->createAttribute(oneAttrib->getName());
  898.             attr->setValue(oneAttrib -> getValue());
  899.             DOMNode* rem = elemImpl->setAttributeNode(attr);
  900.             if (rem)
  901.                 rem->release();
  902. attr->setSpecified(oneAttrib->getSpecified());
  904. // Attributes of type ID.  If this is one, add it to the hashtable of IDs
  905. //   that is constructed for use by GetElementByID().
  906. //
  907. if (oneAttrib->getType()==XMLAttDef::ID)
  908. {
  909.                 if (fDocument->fNodeIDMap == 0)
  910.                     fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
  911.                 fDocument->fNodeIDMap->add(attr);
  912.                 attr->fNode.isIdAttr(true);
  913.             }
  915.             XMLAttDef *attDef = 0;
  916.             if(defAttrs != 0)
  917.                 attDef = defAttrs->findAttDef(oneAttrib -> getURIId(), oneAttrib->getQName());
  919.             if(attDef != 0) {
  920.                 attr->setTypeInfo(attDef->getDOMTypeInfoName(), attDef->getDOMTypeInfoUri());
  921.                 attDef->reset();
  922.             }
  924.         }
  925.     }
  927.     // set up the default attributes
  928. if (defAttrs != 0)
  929. {
  930.         XMLAttDef* attr = 0;
  932.         DOMAttrImpl * insertAttr = 0;
  934.         while (defAttrs->hasMoreElements())
  935.         {
  936.             attr = &defAttrs->nextElement();
  938.             const XMLAttDef::DefAttTypes defType = attr->getDefaultType();
  939.             if ((defType == XMLAttDef::Default)
  940.             ||  (defType == XMLAttDef::Fixed))
  941.             {
  943.                 if (fScanner->getDoNamespaces())
  944.                 {
  945.                     // DOM Level 2 wants all namespace declaration attributes
  946.                     // to be bound to "http://www.w3.org/2000/xmlns/"
  947.                     // So as long as the XML parser doesn't do it, it needs to
  948.                     // done here.
  949.                     const XMLCh* qualifiedName = attr->getFullName();
  950.                     XMLBufBid bbPrefixQName(&fBufMgr);
  951.                     XMLBuffer& prefixBuf = bbPrefixQName.getBuffer();
  952.                     int colonPos = -1;
  953.                     unsigned int uriId = fScanner->resolveQName(qualifiedName, prefixBuf, ElemStack::Mode_Attribute, colonPos);
  955.                     const XMLCh* namespaceURI = 0;
  956.                     if (XMLString::equals(qualifiedName, XMLNS))    //for xmlns=...
  957.                         uriId = fScanner->getXMLNSNamespaceId();
  958.                     if (uriId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
  959.                         namespaceURI = fScanner->getURIText(uriId);
  960.                     }
  962.                     insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
  963.                                                                               namespaceURI,     // NameSpaceURI
  964.                                                                               qualifiedName);   // qualified name
  966.                     DOMAttr* remAttr = elemImpl->setDefaultAttributeNodeNS(insertAttr);
  967.                     if (remAttr)
  968.                         remAttr->release();
  970.                     if (attr->getValue() != 0)
  971.                     {
  972.                         insertAttr->setValue(attr->getValue());
  973.                         insertAttr->setSpecified(false);
  974.                     }
  976.                 }
  977.                 else
  978.                 {
  979.                     // Namespaces is turned off...
  980.                     insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
  982.                     DOMNode* remAttr = elemImpl->setDefaultAttributeNode(insertAttr);
  983.                     if (remAttr)
  984.                         remAttr->release();
  986.                     //need to do this before the get as otherwise we overwrite any value in the attr
  987.                     if (attr->getValue() != 0)
  988.                     {
  989.                         insertAttr->setValue(attr->getValue());
  990.                         insertAttr->setSpecified(false);
  991.                     }
  992.                 }
  994.                 insertAttr->setTypeInfo(attr->getDOMTypeInfoName(), attr->getDOMTypeInfoUri());
  996.             }
  998.             insertAttr = 0;
  999.             attr->reset();
  1000.         }
  1001.     }
  1004.     fCurrentParent->appendChild(elem);
  1006.     fNodeStack->push(fCurrentParent);
  1007.     fCurrentParent = elem;
  1008.     fCurrentNode = elem;
  1009.     fWithinElement = true;
  1011.     // If an empty element, do end right now (no endElement() will be called)
  1012.     if (isEmpty)
  1013.         endElement(elemDecl, urlId, isRoot, elemPrefix);
  1014. }
  1017. void AbstractDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
  1018. {
  1019.     const XMLCh * entName = entDecl.getName();
  1020.     DOMNamedNodeMap *entities = fDocumentType->getEntities();
  1021.     DOMEntityImpl* entity = (DOMEntityImpl*)entities->getNamedItem(entName);
  1022.     if (entity)
  1023.         entity->setActualEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
  1024.     fCurrentEntity = entity;
  1026.     DOMEntityReference *er = fDocument->createEntityReferenceByParser(entName);
  1028.     //set the readOnly flag to false before appending node, will be reset in endEntityReference
  1029.     DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) er;
  1030.     erImpl->setReadOnly(false, true);
  1032.     if (fCreateEntityReferenceNodes == true)
  1033.     {
  1034.         fCurrentParent->appendChild(er);
  1035.     }
  1037.     fNodeStack->push(fCurrentParent);
  1038.     fCurrentParent = er;
  1039.     fCurrentNode = er;
  1041.     // this entityRef needs to be stored in Entity map too.
  1042.     // We'd decide later whether the entity nodes should be created by a
  1043.     // separated method in parser or not. For now just stick it in if
  1044.     // the ref nodes are created
  1045.     if (entity)
  1046.         entity->setEntityRef(er);
  1047. }
  1050. void AbstractDOMParser::XMLDecl(const   XMLCh* const version
  1051.                                 , const XMLCh* const encoding
  1052.                                 , const XMLCh* const standalone
  1053.                                 , const XMLCh* const actualEncStr)
  1054. {
  1055.     fDocument->setStandalone(XMLString::equals(XMLUni::fgYesString, standalone));
  1057.     fDocument->setVersion(version);
  1058.     fDocument->setEncoding(encoding);
  1059.     fDocument->setActualEncoding(actualEncStr);
  1060. }
  1062. // ---------------------------------------------------------------------------
  1063. //  AbstractDOMParser: Helper methods
  1064. // ---------------------------------------------------------------------------
  1065. DOMElement* AbstractDOMParser::createElementNSNode(const XMLCh *namespaceURI,
  1066.                                                    const XMLCh *qualifiedName)
  1067. {
  1068.     return fDocument->createElementNS(namespaceURI, qualifiedName);
  1069. }
  1070. // ---------------------------------------------------------------------------
  1071. //  AbstractDOMParser: Deprecated methods
  1072. // ---------------------------------------------------------------------------
  1073. bool AbstractDOMParser::getDoValidation() const
  1074. {
  1075.     //
  1076.     //  We don't want to tie the public parser classes to the enum used
  1077.     //  by the scanner, so we use a separate one and map.
  1078.     //
  1079.     //  DON'T mix the new and old methods!!
  1080.     //
  1081.     const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
  1082.     if (scheme == XMLScanner::Val_Always)
  1083.         return true;
  1084.     return false;
  1085. }
  1087. void AbstractDOMParser::setDoValidation(const bool newState)
  1088. {
  1089.     fScanner->setDoValidation
  1090.     (
  1091.         newState ? XMLScanner::Val_Always : XMLScanner::Val_Never
  1092.     );
  1093. }
  1095. //doctypehandler interfaces
  1096. void AbstractDOMParser::attDef
  1097. (
  1098.     const   DTDElementDecl&     elemDecl
  1099.     , const DTDAttDef&          attDef
  1100.     , const bool                ignoring
  1101. )
  1102. {
  1103.     if (fDocumentType->isIntSubsetReading())
  1104.     {
  1105.         if (elemDecl.hasAttDefs())
  1106.         {
  1107.             fInternalSubset.append(attDef.getFullName());
  1109.             // Get the type and display it
  1110.             const XMLAttDef::AttTypes type = attDef.getType();
  1111.             switch(type)
  1112.             {
  1113.             case XMLAttDef::CData :
  1114.                 fInternalSubset.append(chSpace);
  1115.                 fInternalSubset.append(XMLUni::fgCDATAString);
  1116.                 break;
  1117.             case XMLAttDef::ID :
  1118.                 fInternalSubset.append(chSpace);
  1119.                 fInternalSubset.append(XMLUni::fgIDString);
  1120.                 break;
  1121.             case XMLAttDef::IDRef :
  1122.                 fInternalSubset.append(chSpace);
  1123.                 fInternalSubset.append(XMLUni::fgIDRefString);
  1124.                 break;
  1125.             case XMLAttDef::IDRefs :
  1126.                 fInternalSubset.append(chSpace);
  1127.                 fInternalSubset.append(XMLUni::fgIDRefsString);
  1128.                 break;
  1129.             case XMLAttDef::Entity :
  1130.                 fInternalSubset.append(chSpace);
  1131.                 fInternalSubset.append(XMLUni::fgEntityString);
  1132.                 break;
  1133.             case XMLAttDef::Entities :
  1134.                 fInternalSubset.append(chSpace);
  1135.                 fInternalSubset.append(XMLUni::fgEntitiesString);
  1136.                 break;
  1137.             case XMLAttDef::NmToken :
  1138.                 fInternalSubset.append(chSpace);
  1139.                 fInternalSubset.append(XMLUni::fgNmTokenString);
  1140.                 break;
  1141.             case XMLAttDef::NmTokens :
  1142.                 fInternalSubset.append(chSpace);
  1143.                 fInternalSubset.append(XMLUni::fgNmTokensString);
  1144.                 break;
  1146.             case XMLAttDef::Notation :
  1147.                 fInternalSubset.append(chSpace);
  1148.                 fInternalSubset.append(XMLUni::fgNotationString);
  1149.                 break;
  1151.             case XMLAttDef::Enumeration :
  1152.                 fInternalSubset.append(chSpace);
  1153.                 const XMLCh* enumString = attDef.getEnumeration();
  1154.                 int length = XMLString::stringLen(enumString);
  1155.                 if (length > 0) {
  1157.                     fInternalSubset.append(chOpenParen );
  1158.                     for(int i=0; i<length; i++) {
  1159.                         if (enumString[i] == chSpace)
  1160.                             fInternalSubset.append(chPipe);
  1161.                         else
  1162.                             fInternalSubset.append(enumString[i]);
  1163.                     }
  1164.                     fInternalSubset.append(chCloseParen);
  1165.                 }
  1166.                 break;
  1167.             }
  1168.             //get te default types of the attlist
  1169.             const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
  1170.             switch(def)
  1171.             {
  1172.             case XMLAttDef::Required :
  1173.                 fInternalSubset.append(chSpace);
  1174.                 fInternalSubset.append(XMLUni::fgRequiredString);
  1175.                 break;
  1176.             case XMLAttDef::Implied :
  1177.                 fInternalSubset.append(chSpace);
  1178.                 fInternalSubset.append(XMLUni::fgImpliedString);
  1179.                 break;
  1180.             case XMLAttDef::Fixed :
  1181.                 fInternalSubset.append(chSpace);
  1182.                 fInternalSubset.append(XMLUni::fgFixedString);
  1183.                 break;
  1184.             }
  1186.             const XMLCh* defaultValue = attDef.getValue();
  1187.             if (defaultValue != 0) {
  1188.                 fInternalSubset.append(chSpace);
  1189.                 fInternalSubset.append(chDoubleQuote);
  1190.                 fInternalSubset.append(defaultValue);
  1191.                 fInternalSubset.append(chDoubleQuote);
  1192.             }
  1193.         }
  1194.     }
  1195. }
  1197. void AbstractDOMParser::doctypeComment
  1198. (
  1199.     const   XMLCh* const    comment
  1200. )
  1201. {
  1202.     if (fDocumentType->isIntSubsetReading())
  1203.     {
  1204.         if (comment != 0)
  1205.         {
  1206.             fInternalSubset.append(XMLUni::fgCommentString);
  1207.             fInternalSubset.append(chSpace);
  1208.             fInternalSubset.append(comment);
  1209.             fInternalSubset.append(chSpace);
  1210.             fInternalSubset.append(chDash);
  1211.             fInternalSubset.append(chDash);
  1212.             fInternalSubset.append(chCloseAngle);
  1213.         }
  1214.     }
  1215. }
  1217. void AbstractDOMParser::doctypeDecl
  1218. (
  1219.     const   DTDElementDecl& elemDecl
  1220.     , const XMLCh* const    publicId
  1221.     , const XMLCh* const    systemId
  1222.     , const bool            hasIntSubset
  1223.     , const bool            hasExtSubset
  1224. )
  1225. {
  1226.     fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
  1227.     fDocument->setDocumentType(fDocumentType);
  1229. }
  1231. void AbstractDOMParser::doctypePI
  1232. (
  1233.     const   XMLCh* const    target
  1234.     , const XMLCh* const    data
  1235. )
  1236. {
  1237.     if (fDocumentType->isIntSubsetReading())
  1238.     {
  1239.         //add these chars to internalSubset variable
  1240.         fInternalSubset.append(chOpenAngle);
  1241.         fInternalSubset.append(chQuestion);
  1242.         fInternalSubset.append(target);
  1243.         fInternalSubset.append(chSpace);
  1244.         fInternalSubset.append(data);
  1245.         fInternalSubset.append(chQuestion);
  1246.         fInternalSubset.append(chCloseAngle);
  1247.     }
  1248. }
  1251. void AbstractDOMParser::doctypeWhitespace
  1252. (
  1253.     const   XMLCh* const    chars
  1254.     , const unsigned int    length
  1255. )
  1256. {
  1257.     if (fDocumentType->isIntSubsetReading())
  1258.         fInternalSubset.append(chars);
  1259. }
  1261. void AbstractDOMParser::elementDecl
  1262. (
  1263.     const   DTDElementDecl& decl
  1264.     , const bool            isIgnored
  1265. )
  1266. {
  1267.     if (fDocumentType->isIntSubsetReading())
  1268.     {
  1269.         fInternalSubset.append(chOpenAngle);
  1270.         fInternalSubset.append(chBang);
  1271.         fInternalSubset.append(XMLUni::fgElemString);
  1272.         fInternalSubset.append(chSpace);
  1273.         fInternalSubset.append(decl.getFullName());
  1275.         //get the ContentSpec information
  1276.         const XMLCh* contentModel = decl.getFormattedContentModel();
  1277.         if (contentModel != 0) {
  1278.             fInternalSubset.append(chSpace);
  1279.             fInternalSubset.append(contentModel);
  1280.         }
  1282.         fInternalSubset.append(chCloseAngle);
  1283.     }
  1284. }
  1286. void AbstractDOMParser::endAttList
  1287. (
  1288.     const   DTDElementDecl& elemDecl
  1289. )
  1290. {
  1291.     if (fDocumentType->isIntSubsetReading())
  1292.     {
  1293.         //print the closing angle
  1294.         fInternalSubset.append(chCloseAngle);
  1295.     }
  1297. // this section sets up default attributes.
  1298. // default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
  1299. // default attribute data attached to the document is used to conform to the
  1300. // DOM spec regarding creating element nodes & removing attributes with default values
  1301. // see DocumentTypeImpl
  1302. if (elemDecl.hasAttDefs())
  1303. {
  1304.         XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
  1305.         XMLAttDef* attr = 0;
  1307.         DOMAttrImpl * insertAttr = 0;
  1308.         DOMElement     *elem  = fDocument->createElement(elemDecl.getFullName());
  1309.         DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
  1311. while (defAttrs->hasMoreElements())
  1312.         {
  1313.             attr = &defAttrs->nextElement();
  1314.             if (attr->getValue() != 0)
  1315.             {
  1316.                 if (fScanner->getDoNamespaces())
  1317.                 {
  1318.                     // DOM Level 2 wants all namespace declaration attributes
  1319.                     // to be bound to "http://www.w3.org/2000/xmlns/"
  1320.                     // So as long as the XML parser doesn't do it, it needs to
  1321.                     // done here.
  1322.                     const XMLCh* qualifiedName = attr->getFullName();
  1323.                     int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
  1325.                     XMLBufBid bbQName(&fBufMgr);
  1326.                     XMLBuffer& buf = bbQName.getBuffer();
  1327.                     static const XMLCh XMLNS[] = {
  1328.                         chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
  1330.                     if (index > 0) {
  1331.                         // there is prefix
  1332.                         // map to XML URI for all cases except when prefix == "xmlns"
  1333.                         XMLCh* prefix;
  1334.                         XMLCh temp[1000];
  1336.                         if (index > 999)
  1337.                             prefix = (XMLCh*) fMemoryManager->allocate
  1338.                             (
  1339.                                 (index + 1) * sizeof(XMLCh)
  1340.                             );//new XMLCh[index+1];
  1341.                         else
  1342.                             prefix = temp;
  1344.                         XMLString::subString(prefix ,qualifiedName, 0, index);
  1346.                         if (XMLString::equals(prefix,XMLNS))
  1347.                             buf.append(XMLUni::fgXMLNSURIName);
  1348.                         else
  1349.                             buf.append(XMLUni::fgXMLURIName);
  1351.                         if (index > 999)
  1352.                             fMemoryManager->deallocate(prefix);//delete [] prefix;
  1353.                     }
  1354.                     else {
  1355.                         //   No prefix
  1356.                         if (XMLString::equals(qualifiedName,XMLNS))
  1357.                             buf.append(XMLUni::fgXMLNSURIName);
  1358.                     }
  1360.                     insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
  1361.                        buf.getRawBuffer(),     // NameSpaceURI
  1362.                        qualifiedName);   // qualified name
  1364.                     DOMNode* remAttr = elemImpl->setAttributeNodeNS(insertAttr);
  1365.                     if (remAttr)
  1366.                         remAttr->release();
  1367.                 }
  1368.                 else
  1369.                 {
  1370.                     // Namespaces is turned off...
  1371.                     insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
  1372.                     DOMNode* remAttr = elemImpl->setAttributeNode(insertAttr);
  1373.                     if (remAttr)
  1374.                         remAttr->release();
  1375.                 }
  1377.                 insertAttr->setValue(attr->getValue());
  1378.                 insertAttr->setSpecified(false);
  1379.             }
  1380.         }
  1381.         DOMNode* rem = fDocumentType->getElements()->setNamedItem(elemImpl);
  1382.         if (rem)
  1383.             rem->release();
  1384.     }
  1385. }
  1387. void AbstractDOMParser::endIntSubset()
  1388. {
  1389.     fDocumentType->setInternalSubset(fInternalSubset.getRawBuffer());
  1390.     // the buffer shouldn't be released as it is reused in the next parse
  1391.     // fBufMgr.releaseBuffer(fInternalSubset);
  1392.     fDocumentType->fIntSubsetReading = false;
  1393. }
  1395. void AbstractDOMParser::endExtSubset()
  1396. {
  1397. }
  1399. void AbstractDOMParser::entityDecl
  1400. (
  1401.     const   DTDEntityDecl&  entityDecl
  1402.     , const bool            isPEDecl
  1403.     , const bool            isIgnored
  1404. )
  1405. {
  1406.     DOMEntityImpl* entity = (DOMEntityImpl *) fDocument->createEntity(entityDecl.getName());
  1408.     entity->setPublicId(entityDecl.getPublicId());
  1409.     entity->setSystemId(entityDecl.getSystemId());
  1410.     entity->setNotationName(entityDecl.getNotationName());
  1411.     entity->setBaseURI(entityDecl.getBaseURI());
  1413.     DOMEntityImpl *previousDef = (DOMEntityImpl *)
  1414.     fDocumentType->getEntities()->setNamedItem( entity );
  1416.     if (previousDef)
  1417.         previousDef->release();
  1419.     if (fDocumentType->isIntSubsetReading())
  1420.     {
  1421.         //add thes chars to internalSubset variable
  1422.         fInternalSubset.append(chOpenAngle);
  1423.         fInternalSubset.append(chBang);
  1424.         fInternalSubset.append(XMLUni::fgEntityString);
  1425.         fInternalSubset.append(chSpace);
  1427.         fInternalSubset.append(entityDecl.getName());
  1429.         const XMLCh* id = entity->getPublicId();
  1430.         if (id != 0) {
  1431.             fInternalSubset.append(chSpace);
  1432.             fInternalSubset.append(XMLUni::fgPubIDString);
  1433.             fInternalSubset.append(chSpace);
  1434.             fInternalSubset.append(chDoubleQuote);
  1435.             fInternalSubset.append(id);
  1436.             fInternalSubset.append(chDoubleQuote);
  1437.         }
  1438.         id = entity->getSystemId();
  1439.         if (id != 0) {
  1440.             fInternalSubset.append(chSpace);
  1441.             fInternalSubset.append(XMLUni::fgSysIDString);
  1442.             fInternalSubset.append(chSpace);
  1443.             fInternalSubset.append(chDoubleQuote);
  1444.             fInternalSubset.append(id);
  1445.             fInternalSubset.append(chDoubleQuote);
  1447.         }
  1448.         id = entity->getNotationName();
  1449.         if (id != 0) {
  1450.             fInternalSubset.append(chSpace);
  1451.             fInternalSubset.append(XMLUni::fgNDATAString);
  1452.             fInternalSubset.append(chSpace);
  1453.             fInternalSubset.append(id);
  1454.         }
  1455.         id = entityDecl.getValue();
  1456.         if (id !=0) {
  1457.             fInternalSubset.append(chSpace);
  1458.             fInternalSubset.append(chDoubleQuote);
  1459.             fInternalSubset.append(id);
  1460.             fInternalSubset.append(chDoubleQuote);
  1461.         }
  1463.         fInternalSubset.append(chCloseAngle);
  1464.     }
  1466. }
  1468. void AbstractDOMParser::resetDocType()
  1469. {
  1470. fDocumentType = 0;
  1471. }
  1473. void AbstractDOMParser::notationDecl
  1474. (
  1475.     const   XMLNotationDecl&    notDecl
  1476.     , const bool                isIgnored
  1477. )
  1478. {
  1479.     DOMNotationImpl* notation = (DOMNotationImpl *)fDocument->createNotation(notDecl.getName());
  1480.     notation->setPublicId(notDecl.getPublicId());
  1481.     notation->setSystemId(notDecl.getSystemId());
  1482.     notation->setBaseURI(notDecl.getBaseURI());
  1484.     DOMNode* rem = fDocumentType->getNotations()->setNamedItem( notation );
  1485.     if (rem)
  1486.         rem->release();
  1488.     if (fDocumentType->isIntSubsetReading())
  1489.     {
  1490.         //add thes chars to internalSubset variable
  1491.         fInternalSubset.append(chOpenAngle);
  1492.         fInternalSubset.append(chBang);
  1493.         fInternalSubset.append(XMLUni::fgNotationString);
  1494.         fInternalSubset.append(chSpace);
  1496.         fInternalSubset.append(notDecl.getName());
  1498.         const XMLCh* id = notation->getPublicId();
  1499.         if (id != 0) {
  1500.             fInternalSubset.append(chSpace);
  1501.             fInternalSubset.append(XMLUni::fgPubIDString);
  1502.             fInternalSubset.append(chSpace);
  1503.             fInternalSubset.append(chDoubleQuote);
  1504.             fInternalSubset.append(id);
  1505.             fInternalSubset.append(chDoubleQuote);
  1506.         }
  1507.         id = notation->getSystemId();
  1508.         if (id != 0) {
  1509.             fInternalSubset.append(chSpace);
  1510.             fInternalSubset.append(XMLUni::fgSysIDString);
  1511.             fInternalSubset.append(chSpace);
  1512.             fInternalSubset.append(chDoubleQuote);
  1513.             fInternalSubset.append(id);
  1514.             fInternalSubset.append(chDoubleQuote);
  1516.         }
  1517.         fInternalSubset.append(chCloseAngle);
  1518.     }
  1519. }
  1521. void AbstractDOMParser::startAttList
  1522. (
  1523.     const   DTDElementDecl& elemDecl
  1524. )
  1525. {
  1526.     if (fDocumentType->isIntSubsetReading())
  1527.     {
  1528.         fInternalSubset.append(chOpenAngle);
  1529.         fInternalSubset.append(chBang);
  1530.         fInternalSubset.append(XMLUni::fgAttListString);
  1531.         fInternalSubset.append(chSpace);
  1532.         fInternalSubset.append(elemDecl.getFullName());
  1533.     }
  1534. }
  1536. void AbstractDOMParser::startIntSubset()
  1537. {
  1538. fDocumentType->fIntSubsetReading = true;
  1539. }
  1541. void AbstractDOMParser::startExtSubset()
  1542. {
  1543. }
  1545. void AbstractDOMParser::TextDecl
  1546. (
  1547.     const   XMLCh* const    versionStr
  1548.     , const XMLCh* const    encodingStr
  1549. )
  1550. {
  1551.     if (fCurrentEntity) {
  1552.         fCurrentEntity->setVersion(versionStr);
  1553.         fCurrentEntity->setEncoding(encodingStr);
  1554.     }
  1555. }
  1557. XERCES_CPP_NAMESPACE_END