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

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

词法分析

开发平台：

Visual C++

SAX2XMLReaderImpl.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: SAX2XMLReaderImpl.cpp,v $
  59.  * Revision 1.21  2003/05/18 14:02:05  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.20  2003/05/16 21:36:59  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.19  2003/05/16 06:01:52  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.18  2003/05/15 18:26:50  knoaman
  69.  * Partial implementation of the configurable memory manager.
  70.  *
  71.  * Revision 1.17  2003/04/17 21:58:50  neilg
  72.  * Adding a new property,
  73.  * http://apache.org/xml/properties/security-manager, with
  74.  * appropriate getSecurityManager/setSecurityManager methods on DOM
  75.  * and SAX parsers.  Also adding a new SecurityManager class.
  76.  *
  77.  * The purpose of these modifications is to permit applications a
  78.  * means to have the parser reject documents whose processing would
  79.  * otherwise consume large amounts of system resources.  Malicious
  80.  * use of such documents could be used to launch a denial-of-service
  81.  * attack against a system running the parser.  Initially, the
  82.  * SecurityManager only knows about attacks that can result from
  83.  * exponential entity expansion; this is the only known attack that
  84.  * involves processing a single XML document.  Other, simlar attacks
  85.  * can be launched if arbitrary schemas may be parsed; there already
  86.  * exist means (via use of the EntityResolver interface) by which
  87.  * applications can deny processing of untrusted schemas.  In future,
  88.  * the SecurityManager will be expanded to take these other exploits
  89.  * into account.
  90.  *
  91.  * Adding SecurityManager support
  92.  * 
  93.  * Revision 1.16  2003/01/03 20:09:36  tng
  94.  * New feature StandardUriConformant to force strict standard uri conformance.
  95.  *
  96.  * Revision 1.15  2002/12/27 16:16:51  knoaman
  97.  * Set scanner options and handlers.
  98.  *
  99.  * Revision 1.14  2002/12/11 22:14:54  knoaman
  100.  * Performance: no need to use temporary buffer to hold namespace value.
  101.  *
  102.  * Revision 1.13  2002/12/04 01:57:09  knoaman
  103.  * Scanner re-organization.
  104.  *
  105.  * Revision 1.12  2002/11/04 14:57:03  tng
  106.  * C++ Namespace Support.
  107.  *
  108.  * Revision 1.11  2002/09/24 20:00:32  tng
  109.  * Performance: use XMLString::equals instead of XMLString::compareString
  110.  *
  111.  * Revision 1.10  2002/08/14 15:20:38  knoaman
  112.  * [Bug 3111] Problem with LexicalHandler::startDTD() and LexicalHandler::endDTD().
  113.  *
  114.  * Revision 1.9  2002/07/11 18:27:20  knoaman
  115.  * Grammar caching/preparsing - initial implementation.
  116.  *
  117.  * Revision 1.8  2002/06/17 15:41:15  tng
  118.  * To be consistent, SAX2 is updated with:
  119.  * 1. the progressive parse methods should use the fReuseGrammar flag set from setFeature instead of using parameter
  120.  * 2. add feature "http://apache.org/xml/features/continue-after-fatal-error", and users should use setFeature instead of setExitOnFirstFatalError
  121.  * 3. add feature "http://apache.org/xml/features/validation-error-as-fatal", and users should use setFeature instead of setValidationConstraintFatal
  122.  *
  123.  * Revision 1.7  2002/05/30 16:20:09  tng
  124.  * Add feature to optionally ignore external DTD.
  125.  *
  126.  * Revision 1.6  2002/05/29 21:37:47  knoaman
  127.  * Add baseURI to resolveEntity to support DOMInputSource.
  128.  *
  129.  * Revision 1.5  2002/05/28 20:44:14  tng
  130.  * [Bug 9104] prefixes dissapearing when schema validation turned on.
  131.  *
  132.  * Revision 1.4  2002/05/27 18:39:21  tng
  133.  * To get ready for 64 bit large file, use XMLSSize_t to represent line and column number.
  134.  *
  135.  * Revision 1.3  2002/05/22 20:53:41  knoaman
  136.  * Prepare for DOM L3 :
  137.  * - Make use of the XMLEntityHandler/XMLErrorReporter interfaces, instead of using
  138.  * EntityHandler/ErrorHandler directly.
  139.  * - Add 'AbstractDOMParser' class to provide common functionality for XercesDOMParser
  140.  * and DOMBuilder.
  141.  *
  142.  * Revision 1.2  2002/02/13 16:09:24  knoaman
  143.  * Move SAX2 features/properties names constants to XMLUni.
  144.  *
  145.  * Revision 1.1.1.1  2002/02/01 22:22:06  peiyongz
  146.  * sane_include
  147.  *
  148.  * Revision 1.25  2002/01/28 17:47:41  knoaman
  149.  * Some SAX calls were not passed to the LexicalHandler.
  150.  *
  151.  * Revision 1.24  2002/01/28 17:08:47  knoaman
  152.  * SAX2-ext's DeclHandler support.
  153.  *
  154.  * Revision 1.23  2002/01/28 16:29:21  knoaman
  155.  * The namespace-prefixes feature in SAX2 should be off by default.
  156.  *
  157.  * Revision 1.22  2002/01/24 16:30:34  tng
  158.  * [Bug 3111] Problem with LexicalHandler::startDTD() and LexicalHandler::endDTD() .
  159.  *
  160.  * Revision 1.21  2001/12/21 18:03:25  tng
  161.  * [Bug 1833] LexicalHandler::startDTD not called correctly.
  162.  *
  163.  * Revision 1.20  2001/11/20 18:51:44  tng
  164.  * 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).
  165.  *
  166.  * Revision 1.19  2001/10/25 19:46:15  tng
  167.  * Comment outside root element should also be reported.
  168.  *
  169.  * Revision 1.18  2001/09/12 13:03:43  tng
  170.  * [Bug 3155] SAX2 does not offer progressive parse.
  171.  *
  172.  * Revision 1.17  2001/08/02 19:00:46  tng
  173.  * [Bug 1329] SAX2XMLReaderImpl leaks XMLBuffers.
  174.  *
  175.  * Revision 1.16  2001/08/01 19:11:02  tng
  176.  * Add full schema constraint checking flag to the samples and the parser.
  177.  *
  178.  * Revision 1.15  2001/06/27 17:39:50  knoaman
  179.  * Fix for bug #2353.
  180.  *
  181.  * Revision 1.14  2001/06/19 16:45:08  tng
  182.  * Add installAdvDocHandler to SAX2XMLReader as the code is there already.
  183.  *
  184.  * Revision 1.13  2001/06/03 19:26:19  jberry
  185.  * Add support for querying error count following parse; enables simple parse without requiring error handler.
  186.  *
  187.  * Revision 1.12  2001/05/11 13:26:21  tng
  188.  * Copyright update.
  189.  *
  190.  * Revision 1.11  2001/05/03 20:34:33  tng
  191.  * Schema: SchemaValidator update
  192.  *
  193.  * Revision 1.10  2001/03/30 16:46:57  tng
  194.  * Schema: Use setDoSchema instead of setSchemaValidation which makes more sense.
  195.  *
  196.  * Revision 1.9  2001/03/21 21:56:08  tng
  197.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  198.  *
  199.  * Revision 1.8  2001/02/15 15:56:29  tng
  200.  * Schema: Add setSchemaValidation and getSchemaValidation for DOMParser and SAXParser.
  201.  * Add feature "http://apache.org/xml/features/validation/schema" for SAX2XMLReader.
  202.  * New data field  fSchemaValidation in XMLScanner as the flag.
  203.  *
  204.  * Revision 1.7  2001/01/15 21:26:33  tng
  205.  * Performance Patches by David Bertoni.
  206.  *
  207.  * Details: (see xerces-c-dev mailing Jan 14)
  208.  * XMLRecognizer.cpp: the internal encoding string XMLUni::fgXMLChEncodingString
  209.  * was going through this function numerous times.  As a result, the top hot-spot
  210.  * for the parse was _wcsicmp().  The real problem is that the Microsofts wide string
  211.  * functions are unbelievably slow.  For things like encodings, it might be
  212.  * better to use a special comparison function that only considers a-z and
  213.  * A-Z as characters with case.  This works since the character set for
  214.  * encodings is limit to printable ASCII characters.
  215.  *
  216.  *  XMLScanner2.cpp: This also has some case-sensitive vs. insensitive compares.
  217.  * They are also much faster.  The other tweak is to only make a copy of an attribute
  218.  * string if it needs to be split.  And then, the strategy is to try to use a
  219.  * stack-based buffer, rather than a dynamically-allocated one.
  220.  *
  221.  * SAX2XMLReaderImpl.cpp: Again, more case-sensitive vs. insensitive comparisons.
  222.  *
  223.  * KVStringPair.cpp & hpp: By storing the size of the allocation, the storage can
  224.  * likely be re-used many times, cutting down on dynamic memory allocations.
  225.  *
  226.  * XMLString.hpp: a more efficient implementation of stringLen().
  227.  *
  228.  * DTDValidator.cpp: another case of using a stack-based buffer when possible
  229.  *
  230.  * These patches made a big difference in parse time in some of our test
  231.  * files, especially the ones are very attribute-heavy.
  232.  *
  233.  * Revision 1.6  2000/12/22 20:41:52  tng
  234.  * XMLUni::fgEmptyString which is defined as "EMPTY" is incorrectly used as an empty string; in fact XMLUni::fgZeroLenString should be used instead
  235.  *
  236.  * Revision 1.5  2000/12/22 15:16:51  tng
  237.  * SAX2-ext's LexicalHandler support added by David Bertoni.
  238.  *
  239.  * Revision 1.4  2000/08/09 23:39:58  jpolast
  240.  * should be namespace-prefixes; not namespaces-prefixes
  241.  *
  242.  * Revision 1.3  2000/08/09 22:16:12  jpolast
  243.  * many conformance & stability changes:
  244.  *   - ContentHandler::resetDocument() removed
  245.  *   - attrs param of ContentHandler::startDocument() made const
  246.  *   - SAXExceptions thrown now have msgs
  247.  *   - removed duplicate function signatures that had 'const'
  248.  *       [ eg: getContentHander() ]
  249.  *   - changed getFeature and getProperty to apply to const objs
  250.  *   - setProperty now takes a void* instead of const void*
  251.  *   - SAX2XMLReaderImpl does not inherit from SAXParser anymore
  252.  *   - Reuse Validator (http://apache.org/xml/features/reuse-validator) implemented
  253.  *   - Features & Properties now read-only during parse
  254.  *
  255.  * Revision 1.2  2000/08/07 22:53:44  jpolast
  256.  * fixes for when 'namespaces' feature is turned off:
  257.  *   * namespaces-prefixes only used when namespaces is on
  258.  *   * URIs not looked up when namespaces is off, blank string instead
  259.  *   * default validation scheme is validation on, auto-validation off.
  260.  *
  261.  * Revision 1.1  2000/08/02 18:04:41  jpolast
  262.  * initial checkin of sax2 implemenation
  263.  * submitted by Simon Fell (simon@fell.com)
  264.  * and Joe Polastre (jpolast@apache.org)
  265.  *
  266.  *
  267.  */
  269. #include <xercesc/util/IOException.hpp>
  270. #include <xercesc/util/XMLChTranscoder.hpp>
  271. #include <xercesc/util/RefStackOf.hpp>
  272. #include <xercesc/util/XMLUniDefs.hpp>
  273. #include <xercesc/util/Janitor.hpp>
  274. #include <xercesc/sax2/ContentHandler.hpp>
  275. #include <xercesc/sax2/LexicalHandler.hpp>
  276. #include <xercesc/sax2/DeclHandler.hpp>
  277. #include <xercesc/sax/DTDHandler.hpp>
  278. #include <xercesc/sax/ErrorHandler.hpp>
  279. #include <xercesc/sax/EntityResolver.hpp>
  280. #include <xercesc/sax/SAXParseException.hpp>
  281. #include <xercesc/sax/SAXException.hpp>
  282. #include <xercesc/internal/XMLScannerResolver.hpp>
  283. #include <xercesc/parsers/SAX2XMLReaderImpl.hpp>
  284. #include <xercesc/validators/common/GrammarResolver.hpp>
  285. #include <string.h>
  287. XERCES_CPP_NAMESPACE_BEGIN
  290. const XMLCh gDTDEntityStr[] =
  291. {
  292.     chOpenSquare, chLatin_d, chLatin_t, chLatin_d, chCloseSquare, chNull
  293. };
  295. SAX2XMLReaderImpl::SAX2XMLReaderImpl(MemoryManager* const manager) :
  297.     fNamespacePrefix(false)
  298.     , fAutoValidation(false)
  299.     , fValidation(true)
  300.     , fParseInProgress(false)
  301.     , fHasExternalSubset(false)
  302.     , fElemDepth(0)
  303.     , fAdvDHCount(0)
  304.     , fAdvDHListSize(32)
  305.     , fDocHandler(0)
  306.     , fTempAttrVec(0)
  307.     , fPrefixes(0)
  308.     , fPrefixCounts(0)
  309.     , fDTDHandler(0)
  310.     , fEntityResolver(0)
  311.     , fErrorHandler(0)
  312.     , fLexicalHandler(0)
  313.     , fDeclHandler(0)
  314.     , fAdvDHList(0)
  315.     , fScanner(0)
  316.     , fGrammarResolver(0)
  317.     , fURIStringPool(0)
  318.     , fValidator(0)
  319.     , fMemoryManager(manager)
  320.     , fStringBuffers(manager)
  321. {
  322.     try
  323.     {
  324.         initialize();
  325.     }
  326.     catch(...)
  327.     {
  328.         cleanUp();
  329.         throw;
  330.     }
  331. }
  333. SAX2XMLReaderImpl::~SAX2XMLReaderImpl()
  334. {
  335.     cleanUp();
  336. }
  338. // ---------------------------------------------------------------------------
  339. //  SAX2XMLReaderImpl: Initialize/Cleanup methods
  340. // ---------------------------------------------------------------------------
  341. void SAX2XMLReaderImpl::initialize()
  342. {
  343.     // Create grammar resolver and string pool that we pass to the scanner
  344.     fGrammarResolver = new (fMemoryManager) GrammarResolver(fMemoryManager);
  345.     fURIStringPool = new (fMemoryManager) XMLStringPool(109, fMemoryManager);
  347.     //  Create a scanner and tell it what validator to use. Then set us
  348.     //  as the document event handler so we can fill the DOM document.
  349.     fScanner = XMLScannerResolver::getDefaultScanner(0, fMemoryManager);
  350.     fScanner->setGrammarResolver(fGrammarResolver);
  351.     fScanner->setURIStringPool(fURIStringPool);
  353.     // Create the initial advanced handler list array and zero it out
  354.     fAdvDHList = (XMLDocumentHandler**) fMemoryManager->allocate
  355.     (
  356.         fAdvDHListSize * sizeof(XMLDocumentHandler*)
  357.     );//new XMLDocumentHandler*[fAdvDHListSize];
  358.     memset(fAdvDHList, 0, sizeof(void*) * fAdvDHListSize);
  360. // SAX2 default is for namespaces (feature http://xml.org/sax/features/namespaces) to be on
  361. setDoNamespaces(true) ;
  363. // default: schema is on
  364. setDoSchema(true);
  366. fPrefixes    = new (fMemoryManager) RefStackOf<XMLBuffer> (10, false, fMemoryManager) ;
  367. fTempAttrVec  = new (fMemoryManager) RefVectorOf<XMLAttr>  (10, false, fMemoryManager) ;
  368. fPrefixCounts = new (fMemoryManager) ValueStackOf<unsigned int>(10, fMemoryManager) ;
  369. }
  372. void SAX2XMLReaderImpl::cleanUp()
  373. {
  374.     fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
  375.     delete fScanner;
  376.     delete fPrefixes;
  377.     delete fTempAttrVec;
  378.     delete fPrefixCounts;
  379.     delete fGrammarResolver;
  380.     delete fURIStringPool;
  381. }
  383. // ---------------------------------------------------------------------------
  384. //  SAX2XMLReaderImpl: Advanced document handler list maintenance methods
  385. // ---------------------------------------------------------------------------
  386. void SAX2XMLReaderImpl::installAdvDocHandler(XMLDocumentHandler* const toInstall)
  387. {
  388.     // See if we need to expand and do so now if needed
  389.     if (fAdvDHCount == fAdvDHListSize)
  390.     {
  391.         // Calc a new size and allocate the new temp buffer
  392.         const unsigned int newSize = (unsigned int)(fAdvDHListSize * 1.5);
  393.         XMLDocumentHandler** newList = (XMLDocumentHandler**) fMemoryManager->allocate
  394.         (
  395.             newSize * sizeof(XMLDocumentHandler*)
  396.         );//new XMLDocumentHandler*[newSize];
  398.         // Copy over the old data to the new list and zero out the rest
  399.         memcpy(newList, fAdvDHList, sizeof(void*) * fAdvDHListSize);
  400.         memset
  401.         (
  402.             &newList[fAdvDHListSize]
  403.             , 0
  404.             , sizeof(void*) * (newSize - fAdvDHListSize)
  405.         );
  407.         // And now clean up the old array and store the new stuff
  408.         fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
  409.         fAdvDHList = newList;
  410.         fAdvDHListSize = newSize;
  411.     }
  413.     // Add this new guy into the empty slot
  414.     fAdvDHList[fAdvDHCount++] = toInstall;
  416.     //
  417.     //  Install ourself as the document handler with the scanner. We might
  418.     //  already be, but its not worth checking, just do it.
  419.     //
  420.     fScanner->setDocHandler(this);
  421. }
  424. bool SAX2XMLReaderImpl::removeAdvDocHandler(XMLDocumentHandler* const toRemove)
  425. {
  426.     // If our count is zero, can't be any installed
  427.     if (!fAdvDHCount)
  428.         return false;
  430.     //
  431.     //  Search the array until we find this handler. If we find a null entry
  432.     //  first, we can stop there before the list is kept contiguous.
  433.     //
  434.     unsigned int index;
  435.     for (index = 0; index < fAdvDHCount; index++)
  436.     {
  437.         //
  438.         //  We found it. We have to keep the list contiguous, so we have to
  439.         //  copy down any used elements after this one.
  440.         //
  441.         if (fAdvDHList[index] == toRemove)
  442.         {
  443.             //
  444.             //  Optimize if only one entry (pretty common). Otherwise, we
  445.             //  have to copy them down to compact them.
  446.             //
  447.             if (fAdvDHCount > 1)
  448.             {
  449.                 index++;
  450.                 while (index < fAdvDHCount)
  451.                     fAdvDHList[index - 1] = fAdvDHList[index];
  452.             }
  454.             // Bump down the count and zero out the last one
  455.             fAdvDHCount--;
  456.             fAdvDHList[fAdvDHCount] = 0;
  458.             //
  459.             //  If this leaves us with no advanced handlers and there is
  460.             //  no SAX doc handler installed on us, then remove us from the
  461.             //  scanner as the document handler.
  462.             //
  463.             if (!fAdvDHCount && !fDocHandler)
  464.                 fScanner->setDocHandler(0);
  466.             return true;
  467.         }
  468.     }
  470.     // Never found it
  471.     return false;
  472. }
  474. // ---------------------------------------------------------------------------
  475. //  SAX2XMLReaderImpl Validator functions
  476. // ---------------------------------------------------------------------------
  477. void SAX2XMLReaderImpl::setValidator(XMLValidator* valueToAdopt)
  478. {
  479.     fValidator = valueToAdopt;
  480. fScanner->setValidator(valueToAdopt);
  481. }
  483. XMLValidator* SAX2XMLReaderImpl::getValidator() const
  484. {
  485. return fScanner->getValidator();
  486. }
  488. // ---------------------------------------------------------------------------
  489. //  SAX2XMLReader Interface
  490. // ---------------------------------------------------------------------------
  491. int SAX2XMLReaderImpl::getErrorCount() const
  492. {
  493.     return fScanner->getErrorCount();
  494. }
  496. void SAX2XMLReaderImpl::setContentHandler(ContentHandler* const handler)
  497. {
  498. fDocHandler = handler;
  499.     if (fDocHandler)
  500.     {
  501.         //
  502.         //  Make sure we are set as the document handler with the scanner.
  503.         //  We may already be (if advanced handlers are installed), but its
  504.         //  not worthing checking, just do it.
  505.         //
  506.         fScanner->setDocHandler(this);
  507.     }
  508.      else
  509.     {
  510.         //
  511.         //  If we don't have any advanced handlers either, then deinstall us
  512.         //  from the scanner because we don't need document events anymore.
  513.         //
  514.         if (!fAdvDHCount)
  515.             fScanner->setDocHandler(0);
  516.     }
  518. }
  520. void SAX2XMLReaderImpl::setDTDHandler(DTDHandler* const handler)
  521. {
  522.     fDTDHandler = handler;
  523.     if (fDTDHandler)
  524.         fScanner->setDocTypeHandler(this);
  525.     else
  526.         fScanner->setDocTypeHandler(0);
  527. }
  530. void SAX2XMLReaderImpl::setErrorHandler(ErrorHandler* const handler)
  531. {
  532.     //
  533.     //  Store the handler. Then either install or deinstall us as the
  534.     //  error reporter on the scanner.
  535.     //
  536.     fErrorHandler = handler;
  537.     if (fErrorHandler) {
  538.         fScanner->setErrorReporter(this);
  539.         fScanner->setErrorHandler(fErrorHandler);
  540.     }
  541.     else {
  542.         fScanner->setErrorReporter(0);
  543.         fScanner->setErrorHandler(0);
  544.     }
  545. }
  548. void SAX2XMLReaderImpl::setLexicalHandler(LexicalHandler* const handler)
  549. {
  550.     fLexicalHandler = handler;
  551.     if (fLexicalHandler)
  552.         fScanner->setDocTypeHandler(this);
  553.     else
  554.         fScanner->setDocTypeHandler(0);
  555. }
  557. void SAX2XMLReaderImpl::setDeclarationHandler(DeclHandler* const handler)
  558. {
  559.     fDeclHandler = handler;
  560.     if (fDeclHandler)
  561.         fScanner->setDocTypeHandler(this);
  562.     else
  563.         fScanner->setDocTypeHandler(0);
  564. }
  567. void SAX2XMLReaderImpl::setEntityResolver(EntityResolver* const resolver)
  568. {
  569.     fEntityResolver = resolver;
  570.     if (fEntityResolver) {
  571.         fScanner->setEntityHandler(this);
  572.     }
  573.     else {
  574.         fScanner->setEntityHandler(0);
  575.     }
  576. }
  578. void SAX2XMLReaderImpl::setExitOnFirstFatalError(const bool newState)
  579. {
  580.     fScanner->setExitOnFirstFatal(newState);
  581. }
  583. void SAX2XMLReaderImpl::setValidationConstraintFatal(const bool newState)
  584. {
  585.     fScanner->setValidationConstraintFatal(newState);
  586. }
  588. void SAX2XMLReaderImpl::parse (const   InputSource&    source)
  589. {
  590.     // Avoid multiple entrance
  591.     if (fParseInProgress)
  592.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  594.     try
  595.     {
  596.         fParseInProgress = true;
  597.         fScanner->scanDocument(source);
  598.         fParseInProgress = false;
  599.     }
  601.     catch (...)
  602.     {
  603.         fParseInProgress = false;
  604.         throw;
  605.     }
  606. }
  608. void SAX2XMLReaderImpl::parse (const   XMLCh* const    systemId)
  609. {
  610.     // Avoid multiple entrance
  611.     if (fParseInProgress)
  612.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  614.     try
  615.     {
  616.         fParseInProgress = true;
  617.         fScanner->scanDocument(systemId);
  618.         fParseInProgress = false;
  619.     }
  621.     catch (...)
  622.     {
  623.         fParseInProgress = false;
  624.         throw;
  625.     }
  626. }
  628. void SAX2XMLReaderImpl::parse (const   char* const     systemId)
  629. {
  630.     // Avoid multiple entrance
  631.     if (fParseInProgress)
  632.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  634.     try
  635.     {
  636.         fParseInProgress = true;
  637.         fScanner->scanDocument(systemId);
  638.         fParseInProgress = false;
  639.     }
  641.     catch (...)
  642.     {
  643.         fParseInProgress = false;
  644.         throw;
  645.     }
  646. }
  648. // ---------------------------------------------------------------------------
  649. //  SAX2XMLReaderImpl: Progressive parse methods
  650. // ---------------------------------------------------------------------------
  651. bool SAX2XMLReaderImpl::parseFirst( const   XMLCh* const    systemId
  652.                             ,       XMLPScanToken&  toFill)
  653. {
  654.     //
  655.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  656.     //  is in progress.
  657.     //
  658.     if (fParseInProgress)
  659.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  661.     return fScanner->scanFirst(systemId, toFill);
  662. }
  664. bool SAX2XMLReaderImpl::parseFirst( const   char* const     systemId
  665.                             ,       XMLPScanToken&  toFill)
  666. {
  667.     //
  668.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  669.     //  is in progress.
  670.     //
  671.     if (fParseInProgress)
  672.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  674.     return fScanner->scanFirst(systemId, toFill);
  675. }
  677. bool SAX2XMLReaderImpl::parseFirst( const   InputSource&    source
  678.                             ,       XMLPScanToken&  toFill)
  679. {
  680.     //
  681.     //  Avoid multiple entrance. We cannot enter here while a regular parse
  682.     //  is in progress.
  683.     //
  684.     if (fParseInProgress)
  685.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  687.     return fScanner->scanFirst(source, toFill);
  688. }
  690. bool SAX2XMLReaderImpl::parseNext(XMLPScanToken& token)
  691. {
  692.     return fScanner->scanNext(token);
  693. }
  695. void SAX2XMLReaderImpl::parseReset(XMLPScanToken& token)
  696. {
  697.     // Reset the scanner
  698.     fScanner->scanReset(token);
  699. }
  701. // ---------------------------------------------------------------------------
  702. //  SAX2XMLReaderImpl: Overrides of the XMLDocumentHandler interface
  703. // ---------------------------------------------------------------------------
  704. void SAX2XMLReaderImpl::docCharacters(  const   XMLCh* const    chars
  705.                                 , const unsigned int    length
  706.                                 , const bool            cdataSection)
  707. {
  708.     // Suppress the chars before the root element.
  709.     if (!fElemDepth)
  710.         return;
  712.    // Call the installed LexicalHandler.
  713.    if (cdataSection && fLexicalHandler)
  714.         fLexicalHandler->startCDATA();
  716.     // Just map to the SAX document handler
  717.     if (fDocHandler)
  718.         fDocHandler->characters(chars, length);
  720.    // Call the installed LexicalHandler.
  721.    if (cdataSection && fLexicalHandler)
  722.         fLexicalHandler->endCDATA();
  724.     //
  725.     //  If there are any installed advanced handlers, then lets call them
  726.     //  with this info.
  727.     //
  728.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  729.         fAdvDHList[index]->docCharacters(chars, length, cdataSection);
  730. }
  733. void SAX2XMLReaderImpl::docComment(const XMLCh* const commentText)
  734. {
  735.    // Call the installed LexicalHandler.
  736.    if (fLexicalHandler)
  737.    {
  738.         // SAX2 reports comment text like characters -- as an
  739.         // array with a length.
  740.         fLexicalHandler->comment(commentText, XMLString::stringLen(commentText));
  741.    }
  743.     //
  744.     //  OK, if there are any installed advanced handlers,
  745.    // then let's call them with this info.
  746.     //
  747.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  748.         fAdvDHList[index]->docComment(commentText);
  749. }
  752. void SAX2XMLReaderImpl::XMLDecl( const  XMLCh* const    versionStr
  753.                         , const XMLCh* const    encodingStr
  754.                         , const XMLCh* const    standaloneStr
  755.                         , const XMLCh* const    actualEncodingStr
  756.                         )
  757. {
  758.     // SAX has no way to report this event. But, if there are any installed
  759.     //  advanced handlers, then lets call them with this info.
  760.     //
  761.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  762.         fAdvDHList[index]->XMLDecl( versionStr,
  763.                                     encodingStr,
  764.                                     standaloneStr,
  765.                                     actualEncodingStr );
  766. }
  769. void SAX2XMLReaderImpl::docPI(  const   XMLCh* const    target
  770.                         , const XMLCh* const    data)
  771. {
  772.     // Just map to the SAX document handler
  773.     if (fDocHandler)
  774.         fDocHandler->processingInstruction(target, data);
  776.     //
  777.     //  If there are any installed advanced handlers, then lets call them
  778.     //  with this info.
  779.     //
  780.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  781.         fAdvDHList[index]->docPI(target, data);
  782. }
  785. void SAX2XMLReaderImpl::endDocument()
  786. {
  787.     if (fDocHandler)
  788.         fDocHandler->endDocument();
  790.     //
  791.     //  If there are any installed advanced handlers, then lets call them
  792.     //  with this info.
  793.     //
  794.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  795.         fAdvDHList[index]->endDocument();
  796. }
  799. void SAX2XMLReaderImpl::endEntityReference(const XMLEntityDecl& entityDecl)
  800. {
  801.    // Call the installed LexicalHandler.
  802.    if (fLexicalHandler)
  803.         fLexicalHandler->endEntity(entityDecl.getName());
  805.     //
  806.     //  SAX has no way to report this event. But, if there are any installed
  807.     //  advanced handlers, then lets call them with this info.
  808.     //
  809.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  810.         fAdvDHList[index]->endEntityReference(entityDecl);
  811. }
  814. void SAX2XMLReaderImpl::ignorableWhitespace(const   XMLCh* const    chars
  815.                                     , const unsigned int    length
  816.                                     , const bool            cdataSection)
  817. {
  818.     // Do not report the whitespace before the root element.
  819.     if (!fElemDepth)
  820.         return;
  822.     // Just map to the SAX document handler
  823.     if (fDocHandler)
  824.         fDocHandler->ignorableWhitespace(chars, length);
  826.     //
  827.     //  If there are any installed advanced handlers, then lets call them
  828.     //  with this info.
  829.     //
  830.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  831.         fAdvDHList[index]->ignorableWhitespace(chars, length, cdataSection);
  832. }
  835. void SAX2XMLReaderImpl::resetDocument()
  836. {
  837.     //
  838.     //  If there are any installed advanced handlers, then lets call them
  839.     //  with this info.
  840.     //
  841.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  842.         fAdvDHList[index]->resetDocument();
  844.     // Make sure our element depth flag gets set back to zero
  845.     fElemDepth = 0;
  847.     // Pop any prefix buffers left over from previous uses
  848.     while (!fPrefixCounts->empty())
  849.     {
  850.         unsigned int numPrefix = fPrefixCounts->pop();
  851.         for (unsigned int i = 0; i < numPrefix; i++)
  852.         {
  853.             XMLBuffer * buf = fPrefixes->pop() ;
  854.             fStringBuffers.releaseBuffer(*buf) ;
  855.         }
  856.     }
  857. }
  860. void SAX2XMLReaderImpl::startDocument()
  861. {
  862.     // Just map to the SAX document handler
  863.     if (fDocHandler)
  864.     {
  865.         fDocHandler->setDocumentLocator(fScanner->getLocator());
  866.         fDocHandler->startDocument();
  867.     }
  869.     //
  870.     //  If there are any installed advanced handlers, then lets call them
  871.     //  with this info.
  872.     //
  873.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  874.         fAdvDHList[index]->startDocument();
  875. }
  878. void SAX2XMLReaderImpl::
  879. startElement(   const   XMLElementDecl&         elemDecl
  880.                 , const unsigned int            elemURLId
  881.                 , const XMLCh* const            elemPrefix
  882.                 , const RefVectorOf<XMLAttr>&   attrList
  883.                 , const unsigned int            attrCount
  884.                 , const bool                    isEmpty
  885.                 , const bool                    isRoot)
  886. {
  887.     // Bump the element depth counter if not empty
  888.     if (!isEmpty)
  889.         fElemDepth++;
  891.     if (fDocHandler)
  892.     {
  893.         XMLBufBid elemQName( &fStringBuffers ) ;
  894.         if (elemPrefix && *elemPrefix) {
  895.             elemQName.set(elemPrefix);
  896.             elemQName.append(chColon);
  897.         }
  898.         elemQName.append(elemDecl.getBaseName());
  900.         if (getDoNamespaces())
  901.         {
  902.             unsigned int numPrefix = 0;
  903.             const XMLCh*   nsString = XMLUni::fgXMLNSString;
  904.             const XMLCh*   nsPrefix = 0;
  905.             const XMLCh*   nsURI    = 0;
  906.             const XMLAttr* tempAttr = 0;
  908.             if (!fNamespacePrefix)
  909.             {
  910.                 fTempAttrVec->removeAllElements();
  911.             }
  913.             for (unsigned int i = 0; i < attrCount; i++)
  914.             {
  915.                 tempAttr = attrList.elementAt(i);
  916.                 if (XMLString::equals(tempAttr->getQName(), nsString))
  917.                     nsURI = tempAttr->getValue();
  918.                 if (XMLString::equals(tempAttr->getPrefix(), nsString))
  919.                 {
  920.                     nsPrefix = tempAttr->getName();
  921.                     nsURI = tempAttr->getValue();
  922.                 }
  923.                 if (!fNamespacePrefix)
  924.                 {
  925.                     if (nsURI == 0)
  926.                         fTempAttrVec->addElement((XMLAttr* const)tempAttr);
  927.                 }
  928.                 if (nsURI != 0)
  929.                 {
  930.                     if (nsPrefix == 0)
  931.                         nsPrefix = XMLUni::fgZeroLenString;
  932.                     fDocHandler->startPrefixMapping(nsPrefix, nsURI);
  933.                     XMLBuffer &buf = fStringBuffers.bidOnBuffer();
  934.                     buf.set ( nsPrefix ) ;
  935.                     fPrefixes->push(&buf) ;
  936.                     numPrefix++;
  937.                 }
  938.                 nsURI = 0;
  939.                 nsPrefix = 0;
  940.             }
  941.             fPrefixCounts->push(numPrefix) ;
  942.             if (!fNamespacePrefix)
  943.                 fAttrList.setVector(fTempAttrVec, fTempAttrVec->size(), fScanner);
  944.             else
  945.                 fAttrList.setVector(&attrList, attrCount, fScanner);
  947.             // call startElement() with namespace declarations
  948.             fDocHandler->startElement
  949.             (
  950.                 fScanner->getURIText(elemURLId)
  951.                 , elemDecl.getBaseName()
  952.                 , elemQName.getRawBuffer()
  953.                 , fAttrList
  954.             );
  955.         }
  956.         else // no namespace
  957.         {
  958.             fAttrList.setVector(&attrList, attrCount, fScanner);
  959.             fDocHandler->startElement(XMLUni::fgZeroLenString,
  960. elemDecl.getBaseName(),
  961. elemDecl.getFullName(),
  962. fAttrList);
  963.         }
  966.         // If its empty, send the end tag event now
  967.         if (isEmpty)
  968.         {
  969.             // call endPrefixMapping appropriately.
  970.             if (getDoNamespaces())
  971.             {
  972.                 fDocHandler->endElement
  973.                 (
  974.                     fScanner->getURIText(elemURLId)
  975.                     , elemDecl.getBaseName()
  976.                     , elemQName.getRawBuffer()
  977.                 );
  979.                 unsigned int numPrefix = fPrefixCounts->pop();
  980.                 for (unsigned int i = 0; i < numPrefix; ++i)
  981.                 {
  982.                     XMLBuffer * buf = fPrefixes->pop() ;
  983.                     fDocHandler->endPrefixMapping( buf->getRawBuffer() );
  984.                     fStringBuffers.releaseBuffer(*buf) ;
  985.                 }
  986.             }
  987.             else
  988.             {
  989.                 fDocHandler->endElement(XMLUni::fgZeroLenString,
  990.                                 elemDecl.getBaseName(),
  991.                                 elemDecl.getFullName());
  992.             }
  993.         }
  994.     }
  996.     //
  997.     //  If there are any installed advanced handlers, then lets call them
  998.     //  with this info.
  999.     //
  1000.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  1001.     {
  1002.         fAdvDHList[index]->startElement
  1003.         (
  1004.             elemDecl
  1005.             , elemURLId
  1006.             , elemPrefix
  1007.             , attrList
  1008.             , attrCount
  1009.             , isEmpty
  1010.             , isRoot
  1011.         );
  1012.     }
  1013. }
  1015. void SAX2XMLReaderImpl::endElement( const   XMLElementDecl& elemDecl
  1016.                             , const unsigned int    uriId
  1017.                             , const bool            isRoot
  1018.                             , const XMLCh* const    elemPrefix)
  1019. {
  1020.     // Just map to the SAX document handler
  1021.     if (fDocHandler)
  1022.     {
  1024.         // get the prefixes back so that we can call endPrefixMapping()
  1025.         if (getDoNamespaces())
  1026.         {
  1027.             XMLBufBid elemQName( &fStringBuffers ) ;
  1028.             if (elemPrefix && *elemPrefix) {
  1029.                 elemQName.set(elemPrefix);
  1030.                 elemQName.append(chColon);
  1031.             }
  1032.             elemQName.append(elemDecl.getBaseName());
  1034.             fDocHandler->endElement
  1035.             (
  1036.                 fScanner->getURIText(uriId)
  1037.                 , elemDecl.getBaseName()
  1038.                 , elemQName.getRawBuffer()
  1039.             );
  1041.             unsigned int numPrefix = fPrefixCounts->pop();
  1042.             for (unsigned int i = 0; i < numPrefix; i++)
  1043.             {
  1044.                 XMLBuffer * buf = fPrefixes->pop() ;
  1045.                 fDocHandler->endPrefixMapping( buf->getRawBuffer() );
  1046.                 fStringBuffers.releaseBuffer(*buf) ;
  1047.             }
  1048.         }
  1049.         else
  1050.         {
  1051.             fDocHandler->endElement(XMLUni::fgZeroLenString,
  1052.             elemDecl.getBaseName(),
  1053.             elemDecl.getFullName() );
  1054.         }
  1055.     }
  1057.     //
  1058.     //  If there are any installed advanced handlers, then lets call them
  1059.     //  with this info.
  1060.     //
  1061.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  1062.         fAdvDHList[index]->endElement(elemDecl, uriId, isRoot, elemPrefix);
  1064.     //
  1065.     //  Dump the element depth down again. Don't let it underflow in case
  1066.     //  of malformed XML.
  1067.     //
  1068.     if (fElemDepth)
  1069.         fElemDepth--;
  1070. }
  1072. void SAX2XMLReaderImpl::startEntityReference(const XMLEntityDecl& entityDecl)
  1073. {
  1074.    // Call the installed LexicalHandler.
  1075.    if (fLexicalHandler)
  1076.         fLexicalHandler->startEntity(entityDecl.getName());
  1077.     //
  1078.     //  SAX has no way to report this. But, If there are any installed
  1079.     //  advanced handlers, then lets call them with this info.
  1080.     //
  1081.     for (unsigned int index = 0; index < fAdvDHCount; index++)
  1082.         fAdvDHList[index]->startEntityReference(entityDecl);
  1083. }
  1085. // ---------------------------------------------------------------------------
  1086. //  SAX2XMLReaderImpl: Overrides of the DocTypeHandler interface
  1087. // ---------------------------------------------------------------------------
  1088. void SAX2XMLReaderImpl::attDef( const   DTDElementDecl& elemDecl
  1089.                         , const DTDAttDef&      attDef
  1090.                         , const bool            ignoring)
  1091. {
  1092.     if (fDeclHandler && !ignoring) {
  1094.         XMLAttDef::AttTypes attType = attDef.getType();
  1095.         XMLAttDef::DefAttTypes defAttType = attDef.getDefaultType();
  1096.         const XMLCh* defAttTypeStr = XMLUni::fgNullString;
  1097.         bool isEnumeration = (attType == XMLAttDef::Notation || attType == XMLAttDef::Enumeration);
  1098.         XMLBuffer enumBuf(128, fMemoryManager);
  1100.         if (defAttType == XMLAttDef::Fixed ||
  1101.             defAttType == XMLAttDef::Implied ||
  1102.             defAttType == XMLAttDef::Required) {
  1103.             defAttTypeStr = attDef.getDefAttTypeString(defAttType);
  1104.         }
  1106.         if (isEnumeration) {
  1108.             const XMLCh* enumString = attDef.getEnumeration();
  1109.             unsigned int enumLen = XMLString::stringLen(enumString);
  1111.             if (attType == XMLAttDef::Notation) {
  1113.                 enumBuf.set(XMLUni::fgNotationString);
  1114.                 enumBuf.append(chSpace);
  1115.             }
  1117.             enumBuf.append(chOpenParen);
  1119.             for (unsigned int i=0; i<enumLen; i++) {
  1120.                 if (enumString[i] == chSpace)
  1121.                     enumBuf.append(chPipe);
  1122.                 else
  1123.                     enumBuf.append(enumString[i]);
  1124.             }
  1126.             enumBuf.append(chCloseParen);
  1127.         }
  1129.         fDeclHandler->attributeDecl(elemDecl.getFullName(),
  1130.                                     attDef.getFullName(),
  1131.                                     (isEnumeration) ? enumBuf.getRawBuffer()
  1132.                                                     : attDef.getAttTypeString(attDef.getType()),
  1133.                                     defAttTypeStr,
  1134.                                     attDef.getValue());
  1135.     }
  1136. }
  1139. void SAX2XMLReaderImpl::doctypeComment(const XMLCh* const commentText)
  1140. {
  1141.    if (fLexicalHandler)
  1142.    {
  1143.         // SAX2 reports comment text like characters -- as an
  1144.         // array with a length.
  1145.         fLexicalHandler->comment(commentText, XMLString::stringLen(commentText));
  1146.    }
  1147. }
  1150. void SAX2XMLReaderImpl::doctypeDecl(const   DTDElementDecl& elemDecl
  1151.                             , const XMLCh* const    publicId
  1152.                             , const XMLCh* const    systemId
  1153.                             , const bool            hasIntSubset
  1154.                             , const bool            hasExtSubset)
  1155. {
  1156.     // Call the installed LexicalHandler.
  1157.     if (fLexicalHandler && (hasIntSubset || hasExtSubset))
  1158.         fLexicalHandler->startDTD(elemDecl.getFullName(), publicId, systemId);
  1160.     fHasExternalSubset = hasExtSubset;
  1162.     // Unused by SAX DTDHandler interface at this time
  1163. }
  1166. void SAX2XMLReaderImpl::doctypePI(  const   XMLCh* const
  1167.                             , const XMLCh* const)
  1168. {
  1169.     // Unused by SAX DTDHandler interface at this time
  1170. }
  1173. void SAX2XMLReaderImpl::doctypeWhitespace(  const   XMLCh* const    chars
  1174.                                     , const unsigned int    length)
  1175. {
  1176.     // Unused by SAX DTDHandler interface at this time
  1177. }
  1180. void SAX2XMLReaderImpl::elementDecl(const DTDElementDecl& elemDecl,
  1181.                                     const bool isIgnored)
  1182. {
  1183.     if (fDeclHandler && !isIgnored)
  1184.         fDeclHandler->elementDecl(elemDecl.getFullName(),
  1185.                                   elemDecl.getFormattedContentModel());
  1186. }
  1189. void SAX2XMLReaderImpl::endAttList(const DTDElementDecl&)
  1190. {
  1191.     // Unused by SAX DTDHandler interface at this time
  1192. }
  1195. void SAX2XMLReaderImpl::endIntSubset()
  1196. {
  1197.    // Call the installed LexicalHandler.
  1198.    if (!fHasExternalSubset && fLexicalHandler)
  1199.         fLexicalHandler->endDTD();
  1201.     // Unused by SAX DTDHandler interface at this time
  1202. }
  1205. void SAX2XMLReaderImpl::endExtSubset()
  1206. {
  1207.     // Call the installed LexicalHandler.
  1208.     if (fLexicalHandler) {
  1210.         fLexicalHandler->endEntity(gDTDEntityStr);
  1211.         fLexicalHandler->endDTD();
  1212.     }
  1214.     // Unused by SAX DTDHandler interface at this time
  1215. }
  1218. void SAX2XMLReaderImpl::entityDecl( const   DTDEntityDecl&  entityDecl
  1219.                             , const bool            isPEDecl
  1220.                             , const bool            isIgnored)
  1221. {
  1222.     //
  1223.     //  If we have a DTD handler, and this entity is not ignored, and
  1224.     //  its an unparsed entity, then send this one, else if we have a Decl
  1225.     //  handler then send this one.
  1226.     //
  1227.     if (!isIgnored) {
  1229.         if (entityDecl.isUnparsed()) {
  1231.             if (fDTDHandler) {
  1232.                 fDTDHandler->unparsedEntityDecl
  1233.                 (
  1234.                     entityDecl.getName()
  1235.                     , entityDecl.getPublicId()
  1236.                     , entityDecl.getSystemId()
  1237.                     , entityDecl.getNotationName()
  1238.                 );
  1239.             }
  1240.         }
  1241.         else if (fDeclHandler) {
  1243.             const XMLCh* entityName = entityDecl.getName();
  1244.             ArrayJanitor<XMLCh> tmpNameJan(0);
  1246.             if (isPEDecl) {
  1248.                 unsigned int nameLen = XMLString::stringLen(entityName);
  1249.                 XMLCh* tmpName = (XMLCh*) fMemoryManager->allocate
  1250.                 (
  1251.                     (nameLen + 2) * sizeof(XMLCh)
  1252.                 );//new XMLCh[nameLen + 2];
  1254.                 tmpNameJan.reset(tmpName, fMemoryManager);
  1255.                 tmpName[0] = chPercent;
  1256.                 XMLString::copyString(tmpName + 1, entityName);
  1257.                 entityName = tmpName;
  1258.             }
  1260.             if (entityDecl.isExternal()) {
  1261.                 fDeclHandler->externalEntityDecl
  1262.                 (
  1263.                     entityName
  1264.                     , entityDecl.getPublicId()
  1265.                     , entityDecl.getSystemId()
  1266.                 );
  1267.             }
  1268.             else {
  1269.                 fDeclHandler->internalEntityDecl
  1270.                 (
  1271.                     entityName
  1272.                     , entityDecl.getValue()
  1273.                 );
  1274.             }
  1275.         }
  1276.     }
  1277. }
  1280. void SAX2XMLReaderImpl::resetDocType()
  1281. {
  1282.     fHasExternalSubset = false;
  1283.     // Just map to the DTD handler
  1284.     if (fDTDHandler)
  1285.         fDTDHandler->resetDocType();
  1286. }
  1289. void SAX2XMLReaderImpl::notationDecl(   const   XMLNotationDecl&    notDecl
  1290.                                 , const bool                isIgnored)
  1291. {
  1292.     if (fDTDHandler && !isIgnored)
  1293.     {
  1294.         fDTDHandler->notationDecl
  1295.         (
  1296.             notDecl.getName()
  1297.             , notDecl.getPublicId()
  1298.             , notDecl.getSystemId()
  1299.         );
  1300.     }
  1301. }
  1304. void SAX2XMLReaderImpl::startAttList(const DTDElementDecl&)
  1305. {
  1306.     // Unused by SAX DTDHandler interface at this time
  1307. }
  1310. void SAX2XMLReaderImpl::startIntSubset()
  1311. {
  1312.     // Unused by SAX DTDHandler interface at this time
  1313. }
  1316. void SAX2XMLReaderImpl::startExtSubset()
  1317. {
  1318.     if (fLexicalHandler)
  1319.         fLexicalHandler->startEntity(gDTDEntityStr);
  1320. }
  1323. void SAX2XMLReaderImpl::TextDecl(   const  XMLCh* const
  1324.                             , const XMLCh* const)
  1325. {
  1326.     // Unused by SAX DTDHandler interface at this time
  1327. }
  1330. // ---------------------------------------------------------------------------
  1331. //  SAX2XMLReaderImpl: Handlers for the XMLEntityHandler interface
  1332. // ---------------------------------------------------------------------------
  1333. void SAX2XMLReaderImpl::endInputSource(const InputSource&)
  1334. {
  1335. }
  1337. bool SAX2XMLReaderImpl::expandSystemId(const XMLCh* const, XMLBuffer&)
  1338. {
  1339.     return false;
  1340. }
  1343. void SAX2XMLReaderImpl::resetEntities()
  1344. {
  1345.     // Nothing to do for this one
  1346. }
  1349. InputSource* SAX2XMLReaderImpl::resolveEntity(   const   XMLCh* const    publicId
  1350.                                                , const   XMLCh* const    systemId
  1351.                                                , const   XMLCh* const    baseURI)
  1352. {
  1353.     // Just map to the SAX entity resolver handler
  1354.     if (fEntityResolver)
  1355.         return fEntityResolver->resolveEntity(publicId, systemId);
  1356.     return 0;
  1357. }
  1360. void SAX2XMLReaderImpl::startInputSource(const InputSource&)
  1361. {
  1362.     // Nothing to do for this one
  1363. }
  1365. // ---------------------------------------------------------------------------
  1366. //  SAX2XMLReaderImpl: Overrides of the XMLErrorReporter interface
  1367. // ---------------------------------------------------------------------------
  1368. void SAX2XMLReaderImpl::resetErrors()
  1369. {
  1370.     if (fErrorHandler)
  1371.         fErrorHandler->resetErrors();
  1372. }
  1375. void SAX2XMLReaderImpl::error(  const   unsigned int                code
  1376.                         , const XMLCh* const                msgDomain
  1377.                         , const XMLErrorReporter::ErrTypes  errType
  1378.                         , const XMLCh* const                errorText
  1379.                         , const XMLCh* const                systemId
  1380.                         , const XMLCh* const                publicId
  1381.                         , const XMLSSize_t                  lineNum
  1382.                         , const XMLSSize_t                  colNum)
  1383. {
  1384.     SAXParseException toThrow = SAXParseException
  1385.     (
  1386.         errorText
  1387.         , publicId
  1388.         , systemId
  1389.         , lineNum
  1390.         , colNum
  1391.     );
  1393.     if (!fErrorHandler)
  1394.     {
  1395.         if (errType == XMLErrorReporter::ErrType_Fatal)
  1396.             throw toThrow;
  1397.         else
  1398.             return;
  1399.     }
  1401.     if (errType == XMLErrorReporter::ErrType_Warning)
  1402.         fErrorHandler->warning(toThrow);
  1403.     else if (errType == XMLErrorReporter::ErrType_Fatal)
  1404.         fErrorHandler->fatalError(toThrow);
  1405.     else
  1406.         fErrorHandler->error(toThrow);
  1407. }
  1410. // ---------------------------------------------------------------------------
  1411. //  SAX2XMLReaderImpl: Features and Properties
  1412. // ---------------------------------------------------------------------------
  1414. void SAX2XMLReaderImpl::setFeature(const XMLCh* const name, const bool value)
  1415. {
  1417.     if (fParseInProgress)
  1418.         throw SAXNotSupportedException("Feature modification is not supported during parse.");
  1420.     if (XMLString::compareIString(name, XMLUni::fgSAX2CoreNameSpaces) == 0)
  1421.     {
  1422.         setDoNamespaces(value);
  1423.     }
  1424.     else if (XMLString::compareIString(name, XMLUni::fgSAX2CoreValidation) == 0)
  1425.     {
  1426.         fValidation = value;
  1427.         if (fValidation)
  1428.             if (fAutoValidation)
  1429.                 setValidationScheme(Val_Auto);
  1430.             else
  1431.                 setValidationScheme(Val_Always);
  1432.         else
  1433.             setValidationScheme(Val_Never);
  1434.     }
  1435.     else if (XMLString::compareIString(name, XMLUni::fgSAX2CoreNameSpacePrefixes) == 0)
  1436.     {
  1437.         fNamespacePrefix = value;
  1438.     }
  1439.     else if (XMLString::compareIString(name, XMLUni::fgXercesDynamic) == 0)
  1440.     {
  1441.         fAutoValidation = value;
  1442.         // for auto validation, the sax2 core validation feature must also be enabled.
  1443.         if (fValidation)
  1444.             if (fAutoValidation)
  1445.                 setValidationScheme(Val_Auto);
  1446.             else
  1447.                 setValidationScheme(Val_Always);
  1448.         else
  1449.             setValidationScheme(Val_Never);
  1450.     }
  1451.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchema) == 0)
  1452.     {
  1453.         setDoSchema(value);
  1454.     }
  1455.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaFullChecking) == 0)
  1456.     {
  1457.         fScanner->setValidationSchemaFullChecking(value);
  1458.     }
  1459.     else if (XMLString::compareIString(name, XMLUni::fgXercesLoadExternalDTD) == 0)
  1460.     {
  1461.         fScanner->setLoadExternalDTD(value);
  1462.     }
  1463.     else if (XMLString::compareIString(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
  1464.     {
  1465.         fScanner->setExitOnFirstFatal(!value);
  1466.     }
  1467.     else if (XMLString::compareIString(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
  1468.     {
  1469.         fScanner->setValidationConstraintFatal(value);
  1470.     }
  1471.     else if (XMLString::compareIString(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
  1472.     {
  1473.         fScanner->cacheGrammarFromParse(value);
  1475.         if (value)
  1476.             fScanner->useCachedGrammarInParse(value);
  1477.     }
  1478.     else if (XMLString::compareIString(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
  1479.     {
  1480.         if (value || !fScanner->isCachingGrammarFromParse())
  1481.             fScanner->useCachedGrammarInParse(value);
  1482.     }
  1483.     else if (XMLString::compareIString(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
  1484.     {
  1485.         fScanner->setCalculateSrcOfs(value);
  1486.     }
  1487.     else if (XMLString::compareIString(name, XMLUni::fgXercesStandardUriConformant) == 0)
  1488.     {
  1489.         fScanner->setStandardUriConformant(value);
  1490.     }
  1491.     else
  1492.        throw SAXNotRecognizedException("Unknown Feature");
  1493. }
  1495. bool SAX2XMLReaderImpl::getFeature(const XMLCh* const name) const
  1496. {
  1497.     if (XMLString::compareIString(name, XMLUni::fgSAX2CoreNameSpaces) == 0)
  1498.         return getDoNamespaces();
  1499.     else if (XMLString::compareIString(name, XMLUni::fgSAX2CoreValidation) == 0)
  1500.         return fValidation;
  1501.     else if (XMLString::compareIString(name, XMLUni::fgSAX2CoreNameSpacePrefixes) == 0)
  1502.         return fNamespacePrefix;
  1503.     else if (XMLString::compareIString(name, XMLUni::fgXercesDynamic) == 0)
  1504.         return fAutoValidation;
  1505.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchema) == 0)
  1506.         return getDoSchema();
  1507.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaFullChecking) == 0)
  1508.         return fScanner->getValidationSchemaFullChecking();
  1509.     else if (XMLString::compareIString(name, XMLUni::fgXercesLoadExternalDTD) == 0)
  1510.         return fScanner->getLoadExternalDTD();
  1511.     else if (XMLString::compareIString(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
  1512.         return !fScanner->getExitOnFirstFatal();
  1513.     else if (XMLString::compareIString(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
  1514.         return fScanner->getValidationConstraintFatal();
  1515.     else if (XMLString::compareIString(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
  1516.         return fScanner->isCachingGrammarFromParse();
  1517.     else if (XMLString::compareIString(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
  1518.         return fScanner->isUsingCachedGrammarInParse();
  1519.     else if (XMLString::compareIString(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
  1520.         return fScanner->getCalculateSrcOfs();
  1521.     else if (XMLString::compareIString(name, XMLUni::fgXercesStandardUriConformant) == 0)
  1522.         return fScanner->getStandardUriConformant();
  1523.     else
  1524.        throw SAXNotRecognizedException("Unknown Feature");
  1526.     return false;
  1527. }
  1529. void SAX2XMLReaderImpl::setProperty(const XMLCh* const name, void* value)
  1530. {
  1531. if (fParseInProgress)
  1532. throw SAXNotSupportedException("Property modification is not supported during parse.");
  1534. if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
  1535. {
  1536. fScanner->setExternalSchemaLocation((XMLCh*)value);
  1537. }
  1538. else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
  1539. {
  1540. fScanner->setExternalNoNamespaceSchemaLocation((XMLCh*)value);
  1541. }
  1542. else if (XMLString::compareIString(name, XMLUni::fgXercesSecurityManager) == 0)
  1543. {
  1544. fScanner->setSecurityManager((SecurityManager*)value);
  1545. }
  1546.     else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
  1547.     {
  1548.         XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
  1549.         (
  1550.             (const XMLCh*) value
  1551.             , fValidator
  1552.             , fMemoryManager
  1553.         );
  1555.         if (tempScanner) {
  1557.             tempScanner->setParseSettings(fScanner);
  1558.             tempScanner->setGrammarResolver(fGrammarResolver);
  1559.             tempScanner->setURIStringPool(fURIStringPool);
  1560.             delete fScanner;
  1561.             fScanner = tempScanner;
  1562.         }
  1563.     }
  1564.     else
  1565.        throw SAXNotRecognizedException("Unknown Property");
  1566. }
  1569. void* SAX2XMLReaderImpl::getProperty(const XMLCh* const name) const
  1570. {
  1571.     if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
  1572.         return (void*)fScanner->getExternalSchemaLocation();
  1573.     else if (XMLString::compareIString(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
  1574.         return (void*)fScanner->getExternalNoNamespaceSchemaLocation();
  1575.     else if (XMLString::compareIString(name, XMLUni::fgXercesSecurityManager) == 0)
  1576.         return (void*)fScanner->getSecurityManager();
  1577.     else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
  1578.         return (void*)fScanner->getName();
  1579.     else
  1580.         throw SAXNotRecognizedException("Unknown Property");
  1581.     return 0;
  1582. }
  1585. // ---------------------------------------------------------------------------
  1586. //  SAX2XMLReaderImpl: Private getters and setters for conveniences
  1587. // ---------------------------------------------------------------------------
  1589. void SAX2XMLReaderImpl::setValidationScheme(const ValSchemes newScheme)
  1590. {
  1591.     if (newScheme == Val_Never)
  1592.         fScanner->setValidationScheme(XMLScanner::Val_Never);
  1593.     else if (newScheme == Val_Always)
  1594.         fScanner->setValidationScheme(XMLScanner::Val_Always);
  1595.     else
  1596.         fScanner->setValidationScheme(XMLScanner::Val_Auto);
  1597. }
  1599. void SAX2XMLReaderImpl::setDoNamespaces(const bool newState)
  1600. {
  1601.     fScanner->setDoNamespaces(newState);
  1602. }
  1604. bool SAX2XMLReaderImpl::getDoNamespaces() const
  1605. {
  1606.     return fScanner->getDoNamespaces();
  1607. }
  1609. void SAX2XMLReaderImpl::setDoSchema(const bool newState)
  1610. {
  1611.     fScanner->setDoSchema(newState);
  1612. }
  1614. bool SAX2XMLReaderImpl::getDoSchema() const
  1615. {
  1616.     return fScanner->getDoSchema();
  1617. }
  1620. // ---------------------------------------------------------------------------
  1621. //  SAX2XMLReaderImpl: Grammar preparsing
  1622. // ---------------------------------------------------------------------------
  1623. Grammar* SAX2XMLReaderImpl::loadGrammar(const char* const systemId,
  1624.                                         const short grammarType,
  1625.                                         const bool toCache)
  1626. {
  1627.     // Avoid multiple entrance
  1628.     if (fParseInProgress)
  1629.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1631.     Grammar* grammar = 0;
  1632.     try
  1633.     {
  1634.         fParseInProgress = true;
  1635.         grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
  1636.         fParseInProgress = false;
  1637.     }
  1639.     catch(...)
  1640.     {
  1641.         fParseInProgress = false;
  1642.         throw;
  1643.     }
  1645.     return grammar;
  1646. }
  1648. Grammar* SAX2XMLReaderImpl::loadGrammar(const XMLCh* const systemId,
  1649.                                         const short grammarType,
  1650.                                         const bool toCache)
  1651. {
  1652.     // Avoid multiple entrance
  1653.     if (fParseInProgress)
  1654.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1656.     Grammar* grammar = 0;
  1657.     try
  1658.     {
  1659.         fParseInProgress = true;
  1660.         grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
  1661.         fParseInProgress = false;
  1662.     }
  1664.     catch(...)
  1665.     {
  1666.         fParseInProgress = false;
  1667.         throw;
  1668.     }
  1670.     return grammar;
  1671. }
  1673. Grammar* SAX2XMLReaderImpl::loadGrammar(const InputSource& source,
  1674.                                         const short grammarType,
  1675.                                         const bool toCache)
  1676. {
  1677.     // Avoid multiple entrance
  1678.     if (fParseInProgress)
  1679.         ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
  1681.     Grammar* grammar = 0;
  1682.     try
  1683.     {
  1684.         fParseInProgress = true;
  1685.         grammar = fScanner->loadGrammar(source, grammarType, toCache);
  1686.         fParseInProgress = false;
  1687.     }
  1689.     catch(...)
  1690.     {
  1691.         fParseInProgress = false;
  1692.         throw;
  1693.     }
  1695.     return grammar;
  1696. }
  1698. void SAX2XMLReaderImpl::resetCachedGrammarPool()
  1699. {
  1700.     fGrammarResolver->resetCachedGrammar();
  1701. }
  1703. Grammar* SAX2XMLReaderImpl::getGrammar(const XMLCh* const nameSpaceKey)
  1704. {
  1705.     return fGrammarResolver->getGrammar(nameSpaceKey);
  1706. }
  1709. XERCES_CPP_NAMESPACE_END