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

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

词法分析

开发平台：

Visual C++

DOMBuilderImpl.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: DOMBuilderImpl.cpp,v 1.24 2003/05/16 21:36:59 knoaman Exp $
  63. *
  64. */
  68. // ---------------------------------------------------------------------------
  69. //  Includes
  70. // ---------------------------------------------------------------------------
  71. #include <xercesc/parsers/DOMBuilderImpl.hpp>
  72. #include <xercesc/util/IOException.hpp>
  73. #include <xercesc/dom/DOMEntityResolver.hpp>
  74. #include <xercesc/dom/DOMErrorHandler.hpp>
  75. #include <xercesc/dom/impl/DOMErrorImpl.hpp>
  76. #include <xercesc/dom/impl/DOMLocatorImpl.hpp>
  77. #include <xercesc/dom/DOMException.hpp>
  78. #include <xercesc/sax/SAXParseException.hpp>
  79. #include <xercesc/internal/XMLScanner.hpp>
  80. #include <xercesc/framework/Wrapper4DOMInputSource.hpp>
  81. #include <xercesc/validators/common/GrammarResolver.hpp>
  83. XERCES_CPP_NAMESPACE_BEGIN
  87. // ---------------------------------------------------------------------------
  88. //  DOMBuilderImpl: Constructors and Destructor
  89. // ---------------------------------------------------------------------------
  90. DOMBuilderImpl::DOMBuilderImpl( XMLValidator* const  valToAdopt
  91.                               , MemoryManager* const manager) :
  93. AbstractDOMParser(valToAdopt, manager)
  94. , fAutoValidation(false)
  95. , fValidation(false)
  96. , fErrorHandler(0)
  97. , fEntityResolver(0)
  98. , fFilter(0)
  99. , fCharsetOverridesXMLEncoding(true)
  100. , fUserAdoptsDocument(false)
  101. {
  102.     // dom spec has different default from scanner's default, so set explicitly
  103.     getScanner()->setNormalizeData(false);
  104. }
  107. DOMBuilderImpl::~DOMBuilderImpl()
  108. {
  109. }
  112. // ---------------------------------------------------------------------------
  113. //  DOMBuilderImpl: Setter methods
  114. // ---------------------------------------------------------------------------
  115. void DOMBuilderImpl::setErrorHandler(DOMErrorHandler* const handler)
  116. {
  117.     fErrorHandler = handler;
  118.     if (fErrorHandler) {
  119.         getScanner()->setErrorReporter(this);
  120.     }
  121.     else {
  122.         getScanner()->setErrorReporter(0);
  123.     }
  124. }
  126. void DOMBuilderImpl::setEntityResolver(DOMEntityResolver* const handler)
  127. {
  128.     fEntityResolver = handler;
  129.     if (fEntityResolver) {
  130.         getScanner()->setEntityHandler(this);
  131.     }
  132.     else {
  133.         getScanner()->setEntityHandler(0);
  134.     }
  135. }
  137. void DOMBuilderImpl::setFilter(DOMBuilderFilter* const filter)
  138. {
  139.     throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  140. }
  143. // ---------------------------------------------------------------------------
  144. //  DOMBuilderImpl: Feature methods
  145. // ---------------------------------------------------------------------------
  146. void DOMBuilderImpl::setFeature(const XMLCh* const name, const bool state)
  147. {
  148.     if (XMLString::compareIString(name, XMLUni::fgDOMEntities) == 0) {
  149.         setCreateEntityReferenceNodes(state);
  150.     }
  151.     else if (XMLString::compareIString(name, XMLUni::fgDOMComments) == 0) {
  152.         setCreateCommentNodes(state);
  153.     }
  154.     else if (XMLString::compareIString(name, XMLUni::fgDOMDatatypeNormalization) == 0) {
  155.         getScanner()->setNormalizeData(state);
  156.     }
  157.     else if (XMLString::compareIString(name, XMLUni::fgDOMNamespaces) == 0) {
  158.         setDoNamespaces(state);
  159.     }
  160.     else if (XMLString::compareIString(name, XMLUni::fgDOMWhitespaceInElementContent) == 0) {
  161.         setIncludeIgnorableWhitespace(state);
  162.     }
  163.     else if (XMLString::compareIString(name, XMLUni::fgDOMValidation) == 0) {
  165.         fValidation = state;
  167.         if (state) {
  168.             if (getValidationScheme() == AbstractDOMParser::Val_Never)
  169.                 setValidationScheme(AbstractDOMParser::Val_Always);
  170.         }
  171.         else {
  172.             setValidationScheme(AbstractDOMParser::Val_Never);
  173.         }
  174.     }
  175.     else if (XMLString::compareIString(name, XMLUni::fgDOMValidateIfSchema) == 0) {
  177.         fAutoValidation = state;
  179.         if (state) {
  180.             setValidationScheme(AbstractDOMParser::Val_Auto);
  181.         }
  182.         else {
  183.             setValidationScheme(AbstractDOMParser::Val_Never);
  184.         }
  185.     }
  186.     else if (XMLString::compareIString(name, XMLUni::fgDOMCharsetOverridesXMLEncoding) == 0) {
  187.         // in fact, setting this has no effect to the parser
  188.         fCharsetOverridesXMLEncoding = state;
  189.     }
  190.     else if (XMLString::compareIString(name, XMLUni::fgDOMSupportedMediatypesOnly) == 0 ||
  191.              XMLString::compareIString(name, XMLUni::fgDOMInfoset) == 0 ||
  192.              XMLString::compareIString(name, XMLUni::fgDOMCanonicalForm) == 0 ) {
  193.         if (state)
  194.             throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  195.     }
  196.     else if (XMLString::compareIString(name, XMLUni::fgDOMNamespaceDeclarations) == 0 ||
  197.              XMLString::compareIString(name, XMLUni::fgDOMCDATASections) == 0 ) {
  198.         if (!state)
  199.             throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  200.     }
  201.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchema) == 0)
  202.     {
  203.         setDoSchema(state);
  204.     }
  205.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaFullChecking) == 0)
  206.     {
  207.         setValidationSchemaFullChecking(state);
  208.     }
  209.     else if (XMLString::compareIString(name, XMLUni::fgXercesUserAdoptsDOMDocument) == 0)
  210.     {
  211.         if(state)
  212.             fUserAdoptsDocument = true;
  213.         else
  214.             fUserAdoptsDocument = false;
  215.     }
  217.     else if (XMLString::compareIString(name, XMLUni::fgXercesLoadExternalDTD) == 0)
  218.     {
  219.         setLoadExternalDTD(state);
  220.     }
  222.     else if (XMLString::compareIString(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
  223.     {
  224.         setExitOnFirstFatalError(!state);
  225.     }
  226.     else if (XMLString::compareIString(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
  227.     {
  228.         setValidationConstraintFatal(state);
  229.     }
  230.     else if (XMLString::compareIString(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
  231.     {
  232.         getScanner()->cacheGrammarFromParse(state);
  234.         if (state)
  235.             getScanner()->useCachedGrammarInParse(state);
  236.     }
  237.     else if (XMLString::compareIString(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
  238.     {
  239.         if (state || !getScanner()->isCachingGrammarFromParse())
  240.             getScanner()->useCachedGrammarInParse(state);
  241.     }
  242.     else if (XMLString::compareIString(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
  243.     {
  244.         getScanner()->setCalculateSrcOfs(state);
  245.     }
  246.     else if (XMLString::compareIString(name, XMLUni::fgXercesStandardUriConformant) == 0)
  247.     {
  248.         getScanner()->setStandardUriConformant(state);
  249.     }
  250.     else {
  251.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  252.     }
  253. }
  255. bool DOMBuilderImpl::getFeature(const XMLCh* const name) const
  256. {
  257.     if (XMLString::compareIString(name, XMLUni::fgDOMEntities) == 0) {
  258.         return getCreateEntityReferenceNodes();
  259.     }
  260.     else if (XMLString::compareIString(name, XMLUni::fgDOMComments) == 0) {
  261.         return getCreateCommentNodes();
  262.     }
  263.     else if (XMLString::compareIString(name, XMLUni::fgDOMDatatypeNormalization) == 0) {
  264.         return getScanner()->getNormalizeData();
  265.     }
  266.     else if (XMLString::compareIString(name, XMLUni::fgDOMNamespaces) == 0) {
  267.         return getDoNamespaces();
  268.     }
  269.     else if (XMLString::compareIString(name, XMLUni::fgDOMWhitespaceInElementContent) == 0) {
  270.         return getIncludeIgnorableWhitespace();
  271.     }
  272.     else if (XMLString::compareIString(name, XMLUni::fgDOMValidation) == 0) {
  273.         return fValidation;
  274.     }
  275.     else if (XMLString::compareIString(name, XMLUni::fgDOMValidateIfSchema) == 0) {
  276.         return fAutoValidation;
  277.     }
  278.     else if (XMLString::compareIString(name, XMLUni::fgDOMCharsetOverridesXMLEncoding) == 0) {
  279.         return fCharsetOverridesXMLEncoding;
  280.     }
  281.     else if (XMLString::compareIString(name, XMLUni::fgDOMSupportedMediatypesOnly) == 0 ||
  282.              XMLString::compareIString(name, XMLUni::fgDOMInfoset) == 0 ||
  283.              XMLString::compareIString(name, XMLUni::fgDOMCanonicalForm) == 0 ) {
  284.         return false;
  285.     }
  286.     else if (XMLString::compareIString(name, XMLUni::fgDOMNamespaceDeclarations) == 0 ||
  287.              XMLString::compareIString(name, XMLUni::fgDOMCDATASections) == 0 ) {
  288.         return true;
  289.     }
  290.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchema) == 0)
  291.     {
  292.         return getDoSchema();
  293.     }
  295.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaFullChecking) == 0)
  296.     {
  297.         return getValidationSchemaFullChecking();
  298.     }
  300.     else if (XMLString::compareIString(name, XMLUni::fgXercesLoadExternalDTD) == 0)
  301.     {
  302.         return getLoadExternalDTD();
  303.     }
  305.     else if (XMLString::compareIString(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
  306.     {
  307.         return !getExitOnFirstFatalError();
  308.     }
  309.     else if (XMLString::compareIString(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
  310.     {
  311.         return getValidationConstraintFatal();
  312.     }
  313.     else if (XMLString::compareIString(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
  314.     {
  315.         return getScanner()->isCachingGrammarFromParse();
  316.     }
  317.     else if (XMLString::compareIString(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
  318.     {
  319.         return getScanner()->isUsingCachedGrammarInParse();
  320.     }
  321.     else if (XMLString::compareIString(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
  322.     {
  323.         return getScanner()->getCalculateSrcOfs();
  324.     }
  325.     else if (XMLString::compareIString(name, XMLUni::fgXercesStandardUriConformant) == 0)
  326.     {
  327.         return getScanner()->getStandardUriConformant();
  328.     }
  329.     else if(XMLString::compareIString(name, XMLUni::fgXercesUserAdoptsDOMDocument) == 0) {
  330.         return fUserAdoptsDocument;
  331.     }
  332.     else {
  333.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  334.     }
  336.     return false;
  337. }
  339. bool DOMBuilderImpl::canSetFeature(const XMLCh* const name, const bool state) const
  340. {
  341.     if ((XMLString::compareIString(name, XMLUni::fgDOMEntities) == 0) ||
  342.         (XMLString::compareIString(name, XMLUni::fgDOMComments) == 0) ||
  343.         (XMLString::compareIString(name, XMLUni::fgDOMDatatypeNormalization) == 0) ||
  344.         (XMLString::compareIString(name, XMLUni::fgDOMNamespaces) == 0) ||
  345.         (XMLString::compareIString(name, XMLUni::fgDOMValidation) == 0) ||
  346.         (XMLString::compareIString(name, XMLUni::fgDOMValidateIfSchema) == 0) ||
  347.         (XMLString::compareIString(name, XMLUni::fgDOMCharsetOverridesXMLEncoding) == 0) ||
  348.         (XMLString::compareIString(name, XMLUni::fgDOMWhitespaceInElementContent) == 0) ||
  349.         (XMLString::compareIString(name, XMLUni::fgXercesUserAdoptsDOMDocument) == 0) ||
  350.         (XMLString::compareIString(name, XMLUni::fgXercesCalculateSrcOfs) == 0) ||
  351.         (XMLString::compareIString(name, XMLUni::fgXercesStandardUriConformant) == 0)) {
  352.         return true;
  353.     }
  355.     else if (XMLString::compareIString(name, XMLUni::fgDOMSupportedMediatypesOnly) == 0 ||
  356.              XMLString::compareIString(name, XMLUni::fgDOMInfoset) == 0 ||
  357.              XMLString::compareIString(name, XMLUni::fgDOMCanonicalForm) == 0 ) {
  358.         if (!state)
  359.             return true;
  360.     }
  361.     else if (XMLString::compareIString(name, XMLUni::fgDOMNamespaceDeclarations) == 0 ||
  362.              XMLString::compareIString(name, XMLUni::fgDOMCDATASections) == 0 ) {
  363.         if (state)
  364.             return true;
  365.     }
  366.     else if ((XMLString::compareIString(name, XMLUni::fgXercesSchema) == 0) ||
  367.              (XMLString::compareIString(name, XMLUni::fgXercesSchemaFullChecking) == 0) ||
  368.              (XMLString::compareIString(name, XMLUni::fgXercesLoadExternalDTD) == 0) ||
  369.              (XMLString::compareIString(name, XMLUni::fgXercesContinueAfterFatalError) == 0) ||
  370.              (XMLString::compareIString(name, XMLUni::fgXercesValidationErrorAsFatal) == 0) ||
  371.              (XMLString::compareIString(name, XMLUni::fgXercesCacheGrammarFromParse) == 0) ||
  372.              (XMLString::compareIString(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)) {
  373.         return true;
  374.     }
  375.     return false;
  376. }
  379. // ---------------------------------------------------------------------------
  380. //  DOMBuilderImpl: Non standard extension
  381. // ---------------------------------------------------------------------------
  382. void DOMBuilderImpl::setProperty(const XMLCh* const name, void* value)
  383. {
  384. if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
  385. {
  386. setExternalSchemaLocation((XMLCh*)value);
  387. }
  389. else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
  390. {
  391. setExternalNoNamespaceSchemaLocation((XMLCh*)value);
  392. }
  393. else if (XMLString::compareIString(name, XMLUni::fgXercesSecurityManager) == 0)
  394. {
  395. setSecurityManager((SecurityManager*)value);
  396. }
  397.     else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
  398.     {
  399.         AbstractDOMParser::useScanner((const XMLCh*) value);
  400.     }
  401.     else
  402.       throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  403. }
  406. void* DOMBuilderImpl::getProperty(const XMLCh* const name) const
  407. {
  408.     if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
  409.         return (void*)getExternalSchemaLocation();
  410.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
  411.         return (void*)getExternalNoNamespaceSchemaLocation();
  412.     else if (XMLString::compareIString(name, XMLUni::fgXercesSecurityManager) == 0)
  413.         return (void*)getSecurityManager();
  414.     else
  415.         throw DOMException(DOMException::NOT_FOUND_ERR, 0);
  416.     return 0;
  417. }
  419. void DOMBuilderImpl::release()
  420. {
  421.     DOMBuilderImpl* builder = (DOMBuilderImpl*) this;
  422.     delete builder;
  423. }
  425. void DOMBuilderImpl::resetDocumentPool()
  426. {
  427.     resetPool();
  428. }
  431. // ---------------------------------------------------------------------------
  432. //  DOMBuilderImpl: Parsing methods
  433. // ---------------------------------------------------------------------------
  434. DOMDocument* DOMBuilderImpl::parse(const DOMInputSource& source)
  435. {
  436.     Wrapper4DOMInputSource isWrapper((DOMInputSource*) &source, false, getMemoryManager());
  438.     AbstractDOMParser::parse(isWrapper);
  439.     if (fUserAdoptsDocument)
  440.         return adoptDocument();
  441.     else
  442.         return getDocument();
  443. }
  445. DOMDocument* DOMBuilderImpl::parseURI(const XMLCh* const systemId)
  446. {
  447.     AbstractDOMParser::parse(systemId);
  448.     if (fUserAdoptsDocument)
  449.         return adoptDocument();
  450.     else
  451.         return getDocument();
  452. }
  454. DOMDocument* DOMBuilderImpl::parseURI(const char* const systemId)
  455. {
  456.     AbstractDOMParser::parse(systemId);
  457.     if (fUserAdoptsDocument)
  458.         return adoptDocument();
  459.     else
  460.         return getDocument();
  461. }
  463. void DOMBuilderImpl::parseWithContext(const DOMInputSource& source,
  464.                                       DOMNode* const contextNode,
  465.                                       const short action)
  466. {
  467.     throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0);
  468. }
  471. // ---------------------------------------------------------------------------
  472. //  DOMBuilderImpl: Implementation of the XMLErrorReporter interface
  473. // ---------------------------------------------------------------------------
  474. void DOMBuilderImpl::error( const   unsigned int                code
  475.                             , const XMLCh* const                msgDomain
  476.                             , const XMLErrorReporter::ErrTypes  errType
  477.                             , const XMLCh* const                errorText
  478.                             , const XMLCh* const                systemId
  479.                             , const XMLCh* const                publicId
  480.                             , const XMLSSize_t                  lineNum
  481.                             , const XMLSSize_t                  colNum)
  482. {
  483.     if (fErrorHandler) {
  485.         short severity = DOMError::DOM_SEVERITY_ERROR;
  487.         if (errType == XMLErrorReporter::ErrType_Warning)
  488.             severity = DOMError::DOM_SEVERITY_WARNING;
  489.         else if (errType == XMLErrorReporter::ErrType_Fatal)
  490.             severity = DOMError::DOM_SEVERITY_FATAL_ERROR;
  492.         DOMLocatorImpl location((int)lineNum, (int) colNum, getCurrentNode(), systemId);
  493.         DOMErrorImpl domError(severity, errorText, &location);
  495.         // if user return false, we should stop the process, so throw an error
  496.         if (!fErrorHandler->handleError(domError) && !getScanner()->getInException())
  497.             throw (XMLErrs::Codes) code;
  498.     }
  499. }
  501. void DOMBuilderImpl::resetErrors()
  502. {
  503. }
  506. // ---------------------------------------------------------------------------
  507. //  DOMBuilderImpl: Implementation of XMLEntityHandler interface
  508. // ---------------------------------------------------------------------------
  509. InputSource*
  510. DOMBuilderImpl::resolveEntity(const XMLCh* const publicId,
  511.                               const XMLCh* const systemId,
  512.                               const XMLCh* const baseURI)
  513. {
  514.     //
  515.     //  Just map it to the SAX entity resolver. If there is not one installed,
  516.     //  return a null pointer to cause the default resolution.
  517.     //
  518.     if (fEntityResolver) {
  520.         DOMInputSource* is = fEntityResolver->resolveEntity(publicId, systemId, baseURI);
  522.         if (is)
  523.             return new Wrapper4DOMInputSource(is, true, getMemoryManager());
  524.     }
  526.     return 0;
  527. }
  529. // ---------------------------------------------------------------------------
  530. //  DOMBuilderImpl: Grammar preparsing methods
  531. // ---------------------------------------------------------------------------
  532. Grammar* DOMBuilderImpl::loadGrammar(const char* const systemId,
  533.                                      const short grammarType,
  534.                                      const bool toCache)
  535. {
  536.     // Avoid multiple entrance
  537.     if (getParseInProgress())
  538.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  540. Grammar* grammar = 0;
  541.     try
  542.     {
  543.         setParseInProgress(true);
  544.         grammar = getScanner()->loadGrammar(systemId, grammarType, toCache);
  546.         // Release DOM tree - DTD
  547.         DOMDocument* doc = adoptDocument();
  548.         if (doc)
  549.             doc->release();
  551.         setParseInProgress(false);
  552.     }
  554.     catch(...)
  555.     {
  556.         setParseInProgress(false);
  557.         throw;
  558.     }
  560.     return grammar;
  561. }
  563. Grammar* DOMBuilderImpl::loadGrammar(const XMLCh* const systemId,
  564.                                      const short grammarType,
  565.                                      const bool toCache)
  566. {
  567.     // Avoid multiple entrance
  568.     if (getParseInProgress())
  569.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  571.     Grammar* grammar = 0;
  572.     try
  573.     {
  574.         setParseInProgress(true);
  575.         grammar = getScanner()->loadGrammar(systemId, grammarType, toCache);
  577.         // Release DOM tree - DTD
  578.         DOMDocument* doc = adoptDocument();
  579.         if (doc)
  580.             doc->release();
  582.         setParseInProgress(false);
  583.     }
  585.     catch(...)
  586.     {
  587.         setParseInProgress(false);
  588.         throw;
  589.     }
  591.     return grammar;
  592. }
  594. Grammar* DOMBuilderImpl::loadGrammar(const DOMInputSource& source,
  595.                                      const short grammarType,
  596.                                      const bool toCache)
  597. {
  598.     // Avoid multiple entrance
  599.     if (getParseInProgress())
  600.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  602.     Grammar* grammar = 0;
  603.     try
  604.     {
  605.         Wrapper4DOMInputSource isWrapper((DOMInputSource*) &source, false, getMemoryManager());
  607.         setParseInProgress(true);
  608.         grammar = getScanner()->loadGrammar(isWrapper, grammarType, toCache);
  610.         // Release DOM tree - DTD
  611.         DOMDocument* doc = adoptDocument();
  612.         if (doc)
  613.             doc->release();
  615.         setParseInProgress(false);
  616.     }
  618.     catch(...)
  619.     {
  620.         setParseInProgress(false);
  621.         throw;
  622.     }
  624.     return grammar;
  625. }
  627. void DOMBuilderImpl::resetCachedGrammarPool()
  628. {
  629.     getGrammarResolver()->resetCachedGrammar();
  630. }
  632. Grammar* DOMBuilderImpl::getGrammar(const XMLCh* const nameSpaceKey) const
  633. {
  634.     return getGrammarResolver()->getGrammar(nameSpaceKey);
  635. }
  637. Grammar* DOMBuilderImpl::getRootGrammar() const
  638. {
  639.     return getScanner()->getRootGrammar();
  640. }
  642. const XMLCh* DOMBuilderImpl::getURIText(unsigned int uriId) const
  643. {
  644.     return getScanner()->getURIText(uriId);
  645. }
  647. unsigned int DOMBuilderImpl::getSrcOffset() const
  648. {
  649.     return getScanner()->getSrcOffset();
  650. }
  652. XERCES_CPP_NAMESPACE_END