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

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

词法分析

开发平台：

Visual C++

SAXParser.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-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) 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.  * $Log: SAXParser.cpp,v $
  59.  * Revision 1.19  2003/05/18 14:02:05  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.18  2003/05/16 21:36:59  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.17  2003/05/15 18:26:50  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.16  2003/04/17 21:58:50  neilg
  69.  * Adding a new property,
  70.  * http://apache.org/xml/properties/security-manager, with
  71.  * appropriate getSecurityManager/setSecurityManager methods on DOM
  72.  * and SAX parsers.  Also adding a new SecurityManager class.
  73.  *
  74.  * The purpose of these modifications is to permit applications a
  75.  * means to have the parser reject documents whose processing would
  76.  * otherwise consume large amounts of system resources.  Malicious
  77.  * use of such documents could be used to launch a denial-of-service
  78.  * attack against a system running the parser.  Initially, the
  79.  * SecurityManager only knows about attacks that can result from
  80.  * exponential entity expansion; this is the only known attack that
  81.  * involves processing a single XML document.  Other, simlar attacks
  82.  * can be launched if arbitrary schemas may be parsed; there already
  83.  * exist means (via use of the EntityResolver interface) by which
  84.  * applications can deny processing of untrusted schemas.  In future,
  85.  * the SecurityManager will be expanded to take these other exploits
  86.  * into account.
  87.  *
  88.  * add security manager
  89.  * 
  90.  * Revision 1.15  2003/02/04 19:27:43  knoaman
  91.  * Performance: use global buffer to eliminate repetitive memory creation/deletion.
  92.  *
  93.  * Revision 1.14  2003/01/09 19:07:08  tng
  94.  * [Bug 15802] Add "const" qualifier to getURIText.
  95.  *
  96.  * Revision 1.13  2003/01/03 20:09:36  tng
  97.  * New feature StandardUriConformant to force strict standard uri conformance.
  98.  *
  99.  * Revision 1.12  2002/12/27 16:16:51  knoaman
  100.  * Set scanner options and handlers.
  101.  *
  102.  * Revision 1.11  2002/12/23 15:23:18  knoaman
  103.  * Added a public api to various parsers to return the src offset within the input
  104.  * source.
  105.  *
  106.  * Revision 1.10  2002/12/04 01:57:09  knoaman
  107.  * Scanner re-organization.
  108.  *
  109.  * Revision 1.9  2002/11/04 14:57:03  tng
  110.  * C++ Namespace Support.
  111.  *
  112.  * Revision 1.8  2002/08/14 15:20:38  knoaman
  113.  * [Bug 3111] Problem with LexicalHandler::startDTD() and LexicalHandler::endDTD().
  114.  *
  115.  * Revision 1.7  2002/07/11 18:27:04  knoaman
  116.  * Grammar caching/preparsing - initial implementation.
  117.  *
  118.  * Revision 1.6  2002/05/30 16:20:09  tng
  119.  * Add feature to optionally ignore external DTD.
  120.  *
  121.  * Revision 1.5  2002/05/29 21:37:47  knoaman
  122.  * Add baseURI to resolveEntity to support DOMInputSource.
  123.  *
  124.  * Revision 1.4  2002/05/28 20:44:14  tng
  125.  * [Bug 9104] prefixes dissapearing when schema validation turned on.
  126.  *
  127.  * Revision 1.3  2002/05/27 18:39:21  tng
  128.  * To get ready for 64 bit large file, use XMLSSize_t to represent line and column number.
  129.  *
  130.  * Revision 1.2  2002/05/22 20:53:41  knoaman
  131.  * Prepare for DOM L3 :
  132.  * - Make use of the XMLEntityHandler/XMLErrorReporter interfaces, instead of using
  133.  * EntityHandler/ErrorHandler directly.
  134.  * - Add 'AbstractDOMParser' class to provide common functionality for XercesDOMParser
  135.  * and DOMBuilder.
  136.  *
  137.  * Revision 1.1.1.1  2002/02/01 22:22:07  peiyongz
  138.  * sane_include
  139.  *
  140.  * Revision 1.23  2001/11/20 18:51:44  tng
  141.  * Schema: schemaLocation and noNamespaceSchemaLocation to be specified outside the instance document.  New methods setExternalSchemaLocation and setExternalNoNamespaceSchemaLocation are added (for SAX2, two new properties are added).
  142.  *
  143.  * Revision 1.22  2001/10/25 19:46:15  tng
  144.  * Comment outside root element should also be reported.
  145.  *
  146.  * Revision 1.21  2001/08/01 19:11:02  tng
  147.  * Add full schema constraint checking flag to the samples and the parser.
  148.  *
  149.  * Revision 1.20  2001/06/03 19:26:20  jberry
  150.  * Add support for querying error count following parse; enables simple parse without requiring error handler.
  151.  *
  152.  * Revision 1.19  2001/05/11 13:26:22  tng
  153.  * Copyright update.
  154.  *
  155.  * Revision 1.18  2001/05/03 19:09:23  knoaman
  156.  * Support Warning/Error/FatalError messaging.
  157.  * Validity constraints errors are treated as errors, with the ability by user to set
  158.  * validity constraints as fatal errors.
  159.  *
  160.  * Revision 1.17  2001/03/30 16:46:57  tng
  161.  * Schema: Use setDoSchema instead of setSchemaValidation which makes more sense.
  162.  *
  163.  * Revision 1.16  2001/03/21 21:56:08  tng
  164.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  165.  *
  166.  * Revision 1.15  2001/02/15 15:56:29  tng
  167.  * Schema: Add setSchemaValidation and getSchemaValidation for DOMParser and SAXParser.
  168.  * Add feature "http://apache.org/xml/features/validation/schema" for SAX2XMLReader.
  169.  * New data field  fSchemaValidation in XMLScanner as the flag.
  170.  *
  171.  * Revision 1.14  2000/09/05 23:38:26  andyh
  172.  * Added advanced callback support for XMLDecl()
  173.  *
  174.  * Revision 1.13  2000/06/19 18:12:56  rahulj
  175.  * Suppress the comments, characters, ignoreableWhitespaces before
  176.  * root element. Only allow the PI's to get through. Still need to come
  177.  * to a consensus on this.
  178.  *
  179.  * Revision 1.12  2000/06/17 02:00:55  rahulj
  180.  * Also pass any PI's, comment's, character's occuring before root
  181.  * element to the registered document Handler. Defect identified
  182.  * by John Smirl and Rich Taylor.
  183.  *
  184.  * Revision 1.11  2000/05/15 22:31:18  andyh
  185.  * Replace #include<memory.h> with <string.h> everywhere.
  186.  *
  187.  * Revision 1.10  2000/04/12 22:58:30  roddey
  188.  * Added support for 'auto validate' mode.
  189.  *
  190.  * Revision 1.9  2000/04/11 19:17:58  roddey
  191.  * If a SAX error handler is installed, then the resetErrors() event handler
  192.  * should call the one on the installed SAX error handler.
  193.  *
  194.  * Revision 1.8  2000/04/05 18:56:17  roddey
  195.  * Init the fDTDHandler member. Enable installation of DTDHandler
  196.  * on SAX parser.
  197.  *
  198.  * Revision 1.7  2000/03/03 01:29:34  roddey
  199.  * Added a scanReset()/parseReset() method to the scanner and
  200.  * parsers, to allow for reset after early exit from a progressive parse.
  201.  * Added calls to new Terminate() call to all of the samples. Improved
  202.  * documentation in SAX and DOM parsers.
  203.  *
  204.  * Revision 1.6  2000/03/02 19:54:33  roddey
  205.  * This checkin includes many changes done while waiting for the
  206.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  207.  * available elsewhere.
  208.  *
  209.  * Revision 1.5  2000/02/17 03:54:26  rahulj
  210.  * Added some new getters to query the parser state and
  211.  * clarified the documentation.
  212.  *
  213.  * Revision 1.4  2000/02/06 07:47:56  rahulj
  214.  * Year 2K copyright swat.
  215.  *
  216.  * Revision 1.3  2000/01/12 00:15:22  roddey
  217.  * Changes to deal with multiply nested, relative pathed, entities and to deal
  218.  * with the new URL class changes.
  219.  *
  220.  * Revision 1.2  1999/12/15 19:57:48  roddey
  221.  * Got rid of redundant 'const' on boolean return value. Some compilers choke
  222.  * on this and its useless.
  223.  *
  224.  * Revision 1.1.1.1  1999/11/09 01:07:50  twl
  225.  * Initial checkin
  226.  *
  227.  * Revision 1.6  1999/11/08 20:44:53  rahul
  228.  * Swat for adding in Product name and CVS comment log variable.
  229.  *
  230.  */
  233. // ---------------------------------------------------------------------------
  234. //  Includes
  235. // ---------------------------------------------------------------------------
  236. #include <xercesc/parsers/SAXParser.hpp>
  237. #include <xercesc/internal/XMLScannerResolver.hpp>
  238. #include <xercesc/framework/XMLValidator.hpp>
  239. #include <xercesc/util/IOException.hpp>
  240. #include <xercesc/sax/DocumentHandler.hpp>
  241. #include <xercesc/sax/DTDHandler.hpp>
  242. #include <xercesc/sax/ErrorHandler.hpp>
  243. #include <xercesc/sax/EntityResolver.hpp>
  244. #include <xercesc/sax/SAXParseException.hpp>
  245. #include <xercesc/validators/common/GrammarResolver.hpp>
  246. #include <string.h>
  248. XERCES_CPP_NAMESPACE_BEGIN
  251. // ---------------------------------------------------------------------------
  252. //  SAXParser: Constructors and Destructor
  253. // ---------------------------------------------------------------------------
  254. SAXParser::SAXParser( XMLValidator* const  valToAdopt
  255.                     , MemoryManager* const manager) :
  257.     fParseInProgress(false)
  258.     , fElemDepth(0)
  259.     , fAdvDHCount(0)
  260.     , fAdvDHListSize(32)
  261.     , fDocHandler(0)
  262.     , fDTDHandler(0)
  263.     , fEntityResolver(0)
  264.     , fErrorHandler(0)
  265.     , fAdvDHList(0)
  266.     , fScanner(0)
  267.     , fGrammarResolver(0)
  268.     , fURIStringPool(0)
  269.     , fValidator(valToAdopt)
  270.     , fMemoryManager(manager)
  271.     , fElemQNameBuf(1023, manager)
  272. {
  273.     try
  274.     {
  275.         initialize();
  276.     }
  277.     catch(...)
  278.     {
  279.         cleanUp();
  280.         throw;
  281.     }
  282. }
  285. SAXParser::~SAXParser()
  286. {
  287.     cleanUp();
  288. }
  290. // ---------------------------------------------------------------------------
  291. //  SAXParser: Initialize/CleanUp methods
  292. // ---------------------------------------------------------------------------
  293. void SAXParser::initialize()
  294. {
  295.     // Create grammar resolver and string pool to pass to scanner
  296.     fGrammarResolver = new (fMemoryManager) GrammarResolver(fMemoryManager);
  297.     fURIStringPool = new (fMemoryManager) XMLStringPool(109, fMemoryManager);
  299.     // Create our scanner and tell it what validator to use
  300.     fScanner = XMLScannerResolver::getDefaultScanner(fValidator,fMemoryManager);
  301.     fScanner->setGrammarResolver(fGrammarResolver);
  302.     fScanner->setURIStringPool(fURIStringPool);
  304.     // Create the initial advanced handler list array and zero it out
  305.     fAdvDHList = (XMLDocumentHandler**) fMemoryManager->allocate
  306.     (
  307.         fAdvDHListSize * sizeof(XMLDocumentHandler*)
  308.     );//new XMLDocumentHandler*[fAdvDHListSize];
  309.     memset(fAdvDHList, 0, sizeof(void*) * fAdvDHListSize);
  310. }
  312. void SAXParser::cleanUp()
  313. {
  314.     fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
  315.     delete fScanner;
  316.     delete fGrammarResolver;
  317.     delete fURIStringPool;
  319.     if (fValidator)
  320.         delete fValidator;
  321. }
  324. // ---------------------------------------------------------------------------
  325. //  SAXParser: Advanced document handler list maintenance methods
  326. // ---------------------------------------------------------------------------
  327. void SAXParser::installAdvDocHandler(XMLDocumentHandler* const toInstall)
  328. {
  329.     // See if we need to expand and do so now if needed
  330.     if (fAdvDHCount == fAdvDHListSize)
  331.     {
  332.         // Calc a new size and allocate the new temp buffer
  333.         const unsigned int newSize = (unsigned int)(fAdvDHListSize * 1.5);
  334.         XMLDocumentHandler** newList = (XMLDocumentHandler**) fMemoryManager->allocate
  335.         (
  336.             newSize * sizeof(XMLDocumentHandler*)
  337.         );//new XMLDocumentHandler*[newSize];
  339.         // Copy over the old data to the new list and zero out the rest
  340.         memcpy(newList, fAdvDHList, sizeof(void*) * fAdvDHListSize);
  341.         memset
  342.         (
  343.             &newList[fAdvDHListSize]
  344.             , 0
  345.             , sizeof(void*) * (newSize - fAdvDHListSize)
  346.         );
  348.         // And now clean up the old array and store the new stuff
  349.         fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
  350.         fAdvDHList = newList;
  351.         fAdvDHListSize = newSize;
  352.     }
  354.     // Add this new guy into the empty slot
  355.     fAdvDHList[fAdvDHCount++] = toInstall;
  357.     //
  358.     //  Install ourself as the document handler with the scanner. We might
  359.     //  already be, but its not worth checking, just do it.
  360.     //
  361.     fScanner->setDocHandler(this);
  362. }
  365. bool SAXParser::removeAdvDocHandler(XMLDocumentHandler* const toRemove)
  366. {
  367.     // If our count is zero, can't be any installed
  368.     if (!fAdvDHCount)
  369.         return false;
  371.     //
  372.     //  Search the array until we find this handler. If we find a null entry
  373.     //  first, we can stop there before the list is kept contiguous.
  374.     //
  375.     unsigned int index;
  376.     for (index = 0; index < fAdvDHCount; index++)
  377.     {
  378.         //
  379.         //  We found it. We have to keep the list contiguous, so we have to
  380.         //  copy down any used elements after this one.
  381.         //
  382.         if (fAdvDHList[index] == toRemove)
  383.         {
  384.             //
  385.             //  Optimize if only one entry (pretty common). Otherwise, we
  386.             //  have to copy them down to compact them.
  387.             //
  388.             if (fAdvDHCount > 1)
  389.             {
  390.                 index++;
  391.                 while (index < fAdvDHCount)
  392.                     fAdvDHList[index - 1] = fAdvDHList[index];
  393.             }
  395.             // Bump down the count and zero out the last one
  396.             fAdvDHCount--;
  397.             fAdvDHList[fAdvDHCount] = 0;
  399.             //
  400.             //  If this leaves us with no advanced handlers and there is
  401.             //  no SAX doc handler installed on us, then remove us from the
  402.             //  scanner as the document handler.
  403.             //
  404.             if (!fAdvDHCount && !fDocHandler)
  405.                 fScanner->setDocHandler(0);
  407.             return true;
  408.         }
  409.     }
  411.     // Never found it
  412.     return false;
  413. }
  416. // ---------------------------------------------------------------------------
  417. //  SAXParser: Getter methods
  418. // ---------------------------------------------------------------------------
  419. const XMLValidator& SAXParser::getValidator() const
  420. {
  421.     return *fScanner->getValidator();
  422. }
  425. bool SAXParser::getDoNamespaces() const
  426. {
  427.     return fScanner->getDoNamespaces();
  428. }
  431. bool SAXParser::getExitOnFirstFatalError() const
  432. {
  433.     return fScanner->getExitOnFirstFatal();
  434. }
  436. bool SAXParser::getValidationConstraintFatal() const
  437. {
  438.     return fScanner->getValidationConstraintFatal();
  439. }
  442. SAXParser::ValSchemes SAXParser::getValidationScheme() const
  443. {
  444.     const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
  446.     if (scheme == XMLScanner::Val_Always)
  447.         return Val_Always;
  448.     else if (scheme == XMLScanner::Val_Never)
  449.         return Val_Never;
  451.     return Val_Auto;
  452. }
  454. bool SAXParser::getDoSchema() const
  455. {
  456.     return fScanner->getDoSchema();
  457. }
  459. bool SAXParser::getValidationSchemaFullChecking() const
  460. {
  461.     return fScanner->getValidationSchemaFullChecking();
  462. }
  464. int SAXParser::getErrorCount() const
  465. {
  466.     return fScanner->getErrorCount();
  467. }
  469. XMLCh* SAXParser::getExternalSchemaLocation() const
  470. {
  471.     return fScanner->getExternalSchemaLocation();
  472. }
  474. XMLCh* SAXParser::getExternalNoNamespaceSchemaLocation() const
  475. {
  476.     return fScanner->getExternalNoNamespaceSchemaLocation();
  477. }
  479. SecurityManager* SAXParser::getSecurityManager() const
  480. {
  481.     return fScanner->getSecurityManager();
  482. }
  484. bool SAXParser::getLoadExternalDTD() const
  485. {
  486.     return fScanner->getLoadExternalDTD();
  487. }
  489. bool SAXParser::isCachingGrammarFromParse() const
  490. {
  491.     return fScanner->isCachingGrammarFromParse();
  492. }
  494. bool SAXParser::isUsingCachedGrammarInParse() const
  495. {
  496.     return fScanner->isUsingCachedGrammarInParse();
  497. }
  499. bool SAXParser::getCalculateSrcOfs() const
  500. {
  501.     return fScanner->getCalculateSrcOfs();
  502. }
  504. bool SAXParser::getStandardUriConformant() const
  505. {
  506.     return fScanner->getStandardUriConformant();
  507. }
  509. Grammar* SAXParser::getGrammar(const XMLCh* const nameSpaceKey)
  510. {
  511.     return fGrammarResolver->getGrammar(nameSpaceKey);
  512. }
  514. Grammar* SAXParser::getRootGrammar()
  515. {
  516.     return fScanner->getRootGrammar();
  517. }
  519. const XMLCh* SAXParser::getURIText(unsigned int uriId) const
  520. {
  521.     return fScanner->getURIText(uriId);
  522. }
  524. unsigned int SAXParser::getSrcOffset() const
  525. {
  526.     return fScanner->getSrcOffset();
  527. }
  529. // ---------------------------------------------------------------------------
  530. //  SAXParser: Setter methods
  531. // ---------------------------------------------------------------------------
  532. void SAXParser::setDoNamespaces(const bool newState)
  533. {
  534.     fScanner->setDoNamespaces(newState);
  535. }
  538. void SAXParser::setExitOnFirstFatalError(const bool newState)
  539. {
  540.     fScanner->setExitOnFirstFatal(newState);
  541. }
  544. void SAXParser::setValidationConstraintFatal(const bool newState)
  545. {
  546.     fScanner->setValidationConstraintFatal(newState);
  547. }
  550. void SAXParser::setValidationScheme(const ValSchemes newScheme)
  551. {
  552.     if (newScheme == Val_Never)
  553.         fScanner->setValidationScheme(XMLScanner::Val_Never);
  554.     else if (newScheme == Val_Always)
  555.         fScanner->setValidationScheme(XMLScanner::Val_Always);
  556.     else
  557.         fScanner->setValidationScheme(XMLScanner::Val_Auto);
  558. }
  560. void SAXParser::setDoSchema(const bool newState)
  561. {
  562.     fScanner->setDoSchema(newState);
  563. }
  565. void SAXParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
  566. {
  567.     fScanner->setValidationSchemaFullChecking(schemaFullChecking);
  568. }
  570. void SAXParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
  571. {
  572.     fScanner->setExternalSchemaLocation(schemaLocation);
  573. }
  574. void SAXParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
  575. {
  576.     fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
  577. }
  579. void SAXParser::setExternalSchemaLocation(const char* const schemaLocation)
  580. {
  581.     fScanner->setExternalSchemaLocation(schemaLocation);
  582. }
  583. void SAXParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
  584. {
  585.     fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
  586. }
  588. void SAXParser::setSecurityManager(SecurityManager* const securityManager)
  589. {
  590.     // since this could impact various components, don't permit it to change
  591.     // during a parse
  592.     if (fParseInProgress)
  593.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  595.     fScanner->setSecurityManager(securityManager);
  596. }
  598. void SAXParser::setLoadExternalDTD(const bool newState)
  599. {
  600.     fScanner->setLoadExternalDTD(newState);
  601. }
  603. void SAXParser::cacheGrammarFromParse(const bool newState)
  604. {
  605.     fScanner->cacheGrammarFromParse(newState);
  607.     if (newState)
  608.         fScanner->useCachedGrammarInParse(newState);
  609. }
  611. void SAXParser::useCachedGrammarInParse(const bool newState)
  612. {
  613.     if (newState || !fScanner->isCachingGrammarFromParse())
  614.         fScanner->useCachedGrammarInParse(newState);
  615. }
  617. void SAXParser::setCalculateSrcOfs(const bool newState)
  618. {
  619.     fScanner->setCalculateSrcOfs(newState);
  620. }
  622. void SAXParser::setStandardUriConformant(const bool newState)
  623. {
  624.     fScanner->setStandardUriConformant(newState);
  625. }
  627. void SAXParser::useScanner(const XMLCh* const scannerName)
  628. {
  629.     XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
  630.     (
  631.         scannerName
  632.         , fValidator
  633.         , fMemoryManager
  634.     );
  636.     if (tempScanner) {
  638.         tempScanner->setParseSettings(fScanner);
  639.         tempScanner->setGrammarResolver(fGrammarResolver);
  640.         tempScanner->setURIStringPool(fURIStringPool);
  641.         delete fScanner;
  642.         fScanner = tempScanner;
  643.     }
  644. }
  647. // ---------------------------------------------------------------------------
  648. //  SAXParser: Overrides of the SAX Parser interface
  649. // ---------------------------------------------------------------------------
  650. void SAXParser::parse(const InputSource& source)
  651. {
  652.     // Avoid multiple entrance
  653.     if (fParseInProgress)
  654.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  656.     try
  657.     {
  658.         fParseInProgress = true;
  659.         fScanner->scanDocument(source);
  660.         fParseInProgress = false;
  661.     }
  663.     catch (...)
  664.     {
  665.         fParseInProgress = false;
  666.         throw;
  667.     }
  668. }
  670. void SAXParser::parse(const XMLCh* const systemId)
  671. {
  672.     // Avoid multiple entrance
  673.     if (fParseInProgress)
  674.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  676.     try
  677.     {
  678.         fParseInProgress = true;
  679.         fScanner->scanDocument(systemId);
  680.         fParseInProgress = false;
  681.     }
  683.     catch (...)
  684.     {
  685.         fParseInProgress = false;
  686.         throw;
  687.     }
  688. }
  690. void SAXParser::parse(const char* const systemId)
  691. {
  692.     // Avoid multiple entrance
  693.     if (fParseInProgress)
  694.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  696.     try
  697.     {
  698.         fParseInProgress = true;
  699.         fScanner->scanDocument(systemId);
  700.         fParseInProgress = false;
  701.     }
  703.     catch (...)
  704.     {
  705.         fParseInProgress = false;
  706.         throw;
  707.     }
  708. }
  710. void SAXParser::setDocumentHandler(DocumentHandler* const handler)
  711. {
  712.     fDocHandler = handler;
  713.     if (fDocHandler)
  714.     {
  715.         //
  716.         //  Make sure we are set as the document handler with the scanner.
  717.         //  We may already be (if advanced handlers are installed), but its
  718.         //  not worthing checking, just do it.
  719.         //
  720.         fScanner->setDocHandler(this);
  721.     }
  722.      else
  723.     {
  724.         //
  725.         //  If we don't have any advanced handlers either, then deinstall us
  726.         //  from the scanner because we don't need document events anymore.
  727.         //
  728.         if (!fAdvDHCount)
  729.             fScanner->setDocHandler(0);
  730.     }
  731. }
  734. void SAXParser::setDTDHandler(DTDHandler* const handler)
  735. {
  736.     fDTDHandler = handler;
  737.     if (fDTDHandler)
  738.         fScanner->setDocTypeHandler(this);
  739.     else
  740.         fScanner->setDocTypeHandler(0);
  741. }
  744. void SAXParser::setErrorHandler(ErrorHandler* const handler)
  745. {
  746.     //
  747.     //  Store the handler. Then either install or deinstall us as the
  748.     //  error reporter on the scanner.
  749.     //
  750.     fErrorHandler = handler;
  751.     if (fErrorHandler) {
  752.         fScanner->setErrorReporter(this);
  753.         fScanner->setErrorHandler(fErrorHandler);
  754.     }
  755.     else {
  756.         fScanner->setErrorReporter(0);
  757.         fScanner->setErrorHandler(0);
  758.     }
  759. }
  762. void SAXParser::setEntityResolver(EntityResolver* const resolver)
  763. {
  764.     fEntityResolver = resolver;
  765.     if (fEntityResolver) {
  766.         fScanner->setEntityHandler(this);
  767.     }
  768.     else {
  769.         fScanner->setEntityHandler(0);
  770.     }
  771. }
  775. // ---------------------------------------------------------------------------
  776. //  SAXParser: Progressive parse methods
  777. // ---------------------------------------------------------------------------
  778. bool SAXParser::parseFirst( const   XMLCh* const    systemId
  779.                             ,       XMLPScanToken&  toFill)
  780. {
  781.     //
  782.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  783.     //  is in progress.
  784.     //
  785.     if (fParseInProgress)
  786.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  788.     return fScanner->scanFirst(systemId, toFill);
  789. }
  791. bool SAXParser::parseFirst( const   char* const     systemId
  792.                             ,       XMLPScanToken&  toFill)
  793. {
  794.     //
  795.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  796.     //  is in progress.
  797.     //
  798.     if (fParseInProgress)
  799.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  801.     return fScanner->scanFirst(systemId, toFill);
  802. }
  804. bool SAXParser::parseFirst( const   InputSource&    source
  805.                             ,       XMLPScanToken&  toFill)
  806. {
  807.     //
  808.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  809.     //  is in progress.
  810.     //
  811.     if (fParseInProgress)
  812.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  814.     return fScanner->scanFirst(source, toFill);
  815. }
  817. bool SAXParser::parseNext(XMLPScanToken& token)
  818. {
  819.     return fScanner->scanNext(token);
  820. }
  822. void SAXParser::parseReset(XMLPScanToken& token)
  823. {
  824.     // Reset the scanner
  825.     fScanner->scanReset(token);
  826. }
  829. // ---------------------------------------------------------------------------
  830. //  SAXParser: Overrides of the XMLDocumentHandler interface
  831. // ---------------------------------------------------------------------------
  832. void SAXParser::docCharacters(  const   XMLCh* const    chars
  833.                                 , const unsigned int    length
  834.                                 , const bool            cdataSection)
  835. {
  836.     // Suppress the chars before the root element.
  837.     if (!fElemDepth)
  838.         return;
  840.     // Just map to the SAX document handler
  841.     if (fDocHandler)
  842.         fDocHandler->characters(chars, length);
  844.     //
  845.     //  If there are any installed advanced handlers, then lets call them
  846.     //  with this info.
  847.     //
  848.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  849.         fAdvDHList[index]->docCharacters(chars, length, cdataSection);
  850. }
  853. void SAXParser::docComment(const XMLCh* const commentText)
  854. {
  855.     //
  856.     //  SAX has no way to report this. But, if there are any installed
  857.     //  advanced handlers, then lets call them with this info.
  858.     //
  859.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  860.         fAdvDHList[index]->docComment(commentText);
  861. }
  864. void SAXParser::XMLDecl( const  XMLCh* const    versionStr
  865.                         , const XMLCh* const    encodingStr
  866.                         , const XMLCh* const    standaloneStr
  867.                         , const XMLCh* const    actualEncodingStr
  868.                         )
  869. {
  870.     //
  871.     //  SAX has no way to report this. But, if there are any installed
  872.     //  advanced handlers, then lets call them with this info.
  873.     //
  874.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  875.         fAdvDHList[index]->XMLDecl( versionStr,
  876.                                     encodingStr,
  877.                                     standaloneStr,
  878.                                     actualEncodingStr );
  879. }
  882. void SAXParser::docPI(  const   XMLCh* const    target
  883.                         , const XMLCh* const    data)
  884. {
  885.     // Just map to the SAX document handler
  886.     if (fDocHandler)
  887.         fDocHandler->processingInstruction(target, data);
  889.     //
  890.     //  If there are any installed advanced handlers, then lets call them
  891.     //  with this info.
  892.     //
  893.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  894.         fAdvDHList[index]->docPI(target, data);
  895. }
  898. void SAXParser::endDocument()
  899. {
  900.     if (fDocHandler)
  901.         fDocHandler->endDocument();
  903.     //
  904.     //  If there are any installed advanced handlers, then lets call them
  905.     //  with this info.
  906.     //
  907.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  908.         fAdvDHList[index]->endDocument();
  909. }
  912. void SAXParser::endElement( const   XMLElementDecl& elemDecl
  913.                             , const unsigned int    uriId
  914.                             , const bool            isRoot
  915.                             , const XMLCh* const    elemPrefix)
  916. {
  917.     // Just map to the SAX document handler
  918.     if (fDocHandler) {
  919.         if (fScanner->getDoNamespaces()) {
  921.             if (elemPrefix && *elemPrefix) {
  923.                 fElemQNameBuf.set(elemPrefix);
  924.                 fElemQNameBuf.append(chColon);
  925.                 fElemQNameBuf.append(elemDecl.getBaseName());
  926.                 fDocHandler->endElement(fElemQNameBuf.getRawBuffer());
  927.             }
  928.             else {
  929.                 fDocHandler->endElement(elemDecl.getBaseName());
  930.             }
  931.         }
  932.         else
  933.             fDocHandler->endElement(elemDecl.getFullName());
  935.     }
  937.     //
  938.     //  If there are any installed advanced handlers, then lets call them
  939.     //  with this info.
  940.     //
  941.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  942.         fAdvDHList[index]->endElement(elemDecl, uriId, isRoot, elemPrefix);
  944.     //
  945.     //  Dump the element depth down again. Don't let it underflow in case
  946.     //  of malformed XML.
  947.     //
  948.     if (fElemDepth)
  949.         fElemDepth--;
  950. }
  953. void SAXParser::endEntityReference(const XMLEntityDecl& entityDecl)
  954. {
  955.     //
  956.     //  SAX has no way to report this event. But, if there are any installed
  957.     //  advanced handlers, then lets call them with this info.
  958.     //
  959.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  960.         fAdvDHList[index]->endEntityReference(entityDecl);
  961. }
  964. void SAXParser::ignorableWhitespace(const   XMLCh* const    chars
  965.                                     , const unsigned int    length
  966.                                     , const bool            cdataSection)
  967. {
  968.     // Do not report the whitespace before the root element.
  969.     if (!fElemDepth)
  970.         return;
  972.     // Just map to the SAX document handler
  973.     if (fDocHandler)
  974.         fDocHandler->ignorableWhitespace(chars, length);
  976.     //
  977.     //  If there are any installed advanced handlers, then lets call them
  978.     //  with this info.
  979.     //
  980.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  981.         fAdvDHList[index]->ignorableWhitespace(chars, length, cdataSection);
  982. }
  985. void SAXParser::resetDocument()
  986. {
  987.     // Just map to the SAX document handler
  988.     if (fDocHandler)
  989.         fDocHandler->resetDocument();
  991.     //
  992.     //  If there are any installed advanced handlers, then lets call them
  993.     //  with this info.
  994.     //
  995.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  996.         fAdvDHList[index]->resetDocument();
  998.     // Make sure our element depth flag gets set back to zero
  999.     fElemDepth = 0;
  1000. }
  1003. void SAXParser::startDocument()
  1004. {
  1005.     // Just map to the SAX document handler
  1006.     if (fDocHandler)
  1007.     {
  1008.         fDocHandler->setDocumentLocator(fScanner->getLocator());
  1009.         fDocHandler->startDocument();
  1010.     }
  1012.     //
  1013.     //  If there are any installed advanced handlers, then lets call them
  1014.     //  with this info.
  1015.     //
  1016.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  1017.         fAdvDHList[index]->startDocument();
  1018. }
  1021. void SAXParser::
  1022. startElement(   const   XMLElementDecl&         elemDecl
  1023.                 , const unsigned int            elemURLId
  1024.                 , const XMLCh* const            elemPrefix
  1025.                 , const RefVectorOf<XMLAttr>&   attrList
  1026.                 , const unsigned int            attrCount
  1027.                 , const bool                    isEmpty
  1028.                 , const bool                    isRoot)
  1029. {
  1030.     // Bump the element depth counter if not empty
  1031.     if (!isEmpty)
  1032.         fElemDepth++;
  1034.     if (fDocHandler)
  1035.     {
  1036.         fAttrList.setVector(&attrList, attrCount);
  1037.         if (fScanner->getDoNamespaces()) {
  1039.             if (elemPrefix && *elemPrefix) {
  1041.                 fElemQNameBuf.set(elemPrefix);
  1042.                 fElemQNameBuf.append(chColon);
  1043.                 fElemQNameBuf.append(elemDecl.getBaseName());
  1044.                 fDocHandler->startElement(fElemQNameBuf.getRawBuffer(), fAttrList);
  1046.                 // If its empty, send the end tag event now
  1047.                 if (isEmpty)
  1048.                     fDocHandler->endElement(fElemQNameBuf.getRawBuffer());
  1049.             }
  1050.             else {
  1052.                 fDocHandler->startElement(elemDecl.getBaseName(), fAttrList);
  1054.                 // If its empty, send the end tag event now
  1055.                 if (isEmpty)
  1056.                     fDocHandler->endElement(elemDecl.getBaseName());
  1057.             }
  1058.         }
  1059.         else {
  1060.             fDocHandler->startElement(elemDecl.getFullName(), fAttrList);
  1062.             // If its empty, send the end tag event now
  1063.             if (isEmpty)
  1064.                 fDocHandler->endElement(elemDecl.getFullName());
  1065.         }
  1066.     }
  1068.     //
  1069.     //  If there are any installed advanced handlers, then lets call them
  1070.     //  with this info.
  1071.     //
  1072.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  1073.     {
  1074.         fAdvDHList[index]->startElement
  1075.         (
  1076.             elemDecl
  1077.             , elemURLId
  1078.             , elemPrefix
  1079.             , attrList
  1080.             , attrCount
  1081.             , isEmpty
  1082.             , isRoot
  1083.         );
  1084.     }
  1085. }
  1088. void SAXParser::startEntityReference(const XMLEntityDecl& entityDecl)
  1089. {
  1090.     //
  1091.     //  SAX has no way to report this. But, If there are any installed
  1092.     //  advanced handlers, then lets call them with this info.
  1093.     //
  1094.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  1095.         fAdvDHList[index]->startEntityReference(entityDecl);
  1096. }
  1100. // ---------------------------------------------------------------------------
  1101. //  SAXParser: Overrides of the DocTypeHandler interface
  1102. // ---------------------------------------------------------------------------
  1103. void SAXParser::attDef( const   DTDElementDecl& elemDecl
  1104.                         , const DTDAttDef&      attDef
  1105.                         , const bool            ignoring)
  1106. {
  1107.     // Unused by SAX DTDHandler interface at this time
  1108. }
  1111. void SAXParser::doctypeComment(const XMLCh* const)
  1112. {
  1113.     // Unused by SAX DTDHandler interface at this time
  1114. }
  1117. void SAXParser::doctypeDecl(const   DTDElementDecl& elemDecl
  1118.                             , const XMLCh* const    publicId
  1119.                             , const XMLCh* const    systemId
  1120.                             , const bool            hasIntSubset
  1121.                             , const bool            hasExtSubset)
  1122. {
  1123.     // Unused by SAX DTDHandler interface at this time
  1124. }
  1127. void SAXParser::doctypePI(  const   XMLCh* const
  1128.                             , const XMLCh* const)
  1129. {
  1130.     // Unused by SAX DTDHandler interface at this time
  1131. }
  1134. void SAXParser::doctypeWhitespace(  const   XMLCh* const    chars
  1135.                                     , const unsigned int    length)
  1136. {
  1137.     // Unused by SAX DTDHandler interface at this time
  1138. }
  1141. void SAXParser::elementDecl(const DTDElementDecl&, const bool)
  1142. {
  1143.     // Unused by SAX DTDHandler interface at this time
  1144. }
  1147. void SAXParser::endAttList(const DTDElementDecl&)
  1148. {
  1149.     // Unused by SAX DTDHandler interface at this time
  1150. }
  1153. void SAXParser::endIntSubset()
  1154. {
  1155.     // Unused by SAX DTDHandler interface at this time
  1156. }
  1159. void SAXParser::endExtSubset()
  1160. {
  1161.     // Unused by SAX DTDHandler interface at this time
  1162. }
  1165. void SAXParser::entityDecl( const   DTDEntityDecl&  entityDecl
  1166.                             , const bool            isPEDecl
  1167.                             , const bool            isIgnored)
  1168. {
  1169.     //
  1170.     //  If we have a DTD handler, and this entity is not ignored, and
  1171.     //  its an unparsed entity, then send this one.
  1172.     //
  1173.     if (fDTDHandler && !isIgnored)
  1174.     {
  1175.         if (entityDecl.isUnparsed())
  1176.         {
  1177.             fDTDHandler->unparsedEntityDecl
  1178.             (
  1179.                 entityDecl.getName()
  1180.                 , entityDecl.getPublicId()
  1181.                 , entityDecl.getSystemId()
  1182.                 , entityDecl.getNotationName()
  1183.             );
  1184.         }
  1185.     }
  1186. }
  1189. void SAXParser::resetDocType()
  1190. {
  1191.     // Just map to the DTD handler
  1192.     if (fDTDHandler)
  1193.         fDTDHandler->resetDocType();
  1194. }
  1197. void SAXParser::notationDecl(   const   XMLNotationDecl&    notDecl
  1198.                                 , const bool                isIgnored)
  1199. {
  1200.     if (fDTDHandler && !isIgnored)
  1201.     {
  1202.         fDTDHandler->notationDecl
  1203.         (
  1204.             notDecl.getName()
  1205.             , notDecl.getPublicId()
  1206.             , notDecl.getSystemId()
  1207.         );
  1208.     }
  1209. }
  1212. void SAXParser::startAttList(const DTDElementDecl&)
  1213. {
  1214.     // Unused by SAX DTDHandler interface at this time
  1215. }
  1218. void SAXParser::startIntSubset()
  1219. {
  1220.     // Unused by SAX DTDHandler interface at this time
  1221. }
  1224. void SAXParser::startExtSubset()
  1225. {
  1226.     // Unused by SAX DTDHandler interface at this time
  1227. }
  1230. void SAXParser::TextDecl(   const  XMLCh* const
  1231.                             , const XMLCh* const)
  1232. {
  1233.     // Unused by SAX DTDHandler interface at this time
  1234. }
  1237. // ---------------------------------------------------------------------------
  1238. //  SAXParser: Overrides of the XMLErrorReporter interface
  1239. // ---------------------------------------------------------------------------
  1240. void SAXParser::resetErrors()
  1241. {
  1242.     if (fErrorHandler)
  1243.         fErrorHandler->resetErrors();
  1244. }
  1247. void SAXParser::error(  const   unsigned int                code
  1248.                         , const XMLCh* const                msgDomain
  1249.                         , const XMLErrorReporter::ErrTypes  errType
  1250.                         , const XMLCh* const                errorText
  1251.                         , const XMLCh* const                systemId
  1252.                         , const XMLCh* const                publicId
  1253.                         , const XMLSSize_t                  lineNum
  1254.                         , const XMLSSize_t                  colNum)
  1255. {
  1256.     SAXParseException toThrow = SAXParseException
  1257.     (
  1258.         errorText
  1259.         , publicId
  1260.         , systemId
  1261.         , lineNum
  1262.         , colNum
  1263.     );
  1265.     if (!fErrorHandler)
  1266.     {
  1267.         if (errType == XMLErrorReporter::ErrType_Fatal)
  1268.             throw toThrow;
  1269.         else
  1270.             return;
  1271.     }
  1273.     if (errType == XMLErrorReporter::ErrType_Warning)
  1274.         fErrorHandler->warning(toThrow);
  1275.     else if (errType == XMLErrorReporter::ErrType_Fatal)
  1276.         fErrorHandler->fatalError(toThrow);
  1277.     else
  1278.         fErrorHandler->error(toThrow);
  1279. }
  1283. // ---------------------------------------------------------------------------
  1284. //  SAXParser: Handlers for the XMLEntityHandler interface
  1285. // ---------------------------------------------------------------------------
  1286. void SAXParser::endInputSource(const InputSource&)
  1287. {
  1288. }
  1290. bool SAXParser::expandSystemId(const XMLCh* const, XMLBuffer&)
  1291. {
  1292.     return false;
  1293. }
  1296. void SAXParser::resetEntities()
  1297. {
  1298.     // Nothing to do for this one
  1299. }
  1302. InputSource*
  1303. SAXParser::resolveEntity(   const   XMLCh* const    publicId
  1304.                             , const XMLCh* const    systemId
  1305.                             , const XMLCh* const    baseURI)
  1306. {
  1307.     // Just map to the SAX entity resolver handler
  1308.     if (fEntityResolver)
  1309.         return fEntityResolver->resolveEntity(publicId, systemId);
  1310.     return 0;
  1311. }
  1314. void SAXParser::startInputSource(const InputSource&)
  1315. {
  1316.     // Nothing to do for this one
  1317. }
  1321. // ---------------------------------------------------------------------------
  1322. //  SAXParser: Deprecated methods
  1323. // ---------------------------------------------------------------------------
  1324. bool SAXParser::getDoValidation() const
  1325. {
  1326.     //
  1327.     //  We don't want to tie the public parser classes to the enum used
  1328.     //  by the scanner, so we use a separate one and map.
  1329.     //
  1330.     //  DON'T mix the new and old methods!!
  1331.     //
  1332.     const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
  1333.     if (scheme == XMLScanner::Val_Always)
  1334.         return true;
  1335.     return false;
  1336. }
  1338. void SAXParser::setDoValidation(const bool newState)
  1339. {
  1340.     fScanner->setDoValidation
  1341.     (
  1342.         newState ? XMLScanner::Val_Always : XMLScanner::Val_Never
  1343.     );
  1344. }
  1347. // ---------------------------------------------------------------------------
  1348. //  SAXParser: Grammar preparsing methods
  1349. // ---------------------------------------------------------------------------
  1350. Grammar* SAXParser::loadGrammar(const char* const systemId,
  1351.                                 const short grammarType,
  1352.                                 const bool toCache)
  1353. {
  1354.     // Avoid multiple entrance
  1355.     if (fParseInProgress)
  1356.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1358.     Grammar* grammar = 0;
  1359.     try
  1360.     {
  1361.         fParseInProgress = true;
  1362.         grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
  1363.         fParseInProgress = false;
  1364.     }
  1366.     catch(...)
  1367.     {
  1368.         fParseInProgress = false;
  1369.         throw;
  1370.     }
  1372.     return grammar;
  1373. }
  1375. Grammar* SAXParser::loadGrammar(const XMLCh* const systemId,
  1376.                                 const short grammarType,
  1377.                                 const bool toCache)
  1378. {
  1379.     // Avoid multiple entrance
  1380.     if (fParseInProgress)
  1381.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1383.     Grammar* grammar = 0;
  1384.     try
  1385.     {
  1386.         fParseInProgress = true;
  1387.         grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
  1388.         fParseInProgress = false;
  1389.     }
  1391.     catch(...)
  1392.     {
  1393.         fParseInProgress = false;
  1394.         throw;
  1395.     }
  1397.     return grammar;
  1398. }
  1400. Grammar* SAXParser::loadGrammar(const InputSource& source,
  1401.                                 const short grammarType,
  1402.                                 const bool toCache)
  1403. {
  1404.     // Avoid multiple entrance
  1405.     if (fParseInProgress)
  1406.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1408.     Grammar* grammar = 0;
  1409.     try
  1410.     {
  1411.         fParseInProgress = true;
  1412.         grammar = fScanner->loadGrammar(source, grammarType, toCache);
  1413.         fParseInProgress = false;
  1414.     }
  1416.     catch(...)
  1417.     {
  1418.         fParseInProgress = false;
  1419.         throw;
  1420.     }
  1422.     return grammar;
  1423. }
  1425. void SAXParser::resetCachedGrammarPool()
  1426. {
  1427.     fGrammarResolver->resetCachedGrammar();
  1428. }
  1430. XERCES_CPP_NAMESPACE_END