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

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

词法分析

开发平台：

Visual C++

DOMParser.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /**
  58. *  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: DOMParser.cpp,v 1.18 2003/05/22 02:26:50 knoaman Exp $
  63. *
  64. */
  68. // ---------------------------------------------------------------------------
  69. //  Includes
  70. // ---------------------------------------------------------------------------
  71. #include <xercesc/internal/XMLScannerResolver.hpp>
  72. #include <xercesc/sax/EntityResolver.hpp>
  73. #include <xercesc/util/XMLUniDefs.hpp>
  74. #include <xercesc/sax/ErrorHandler.hpp>
  75. #include <xercesc/sax/SAXParseException.hpp>
  76. #include <xercesc/framework/XMLNotationDecl.hpp>
  77. #include <xercesc/util/IOException.hpp>
  78. #include <xercesc/framework/XMLValidator.hpp>
  79. #include <xercesc/validators/common/GrammarResolver.hpp>
  80. #include "DOMParser.hpp"
  81. #include "ElementImpl.hpp"
  82. #include "AttrImpl.hpp"
  83. #include "AttrNSImpl.hpp"
  84. #include "TextImpl.hpp"
  85. #include "DocumentImpl.hpp"
  86. #include "DocumentTypeImpl.hpp"
  87. #include "EntityImpl.hpp"
  88. #include "NotationImpl.hpp"
  89. #include "NamedNodeMapImpl.hpp"
  90. #include "NodeIDMap.hpp"
  93. #include <xercesc/validators/common/ContentSpecNode.hpp>
  94. #include <xercesc/validators/DTD/DTDAttDefList.hpp>
  96. XERCES_CPP_NAMESPACE_BEGIN
  99. // ---------------------------------------------------------------------------
  100. //  DOMParser: Constructors and Destructor
  101. // ---------------------------------------------------------------------------
  102. DOMParser::DOMParser( XMLValidator* const  valToAdopt
  103.                     , MemoryManager* const manager) :
  105.     fToCreateXMLDeclTypeNode(false)
  106.     , fCreateEntityReferenceNodes(true)
  107.     , fIncludeIgnorableWhitespace(true)
  108.     , fParseInProgress(false)
  109.     , fWithinElement(false)
  110.     , fEntityResolver(0)
  111.     , fErrorHandler(0)
  112.     , fNodeStack(0)
  113.     , fScanner(0)
  114.     , fDocumentType(0)
  115.     , fGrammarResolver(0)
  116.     , fURIStringPool(0)
  117.     , fValidator(valToAdopt)
  118.     , fMemoryManager(manager)
  119. {
  120.     try
  121.     {
  122.         initialize();
  123.     }
  124.     catch(...)
  125.     {
  126.         cleanUp();
  127.         throw;
  128.     }
  129. }
  132. DOMParser::~DOMParser()
  133. {
  134.     cleanUp();
  135. }
  137. // ---------------------------------------------------------------------------
  138. //  DOMParser: Initialize/CleanUp methods
  139. // ---------------------------------------------------------------------------
  140. void DOMParser::initialize()
  141. {
  142.     // Create grammar resolver and URI string pool to pass to the scanner
  143.     fGrammarResolver = new (fMemoryManager) GrammarResolver(fMemoryManager);
  144.     fURIStringPool = new (fMemoryManager) XMLStringPool(109, fMemoryManager);
  146.     //  Create a scanner and tell it what validator to use. Then set us
  147.     //  as the document event handler so we can fill the DOM document.
  148.     fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fMemoryManager);
  149.     fScanner->setDocHandler(this);
  150.     fScanner->setDocTypeHandler(this);
  151.     fScanner->setGrammarResolver(fGrammarResolver);
  152.     fScanner->setURIStringPool(fURIStringPool);
  154.     fNodeStack = new (fMemoryManager) ValueStackOf<DOM_Node>(64, fMemoryManager);
  155.     this->reset();
  156. }
  158. void DOMParser::cleanUp()
  159. {
  160.     delete fNodeStack;
  161.     delete fScanner;
  162.     delete fGrammarResolver;
  163.     delete fURIStringPool;
  165.     if (fValidator)
  166.         delete fValidator;
  167. }
  169. void DOMParser::reset()
  170. {
  171.     //
  172.     //  Note: DOM Documents are reference counted. Doing this assignment
  173.     //  will cause the old one to go away unless application code is also
  174.     //  holding a reference to it.
  175.     //
  176.     fDocument = DOM_Document::createDocument(fMemoryManager);
  177.     resetDocType();
  179.     fCurrentParent   = 0;
  180.     fCurrentNode     = 0;
  181.     fParseInProgress = false;
  182.     fWithinElement   = false;
  183.     fNodeStack->removeAllElements();
  184. };
  188. // ---------------------------------------------------------------------------
  189. //  DOMParser: Getter methods
  190. // ---------------------------------------------------------------------------
  191. const XMLValidator& DOMParser::getValidator() const
  192. {
  193.     return *fScanner->getValidator();
  194. }
  196. bool DOMParser::getDoNamespaces() const
  197. {
  198.     return fScanner->getDoNamespaces();
  199. }
  201. bool DOMParser::getExitOnFirstFatalError() const
  202. {
  203.     return fScanner->getExitOnFirstFatal();
  204. }
  206. bool DOMParser::getValidationConstraintFatal() const
  207. {
  208.     return fScanner->getValidationConstraintFatal();
  209. }
  211. DOMParser::ValSchemes DOMParser::getValidationScheme() const
  212. {
  213.     const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
  215.     if (scheme == XMLScanner::Val_Always)
  216.         return Val_Always;
  217.     else if (scheme == XMLScanner::Val_Never)
  218.         return Val_Never;
  220.     return Val_Auto;
  221. }
  223. bool DOMParser::getDoSchema() const
  224. {
  225.     return fScanner->getDoSchema();
  226. }
  228. bool DOMParser::getValidationSchemaFullChecking() const
  229. {
  230.     return fScanner->getValidationSchemaFullChecking();
  231. }
  233. int DOMParser::getErrorCount() const
  234. {
  235.     return fScanner->getErrorCount();
  236. }
  238. XMLCh* DOMParser::getExternalSchemaLocation() const
  239. {
  240.     return fScanner->getExternalSchemaLocation();
  241. }
  243. XMLCh* DOMParser::getExternalNoNamespaceSchemaLocation() const
  244. {
  245.     return fScanner->getExternalNoNamespaceSchemaLocation();
  246. }
  248. bool DOMParser::isCachingGrammarFromParse() const
  249. {
  250.     return fScanner->isCachingGrammarFromParse();
  251. }
  253. bool DOMParser::isUsingCachedGrammarInParse() const
  254. {
  255.     return fScanner->isUsingCachedGrammarInParse();
  256. }
  258. Grammar* DOMParser::getGrammar(const XMLCh* const nameSpaceKey)
  259. {
  260.     return fGrammarResolver->getGrammar(nameSpaceKey);
  261. }
  263. Grammar* DOMParser::getRootGrammar()
  264. {
  265.     return fScanner->getRootGrammar();
  266. }
  268. const XMLCh* DOMParser::getURIText(unsigned int uriId) const
  269. {
  270.     return fScanner->getURIText(uriId);
  271. }
  273. bool DOMParser::getCalculateSrcOfs() const
  274. {
  275.     return fScanner->getCalculateSrcOfs();
  276. }
  278. bool DOMParser::getStandardUriConformant() const
  279. {
  280.     return fScanner->getStandardUriConformant();
  281. }
  283. unsigned int DOMParser::getSrcOffset() const
  284. {
  285.     return fScanner->getSrcOffset();
  286. }
  288. // ---------------------------------------------------------------------------
  289. //  DOMParser: Setter methods
  290. // ---------------------------------------------------------------------------
  291. void DOMParser::setDoNamespaces(const bool newState)
  292. {
  293.     fScanner->setDoNamespaces(newState);
  294. }
  296. void DOMParser::setErrorHandler(ErrorHandler* const handler)
  297. {
  298.     fErrorHandler = handler;
  299.     if (fErrorHandler) {
  300.         fScanner->setErrorReporter(this);
  301.         fScanner->setErrorHandler(fErrorHandler);
  302.     }
  303.     else {
  304.         fScanner->setErrorReporter(0);
  305.         fScanner->setErrorHandler(0);
  306.     }
  307. }
  309. void DOMParser::setEntityResolver(EntityResolver* const handler)
  310. {
  311.     fEntityResolver = handler;
  312.     if (fEntityResolver) {
  313.         fScanner->setEntityHandler(this);
  314.     }
  315.     else {
  316.         fScanner->setEntityHandler(0);
  317.     }
  318. }
  320. void DOMParser::setExitOnFirstFatalError(const bool newState)
  321. {
  322.     fScanner->setExitOnFirstFatal(newState);
  323. }
  325. void DOMParser::setValidationConstraintFatal(const bool newState)
  326. {
  327.     fScanner->setValidationConstraintFatal(newState);
  328. }
  330. void DOMParser::setValidationScheme(const ValSchemes newScheme)
  331. {
  332.     if (newScheme == Val_Never)
  333.         fScanner->setValidationScheme(XMLScanner::Val_Never);
  334.     else if (newScheme == Val_Always)
  335.         fScanner->setValidationScheme(XMLScanner::Val_Always);
  336.     else
  337.         fScanner->setValidationScheme(XMLScanner::Val_Auto);
  338. }
  340. void DOMParser::setDoSchema(const bool newState)
  341. {
  342.     fScanner->setDoSchema(newState);
  343. }
  345. void DOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
  346. {
  347.     fScanner->setValidationSchemaFullChecking(schemaFullChecking);
  348. }
  350. void DOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
  351. {
  352.     fScanner->setExternalSchemaLocation(schemaLocation);
  353. }
  354. void DOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
  355. {
  356.     fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
  357. }
  359. void DOMParser::setExternalSchemaLocation(const char* const schemaLocation)
  360. {
  361.     fScanner->setExternalSchemaLocation(schemaLocation);
  362. }
  363. void DOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
  364. {
  365.     fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
  366. }
  368. void DOMParser::cacheGrammarFromParse(const bool newState)
  369. {
  370.     fScanner->cacheGrammarFromParse(newState);
  372.     if (newState)
  373.         fScanner->useCachedGrammarInParse(newState);
  374. }
  376. void DOMParser::useCachedGrammarInParse(const bool newState)
  377. {
  378.     if (newState || !fScanner->isCachingGrammarFromParse())
  379.         fScanner->useCachedGrammarInParse(newState);
  380. }
  382. void DOMParser::setCalculateSrcOfs(const bool newState)
  383. {
  384.     fScanner->setCalculateSrcOfs(newState);
  385. }
  387. void DOMParser::setStandardUriConformant(const bool newState)
  388. {
  389.     fScanner->setStandardUriConformant(newState);
  390. }
  392. void DOMParser::useScanner(const XMLCh* const scannerName)
  393. {
  394.     XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
  395.     (
  396.         scannerName
  397.         , fValidator
  398.         , fMemoryManager
  399.     );
  401.     if (tempScanner) {
  403.         tempScanner->setParseSettings(fScanner);
  404.         tempScanner->setGrammarResolver(fGrammarResolver);
  405.         tempScanner->setURIStringPool(fURIStringPool);
  406.         delete fScanner;
  407.         fScanner = tempScanner;
  408.     }
  409. }
  411. // ---------------------------------------------------------------------------
  412. //  DOMParser: Parsing methods
  413. // ---------------------------------------------------------------------------
  414. void DOMParser::parse(const InputSource& source)
  415. {
  416.     // Avoid multiple entrance
  417.     if (fParseInProgress)
  418.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  420.     try
  421.     {
  422.         fParseInProgress = true;
  423.         fScanner->scanDocument(source);
  424.         fParseInProgress = false;
  425.     }
  427.     catch(...)
  428.     {
  429.         fParseInProgress = false;
  430.         throw;
  431.     }
  432. }
  434. void DOMParser::parse(const XMLCh* const systemId)
  435. {
  436.     // Avoid multiple entrance
  437.     if (fParseInProgress)
  438.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  440.     try
  441.     {
  442.         fParseInProgress = true;
  443.         fScanner->scanDocument(systemId);
  444.         fParseInProgress = false;
  445.     }
  447.     catch(...)
  448.     {
  449.         fParseInProgress = false;
  450.         throw;
  451.     }
  452. }
  454. void DOMParser::parse(const char* const systemId)
  455. {
  456.     // Avoid multiple entrance
  457.     if (fParseInProgress)
  458.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  460.     try
  461.     {
  462.         fParseInProgress = true;
  463.         fScanner->scanDocument(systemId);
  464.         fParseInProgress = false;
  465.     }
  467.     catch(...)
  468.     {
  469.         fParseInProgress = false;
  470.         throw;
  471.     }
  472. }
  476. // ---------------------------------------------------------------------------
  477. //  DOMParser: Progressive parse methods
  478. // ---------------------------------------------------------------------------
  479. bool DOMParser::parseFirst( const   XMLCh* const    systemId
  480.                            ,       XMLPScanToken&  toFill)
  481. {
  482.     //
  483.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  484.     //  is in progress.
  485.     //
  486.     if (fParseInProgress)
  487.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  489.     return fScanner->scanFirst(systemId, toFill);
  490. }
  492. bool DOMParser::parseFirst( const   char* const         systemId
  493.                            ,       XMLPScanToken&      toFill)
  494. {
  495.     //
  496.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  497.     //  is in progress.
  498.     //
  499.     if (fParseInProgress)
  500.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  502.     return fScanner->scanFirst(systemId, toFill);
  503. }
  505. bool DOMParser::parseFirst( const   InputSource&    source
  506.                            ,       XMLPScanToken&  toFill)
  507. {
  508.     //
  509.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  510.     //  is in progress.
  511.     //
  512.     if (fParseInProgress)
  513.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  515.     return fScanner->scanFirst(source, toFill);
  516. }
  518. bool DOMParser::parseNext(XMLPScanToken& token)
  519. {
  520.     return fScanner->scanNext(token);
  521. }
  523. void DOMParser::parseReset(XMLPScanToken& token)
  524. {
  525.     // Reset the scanner, and then reset the parser
  526.     fScanner->scanReset(token);
  527.     reset();
  528. }
  531. // ---------------------------------------------------------------------------
  532. //  DOMParser: Implementation of the XMLErrorReporter interface
  533. // ---------------------------------------------------------------------------
  534. void DOMParser::error(  const   unsigned int                code
  535.                       , const XMLCh* const                msgDomain
  536.                       , const XMLErrorReporter::ErrTypes  errType
  537.                       , const XMLCh* const                errorText
  538.                       , const XMLCh* const                systemId
  539.                       , const XMLCh* const                publicId
  540.                       , const XMLSSize_t                  lineNum
  541.                       , const XMLSSize_t                  colNum)
  542. {
  543.     SAXParseException toThrow = SAXParseException
  544.         (
  545.         errorText
  546.         , publicId
  547.         , systemId
  548.         , lineNum
  549.         , colNum
  550.         );
  552.     //
  553.     //  If there is an error handler registered, call it, otherwise ignore
  554.     //  all but the fatal errors.
  555.     //
  556.     if (!fErrorHandler)
  557.     {
  558.         if (errType == XMLErrorReporter::ErrType_Fatal)
  559.             throw toThrow;
  560.         return;
  561.     }
  563.     if (errType == XMLErrorReporter::ErrType_Warning)
  564.         fErrorHandler->warning(toThrow);
  565.     else if (errType >= XMLErrorReporter::ErrType_Fatal)
  566.         fErrorHandler->fatalError(toThrow);
  567.     else
  568.         fErrorHandler->error(toThrow);
  569. }
  571. void DOMParser::resetErrors()
  572. {
  573. }
  576. // ---------------------------------------------------------------------------
  577. //  DOMParser: Implementation of XMLEntityHandler interface
  578. // ---------------------------------------------------------------------------
  579. InputSource*
  580. DOMParser::resolveEntity(const XMLCh* const publicId,
  581.                          const XMLCh* const systemId,
  582.                          const XMLCh* const baseURI)
  583. {
  584.     //
  585.     //  Just map it to the SAX entity resolver. If there is not one installed,
  586.     //  return a null pointer to cause the default resolution.
  587.     //
  588.     if (fEntityResolver)
  589.         return fEntityResolver->resolveEntity(publicId, systemId);
  590.     return 0;
  591. }
  595. // ---------------------------------------------------------------------------
  596. //  DOMParser: Implementation of XMLDocumentHandler interface
  597. // ---------------------------------------------------------------------------
  598. void DOMParser::docCharacters(  const   XMLCh* const    chars
  599.                               , const unsigned int    length
  600.                               , const bool            cdataSection)
  601. {
  602.     // Ignore chars outside of content
  603.     if (!fWithinElement)
  604.         return;
  606.     if (cdataSection == true)
  607.     {
  608.         DOM_CDATASection node = fDocument.createCDATASection
  609.             (
  610.             DOMString(chars, length)
  611.             );
  612.         fCurrentParent.appendChild(node);
  613.         fCurrentNode = node;
  614.     }
  615.     else
  616.     {
  617.         if (fCurrentNode.getNodeType() == DOM_Node::TEXT_NODE)
  618.         {
  619.             DOM_Text node = (DOM_Text&)fCurrentNode;
  620.             node.appendData(DOMString(chars, length));
  621.         }
  622.         else
  623.         {
  624.             DOM_Text node = fDocument.createTextNode(DOMString(chars, length));
  625.             fCurrentParent.appendChild(node);
  627.             fCurrentNode = node;
  629.         }
  630.     }
  631. }
  634. void DOMParser::docComment(const XMLCh* const comment)
  635. {
  636.     DOM_Comment dcom = fDocument.createComment(comment);
  637.     fCurrentParent.appendChild(dcom);
  638.     fCurrentNode = dcom;
  639. }
  642. void DOMParser::docPI(  const   XMLCh* const    target
  643.                       , const XMLCh* const    data)
  644. {
  645.     DOM_ProcessingInstruction pi = fDocument.createProcessingInstruction
  646.         (
  647.         target
  648.         , data
  649.         );
  650.     fCurrentParent.appendChild(pi);
  651.     fCurrentNode = pi;
  652. }
  655. void DOMParser::endEntityReference(const XMLEntityDecl& entDecl)
  656. {
  657.     if (fCreateEntityReferenceNodes == true)
  658.     {
  659.         if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
  660.             ((DOM_EntityReference&)fCurrentParent).fImpl->setReadOnly(true, true);
  661.         }
  662.         fCurrentParent = fNodeStack->pop();
  663.         fCurrentNode   = fCurrentParent;
  664.     }
  665. }
  668. void DOMParser::endElement( const   XMLElementDecl&    elemDecl
  669.                            , const unsigned int        urlId
  670.                            , const bool                isRoot
  671.                            , const XMLCh* const        elemPrefix)
  672. {
  673.     fCurrentNode   = fCurrentParent;
  674.     fCurrentParent = fNodeStack->pop();
  676.     // If we've hit the end of content, clear the flag
  677.     if (fNodeStack->empty())
  678.         fWithinElement = false;
  679. }
  682. void DOMParser::ignorableWhitespace(const   XMLCh* const    chars
  683.                                     , const unsigned int    length
  684.                                     , const bool            cdataSection)
  685. {
  686.     // Ignore chars before the root element
  687.     if (!fWithinElement || !fIncludeIgnorableWhitespace)
  688.         return;
  690.     if (fCurrentNode.getNodeType() == DOM_Node::TEXT_NODE)
  691.     {
  692.         DOM_Text node = (DOM_Text&)fCurrentNode;
  693.         node.appendData(DOMString(chars, length));
  694.     }
  695.     else
  696.     {
  697.         DOM_Text node = fDocument.createTextNode(DOMString(chars, length));
  698.         TextImpl *text = (TextImpl *) node.fImpl;
  699.         text -> setIgnorableWhitespace(true);
  700.         fCurrentParent.appendChild(node);
  702.         fCurrentNode = node;
  703.     }
  704. }
  707. void DOMParser::resetDocument()
  708. {
  709.     //
  710.     //  The reset methods are called before a new parse event occurs.
  711.     //  Reset this parsers state to clear out anything that may be left
  712.     //  from a previous use, in particular the DOM document itself.
  713.     //
  714.     this->reset();
  715. }
  718. void DOMParser::startDocument()
  719. {
  720.     // Just set the document as the current parent and current node
  721.     fCurrentParent = fDocument;
  722.     fCurrentNode   = fDocument;
  723.     // set DOM error checking off
  724.     fDocument.setErrorChecking(false);
  725. }
  728. void DOMParser::endDocument()
  729. {
  730.     // set DOM error checking back on
  731.     fDocument.setErrorChecking(true);
  732. }
  735. void DOMParser::startElement(const  XMLElementDecl&         elemDecl
  736.                              , const unsigned int            urlId
  737.                              , const XMLCh* const            elemPrefix
  738.                              , const RefVectorOf<XMLAttr>&   attrList
  739.                              , const unsigned int            attrCount
  740.                              , const bool                    isEmpty
  741.                              , const bool                    isRoot)
  742. {
  743.     DOM_Element     elem;
  744.     DocumentImpl    *docImpl = (DocumentImpl *)fDocument.fImpl;
  746.     if (fScanner -> getDoNamespaces()) {    //DOM Level 2, doNamespaces on
  747.         XMLBuffer buf(1023, fMemoryManager);
  748.         DOMString namespaceURI = 0;
  749.         DOMString elemQName = 0;
  750.         if (urlId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
  751.             fScanner->getURIText(urlId, buf);   //get namespaceURI
  752.             namespaceURI = DOMString(buf.getRawBuffer());
  754.             if (elemPrefix && *elemPrefix) {
  755.                 elemQName.appendData(elemPrefix);
  756.                 elemQName.appendData(chColon);
  757.             }
  758.         }
  759.         elemQName.appendData(elemDecl.getBaseName());
  761.         elem = fDocument.createElementNS(namespaceURI, elemQName);
  762.         ElementImpl *elemImpl = (ElementImpl *) elem.fImpl;
  763.         for (unsigned int index = 0; index < attrCount; ++index) {
  764.             static const XMLCh XMLNS[] = {
  765.             chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull
  766.             };
  767.             const XMLAttr* oneAttrib = attrList.elementAt(index);
  768.             unsigned int attrURIId = oneAttrib -> getURIId();
  769.             namespaceURI = 0;
  770.             if (!XMLString::compareString(oneAttrib -> getName(), XMLNS))    //for xmlns=...
  771.                 attrURIId = fScanner->getXMLNSNamespaceId();
  772.             if (attrURIId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
  773.                 fScanner->getURIText(attrURIId, buf);   //get namespaceURI
  774.                 namespaceURI = DOMString(buf.getRawBuffer());
  775.             }
  776.             AttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
  777.             oneAttrib -> getValue());
  779.             // Attributes of type ID.  If this is one, add it to the hashtable of IDs
  780.             //   that is constructed for use by GetElementByID().
  781.             //
  782.             if (oneAttrib->getType()==XMLAttDef::ID)
  783.             {
  784.                 if (docImpl->fNodeIDMap == 0)
  785.                     docImpl->fNodeIDMap = new (fMemoryManager) NodeIDMap(500, fMemoryManager);
  786.                 docImpl->fNodeIDMap->add(attr);
  787.                 attr->isIdAttr(true);
  788.             }
  790.             attr->setSpecified(oneAttrib->getSpecified());
  791.         }
  792.     }
  793.     else {    //DOM Level 1
  794.         elem = fDocument.createElement(elemDecl.getFullName());
  795.         ElementImpl *elemImpl = (ElementImpl *) elem.fImpl;
  796.         for (unsigned int index = 0; index < attrCount; ++index) {
  797.             const XMLAttr* oneAttrib = attrList.elementAt(index);
  798.             AttrImpl *attr = elemImpl->setAttribute(oneAttrib->getName(), oneAttrib->getValue());
  799.             attr->setSpecified(oneAttrib->getSpecified());
  801.             // Attributes of type ID.  If this is one, add it to the hashtable of IDs
  802.             //   that is constructed for use by GetElementByID().
  803.             //
  804.             if (oneAttrib->getType()==XMLAttDef::ID)
  805.             {
  806.                 if (docImpl->fNodeIDMap == 0)
  807.                     docImpl->fNodeIDMap = new (fMemoryManager) NodeIDMap(500, fMemoryManager);
  808.                 docImpl->fNodeIDMap->add(attr);
  809.                 attr->isIdAttr(true);
  810.             }
  811.         }
  812.     }
  814.     fCurrentParent.appendChild(elem);
  816.     fNodeStack->push(fCurrentParent);
  817.     fCurrentParent = elem;
  818.     fCurrentNode = elem;
  819.     fWithinElement = true;
  821.     // If an empty element, do end right now (no endElement() will be called)
  822.     if (isEmpty)
  823.         endElement(elemDecl, urlId, isRoot, elemPrefix);
  824. }
  827. void DOMParser::startEntityReference(const XMLEntityDecl& entDecl)
  828. {
  829.     if (fCreateEntityReferenceNodes == true)
  830.     {
  831. DOMString entName(entDecl.getName());
  832.         DOM_EntityReference er = fDocument.createEntityReference(entName);
  834.         //set the readOnly flag to false before appending node, will be reset in endEntityReference
  835.         er.fImpl->setReadOnly(false, true);
  837.         fCurrentParent.appendChild(er);
  838.         fNodeStack->push(fCurrentParent);
  839.         fCurrentParent = er;
  840.         fCurrentNode = er;
  842. // this entityRef needs to be stored in Entity map too.
  843.         // We'd decide later whether the entity nodes should be created by a
  844.         // separated method in parser or not. For now just stick it in if
  845.         // the ref nodes are created
  846. EntityImpl* entity = (EntityImpl*)fDocumentType->entities->getNamedItem(entName);
  847. entity->setEntityRef((EntityReferenceImpl*)er.fImpl);
  849.     }
  850. }
  853. void DOMParser::XMLDecl(const   XMLCh* const version
  854.                         , const XMLCh* const encoding
  855.                         , const XMLCh* const standalone
  856.                         , const XMLCh* const actualEncStr)
  857. {
  858.     //This is a non-standard extension to creating XMLDecl type nodes and attching to DOM Tree
  859.     // currently this flag it set to false unless user explicitly asks for it
  860.     // Needs to be revisited after W3C specs are laid out on this issue.
  862.     if (fToCreateXMLDeclTypeNode) {
  864.         DOMString ver(version);
  865.         DOMString enc(encoding);
  866.         DOMString isStd(standalone);
  867.         DOM_XMLDecl xmlDecl = fDocument.createXMLDecl(ver, enc, isStd);
  869.         fCurrentParent.appendChild(xmlDecl);
  870.     }
  871. }
  875. // ---------------------------------------------------------------------------
  876. //  DOMParser: Deprecated methods
  877. // ---------------------------------------------------------------------------
  878. bool DOMParser::getDoValidation() const
  879. {
  880.     //
  881.     //  We don't want to tie the public parser classes to the enum used
  882.     //  by the scanner, so we use a separate one and map.
  883.     //
  884.     //  DON'T mix the new and old methods!!
  885.     //
  886.     const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
  887.     if (scheme == XMLScanner::Val_Always)
  888.         return true;
  889.     return false;
  890. }
  892. void DOMParser::setDoValidation(const bool newState)
  893. {
  894.     fScanner->setDoValidation
  895.     (
  896.         newState ? XMLScanner::Val_Always : XMLScanner::Val_Never
  897.     );
  898. }
  900. //doctypehandler interfaces
  901. void DOMParser::attDef
  902. (
  903.     const   DTDElementDecl&     elemDecl
  904.     , const DTDAttDef&          attDef
  905.     , const bool                ignoring
  906. )
  907. {
  908.     if (fDocumentType->isIntSubsetReading())
  909.     {
  910.         DOMString attString;
  911.         if (elemDecl.hasAttDefs())
  912.         {
  913.             attString.appendData(chOpenAngle);
  914.             attString.appendData(chBang);
  915.             attString.appendData(XMLUni::fgAttListString);
  916.             attString.appendData(chSpace);
  917.             attString.appendData(elemDecl.getFullName());
  919.             attString.appendData(chSpace);
  920.             attString.appendData(attDef.getFullName());
  922.             // Get the type and display it
  923.             const XMLAttDef::AttTypes type = attDef.getType();
  924.             switch(type)
  925.             {
  926.             case XMLAttDef::CData :
  927.                 attString.appendData(chSpace);
  928.                 attString.appendData(XMLUni::fgCDATAString);
  929.                 break;
  930.             case XMLAttDef::ID :
  931.                 attString.appendData(chSpace);
  932.                 attString.appendData(XMLUni::fgIDString);
  933.                 break;
  934.             case XMLAttDef::IDRef :
  935.                 attString.appendData(chSpace);
  936.                 attString.appendData(XMLUni::fgIDRefString);
  937.                 break;
  938.             case XMLAttDef::IDRefs :
  939.                 attString.appendData(chSpace);
  940.                 attString.appendData(XMLUni::fgIDRefsString);
  941.                 break;
  942.             case XMLAttDef::Entity :
  943.                 attString.appendData(chSpace);
  944.                 attString.appendData(XMLUni::fgEntityString);
  945.                 break;
  946.             case XMLAttDef::Entities :
  947.                 attString.appendData(chSpace);
  948.                 attString.appendData(XMLUni::fgEntitiesString);
  949.                 break;
  950.             case XMLAttDef::NmToken :
  951.                 attString.appendData(chSpace);
  952.                 attString.appendData(XMLUni::fgNmTokenString);
  953.                 break;
  954.             case XMLAttDef::NmTokens :
  955.                 attString.appendData(chSpace);
  956.                 attString.appendData(XMLUni::fgNmTokensString);
  957.                 break;
  959.             case XMLAttDef::Notation :
  960.                 attString.appendData(chSpace);
  961.                 attString.appendData(XMLUni::fgNotationString);
  962.                 break;
  964.             case XMLAttDef::Enumeration :
  965.                 attString.appendData(chSpace);
  966.                 //  attString.appendData(XMLUni::fgEnumerationString);
  967.                 const XMLCh* enumString = attDef.getEnumeration();
  968.                 int length = XMLString::stringLen(enumString);
  969.                 if (length > 0) {
  971.                     DOMString anotherEnumString;
  973.                     anotherEnumString.appendData(chOpenParen );
  974.                     for(int i=0; i<length; i++) {
  975.                         if (enumString[i] == chSpace)
  976.                             anotherEnumString.appendData(chPipe);
  977.                         else
  978.                             anotherEnumString.appendData(enumString[i]);
  979.                     }
  980.                     anotherEnumString.appendData(chCloseParen);
  981.                     attString.appendData(anotherEnumString);
  982.                 }
  983.                 break;
  984.             }
  985.             //get te default types of the attlist
  986.             const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
  987.             switch(def)
  988.             {
  989.             case XMLAttDef::Required :
  990.                 attString.appendData(chSpace);
  991.                 attString.appendData(XMLUni::fgRequiredString);
  992.                 break;
  993.             case XMLAttDef::Implied :
  994.                 attString.appendData(chSpace);
  995.                 attString.appendData(XMLUni::fgImpliedString);
  996.                 break;
  997.             case XMLAttDef::Fixed :
  998.                 attString.appendData(chSpace);
  999.                 attString.appendData(XMLUni::fgFixedString);
  1000.                 break;
  1001.             }
  1003.             const XMLCh* defaultValue = attDef.getValue();
  1004.             if (defaultValue != 0) {
  1005.                 attString.appendData(chSpace);
  1006.                 attString.appendData(chDoubleQuote);
  1007.                 attString.appendData(defaultValue);
  1008.                 attString.appendData(chDoubleQuote);
  1009.             }
  1011.             attString.appendData(chCloseAngle);
  1012.             fDocumentType->internalSubset.appendData(attString);
  1013.         }
  1014.     }
  1015. }
  1017. void DOMParser::doctypeComment
  1018. (
  1019.     const   XMLCh* const    comment
  1020. )
  1021. {
  1022.     if (fDocumentType->isIntSubsetReading())
  1023.     {
  1024.         if (comment != 0)
  1025.         {
  1026.             DOMString comString;
  1027.             comString.appendData(XMLUni::fgCommentString);
  1028.             comString.appendData(chSpace);
  1029.             comString.appendData(comment);
  1030.             comString.appendData(chSpace);
  1031.             comString.appendData(chDash);
  1032.             comString.appendData(chDash);
  1033.             comString.appendData(chCloseAngle);
  1034.             fDocumentType->internalSubset.appendData(comString);
  1035.         }
  1036.     }
  1037. }
  1039. void DOMParser::doctypeDecl
  1040. (
  1041.     const   DTDElementDecl& elemDecl
  1042.     , const XMLCh* const    publicId
  1043.     , const XMLCh* const    systemId
  1044.     , const bool            hasIntSubset
  1045.     , const bool            hasExtSubset
  1046. )
  1047. {
  1048. DOM_DocumentType dt;
  1049. dt = fDocument.getImplementation().createDocumentType(elemDecl.getFullName(), publicId, systemId);
  1050.     fDocumentType = (DocumentTypeImpl*)dt.fImpl;
  1051. ((DocumentImpl*)fDocument.fImpl)->setDocumentType(fDocumentType);
  1053. }
  1055. void DOMParser::doctypePI
  1056. (
  1057.     const   XMLCh* const    target
  1058.     , const XMLCh* const    data
  1059. )
  1060. {
  1061.     if (fDocumentType->isIntSubsetReading())
  1062. {
  1063. //add these chars to internalSubset variable
  1064.         DOMString pi;
  1065.         pi.appendData(chOpenAngle);
  1066.         pi.appendData(chQuestion);
  1067.         pi.appendData(target);
  1068.         pi.appendData(chSpace);
  1069.         pi.appendData(data);
  1070.         pi.appendData(chQuestion);
  1071.         pi.appendData(chCloseAngle);
  1073. fDocumentType->internalSubset.appendData(pi);
  1074. }
  1076. }
  1079. void DOMParser::doctypeWhitespace
  1080. (
  1081.     const   XMLCh* const    chars
  1082.     , const unsigned int    length
  1083. )
  1084. {
  1085.     if (fDocumentType->isIntSubsetReading())
  1086. fDocumentType->internalSubset.appendData(chars);
  1087. }
  1089. void DOMParser::elementDecl
  1090. (
  1091.     const   DTDElementDecl& decl
  1092.     , const bool            isIgnored
  1093. )
  1094. {
  1095.     if (fDocumentType->isIntSubsetReading())
  1096. {
  1097.         DOMString elemDecl;
  1099.         elemDecl.appendData(chOpenAngle);
  1100.         elemDecl.appendData(chBang);
  1101.         elemDecl.appendData(XMLUni::fgElemString);
  1102.         elemDecl.appendData(chSpace);
  1103.         elemDecl.appendData(decl.getFullName());
  1105.         //get the ContentSpec information
  1106.         const XMLCh* contentModel = decl.getFormattedContentModel();
  1107.         if (contentModel != 0) {
  1108.             elemDecl.appendData(chSpace);
  1109.             elemDecl.appendData(contentModel);
  1110.         }
  1112.         elemDecl.appendData(chCloseAngle);
  1113. fDocumentType->internalSubset.appendData(elemDecl);
  1114. }
  1115. }
  1117. void DOMParser::endAttList
  1118. (
  1119.     const   DTDElementDecl& elemDecl
  1120. )
  1121. {
  1122. // this section sets up default attributes.
  1123. // default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
  1124. // default attribute data attached to the document is used to conform to the
  1125. // DOM spec regarding creating element nodes & removing attributes with default values
  1126. // see DocumentTypeImpl
  1127. if (elemDecl.hasAttDefs())
  1128. {
  1129. XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
  1130. XMLAttDef* attr = 0;
  1131. AttrImpl* insertAttr = 0;
  1132. DOM_Element dom_elem = fDocument.createElement(elemDecl.getFullName());
  1133. ElementImpl* elem = (ElementImpl*)(dom_elem.fImpl);
  1135. while (defAttrs->hasMoreElements())
  1136.         {
  1137.             attr = &defAttrs->nextElement();
  1138.             if (attr->getValue() != null)
  1139.             {
  1140.                 if (fScanner->getDoNamespaces())
  1141.                 {
  1142.                     // DOM Level 2 wants all namespace declaration attributes
  1143.                     // to be bound to "http://www.w3.org/2000/xmlns/"
  1144.                     // So as long as the XML parser doesn't do it, it needs to
  1145.                     // done here.
  1146.                     DOMString qualifiedName = attr->getFullName();
  1147.                     int index = DocumentImpl::indexofQualifiedName(qualifiedName);
  1149.                     XMLBuffer buf(1023, fMemoryManager);
  1150.                     static const XMLCh XMLNS[] = {
  1151.                         chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
  1153.                     if (index > 0) {
  1154.                         // there is prefix
  1155.                         // map to XML URI for all cases except when prefix == "xmlns"
  1156.                         DOMString prefix = qualifiedName.substringData(0, index);
  1158.                         if (prefix.equals(XMLNS))
  1159.                             buf.append(XMLUni::fgXMLNSURIName);
  1160.                         else
  1161.                             buf.append(XMLUni::fgXMLURIName);
  1162.                     }
  1163.                     else {
  1164.                         //   No prefix
  1165.                         if (qualifiedName.equals(XMLNS))
  1166.                             buf.append(XMLUni::fgXMLNSURIName);
  1167.                     }
  1169.                     insertAttr = new (fMemoryManager) AttrNSImpl((DocumentImpl*)fDocument.fImpl,
  1170.                        DOMString(buf.getRawBuffer()),     // NameSpaceURI
  1171.                        qualifiedName);   // qualified name
  1173.                 }
  1174.                 else
  1175.                 {
  1176.                     // Namespaces is turned off...
  1177.                     insertAttr = new (fMemoryManager) AttrImpl((DocumentImpl*)fDocument.fImpl, attr->getFullName());
  1178.                 }
  1179.                 insertAttr->setValue(attr->getValue());
  1180.                 // memory leak here
  1181.                 AttrImpl * previousAttr = elem->setAttributeNode(insertAttr);
  1182. if ( previousAttr != 0 && previousAttr->nodeRefCount ==0)
  1183. NodeImpl::deleteIf(previousAttr);
  1185.                 insertAttr->setSpecified(false);
  1186.             }
  1187.         }
  1188.         ElementImpl *previousElem = (ElementImpl *)
  1189.                 fDocumentType->getElements()->setNamedItem( elem );
  1191.         //
  1192.         //  If this new element is replacing an element node that was already
  1193.         //    in the element named node map, we need to delete the original
  1194.         //    element node, assuming no-one else was referencing it.
  1195.         //
  1196.         if (previousElem != 0 && previousElem->nodeRefCount == 0)
  1197.             NodeImpl::deleteIf(previousElem);
  1198.     }
  1199. }
  1201. void DOMParser::endIntSubset()
  1202. {
  1203. fDocumentType->intSubsetReading = false;
  1204. }
  1206. void DOMParser::endExtSubset()
  1207. {
  1208. }
  1210. void DOMParser::entityDecl
  1211. (
  1212.     const   DTDEntityDecl&  entityDecl
  1213.     , const bool            isPEDecl
  1214.     , const bool            isIgnored
  1215. )
  1216. {
  1217. EntityImpl* entity = ((DocumentImpl*)fDocument.fImpl)->createEntity(entityDecl.getName());
  1219. entity->setPublicId(entityDecl.getPublicId());
  1220. entity->setSystemId(entityDecl.getSystemId());
  1221. entity->setNotationName(entityDecl.getNotationName());
  1223.     EntityImpl *previousDef = (EntityImpl *)
  1224.     fDocumentType->entities->setNamedItem( entity );
  1226.     //
  1227.     //  If this new entity node is replacing an entity node that was already
  1228.     //    in the entities named node map (happens if documents redefine the
  1229.     //    predefined entited such as lt), we need to delete the original
  1230.     //    entitiy node, assuming no-one else was referencing it.
  1231.     //
  1232.     if (previousDef != 0 && previousDef->nodeRefCount == 0)
  1233.              NodeImpl::deleteIf(previousDef);
  1236. if (fDocumentType->isIntSubsetReading())
  1237. {
  1238. //add thes chars to internalSubset variable
  1239. DOMString entityName;
  1240. entityName.appendData(chOpenAngle);
  1241.         entityName.appendData(chBang);
  1242. entityName.appendData(XMLUni::fgEntityString);
  1243.         entityName.appendData(chSpace);
  1245.         entityName.appendData(entityDecl.getName());
  1246.         DOMString id = entity->getPublicId();
  1247.         if (id != 0) {
  1248.             entityName.appendData(chSpace);
  1249.             entityName.appendData(XMLUni::fgPubIDString);
  1250.             entityName.appendData(chSpace);
  1251.             entityName.appendData(chDoubleQuote);
  1252.             entityName.appendData(id);
  1253.             entityName.appendData(chDoubleQuote);
  1254.         }
  1255.         id = entity->getSystemId();
  1256.         if (id != 0) {
  1257.             entityName.appendData(chSpace);
  1258.             entityName.appendData(XMLUni::fgSysIDString);
  1259.             entityName.appendData(chSpace);
  1260.             entityName.appendData(chDoubleQuote);
  1261.             entityName.appendData(id);
  1262.             entityName.appendData(chDoubleQuote);
  1264.         }
  1265.         id = entity->getNotationName();
  1266.         if (id != 0) {
  1267.             entityName.appendData(chSpace);
  1268.             entityName.appendData(XMLUni::fgNDATAString);
  1269.             entityName.appendData(chSpace);
  1270.             entityName.appendData(chDoubleQuote);
  1271.             entityName.appendData(id);
  1272.             entityName.appendData(chDoubleQuote);
  1273.         }
  1274.         id = entityDecl.getValue();
  1275.         if (id !=0) {
  1276.             entityName.appendData(chSpace);
  1277.             entityName.appendData(chDoubleQuote);
  1278.             entityName.appendData(id);
  1279.             entityName.appendData(chDoubleQuote);
  1280.         }
  1282.         entityName.appendData(chCloseAngle);
  1283.         fDocumentType->internalSubset.appendData(entityName);
  1284.     }
  1286. }
  1288. void DOMParser::resetDocType()
  1289. {
  1290. fDocumentType = null;
  1291. }
  1293. void DOMParser::notationDecl
  1294. (
  1295.     const   XMLNotationDecl&    notDecl
  1296.     , const bool                isIgnored
  1297. )
  1298. {
  1299. NotationImpl* notation = ((DocumentImpl*)fDocument.fImpl)->createNotation(notDecl.getName());
  1300. notation->setPublicId(notDecl.getPublicId());
  1301. notation->setSystemId(notDecl.getSystemId());
  1303.     NotationImpl *previousNot = (NotationImpl *)
  1304.        fDocumentType->notations->setNamedItem( notation );
  1306.     //
  1307.     //  If this new notation is replacing a notation node that was already
  1308.     //    in the notation named node map, we need to delete the original
  1309.     //    notation node, assuming no-one else was referencing it.
  1310.     //
  1311.     if (previousNot != 0 && previousNot->nodeRefCount == 0)
  1312.         NodeImpl::deleteIf(previousNot);
  1314. }
  1316. void DOMParser::startAttList
  1317. (
  1318.     const   DTDElementDecl& elemDecl
  1319. )
  1320. {
  1321. }
  1323. void DOMParser::startIntSubset()
  1324. {
  1325. fDocumentType->intSubsetReading = true;
  1326. }
  1328. void DOMParser::startExtSubset()
  1329. {
  1330. }
  1332. void DOMParser::TextDecl
  1333. (
  1334.     const   XMLCh* const    versionStr
  1335.     , const XMLCh* const    encodingStr
  1336. )
  1337. {
  1338. }
  1341. // ---------------------------------------------------------------------------
  1342. //  DOMParser: Grammar preparsing methods
  1343. // ---------------------------------------------------------------------------
  1344. Grammar* DOMParser::loadGrammar(const char* const systemId,
  1345.                                 const short grammarType,
  1346.                                 const bool toCache)
  1347. {
  1348.     // Avoid multiple entrance
  1349.     if (fParseInProgress)
  1350.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1352.     Grammar* grammar = 0;
  1353.     try
  1354.     {
  1355.         fParseInProgress = true;
  1356.         grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
  1357.         fParseInProgress = false;
  1358.     }
  1360.     catch(...)
  1361.     {
  1362.         fParseInProgress = false;
  1363.         throw;
  1364.     }
  1366.     return grammar;
  1367. }
  1369. Grammar* DOMParser::loadGrammar(const XMLCh* const systemId,
  1370.                                 const short grammarType,
  1371.                                 const bool toCache)
  1372. {
  1373.     // Avoid multiple entrance
  1374.     if (fParseInProgress)
  1375.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1377.     Grammar* grammar = 0;
  1378.     try
  1379.     {
  1380.         fParseInProgress = true;
  1381.         grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
  1382.         fParseInProgress = false;
  1383.     }
  1385.     catch(...)
  1386.     {
  1387.         fParseInProgress = false;
  1388.         throw;
  1389.     }
  1391.     return grammar;
  1392. }
  1394. Grammar* DOMParser::loadGrammar(const InputSource& source,
  1395.                                 const short grammarType,
  1396.                                 const bool toCache)
  1397. {
  1398.     // Avoid multiple entrance
  1399.     if (fParseInProgress)
  1400.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1402.    Grammar* grammar = 0;
  1403.     try
  1404.     {
  1405.         fParseInProgress = true;
  1406.         grammar = fScanner->loadGrammar(source, grammarType, toCache);
  1407.         fParseInProgress = false;
  1408.     }
  1410.     catch(...)
  1411.     {
  1412.         fParseInProgress = false;
  1413.         throw;
  1414.     }
  1416.     return grammar;
  1417. }
  1419. void DOMParser::resetCachedGrammarPool()
  1420. {
  1421.     fGrammarResolver->resetCachedGrammar();
  1422. }
  1424. XERCES_CPP_NAMESPACE_END