SAXParser.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:79k
源码类别:

词法分析

开发平台:

Visual C++

  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.  */
  56. /*
  57.  * $Log: SAXParser.hpp,v $
  58.  * Revision 1.23  2003/05/15 18:26:50  knoaman
  59.  * Partial implementation of the configurable memory manager.
  60.  *
  61.  * Revision 1.22  2003/04/17 21:58:50  neilg
  62.  * Adding a new property,
  63.  * http://apache.org/xml/properties/security-manager, with
  64.  * appropriate getSecurityManager/setSecurityManager methods on DOM
  65.  * and SAX parsers.  Also adding a new SecurityManager class.
  66.  *
  67.  * The purpose of these modifications is to permit applications a
  68.  * means to have the parser reject documents whose processing would
  69.  * otherwise consume large amounts of system resources.  Malicious
  70.  * use of such documents could be used to launch a denial-of-service
  71.  * attack against a system running the parser.  Initially, the
  72.  * SecurityManager only knows about attacks that can result from
  73.  * exponential entity expansion; this is the only known attack that
  74.  * involves processing a single XML document.  Other, simlar attacks
  75.  * can be launched if arbitrary schemas may be parsed; there already
  76.  * exist means (via use of the EntityResolver interface) by which
  77.  * applications can deny processing of untrusted schemas.  In future,
  78.  * the SecurityManager will be expanded to take these other exploits
  79.  * into account.
  80.  *
  81.  * Add support for the SecurityManager
  82.  * 
  83.  * Revision 1.21  2003/03/07 18:09:17  tng
  84.  * Return a reference instead of void for operator=
  85.  *
  86.  * Revision 1.20  2003/02/04 19:27:43  knoaman
  87.  * Performance: use global buffer to eliminate repetitive memory creation/deletion.
  88.  *
  89.  * Revision 1.19  2003/01/09 19:07:08  tng
  90.  * [Bug 15802] Add "const" qualifier to getURIText.
  91.  *
  92.  * Revision 1.18  2003/01/03 20:09:36  tng
  93.  * New feature StandardUriConformant to force strict standard uri conformance.
  94.  *
  95.  * Revision 1.17  2002/12/30 20:15:51  knoaman
  96.  * Make calculate src offset option false by default.
  97.  *
  98.  * Revision 1.16  2002/12/23 15:23:18  knoaman
  99.  * Added a public api to various parsers to return the src offset within the input
  100.  * source.
  101.  *
  102.  * Revision 1.15  2002/12/04 01:57:09  knoaman
  103.  * Scanner re-organization.
  104.  *
  105.  * Revision 1.14  2002/11/04 14:57:03  tng
  106.  * C++ Namespace Support.
  107.  *
  108.  * Revision 1.13  2002/08/14 15:20:38  knoaman
  109.  * [Bug 3111] Problem with LexicalHandler::startDTD() and LexicalHandler::endDTD().
  110.  *
  111.  * Revision 1.12  2002/07/11 18:27:03  knoaman
  112.  * Grammar caching/preparsing - initial implementation.
  113.  *
  114.  * Revision 1.11  2002/06/27 18:48:04  tng
  115.  * API Documentation Update and move getScanner as protected
  116.  *
  117.  * Revision 1.10  2002/06/17 15:41:44  tng
  118.  * Update API Documentation
  119.  *
  120.  * Revision 1.9  2002/06/06 20:38:18  tng
  121.  * Document Fix: document that the returned object from resolveEntity is owned by the parser
  122.  *
  123.  * Revision 1.8  2002/05/31 15:13:53  tng
  124.  * Fix doxygen documentation.
  125.  *
  126.  * Revision 1.7  2002/05/30 16:39:06  knoaman
  127.  * DOM L3 LS.
  128.  *
  129.  * Revision 1.6  2002/05/30 16:20:09  tng
  130.  * Add feature to optionally ignore external DTD.
  131.  *
  132.  * Revision 1.5  2002/05/29 21:37:47  knoaman
  133.  * Add baseURI to resolveEntity to support DOMInputSource.
  134.  *
  135.  * Revision 1.4  2002/05/28 20:44:14  tng
  136.  * [Bug 9104] prefixes dissapearing when schema validation turned on.
  137.  *
  138.  * Revision 1.3  2002/05/27 18:39:21  tng
  139.  * To get ready for 64 bit large file, use XMLSSize_t to represent line and column number.
  140.  *
  141.  * Revision 1.2  2002/02/20 18:17:01  tng
  142.  * [Bug 5977] Warnings on generating apiDocs.
  143.  *
  144.  * Revision 1.1.1.1  2002/02/01 22:22:07  peiyongz
  145.  * sane_include
  146.  *
  147.  * Revision 1.22  2001/12/05 22:09:02  tng
  148.  * Update documentation for setExternalSchemaLocation and setExternalNoNamespaceSchemaLocation.
  149.  *
  150.  * Revision 1.21  2001/11/20 18:51:44  tng
  151.  * 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).
  152.  *
  153.  * Revision 1.20  2001/08/01 19:11:02  tng
  154.  * Add full schema constraint checking flag to the samples and the parser.
  155.  *
  156.  * Revision 1.19  2001/07/27 20:24:21  tng
  157.  * put getScanner() back as they were there before, not to break existing apps.
  158.  *
  159.  * Revision 1.18  2001/07/16 12:52:09  tng
  160.  * APIDocs fix: default for schema processing in DOMParser, IDOMParser, and SAXParser should be false.
  161.  *
  162.  * Revision 1.17  2001/06/23 14:13:16  tng
  163.  * Remove getScanner from the Parser headers as this is not needed and Scanner is not internal class.
  164.  *
  165.  * Revision 1.16  2001/06/03 19:26:20  jberry
  166.  * Add support for querying error count following parse; enables simple parse without requiring error handler.
  167.  *
  168.  * Revision 1.15  2001/05/11 13:26:22  tng
  169.  * Copyright update.
  170.  *
  171.  * Revision 1.14  2001/05/03 19:09:25  knoaman
  172.  * Support Warning/Error/FatalError messaging.
  173.  * Validity constraints errors are treated as errors, with the ability by user to set
  174.  * validity constraints as fatal errors.
  175.  *
  176.  * Revision 1.13  2001/03/30 16:46:57  tng
  177.  * Schema: Use setDoSchema instead of setSchemaValidation which makes more sense.
  178.  *
  179.  * Revision 1.12  2001/03/21 21:56:09  tng
  180.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  181.  *
  182.  * Revision 1.11  2001/02/15 15:56:29  tng
  183.  * Schema: Add setSchemaValidation and getSchemaValidation for DOMParser and SAXParser.
  184.  * Add feature "http://apache.org/xml/features/validation/schema" for SAX2XMLReader.
  185.  * New data field  fSchemaValidation in XMLScanner as the flag.
  186.  *
  187.  * Revision 1.10  2001/01/12 21:23:41  tng
  188.  * Documentation Enhancement: explain values of Val_Scheme
  189.  *
  190.  * Revision 1.9  2000/08/02 18:05:15  jpolast
  191.  * changes required for sax2
  192.  * (changed private members to protected)
  193.  *
  194.  * Revision 1.8  2000/04/12 22:58:30  roddey
  195.  * Added support for 'auto validate' mode.
  196.  *
  197.  * Revision 1.7  2000/03/03 01:29:34  roddey
  198.  * Added a scanReset()/parseReset() method to the scanner and
  199.  * parsers, to allow for reset after early exit from a progressive parse.
  200.  * Added calls to new Terminate() call to all of the samples. Improved
  201.  * documentation in SAX and DOM parsers.
  202.  *
  203.  * Revision 1.6  2000/02/17 03:54:27  rahulj
  204.  * Added some new getters to query the parser state and
  205.  * clarified the documentation.
  206.  *
  207.  * Revision 1.5  2000/02/16 03:42:58  rahulj
  208.  * Finished documenting the SAX Driver implementation.
  209.  *
  210.  * Revision 1.4  2000/02/15 04:47:37  rahulj
  211.  * Documenting the SAXParser framework. Not done yet.
  212.  *
  213.  * Revision 1.3  2000/02/06 07:47:56  rahulj
  214.  * Year 2K copyright swat.
  215.  *
  216.  * Revision 1.2  1999/12/15 19:57:48  roddey
  217.  * Got rid of redundant 'const' on boolean return value. Some compilers choke
  218.  * on this and its useless.
  219.  *
  220.  * Revision 1.1.1.1  1999/11/09 01:07:51  twl
  221.  * Initial checkin
  222.  *
  223.  * Revision 1.6  1999/11/08 20:44:54  rahul
  224.  * Swat for adding in Product name and CVS comment log variable.
  225.  *
  226.  */
  227. #if !defined(SAXPARSER_HPP)
  228. #define SAXPARSER_HPP
  229. #include <xercesc/sax/Parser.hpp>
  230. #include <xercesc/internal/VecAttrListImpl.hpp>
  231. #include <xercesc/framework/XMLDocumentHandler.hpp>
  232. #include <xercesc/framework/XMLElementDecl.hpp>
  233. #include <xercesc/framework/XMLEntityHandler.hpp>
  234. #include <xercesc/framework/XMLErrorReporter.hpp>
  235. #include <xercesc/framework/XMLBuffer.hpp>
  236. #include <xercesc/util/SecurityManager.hpp>
  237. #include <xercesc/validators/DTD/DocTypeHandler.hpp>
  238. XERCES_CPP_NAMESPACE_BEGIN
  239. class DocumentHandler;
  240. class EntityResolver;
  241. class XMLPScanToken;
  242. class XMLScanner;
  243. class XMLValidator;
  244. class Grammar;
  245. class GrammarResolver;
  246. /**
  247.   * This class implements the SAX 'Parser' interface and should be
  248.   * used by applications wishing to parse the XML files using SAX.
  249.   * It allows the client program to install SAX handlers for event
  250.   * callbacks.
  251.   *
  252.   * <p>It can be used to instantiate a validating or non-validating
  253.   * parser, by setting a member flag.</p>
  254.   */
  255. class PARSERS_EXPORT SAXParser :
  256.     public XMemory
  257.     , public Parser
  258.     , public XMLDocumentHandler
  259.     , public XMLErrorReporter
  260.     , public XMLEntityHandler
  261.     , public DocTypeHandler    
  262. {
  263. public :
  264.     // -----------------------------------------------------------------------
  265.     //  Class types
  266.     // -----------------------------------------------------------------------
  267.     /** ValScheme enum used in setValidationScheme
  268.       *    Val_Never:  Do not report validation errors.
  269.       *    Val_Always: The parser will always report validation errors.
  270.       *    Val_Auto:   The parser will report validation errors only if a grammar is specified.
  271.       *
  272.       * @see #setValidationScheme
  273.       */
  274.     enum ValSchemes
  275.     {
  276.         Val_Never
  277.         , Val_Always
  278.         , Val_Auto
  279.     };
  280.     // -----------------------------------------------------------------------
  281.     //  Constructors and Destructor
  282.     // -----------------------------------------------------------------------
  283.     /** @name Constructors and Destructor */
  284.     //@{
  285.     /** Constructor with an instance of validator class to use for
  286.       * validation.
  287.       * @param valToAdopt Pointer to the validator instance to use. The
  288.       *                   parser is responsible for freeing the memory.
  289.       */
  290.     SAXParser
  291.     (
  292.           XMLValidator* const  valToAdopt = 0
  293.         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  294.     );
  295.     /**
  296.       * Destructor
  297.       */
  298.     ~SAXParser();
  299.     //@}
  300.     // -----------------------------------------------------------------------
  301.     //  Getter Methods
  302.     // -----------------------------------------------------------------------
  303.     /** @name Getter methods */
  304.     //@{
  305.     /**
  306.       * This method returns the installed document handler. Suitable
  307.       * for 'lvalue' usages.
  308.       *
  309.       * @return The pointer to the installed document handler object.
  310.       */
  311.     DocumentHandler* getDocumentHandler();
  312.     /**
  313.       * This method returns the installed document handler. Suitable
  314.       * only for 'rvalue' usages.
  315.       *
  316.       * @return A const pointer to the installed document handler object.
  317.       */
  318.     const DocumentHandler* getDocumentHandler() const;
  319.     /**
  320.       * This method returns the installed entity resolver. Suitable
  321.       * for 'lvalue' usages.
  322.       *
  323.       * @return The pointer to the installed entity resolver object.
  324.       */
  325.     EntityResolver* getEntityResolver();
  326.     /**
  327.       * This method returns the installed entity resolver. Suitable
  328.       * for 'rvalue' usages.
  329.       *
  330.       * @return A const pointer to the installed entity resolver object.
  331.       */
  332.     const EntityResolver* getEntityResolver() const;
  333.     /**
  334.       * This method returns the installed error handler. Suitable
  335.       * for 'lvalue' usages.
  336.       *
  337.       * @return The pointer to the installed error handler object.
  338.       */
  339.     ErrorHandler* getErrorHandler();
  340.     /**
  341.       * This method returns the installed error handler. Suitable
  342.       * for 'rvalue' usages.
  343.       *
  344.       * @return A const pointer to the installed error handler object.
  345.       */
  346.     const ErrorHandler* getErrorHandler() const;
  347.     /**
  348.       * This method returns a reference to the parser's installed
  349.       * validator.
  350.       *
  351.       * @return A const reference to the installed validator object.
  352.       */
  353.     const XMLValidator& getValidator() const;
  354.     /**
  355.       * This method returns an enumerated value that indicates the current
  356.       * validation scheme set on this parser.
  357.       *
  358.       * @return The ValSchemes value current set on this parser.
  359.       * @see #setValidationScheme
  360.       */
  361.     ValSchemes getValidationScheme() const;
  362.     /** Get the 'do schema' flag
  363.       *
  364.       * This method returns the state of the parser's schema processing
  365.       * flag.
  366.       *
  367.       * @return true, if the parser is currently configured to
  368.       *         understand schema, false otherwise.
  369.       *
  370.       * @see #setDoSchema
  371.       */
  372.     bool getDoSchema() const;
  373.     /** Get the 'full schema constraint checking' flag
  374.       *
  375.       * This method returns the state of the parser's full schema constraint
  376.       * checking flag.
  377.       *
  378.       * @return true, if the parser is currently configured to
  379.       *         have full schema constraint checking, false otherwise.
  380.       *
  381.       * @see #setValidationSchemaFullChecking
  382.       */
  383.     bool getValidationSchemaFullChecking() const;
  384.     /** Get error count from the last parse operation.
  385.       *
  386.       * This method returns the error count from the last parse
  387.       * operation. Note that this count is actually stored in the
  388.       * scanner, so this method simply returns what the
  389.       * scanner reports.
  390.       *
  391.       * @return number of errors encountered during the latest
  392.       * parse operation.
  393.       */
  394.     int getErrorCount() const;
  395.     /**
  396.       * This method returns the state of the parser's namespace
  397.       * handling capability.
  398.       *
  399.       * @return true, if the parser is currently configured to
  400.       *         understand namespaces, false otherwise.
  401.       *
  402.       * @see #setDoNamespaces
  403.       */
  404.     bool getDoNamespaces() const;
  405.     /**
  406.       * This method returns the state of the parser's
  407.       * exit-on-First-Fatal-Error flag.
  408.       *
  409.       * @return true, if the parser is currently configured to
  410.       *         exit on the first fatal error, false otherwise.
  411.       *
  412.       * @see #setExitOnFirstFatalError
  413.       */
  414.     bool getExitOnFirstFatalError() const;
  415.     /**
  416.       * This method returns the state of the parser's
  417.       * validation-constraint-fatal flag.
  418.       *
  419.       * @return true, if the parser is currently configured to
  420.       *         set validation constraint errors as fatal, false
  421.       *         otherwise.
  422.       *
  423.       * @see #setValidationContraintFatal
  424.       */
  425.     bool getValidationConstraintFatal() const;
  426.    /** Get the set of Namespace/SchemaLocation that is specified externaly.
  427.       *
  428.       * This method returns the list of Namespace/SchemaLocation that was
  429.       * specified using setExternalSchemaLocation.
  430.       *
  431.       * The parser owns the returned string, and the memory allocated for
  432.       * the returned string will be destroyed when the parser is deleted.
  433.       *
  434.       * To ensure assessiblity of the returned information after the parser
  435.       * is deleted, callers need to copy and store the returned information
  436.       * somewhere else.
  437.       *
  438.       * @return a pointer to the list of Namespace/SchemaLocation that was
  439.       *         specified externally.  The pointer spans the same life-time as
  440.       *         the parser.  A null pointer is returned if nothing
  441.       *         was specified externally.
  442.       *
  443.       * @see #setExternalSchemaLocation(const XMLCh* const)
  444.       */
  445.     XMLCh* getExternalSchemaLocation() const;
  446.    /** Get the noNamespace SchemaLocation that is specified externaly.
  447.       *
  448.       * This method returns the no target namespace XML Schema Location
  449.       * that was specified using setExternalNoNamespaceSchemaLocation.
  450.       *
  451.       * The parser owns the returned string, and the memory allocated for
  452.       * the returned string will be destroyed when the parser is deleted.
  453.       *
  454.       * To ensure assessiblity of the returned information after the parser
  455.       * is deleted, callers need to copy and store the returned information
  456.       * somewhere else.
  457.       *
  458.       * @return a pointer to the no target namespace Schema Location that was
  459.       *         specified externally.  The pointer spans the same life-time as
  460.       *         the parser.  A null pointer is returned if nothing
  461.       *         was specified externally.
  462.       *
  463.       * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
  464.       */
  465.     XMLCh* getExternalNoNamespaceSchemaLocation() const;
  466.    /** Get the SecurityManager instance attached to this parser.
  467.       *
  468.       * This method returns the security manager 
  469.       * that was specified using setSecurityManager.
  470.       *
  471.       * The SecurityManager instance must have been specified by the application; 
  472.       * this should not be deleted until after the parser has been deleted (or
  473.       * a new SecurityManager instance has been supplied to the parser).
  474.       * 
  475.       * @return a pointer to the SecurityManager instance 
  476.       *         specified externally.  A null pointer is returned if nothing
  477.       *         was specified externally.
  478.       *
  479.       * @see #setSecurityManager(const SecurityManager* const)
  480.       */
  481.     SecurityManager* getSecurityManager() const;
  482.     /** Get the 'Loading External DTD' flag
  483.       *
  484.       * This method returns the state of the parser's loading external DTD
  485.       * flag.
  486.       *
  487.       * @return false, if the parser is currently configured to
  488.       *         ignore external DTD completely, true otherwise.
  489.       *
  490.       * @see #setLoadExternalDTD
  491.       * @see #getValidationScheme
  492.       */
  493.     bool getLoadExternalDTD() const;
  494.     /** Get the 'Grammar caching' flag
  495.       *
  496.       * This method returns the state of the parser's grammar caching when
  497.       * parsing an XML document.
  498.       *
  499.       * @return true, if the parser is currently configured to
  500.       *         cache grammars, false otherwise.
  501.       *
  502.       * @see #cacheGrammarFromParse
  503.       */
  504.     bool isCachingGrammarFromParse() const;
  505.     /** Get the 'Use cached grammar' flag
  506.       *
  507.       * This method returns the state of the parser's use of cached grammar
  508.       * when parsing an XML document.
  509.       *
  510.       * @return true, if the parser is currently configured to
  511.       *         use cached grammars, false otherwise.
  512.       *
  513.       * @see #useCachedGrammarInParse
  514.       */
  515.     bool isUsingCachedGrammarInParse() const;
  516.     /**
  517.       * Get the 'calculate src offset flag'
  518.       *
  519.       * This method returns the state of the parser's src offset calculation
  520.       * when parsing an XML document.
  521.       *
  522.       * @return true, if the parser is currently configured to
  523.       *         calculate src offsets, false otherwise.
  524.       *
  525.       * @see #setCalculateSrcOfs
  526.       */
  527.     bool getCalculateSrcOfs() const;
  528.     /**
  529.       * Get the 'force standard uri flag'
  530.       *
  531.       * This method returns the state if the parser forces standard uri
  532.       *
  533.       * @return true, if the parser is currently configured to
  534.       *         force standard uri, i.e. malformed uri will be rejected.
  535.       *
  536.       * @see #setStandardUriConformant
  537.       */
  538.     bool getStandardUriConformant() const;
  539.     /**
  540.      * Retrieve the grammar that is associated with the specified namespace key
  541.      *
  542.      * @param  nameSpaceKey Namespace key
  543.      * @return Grammar associated with the Namespace key.
  544.      */
  545.     Grammar* getGrammar(const XMLCh* const nameSpaceKey);
  546.     /**
  547.      * Retrieve the grammar where the root element is declared.
  548.      *
  549.      * @return Grammar where root element declared
  550.      */
  551.     Grammar* getRootGrammar();
  552.     /**
  553.      * Returns the string corresponding to a URI id from the URI string pool.
  554.      *
  555.      * @param uriId id of the string in the URI string pool.
  556.      * @return URI string corresponding to the URI id.
  557.      */
  558.     const XMLCh* getURIText(unsigned int uriId) const;
  559.     /**
  560.      * Returns the current src offset within the input source.
  561.      *
  562.      * @return offset within the input source
  563.      */
  564.     unsigned int getSrcOffset() const;
  565.     //@}
  566.     // -----------------------------------------------------------------------
  567.     //  Setter methods
  568.     // -----------------------------------------------------------------------
  569.     /** @name Setter methods */
  570.     //@{
  571.     /**
  572.       * This method allows users to enable or disable the parser's
  573.       * namespace processing. When set to true, parser starts enforcing
  574.       * all the constraints / rules specified by the NameSpace
  575.       * specification.
  576.       *
  577.       * <p>The parser's default state is: false.</p>
  578.       *
  579.       * @param newState The value specifying whether NameSpace rules should
  580.       *                 be enforced or not.
  581.       *
  582.       * @see #getDoNamespaces
  583.       */
  584.     void setDoNamespaces(const bool newState);
  585.     /**
  586.       * This method allows users to set the validation scheme to be used
  587.       * by this parser. The value is one of the ValSchemes enumerated values
  588.       * defined by this class:
  589.       *
  590.       * <br>  Val_Never  - turn off validation
  591.       * <br>  Val_Always - turn on validation
  592.       * <br>  Val_Auto   - turn on validation if any internal/external
  593.       *                  DTD subset have been seen
  594.       *
  595.       * <p>The parser's default state is: Val_Auto.</p>
  596.       *
  597.       * @param newScheme The new validation scheme to use.
  598.       *
  599.       * @see #getValidationScheme
  600.       */
  601.     void setValidationScheme(const ValSchemes newScheme);
  602.     /** Set the 'schema support' flag
  603.       *
  604.       * This method allows users to enable or disable the parser's
  605.       * schema processing. When set to false, parser will not process
  606.       * any schema found.
  607.       *
  608.       * The parser's default state is: false.
  609.       *
  610.       * Note: If set to true, namespace processing must also be turned on.
  611.       *
  612.       * @param newState The value specifying whether schema support should
  613.       *                 be enforced or not.
  614.       *
  615.       * @see #getDoSchema
  616.       */
  617.     void setDoSchema(const bool newState);
  618.     /**
  619.       * This method allows the user to turn full Schema constraint checking on/off.
  620.       * Only takes effect if Schema validation is enabled.
  621.       * If turned off, partial constraint checking is done.
  622.       *
  623.       * Full schema constraint checking includes those checking that may
  624.       * be time-consuming or memory intensive. Currently, particle unique
  625.       * attribution constraint checking and particle derivation resriction checking
  626.       * are controlled by this option.
  627.       *
  628.       * The parser's default state is: false.
  629.       *
  630.       * @param schemaFullChecking True to turn on full schema constraint checking.
  631.       *
  632.       * @see #getValidationSchemaFullChecking
  633.       */
  634.     void setValidationSchemaFullChecking(const bool schemaFullChecking);
  635.     /**
  636.       * This method allows users to set the parser's behaviour when it
  637.       * encounters the first fatal error. If set to true, the parser
  638.       * will exit at the first fatal error. If false, then it will
  639.       * report the error and continue processing.
  640.       *
  641.       * <p>The default value is 'true' and the parser exits on the
  642.       * first fatal error.</p>
  643.       *
  644.       * @param newState The value specifying whether the parser should
  645.       *                 continue or exit when it encounters the first
  646.       *                 fatal error.
  647.       *
  648.       * @see #getExitOnFirstFatalError
  649.       */
  650.     void setExitOnFirstFatalError(const bool newState);
  651.     /**
  652.       * This method allows users to set the parser's behaviour when it
  653.       * encounters a validtion constraint error. If set to true, and the
  654.       * the parser will treat validation error as fatal and will exit depends on the
  655.       * state of "getExitOnFirstFatalError". If false, then it will
  656.       * report the error and continue processing.
  657.       *
  658.       * Note: setting this true does not mean the validation error will be printed with
  659.       * the word "Fatal Error".   It is still printed as "Error", but the parser
  660.       * will exit if "setExitOnFirstFatalError" is set to true.
  661.       *
  662.       * <p>The default value is 'false'.</p>
  663.       *
  664.       * @param newState If true, the parser will exit if "setExitOnFirstFatalError"
  665.       *                 is set to true.
  666.       *
  667.       * @see #getValidationConstraintFatal
  668.       * @see #setExitOnFirstFatalError
  669.       */
  670.     void setValidationConstraintFatal(const bool newState);
  671.     /**
  672.       * This method allows the user to specify a list of schemas to use.
  673.       * If the targetNamespace of a schema specified using this method matches
  674.       * the targetNamespace of a schema occuring in the instance document in
  675.       * the schemaLocation attribute, or if the targetNamespace matches the
  676.       * namespace attribute of the "import" element, the schema specified by the
  677.       * user using this method will be used (i.e., the schemaLocation attribute
  678.       * in the instance document or on the "import" element will be effectively ignored).
  679.       *
  680.       * If this method is called more than once, only the last one takes effect.
  681.       *
  682.       * The syntax is the same as for schemaLocation attributes in instance
  683.       * documents: e.g, "http://www.example.com file_name.xsd". The user can
  684.       * specify more than one XML Schema in the list.
  685.       *
  686.       * @param schemaLocation the list of schemas to use
  687.       *
  688.       * @see #getExternalSchemaLocation
  689.       */
  690.     void setExternalSchemaLocation(const XMLCh* const schemaLocation);
  691.     /**
  692.       * This method is same as setExternalSchemaLocation(const XMLCh* const).
  693.       * It takes native char string as parameter
  694.       *
  695.       * @param schemaLocation the list of schemas to use
  696.       *
  697.       * @see #setExternalSchemaLocation(const XMLCh* const)
  698.       */
  699.     void setExternalSchemaLocation(const char* const schemaLocation);
  700.     /**
  701.       * This method allows the user to specify the no target namespace XML
  702.       * Schema Location externally.  If specified, the instance document's
  703.       * noNamespaceSchemaLocation attribute will be effectively ignored.
  704.       *
  705.       * If this method is called more than once, only the last one takes effect.
  706.       *
  707.       * The syntax is the same as for the noNamespaceSchemaLocation attribute
  708.       * that may occur in an instance document: e.g."file_name.xsd".
  709.       *
  710.       * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
  711.       *
  712.       * @see #getExternalNoNamespaceSchemaLocation
  713.       */
  714.     void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
  715.     /**
  716.       * This method is same as setExternalNoNamespaceSchemaLocation(const XMLCh* const).
  717.       * It takes native char string as parameter
  718.       *
  719.       * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
  720.       *
  721.       * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
  722.       */
  723.     void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
  724.     /**
  725.       * This allows an application to set a SecurityManager on
  726.       * the parser; this object stores information that various
  727.       * components use to limit their consumption of system
  728.       * resources while processing documents.
  729.       *
  730.       * If this method is called more than once, only the last one takes effect.
  731.       * It may not be reset during a parse.
  732.       *
  733.       *
  734.       * @param securityManager  the SecurityManager instance to
  735.       * be used by this parser
  736.       *
  737.       * @see #getSecurityManager
  738.       */
  739.     void setSecurityManager(SecurityManager* const securityManager);
  740.     /** Set the 'Loading External DTD' flag
  741.       *
  742.       * This method allows users to enable or disable the loading of external DTD.
  743.       * When set to false, the parser will ignore any external DTD completely
  744.       * if the validationScheme is set to Val_Never.
  745.       *
  746.       * The parser's default state is: true.
  747.       *
  748.       * This flag is ignored if the validationScheme is set to Val_Always or Val_Auto.
  749.       *
  750.       * @param newState The value specifying whether external DTD should
  751.       *                 be loaded or not.
  752.       *
  753.       * @see #getLoadExternalDTD
  754.       * @see #setValidationScheme
  755.       */
  756.     void setLoadExternalDTD(const bool newState);
  757.     /** Set the 'Grammar caching' flag
  758.       *
  759.       * This method allows users to enable or disable caching of grammar when
  760.       * parsing XML documents. When set to true, the parser will cache the
  761.       * resulting grammar for use in subsequent parses.
  762.       *
  763.       * If the flag is set to true, the 'Use cached grammar' flag will also be
  764.       * set to true.
  765.       *
  766.       * The parser's default state is: false.
  767.       *
  768.       * @param newState The value specifying whether we should cache grammars
  769.       *                 or not.
  770.       *
  771.       * @see #isCachingGrammarFromParse
  772.       * @see #useCachedGrammarInParse
  773.       */
  774.     void cacheGrammarFromParse(const bool newState);
  775.     /** Set the 'Use cached grammar' flag
  776.       *
  777.       * This method allows users to enable or disable the use of cached
  778.       * grammars.  When set to true, the parser will use the cached grammar,
  779.       * instead of building the grammar from scratch, to validate XML
  780.       * documents.
  781.       *
  782.       * If the 'Grammar caching' flag is set to true, this mehod ignore the
  783.       * value passed in.
  784.       *
  785.       * The parser's default state is: false.
  786.       *
  787.       * @param newState The value specifying whether we should use the cached
  788.       *                 grammar or not.
  789.       *
  790.       * @see #isUsingCachedGrammarInParse
  791.       * @see #cacheGrammarFromParse
  792.       */
  793.     void useCachedGrammarInParse(const bool newState);
  794.     /** Enable/disable src offset calculation
  795.       *
  796.       * This method allows users to enable/disable src offset calculation.
  797.       * Disabling the calculation will improve performance.
  798.       *
  799.       * The parser's default state is: false.
  800.       *
  801.       * @param newState The value specifying whether we should enable or
  802.       *                 disable src offset calculation
  803.       *
  804.       * @see #getCalculateSrcOfs
  805.       */
  806.     void setCalculateSrcOfs(const bool newState);
  807.     /** Force standard uri
  808.       *
  809.       * This method allows users to tell the parser to force standard uri conformance.
  810.       *
  811.       * The parser's default state is: false.
  812.       *
  813.       * @param newState The value specifying whether the parser should reject malformed URI.
  814.       *
  815.       * @see #getStandardUriConformant
  816.       */
  817.     void setStandardUriConformant(const bool newState);
  818.     /** Set the scanner to use when scanning the XML document
  819.       *
  820.       * This method allows users to set the scanner to use
  821.       * when scanning a given XML document.
  822.       *
  823.       * @param scannerName The name of the desired scanner
  824.       */
  825.     void useScanner(const XMLCh* const scannerName);
  826.     //@}
  827.     // -----------------------------------------------------------------------
  828.     //  Advanced document handler list maintenance methods
  829.     // -----------------------------------------------------------------------
  830.     /** @name Advanced document handler list maintenance methods */
  831.     //@{
  832.     /**
  833.       * This method installs the specified 'advanced' document callback
  834.       * handler, thereby allowing the user to customize the processing,
  835.       * if they choose to do so. Any number of advanced callback handlers
  836.       * maybe installed.
  837.       *
  838.       * <p>The methods in the advanced callback interface represent
  839.       * Xerces-C extensions. There is no specification for this interface.</p>
  840.       *
  841.       * @param toInstall A pointer to the users advanced callback handler.
  842.       *
  843.       * @see #removeAdvDocHandler
  844.       */
  845.     void installAdvDocHandler(XMLDocumentHandler* const toInstall);
  846.     /**
  847.       * This method removes the 'advanced' document handler callback from
  848.       * the underlying parser scanner. If no handler is installed, advanced
  849.       * callbacks are not invoked by the scanner.
  850.       * @param toRemove A pointer to the advanced callback handler which
  851.       *                 should be removed.
  852.       *
  853.       * @see #installAdvDocHandler
  854.       */
  855.     bool removeAdvDocHandler(XMLDocumentHandler* const toRemove);
  856.     //@}
  857.     // -----------------------------------------------------------------------
  858.     //  Progressive scan methods
  859.     // -----------------------------------------------------------------------
  860.     /** @name Progressive scan methods */
  861.     //@{
  862.     /** Begin a progressive parse operation
  863.       *
  864.       * This method is used to start a progressive parse on a XML file.
  865.       * To continue parsing, subsequent calls must be to the parseNext
  866.       * method.
  867.       *
  868.       * It scans through the prolog and returns a token to be used on
  869.       * subsequent scanNext() calls. If the return value is true, then the
  870.       * token is legal and ready for further use. If it returns false, then
  871.       * the scan of the prolog failed and the token is not going to work on
  872.       * subsequent scanNext() calls.
  873.       *
  874.       * @param systemId A pointer to a Unicode string represting the path
  875.       *                 to the XML file to be parsed.
  876.       * @param toFill   A token maintaing state information to maintain
  877.       *                 internal consistency between invocation of 'parseNext'
  878.       *                 calls.
  879.       *
  880.       * @return 'true', if successful in parsing the prolog. It indicates the
  881.       *         user can go ahead with parsing the rest of the file. It
  882.       *         returns 'false' to indicate that the parser could parse the
  883.       *         prolog (which means the token will not be valid.)
  884.       *
  885.       * @see #parseNext
  886.       * @see #parseFirst(char*,...)
  887.       * @see #parseFirst(InputSource&,...)
  888.       */
  889.     bool parseFirst
  890.     (
  891.         const   XMLCh* const    systemId
  892.         ,       XMLPScanToken&  toFill
  893.     );
  894.     /** Begin a progressive parse operation
  895.       *
  896.       * This method is used to start a progressive parse on a XML file.
  897.       * To continue parsing, subsequent calls must be to the parseNext
  898.       * method.
  899.       *
  900.       * It scans through the prolog and returns a token to be used on
  901.       * subsequent scanNext() calls. If the return value is true, then the
  902.       * token is legal and ready for further use. If it returns false, then
  903.       * the scan of the prolog failed and the token is not going to work on
  904.       * subsequent scanNext() calls.
  905.       *
  906.       * @param systemId A pointer to a regular native string represting
  907.       *                 the path to the XML file to be parsed.
  908.       * @param toFill   A token maintaing state information to maintain
  909.       *                 internal consIstency between invocation of 'parseNext'
  910.       *                 calls.
  911.       *
  912.       * @return 'true', if successful in parsing the prolog. It indicates the
  913.       *         user can go ahead with parsing the rest of the file. It
  914.       *         returns 'false' to indicate that the parser could not parse
  915.       *         the prolog.
  916.       *
  917.       * @see #parseNext
  918.       * @see #parseFirst(XMLCh*,...)
  919.       * @see #parseFirst(InputSource&,...)
  920.       */
  921.     bool parseFirst
  922.     (
  923.         const   char* const     systemId
  924.         ,       XMLPScanToken&  toFill
  925.     );
  926.     /** Begin a progressive parse operation
  927.       *
  928.       * This method is used to start a progressive parse on a XML file.
  929.       * To continue parsing, subsequent calls must be to the parseNext
  930.       * method.
  931.       *
  932.       * It scans through the prolog and returns a token to be used on
  933.       * subsequent scanNext() calls. If the return value is true, then the
  934.       * token is legal and ready for further use. If it returns false, then
  935.       * the scan of the prolog failed and the token is not going to work on
  936.       * subsequent scanNext() calls.
  937.       *
  938.       * @param source   A const reference to the InputSource object which
  939.       *                 points to the XML file to be parsed.
  940.       * @param toFill   A token maintaing state information to maintain
  941.       *                 internal consistency between invocation of 'parseNext'
  942.       *                 calls.
  943.       *
  944.       * @return 'true', if successful in parsing the prolog. It indicates the
  945.       *         user can go ahead with parsing the rest of the file. It
  946.       *         returns 'false' to indicate that the parser could not parse
  947.       *         the prolog.
  948.       *
  949.       * @see #parseNext
  950.       * @see #parseFirst(XMLCh*,...)
  951.       * @see #parseFirst(char*,...)
  952.       */
  953.     bool parseFirst
  954.     (
  955.         const   InputSource&    source
  956.         ,       XMLPScanToken&  toFill
  957.     );
  958.     /** Continue a progressive parse operation
  959.       *
  960.       * This method is used to continue with progressive parsing of
  961.       * XML files started by a call to 'parseFirst' method.
  962.       *
  963.       * It parses the XML file and stops as soon as it comes across
  964.       * a XML token (as defined in the XML specification). Relevant
  965.       * callback handlers are invoked as required by the SAX
  966.       * specification.
  967.       *
  968.       * @param token A token maintaing state information to maintain
  969.       *              internal consistency between invocation of 'parseNext'
  970.       *              calls.
  971.       *
  972.       * @return 'true', if successful in parsing the next XML token.
  973.       *         It indicates the user can go ahead with parsing the rest
  974.       *         of the file. It returns 'false' to indicate that the parser
  975.       *         could not find next token as per the XML specification
  976.       *         production rule.
  977.       *
  978.       * @see #parseFirst(XMLCh*,...)
  979.       * @see #parseFirst(char*,...)
  980.       * @see #parseFirst(InputSource&,...)
  981.       */
  982.     bool parseNext(XMLPScanToken& token);
  983.     /** Reset the parser after a progressive parse
  984.       *
  985.       * If a progressive parse loop exits before the end of the document
  986.       * is reached, the parser has no way of knowing this. So it will leave
  987.       * open any files or sockets or memory buffers that were in use at
  988.       * the time that the parse loop exited.
  989.       *
  990.       * The next parse operation will cause these open files and such to
  991.       * be closed, but the next parse operation might occur at some unknown
  992.       * future point. To avoid this problem, you should reset the parser if
  993.       * you exit the loop early.
  994.       *
  995.       * If you exited because of an error, then this cleanup will be done
  996.       * for you. Its only when you exit the file prematurely of your own
  997.       * accord, because you've found what you wanted in the file most
  998.       * likely.
  999.       *
  1000.       * @param token A token maintaing state information to maintain
  1001.       *              internal consistency between invocation of 'parseNext'
  1002.       *              calls.
  1003.       */
  1004.     void parseReset(XMLPScanToken& token);
  1005.     //@}
  1006.     // -----------------------------------------------------------------------
  1007.     //  Grammar preparsing interface
  1008.     // -----------------------------------------------------------------------
  1009.     /** @name Implementation of Grammar preparsing interface's. */
  1010.     //@{
  1011.     /**
  1012.       * Preparse schema grammar (XML Schema, DTD, etc.) via an input source
  1013.       * object.
  1014.       *
  1015.       * This method invokes the preparsing process on a schema grammar XML
  1016.       * file specified by the SAX InputSource parameter. If the 'toCache' flag
  1017.       * is enabled, the parser will cache the grammars for re-use. If a grammar
  1018.       * key is found in the pool, no caching of any grammar will take place.
  1019.       *
  1020.       * <p><b>"Experimental - subject to change"</b></p>
  1021.       *
  1022.       * @param source A const reference to the SAX InputSource object which
  1023.       *               points to the schema grammar file to be preparsed.
  1024.       * @param grammarType The grammar type (Schema or DTD).
  1025.       * @param toCache If <code>true</code>, we cache the preparsed grammar,
  1026.       *                otherwise, no chaching. Default is <code>false</code>.
  1027.       * @return The preparsed schema grammar object (SchemaGrammar or
  1028.       *         DTDGrammar). That grammar object is owned by the parser.
  1029.       *
  1030.       * @exception SAXException Any SAX exception, possibly
  1031.       *            wrapping another exception.
  1032.       * @exception XMLException An exception from the parser or client
  1033.       *            handler code.
  1034.       * @exception DOMException A DOM exception as per DOM spec.
  1035.       *
  1036.       * @see InputSource#InputSource
  1037.       */
  1038.     Grammar* loadGrammar(const InputSource& source,
  1039.                          const short grammarType,
  1040.                          const bool toCache = false);
  1041.     /**
  1042.       * Preparse schema grammar (XML Schema, DTD, etc.) via a file path or URL
  1043.       *
  1044.       * This method invokes the preparsing process on a schema grammar XML
  1045.       * file specified by the file path parameter. If the 'toCache' flag
  1046.       * is enabled, the parser will cache the grammars for re-use. If a grammar
  1047.       * key is found in the pool, no caching of any grammar will take place.
  1048.       *
  1049.       * <p><b>"Experimental - subject to change"</b></p>
  1050.       *
  1051.       * @param systemId A const XMLCh pointer to the Unicode string which
  1052.       *                 contains the path to the XML grammar file to be
  1053.       *                 preparsed.
  1054.       * @param grammarType The grammar type (Schema or DTD).
  1055.       * @param toCache If <code>true</code>, we cache the preparsed grammar,
  1056.       *                otherwise, no chaching. Default is <code>false</code>.
  1057.       * @return The preparsed schema grammar object (SchemaGrammar or
  1058.       *         DTDGrammar). That grammar object is owned by the parser.
  1059.       *
  1060.       * @exception SAXException Any SAX exception, possibly
  1061.       *            wrapping another exception.
  1062.       * @exception XMLException An exception from the parser or client
  1063.       *            handler code.
  1064.       * @exception DOMException A DOM exception as per DOM spec.
  1065.       */
  1066.     Grammar* loadGrammar(const XMLCh* const systemId,
  1067.                          const short grammarType,
  1068.                          const bool toCache = false);
  1069.     /**
  1070.       * Preparse schema grammar (XML Schema, DTD, etc.) via a file path or URL
  1071.       *
  1072.       * This method invokes the preparsing process on a schema grammar XML
  1073.       * file specified by the file path parameter. If the 'toCache' flag
  1074.       * is enabled, the parser will cache the grammars for re-use. If a grammar
  1075.       * key is found in the pool, no caching of any grammar will take place.
  1076.       *
  1077.       * <p><b>"Experimental - subject to change"</b></p>
  1078.       *
  1079.       * @param systemId A const char pointer to a native string which contains
  1080.       *                 the path to the XML grammar file to be preparsed.
  1081.       * @param grammarType The grammar type (Schema or DTD).
  1082.       * @param toCache If <code>true</code>, we cache the preparsed grammar,
  1083.       *                otherwise, no chaching. Default is <code>false</code>.
  1084.       * @return The preparsed schema grammar object (SchemaGrammar or
  1085.       *         DTDGrammar). That grammar object is owned by the parser.
  1086.       *
  1087.       * @exception SAXException Any SAX exception, possibly
  1088.       *            wrapping another exception.
  1089.       * @exception XMLException An exception from the parser or client
  1090.       *            handler code.
  1091.       * @exception DOMException A DOM exception as per DOM spec.
  1092.       */
  1093.     Grammar* loadGrammar(const char* const systemId,
  1094.                          const short grammarType,
  1095.                          const bool toCache = false);
  1096.     /**
  1097.       * This method allows the user to reset the pool of cached grammars.
  1098.       */
  1099.     void resetCachedGrammarPool();
  1100.     //@}
  1101.     // -----------------------------------------------------------------------
  1102.     //  Implementation of the SAX Parser interface
  1103.     // -----------------------------------------------------------------------
  1104.     /** @name Implementation of SAX 1.0 Parser interface's. */
  1105.     //@{
  1106.     /**
  1107.       * This method invokes the parsing process on the XML file specified
  1108.       * by the InputSource parameter.
  1109.       *
  1110.       * @param source A const reference to the InputSource object which
  1111.       *               points to the XML file to be parsed.
  1112.       *
  1113.       * @see Parser#parse(InputSource)
  1114.       */
  1115.     virtual void parse(const InputSource& source);
  1116.     /**
  1117.       * This method invokes the parsing process on the XML file specified by
  1118.       * the Unicode string parameter 'systemId'.
  1119.       *
  1120.       * @param systemId A const XMLCh pointer to the Unicode string which
  1121.       *                 contains the path to the XML file to be parsed.
  1122.       *
  1123.       * @see Parser#parse(XMLCh*)
  1124.       */
  1125.     virtual void parse(const XMLCh* const systemId);
  1126.     /**
  1127.       * This method invokes the parsing process on the XML file specified by
  1128.       * the native char* string parameter 'systemId'.
  1129.       *
  1130.       * @param systemId A const char pointer to a native string which
  1131.       *                 contains the path to the XML file to be parsed.
  1132.       */
  1133.     virtual void parse(const char* const systemId);
  1134.     /**
  1135.       * This method installs the user specified SAX Document Handler
  1136.       * callback function on parser.
  1137.       *
  1138.       * @param handler A pointer to the document handler to be called
  1139.       *                when the parser comes across 'document' events
  1140.       *                as per the SAX specification.
  1141.       *
  1142.       * @see Parser#parse(char*)
  1143.       */
  1144.     virtual void setDocumentHandler(DocumentHandler* const handler);
  1145.     /**
  1146.       * This method installs the user specified DTD handler on the parser.
  1147.       *
  1148.       * @param handler A pointer to the DTD handler to be called
  1149.       *                when the parser comes across 'DTD' events
  1150.       *                as per the SAX specification.
  1151.       *
  1152.       * @see Parser#setDTDHandler
  1153.       */
  1154.     virtual void setDTDHandler(DTDHandler* const handler);
  1155.     /**
  1156.       * This method installs the user specified error handler on
  1157.       * the parser.
  1158.       *
  1159.       * @param handler A pointer to the error handler to be called
  1160.       *                when the parser comes across 'error' events
  1161.       *                as per the SAX specification.
  1162.       *
  1163.       * @see Parser#setErrorHandler
  1164.       */
  1165.     virtual void setErrorHandler(ErrorHandler* const handler);
  1166.     /**
  1167.       * This method installs the user specified entity resolver on the
  1168.       * parser. It allows applications to trap and redirect calls to
  1169.       * external entities.
  1170.       *
  1171.       * @param resolver A pointer to the entity resolver to be called
  1172.       *                 when the parser comes across references to
  1173.       *                 entities in the XML file.
  1174.       *
  1175.       * @see Parser#setEntityResolver
  1176.       */
  1177.     virtual void setEntityResolver(EntityResolver* const resolver);
  1178.     //@}
  1179.     // -----------------------------------------------------------------------
  1180.     //  Implementation of the XMLDocumentHandler interface
  1181.     // -----------------------------------------------------------------------
  1182.     /** @name Implementation of the XMLDocumentHandler Interface. */
  1183.     //@{
  1184.     /**
  1185.       * This method is used to report all the characters scanned
  1186.       * by the parser. The driver will invoke the 'characters'
  1187.       * method of the user installed SAX Document Handler.
  1188.       *
  1189.       * <p>If any advanced callback handlers are installed, the
  1190.       * corresponding 'docCharacters' method will also be invoked.</p>
  1191.       *
  1192.       * @param chars   A const pointer to a Unicode string representing the
  1193.       *                character data.
  1194.       * @param length  The length of the Unicode string returned in 'chars'.
  1195.       * @param cdataSection  A flag indicating if the characters represent
  1196.       *                      content from the CDATA section.
  1197.       * @see DocumentHandler#characters
  1198.       */
  1199.     virtual void docCharacters
  1200.     (
  1201.         const   XMLCh* const    chars
  1202.         , const unsigned int    length
  1203.         , const bool            cdataSection
  1204.     );
  1205.     /**
  1206.       * This method is used to report any comments scanned by the parser.
  1207.       * This method is a no-op unless, unless an advanced callback handler
  1208.       * is installed, in which case the corresponding 'docComment' method
  1209.       * is invoked.
  1210.       *
  1211.       * @param comment A const pointer to a null terminated Unicode
  1212.       *                string representing the comment text.
  1213.       */
  1214.     virtual void docComment
  1215.     (
  1216.         const   XMLCh* const    comment
  1217.     );
  1218.     /**
  1219.       * This method is used to report any PI scanned by the parser.
  1220.       *
  1221.       * <p>Any PI's occurring before any 'content' are not reported
  1222.       * to any SAX handler as per the specification. However, all
  1223.       * PI's within content are reported via the SAX Document Handler's
  1224.       * 'processingInstruction' method.
  1225.       *
  1226.       * <p>If any advanced callback handlers are installed, the
  1227.       * corresponding 'docPI' method will be invoked.</p>
  1228.       *
  1229.       * @param target A const pointer to a Unicode string representing the
  1230.       *               target of the PI declaration.
  1231.       * @param data   A const pointer to a Unicode string representing the
  1232.       *               data of the PI declaration. See the PI production rule
  1233.       *               in the XML specification for details.
  1234.       *
  1235.       * @see DocumentHandler#processingInstruction
  1236.       */
  1237.     virtual void docPI
  1238.     (
  1239.         const   XMLCh* const    target
  1240.         , const XMLCh* const    data
  1241.     );
  1242.     /**
  1243.       * This method is used to indicate the end of root element
  1244.       * was just scanned by the parser. Corresponding 'endDocument'
  1245.       * method of the user installed SAX Document Handler will also
  1246.       * be invoked.
  1247.       *
  1248.       * <p>In addition, if any advanced callback handlers are installed,
  1249.       * the corresponding 'endDocument' method is invoked.</p>
  1250.       *
  1251.       * @see DocumentHandler#endDocument
  1252.       */
  1253.     virtual void endDocument();
  1254.     /**
  1255.       * This method is used to indicate the end tag of an element.
  1256.       * The driver will invoke the corresponding 'endElement' method of
  1257.       * the SAX Document Handler interface.
  1258.       *
  1259.       * <p>If any advanced callback handlers are installed, the
  1260.       * corresponding 'endElement' method is also invoked.</p>
  1261.       *
  1262.       * @param elemDecl A const reference to the object containing element
  1263.       *                 declaration information.
  1264.       * @param urlId    An id referring to the namespace prefix, if
  1265.       *                 namespaces setting is switched on.
  1266.       * @param isRoot   A flag indicating whether this element was the
  1267.       *                 root element.
  1268.       * @param elemPrefix A const pointer to a Unicode string containing
  1269.       *                   the namespace prefix for this element. Applicable
  1270.       *                   only when namespace processing is enabled.
  1271.       * @see DocumentHandler#endElement
  1272.       */
  1273.     virtual void endElement
  1274.     (
  1275.         const   XMLElementDecl& elemDecl
  1276.         , const unsigned int    urlId
  1277.         , const bool            isRoot
  1278.         , const XMLCh* const    elemPrefix
  1279.     );
  1280.     /**
  1281.       * This method is used to indicate that an end of an entity reference
  1282.       * was just scanned.
  1283.       *
  1284.       * <p>If any advanced callback handlers are installed, the
  1285.       * corresponding 'endEnityReference' method is invoked.</p>
  1286.       *
  1287.       * @param entDecl A const reference to the object containing the
  1288.       *                entity declaration information.
  1289.       */
  1290.     virtual void endEntityReference
  1291.     (
  1292.         const   XMLEntityDecl&  entDecl
  1293.     );
  1294.     /**
  1295.       * This method is used to report all the whitespace characters,
  1296.       * which are determined to be 'ignorable'. This distinction
  1297.       * between characters is only made, if validation is enabled.
  1298.       * Corresponding 'ignorableWhitespace' method of the user installed
  1299.       * SAX Document Handler interface is called.
  1300.       *
  1301.       * <p>Any whitespace before content is not reported to the SAX
  1302.       * Document Handler method, as per the SAX specification.
  1303.       * However, if any advanced callback handlers are installed, the
  1304.       * corresponding 'ignorableWhitespace' method is invoked.</p>
  1305.       *
  1306.       * @param chars   A const pointer to a Unicode string representing the
  1307.       *                ignorable whitespace character data.
  1308.       * @param length  The length of the Unicode string 'chars'.
  1309.       * @param cdataSection  A flag indicating if the characters represent
  1310.       *                      content from the CDATA section.
  1311.       * @see DocumentHandler#ignorableWhitespace
  1312.       */
  1313.     virtual void ignorableWhitespace
  1314.     (
  1315.         const   XMLCh* const    chars
  1316.         , const unsigned int    length
  1317.         , const bool            cdataSection
  1318.     );
  1319.     /**
  1320.       * This method allows the user installed Document Handler and
  1321.       * any advanced callback handlers to 'reset' themselves.
  1322.       */
  1323.     virtual void resetDocument();
  1324.     /**
  1325.       * This method is used to report the start of the parsing process.
  1326.       * The corresponding user installed SAX Document Handler's method
  1327.       * 'startDocument' is invoked.
  1328.       *
  1329.       * <p>If any advanced callback handlers are installed, then the
  1330.       * corresponding 'startDocument' method is also called.</p>
  1331.       *
  1332.       * @see DocumentHandler#startDocument
  1333.       */
  1334.     virtual void startDocument();
  1335.     /**
  1336.       * This method is used to report the start of an element. It is
  1337.       * called at the end of the element, by which time all attributes
  1338.       * specified are also parsed. The corresponding user installed
  1339.       * SAX Document Handler's method 'startElement' is invoked.
  1340.       *
  1341.       * <p>If any advanced callback handlers are installed, then the
  1342.       * corresponding 'startElement' method is also called.</p>
  1343.       *
  1344.       * @param elemDecl A const reference to the object containing element
  1345.       *                 declaration information.
  1346.       * @param urlId    An id referring to the namespace prefix, if
  1347.       *                 namespaces setting is switched on.
  1348.       * @param elemPrefix A const pointer to a Unicode string containing
  1349.       *                   the namespace prefix for this element. Applicable
  1350.       *                   only when namespace processing is enabled.
  1351.       * @param attrList  A const reference to the object containing the
  1352.       *                  list of attributes just scanned for this element.
  1353.       * @param attrCount A count of number of attributes in the list
  1354.       *                  specified by the parameter 'attrList'.
  1355.       * @param isEmpty  A flag indicating whether this is an empty element
  1356.       *                 or not.
  1357.       * @param isRoot   A flag indicating whether this element was the
  1358.       *                 root element.
  1359.       * @see DocumentHandler#startElement
  1360.       */
  1361.     virtual void startElement
  1362.     (
  1363.         const   XMLElementDecl&         elemDecl
  1364.         , const unsigned int            urlId
  1365.         , const XMLCh* const            elemPrefix
  1366.         , const RefVectorOf<XMLAttr>&   attrList
  1367.         , const unsigned int            attrCount
  1368.         , const bool                    isEmpty
  1369.         , const bool                    isRoot
  1370.     );
  1371.     /**
  1372.       * This method is used to indicate the start of an entity reference.
  1373.       *
  1374.       * <p>If any advanced callback handlers are installed, the
  1375.       * corresponding 'endEnityReference' method is invoked.</p>
  1376.       *
  1377.       * @param entDecl A const reference to the object containing the
  1378.       *                entity declaration information.
  1379.       */
  1380.     virtual void startEntityReference
  1381.     (
  1382.         const   XMLEntityDecl&  entDecl
  1383.     );
  1384.     /**
  1385.       * This method is used to report the XML decl scanned by the parser.
  1386.       * Refer to the XML specification to see the meaning of parameters.
  1387.       *
  1388.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1389.       * implementation.</font></b>
  1390.       *
  1391.       * @param versionStr A const pointer to a Unicode string representing
  1392.       *                   version string value.
  1393.       * @param encodingStr A const pointer to a Unicode string representing
  1394.       *                    the encoding string value.
  1395.       * @param standaloneStr A const pointer to a Unicode string
  1396.       *                      representing the standalone string value.
  1397.       * @param actualEncodingStr A const pointer to a Unicode string
  1398.       *                          representing the actual encoding string
  1399.       *                          value.
  1400.       */
  1401.     virtual void XMLDecl
  1402.     (
  1403.         const   XMLCh* const    versionStr
  1404.         , const XMLCh* const    encodingStr
  1405.         , const XMLCh* const    standaloneStr
  1406.         , const XMLCh* const    actualEncodingStr
  1407.     );
  1408.     //@}
  1409.     // -----------------------------------------------------------------------
  1410.     //  Implementation of the XMLErrorReporter interface
  1411.     // -----------------------------------------------------------------------
  1412.     /** @name Implementation of the XMLErrorReporter Interface. */
  1413.     //@{
  1414.     /**
  1415.       * This method is used to report back errors found while parsing the
  1416.       * XML file. The driver will call the corresponding user installed
  1417.       * SAX Error Handler methods: 'fatal', 'error', 'warning' depending
  1418.       * on the severity of the error. This classification is defined by
  1419.       * the XML specification.
  1420.       *
  1421.       * @param errCode An integer code for the error.
  1422.       * @param msgDomain A const pointer to an Unicode string representing
  1423.       *                  the message domain to use.
  1424.       * @param errType An enumeration classifying the severity of the error.
  1425.       * @param errorText A const pointer to an Unicode string representing
  1426.       *                  the text of the error message.
  1427.       * @param systemId  A const pointer to an Unicode string representing
  1428.       *                  the system id of the XML file where this error
  1429.       *                  was discovered.
  1430.       * @param publicId  A const pointer to an Unicode string representing
  1431.       *                  the public id of the XML file where this error
  1432.       *                  was discovered.
  1433.       * @param lineNum   The line number where the error occurred.
  1434.       * @param colNum    The column number where the error occurred.
  1435.       * @see ErrorHandler
  1436.       */
  1437.     virtual void error
  1438.     (
  1439.         const   unsigned int                errCode
  1440.         , const XMLCh* const                msgDomain
  1441.         , const XMLErrorReporter::ErrTypes  errType
  1442.         , const XMLCh* const                errorText
  1443.         , const XMLCh* const                systemId
  1444.         , const XMLCh* const                publicId
  1445.         , const XMLSSize_t                  lineNum
  1446.         , const XMLSSize_t                  colNum
  1447.     );
  1448.     /**
  1449.       * This method allows the user installed Error Handler
  1450.       * callback to 'reset' itself.
  1451.       *
  1452.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1453.       * implementation.</font></b>
  1454.       *
  1455.       */
  1456.     virtual void resetErrors();
  1457.     //@}
  1458.     // -----------------------------------------------------------------------
  1459.     //  Implementation of the XMLEntityHandler interface
  1460.     // -----------------------------------------------------------------------
  1461.     /** @name Implementation of the XMLEntityHandler Interface. */
  1462.     //@{
  1463.     /**
  1464.       * This method is used to indicate the end of parsing of an external
  1465.       * entity file.
  1466.       *
  1467.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1468.       * implementation.</font></b>
  1469.       *
  1470.       * @param inputSource A const reference to the InputSource object
  1471.       *                    which points to the XML file being parsed.
  1472.       * @see InputSource
  1473.       */
  1474.     virtual void endInputSource(const InputSource& inputSource);
  1475.     /**
  1476.       * This method allows an installed XMLEntityHandler to further
  1477.       * process any system id's of enternal entities encountered in
  1478.       * the XML file being parsed, such as redirection etc.
  1479.       *
  1480.       * <b><font color="#FF0000">This method always returns 'false'
  1481.       * for this SAX driver implementation.</font></b>
  1482.       *
  1483.       * @param systemId  A const pointer to an Unicode string representing
  1484.       *                  the system id scanned by the parser.
  1485.       * @param toFill    A pointer to a buffer in which the application
  1486.       *                  processed system id is stored.
  1487.       * @return 'true', if any processing is done, 'false' otherwise.
  1488.       */
  1489.     virtual bool expandSystemId
  1490.     (
  1491.         const   XMLCh* const    systemId
  1492.         ,       XMLBuffer&      toFill
  1493.     );
  1494.     /**
  1495.       * This method allows the installed XMLEntityHandler to reset
  1496.       * itself.
  1497.       *
  1498.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1499.       * implementation.</font></b>
  1500.       */
  1501.     virtual void resetEntities();
  1502.     /**
  1503.       * This method allows a user installed entity handler to further
  1504.       * process any pointers to external entities. The applications
  1505.       * can implement 'redirection' via this callback. The driver
  1506.       * should call the SAX EntityHandler 'resolveEntity' method.
  1507.       *
  1508.       * @param publicId A const pointer to a Unicode string representing the
  1509.       *                 public id of the entity just parsed.
  1510.       * @param systemId A const pointer to a Unicode string representing the
  1511.       *                 system id of the entity just parsed.
  1512.       * @param baseURI  A const pointer to a Unicode string representing the
  1513.       *                 base URI of the entity just parsed,
  1514.       *                 or <code>null</code> if there is no base URI.
  1515.       * @return The value returned by the SAX resolveEntity method or
  1516.       *         NULL otherwise to indicate no processing was done.
  1517.       *         The returned InputSource is owned by the parser which is
  1518.       *         responsible to clean up the memory.
  1519.       * @see EntityResolver
  1520.       * @see XMLEntityHandler
  1521.       */
  1522.     virtual InputSource* resolveEntity
  1523.     (
  1524.         const   XMLCh* const    publicId
  1525.         , const XMLCh* const    systemId
  1526.         , const XMLCh* const    baseURI = 0
  1527.     );
  1528.     /**
  1529.       * This method is used to indicate the start of parsing an
  1530.       * external entity file.
  1531.       *
  1532.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1533.       * implementation.</font></b>
  1534.       *
  1535.       * @param inputSource A const reference to the InputSource object
  1536.       *                    which points to the external entity
  1537.       *                    being parsed.
  1538.       */
  1539.     virtual void startInputSource(const InputSource& inputSource);
  1540.     //@}
  1541.     // -----------------------------------------------------------------------
  1542.     //  Implementation of the Deprecated DocTypeHandler Interface
  1543.     // -----------------------------------------------------------------------
  1544.     /** @name Implementation of the deprecated DocTypeHandler Interface */
  1545.     //@{
  1546.     /**
  1547.       * This method is used to report an attribute definition.
  1548.       *
  1549.       * <b><font color="#FF0000">This method is a no-op for this SAX
  1550.       * driver implementation.</font></b>
  1551.       *
  1552.       * @param elemDecl A const reference to the object containing information
  1553.       *                 about the element whose attribute definition was just
  1554.       *                 parsed.
  1555.       * @param attDef   A const reference to the object containing information
  1556.       *                 attribute definition.
  1557.       * @param ignore   The flag indicating whether this attribute definition
  1558.       *                 was ignored by the parser or not.
  1559.       */
  1560.     virtual void attDef
  1561.     (
  1562.         const   DTDElementDecl& elemDecl
  1563.         , const DTDAttDef&      attDef
  1564.         , const bool            ignore
  1565.     );
  1566.     /**
  1567.       * This method is used to report a comment occurring within the DTD.
  1568.       *
  1569.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1570.       * implementation.</font></b>
  1571.       *
  1572.       * @param comment  A const pointer to a Unicode string representing the
  1573.       *                 text of the comment just parsed.
  1574.       */
  1575.     virtual void doctypeComment
  1576.     (
  1577.         const   XMLCh* const    comment
  1578.     );
  1579.     /**
  1580.       * This method is used to report the DOCTYPE declaration.
  1581.       *
  1582.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1583.       * implementation.</font></b>
  1584.       *
  1585.       * @param elemDecl A const reference to the object containing information
  1586.       *                 about the root element definition declaration of the
  1587.       *                 XML document being parsed.
  1588.       * @param publicId A const pointer to a Unicode string representing the
  1589.       *                 public id of the DTD file.
  1590.       * @param systemId A const pointer to a Unicode string representing the
  1591.       *                 system id of the DTD file.
  1592.       * @param hasIntSubset A flag indicating if this XML file contains any
  1593.       *                     internal subset.
  1594.       * @param hasExtSubset A flag indicating if this XML file contains any
  1595.       *                     external subset. Default is false.
  1596.       */
  1597.     virtual void doctypeDecl
  1598.     (
  1599.         const   DTDElementDecl& elemDecl
  1600.         , const XMLCh* const    publicId
  1601.         , const XMLCh* const    systemId
  1602.         , const bool            hasIntSubset
  1603.         , const bool            hasExtSubset = false
  1604.     );
  1605.     /**
  1606.       * This method is used to report any PI declarations
  1607.       * occurring inside the DTD definition block.
  1608.       *
  1609.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1610.       * implementation.</font></b>
  1611.       *
  1612.       * @param target A const pointer to a Unicode string representing the
  1613.       *               target of the PI declaration.
  1614.       * @param data   A const pointer to a Unicode string representing the
  1615.       *               data of the PI declaration. See the PI production rule
  1616.       *               in the XML specification for details.
  1617.       */
  1618.     virtual void doctypePI
  1619.     (
  1620.         const   XMLCh* const    target
  1621.         , const XMLCh* const    data
  1622.     );
  1623.     /**
  1624.       * This method is used to report any whitespaces
  1625.       * occurring inside the DTD definition block.
  1626.       *
  1627.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1628.       * implementation.</font></b>
  1629.       *
  1630.       * @param chars  A const pointer to a Unicode string representing the
  1631.       *               whitespace characters.
  1632.       * @param length The length of the whitespace Unicode string.
  1633.       */
  1634.     virtual void doctypeWhitespace
  1635.     (
  1636.         const   XMLCh* const    chars
  1637.         , const unsigned int    length
  1638.     );
  1639.     /**
  1640.       * This method is used to report an element declarations
  1641.       * successfully scanned by the parser.
  1642.       *
  1643.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1644.       * implementation.</font></b>
  1645.       *
  1646.       * @param decl   A const reference to the object containing element
  1647.       *               declaration information.
  1648.       * @param isIgnored The flag indicating whether this definition was
  1649.       *                  ignored by the parser or not.
  1650.       */
  1651.     virtual void elementDecl
  1652.     (
  1653.         const   DTDElementDecl& decl
  1654.         , const bool            isIgnored
  1655.     );
  1656.     /**
  1657.       * This method is used to report the end of an attribute
  1658.       * list declaration for an element.
  1659.       *
  1660.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1661.       * implementation.</font></b>
  1662.       *
  1663.       * @param elemDecl A const reference to the object containing element
  1664.       *                 declaration information.
  1665.       */
  1666.     virtual void endAttList
  1667.     (
  1668.         const   DTDElementDecl& elemDecl
  1669.     );
  1670.     /**
  1671.       * This method is used to report the end of the internal subset.
  1672.       *
  1673.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1674.       * implementation.</font></b>
  1675.       */
  1676.     virtual void endIntSubset();
  1677.     /**
  1678.       * This method is used to report the end of the external subset.
  1679.       *
  1680.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1681.       * implementation.</font></b>
  1682.       */
  1683.     virtual void endExtSubset();
  1684.     /**
  1685.       * This method is used to report any entity declarations.
  1686.       * For unparsed entities, this driver will invoke the
  1687.       * SAX DTDHandler::unparsedEntityDecl callback.
  1688.       *
  1689.       * @param entityDecl A const reference to the object containing
  1690.       *                   the entity declaration information.
  1691.       * @param isPEDecl  The flag indicating whether this was a
  1692.       *                  parameter entity declaration or not.
  1693.       * @param isIgnored The flag indicating whether this definition
  1694.       *                  was ignored by the parser or not.
  1695.       *
  1696.       * @see DTDHandler#unparsedEntityDecl
  1697.       */
  1698.     virtual void entityDecl
  1699.     (
  1700.         const   DTDEntityDecl&  entityDecl
  1701.         , const bool            isPEDecl
  1702.         , const bool            isIgnored
  1703.     );
  1704.     /**
  1705.       * This method allows the user installed DTD handler to
  1706.       * reset itself.
  1707.       */
  1708.     virtual void resetDocType();
  1709.     /**
  1710.       * This method is used to report any notation declarations.
  1711.       * If there is a user installed DTDHandler, then the driver will
  1712.       * invoke the SAX DTDHandler::notationDecl callback.
  1713.       *
  1714.       * @param notDecl A const reference to the object containing the notation
  1715.       *                declaration information.
  1716.       * @param isIgnored The flag indicating whether this definition was ignored
  1717.       *                  by the parser or not.
  1718.       *
  1719.       * @see DTDHandler#notationDecl
  1720.       */
  1721.     virtual void notationDecl
  1722.     (
  1723.         const   XMLNotationDecl&    notDecl
  1724.         , const bool                isIgnored
  1725.     );
  1726.     /**
  1727.       * This method is used to indicate the start of an element's attribute
  1728.       * list declaration.
  1729.       *
  1730.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1731.       * implementation.</font></b>
  1732.       *
  1733.       * @param elemDecl A const reference to the object containing element
  1734.       *                 declaration information.
  1735.       */
  1736.     virtual void startAttList
  1737.     (
  1738.         const   DTDElementDecl& elemDecl
  1739.     );
  1740.     /**
  1741.       * This method is used indicate the start of the internal subset.
  1742.       *
  1743.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1744.       * implementation.</font></b>
  1745.       */
  1746.     virtual void startIntSubset();
  1747.     /**
  1748.       * This method is used indicate the start of the external subset.
  1749.       *
  1750.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1751.       * implementation.</font></b>
  1752.       */
  1753.     virtual void startExtSubset();
  1754.     /**
  1755.       * This method is used to report the TextDecl. Refer to the XML
  1756.       * specification for the syntax of a TextDecl.
  1757.       *
  1758.       * <b><font color="#FF0000">This method is a no-op for this SAX driver
  1759.       * implementation.</font></b>
  1760.       *
  1761.       * @param versionStr A const pointer to a Unicode string representing
  1762.       *                   the version number of the 'version' clause.
  1763.       * @param encodingStr A const pointer to a Unicode string representing
  1764.       *                    the encoding name of the 'encoding' clause.
  1765.       */
  1766.     virtual void TextDecl
  1767.     (
  1768.         const   XMLCh* const    versionStr
  1769.         , const XMLCh* const    encodingStr
  1770.     );
  1771.     //@}
  1772.     // -----------------------------------------------------------------------
  1773.     //  Deprecated Methods
  1774.     // -----------------------------------------------------------------------
  1775.     /** @name Deprecated Methods */
  1776.     //@{
  1777.     /**
  1778.       * This method returns the state of the parser's validation
  1779.       * handling flag which controls whether validation checks
  1780.       * are enforced or not.
  1781.       *
  1782.       * @return true, if the parser is currently configured to
  1783.       *         do validation, false otherwise.
  1784.       *
  1785.       * @see #setDoValidation
  1786.       */
  1787.     bool getDoValidation() const;
  1788.     /**
  1789.       * This method allows users to enable or disable the parser's validation
  1790.       * checks.
  1791.       *
  1792.       * <p>By default, the parser does not to any validation. The default
  1793.       * value is false.</p>
  1794.       *
  1795.       * @param newState The value specifying whether the parser should
  1796.       *                 do validity checks or not against the DTD in the
  1797.       *                 input XML document.
  1798.       *
  1799.       * @see #getDoValidation
  1800.       */
  1801.     void setDoValidation(const bool newState);
  1802.     //@}
  1803. protected :
  1804.     // -----------------------------------------------------------------------
  1805.     //  Protected Methods
  1806.     // -----------------------------------------------------------------------
  1807.     /**
  1808.       * This method returns a reference to the underlying scanner object.
  1809.       * It allows read only access to data maintained in the scanner.
  1810.       *
  1811.       * @return A const reference to the underlying scanner object.
  1812.       */
  1813.     const XMLScanner& getScanner() const;
  1814. private:
  1815.     // -----------------------------------------------------------------------
  1816.     //  Unimplemented constructors and operators
  1817.     // -----------------------------------------------------------------------
  1818.     SAXParser(const SAXParser&);
  1819.     SAXParser& operator=(const SAXParser&);
  1820.     // -----------------------------------------------------------------------
  1821.     //  Initialize/Cleanup methods
  1822.     // -----------------------------------------------------------------------
  1823.     void initialize();
  1824.     void cleanUp();
  1825.     // -----------------------------------------------------------------------
  1826.     //  Private data members
  1827.     //
  1828.     //  fAttrList
  1829.     //      A temporary implementation of the basic SAX attribute list
  1830.     //      interface. We use this one over and over on each startElement
  1831.     //      event to allow SAX-like access to the element attributes.
  1832.     //
  1833.     //  fDocHandler
  1834.     //      The installed SAX doc handler, if any. Null if none.
  1835.     //
  1836.     //  fDTDHandler
  1837.     //      The installed SAX DTD handler, if any. Null if none.
  1838.     //
  1839.     //  fElemDepth
  1840.     //      This is used to track the element nesting depth, so that we can
  1841.     //      know when we are inside content. This is so we can ignore char
  1842.     //      data outside of content.
  1843.     //
  1844.     //  fEntityResolver
  1845.     //      The installed SAX entity handler, if any. Null if none.
  1846.     //
  1847.     //  fErrorHandler
  1848.     //      The installed SAX error handler, if any. Null if none.
  1849.     //
  1850.     //  fAdvDHCount
  1851.     //  fAdvDHList
  1852.     //  fAdvDHListSize
  1853.     //      This is an array of pointers to XMLDocumentHandlers, which is
  1854.     //      how we see installed advanced document handlers. There will
  1855.     //      usually not be very many at all, so a simple array is used
  1856.     //      instead of a collection, for performance. It will grow if needed,
  1857.     //      but that is unlikely.
  1858.     //
  1859.     //      The count is how many handlers are currently installed. The size
  1860.     //      is how big the array itself is (for expansion purposes.) When
  1861.     //      count == size, is time to expand.
  1862.     //
  1863.     //  fParseInProgress
  1864.     //      This flag is set once a parse starts. It is used to prevent
  1865.     //      multiple entrance or reentrance of the parser.
  1866.     //
  1867.     //  fScanner
  1868.     //      The scanner being used by this parser. It is created internally
  1869.     //      during construction.
  1870.     //
  1871.     // -----------------------------------------------------------------------
  1872.     bool                 fParseInProgress;
  1873.     unsigned int         fElemDepth;
  1874.     unsigned int         fAdvDHCount;
  1875.     unsigned int         fAdvDHListSize;
  1876.     VecAttrListImpl      fAttrList;
  1877.     DocumentHandler*     fDocHandler;
  1878.     DTDHandler*          fDTDHandler;
  1879.     EntityResolver*      fEntityResolver;
  1880.     ErrorHandler*        fErrorHandler;
  1881.     XMLDocumentHandler** fAdvDHList;
  1882.     XMLScanner*          fScanner;
  1883.     GrammarResolver*     fGrammarResolver;
  1884.     XMLStringPool*       fURIStringPool;
  1885.     XMLValidator*        fValidator;
  1886.     MemoryManager*       fMemoryManager;
  1887.     XMLBuffer            fElemQNameBuf;
  1888. };
  1889. // ---------------------------------------------------------------------------
  1890. //  SAXParser: Getter methods
  1891. // ---------------------------------------------------------------------------
  1892. inline DocumentHandler* SAXParser::getDocumentHandler()
  1893. {
  1894.     return fDocHandler;
  1895. }
  1896. inline const DocumentHandler* SAXParser::getDocumentHandler() const
  1897. {
  1898.     return fDocHandler;
  1899. }
  1900. inline EntityResolver* SAXParser::getEntityResolver()
  1901. {
  1902.     return fEntityResolver;
  1903. }
  1904. inline const EntityResolver* SAXParser::getEntityResolver() const
  1905. {
  1906.     return fEntityResolver;
  1907. }
  1908. inline ErrorHandler* SAXParser::getErrorHandler()
  1909. {
  1910.     return fErrorHandler;
  1911. }
  1912. inline const ErrorHandler* SAXParser::getErrorHandler() const
  1913. {
  1914.     return fErrorHandler;
  1915. }
  1916. inline const XMLScanner& SAXParser::getScanner() const
  1917. {
  1918.     return *fScanner;
  1919. }
  1920. XERCES_CPP_NAMESPACE_END
  1921. #endif