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

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

词法分析

开发平台：

Visual C++

XMLScanner.hpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Log: XMLScanner.hpp,v $
  59.  * Revision 1.22  2003/05/16 21:36:58  knoaman
  60.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  61.  *
  62.  * Revision 1.21  2003/05/15 18:26:29  knoaman
  63.  * Partial implementation of the configurable memory manager.
  64.  *
  65.  * Revision 1.20  2003/04/22 14:52:37  knoaman
  66.  * Initialize security manager in constructor.
  67.  *
  68.  * Revision 1.19  2003/04/17 22:00:46  neilg
  69.  * This commit implements detection of exponential entity
  70.  * expansions inside the scanner code.  This is only done when a
  71.  * security manager instance has been registered with the parser by
  72.  * the application.  The default number of entities which may be
  73.  * expanded is 50000; this appears to work very well for SAX, but DOM
  74.  * parsing applications may wish to set this limit considerably lower.
  75.  *
  76.  * Added SecurityManager to enable detection of exponentially-expanding entities
  77.  * 
  78.  * Revision 1.18  2003/03/10 15:27:29  tng
  79.  * XML1.0 Errata E38
  80.  *
  81.  * Revision 1.17  2003/03/07 18:08:58  tng
  82.  * Return a reference instead of void for operator=
  83.  *
  84.  * Revision 1.16  2003/01/03 20:08:40  tng
  85.  * New feature StandardUriConformant to force strict standard uri conformance.
  86.  *
  87.  * Revision 1.15  2002/12/27 16:16:51  knoaman
  88.  * Set scanner options and handlers.
  89.  *
  90.  * Revision 1.14  2002/12/20 22:09:56  tng
  91.  * XML 1.1
  92.  *
  93.  * Revision 1.13  2002/12/04 01:41:14  knoaman
  94.  * Scanner re-organization.
  95.  *
  96.  * Revision 1.12  2002/11/04 14:58:19  tng
  97.  * C++ Namespace Support.
  98.  *
  99.  * Revision 1.11  2002/08/27 05:56:39  knoaman
  100.  * Identity Constraint: handle case of recursive elements.
  101.  *
  102.  * Revision 1.10  2002/08/16 15:46:17  knoaman
  103.  * Bug 7698 : filenames with embedded spaces in schemaLocation strings not handled properly.
  104.  *
  105.  * Revision 1.9  2002/07/31 18:49:29  tng
  106.  * [Bug 6227] Make method getLastExtLocation() constant.
  107.  *
  108.  * Revision 1.8  2002/07/11 18:22:13  knoaman
  109.  * Grammar caching/preparsing - initial implementation.
  110.  *
  111.  * Revision 1.7  2002/06/17 16:13:01  tng
  112.  * DOM L3: Add the flag fNormalizeData so that datatype normalization defined by schema is done only if asked.
  113.  *
  114.  * Revision 1.6  2002/06/07 18:35:49  tng
  115.  * Add getReaderMgr in XMLScanner so that the parser can query encoding information.
  116.  *
  117.  * Revision 1.5  2002/05/30 16:20:57  tng
  118.  * Add feature to optionally ignore external DTD.
  119.  *
  120.  * Revision 1.4  2002/05/27 18:42:14  tng
  121.  * To get ready for 64 bit large file, use XMLSSize_t to represent line and column number.
  122.  *
  123.  * Revision 1.3  2002/05/22 20:54:33  knoaman
  124.  * Prepare for DOM L3 :
  125.  * - Make use of the XMLEntityHandler/XMLErrorReporter interfaces, instead of using
  126.  * EntityHandler/ErrorHandler directly.
  127.  * - Add 'AbstractDOMParser' class to provide common functionality for XercesDOMParser
  128.  * and DOMBuilder.
  129.  *
  130.  * Revision 1.2  2002/03/25 20:25:32  knoaman
  131.  * Move particle derivation checking from TraverseSchema to SchemaValidator.
  132.  *
  133.  * Revision 1.1.1.1  2002/02/01 22:22:03  peiyongz
  134.  * sane_include
  135.  *
  136.  * Revision 1.38  2001/11/30 22:19:15  peiyongz
  137.  * cleanUp function made member function
  138.  * cleanUp object moved to file scope
  139.  *
  140.  * Revision 1.37  2001/11/20 18:51:44  tng
  141.  * Schema: schemaLocation and noNamespaceSchemaLocation to be specified outside the instance document.  New methods setExternalSchemaLocation and setExternalNoNamespaceSchemaLocation are added (for SAX2, two new properties are added).
  142.  *
  143.  * Revision 1.36  2001/11/13 13:27:28  tng
  144.  * Move root element check to XMLScanner.
  145.  *
  146.  * Revision 1.35  2001/11/02 14:20:14  knoaman
  147.  * Add support for identity constraints.
  148.  *
  149.  * Revision 1.34  2001/10/12 20:52:18  tng
  150.  * Schema: Find the attributes see if they should be (un)qualified.
  151.  *
  152.  * Revision 1.33  2001/09/10 15:16:04  tng
  153.  * Store the fGrammarType instead of calling getGrammarType all the time for faster performance.
  154.  *
  155.  * Revision 1.32  2001/09/10 14:06:22  tng
  156.  * Schema: AnyAttribute support in Scanner and Validator.
  157.  *
  158.  * Revision 1.31  2001/08/13 15:06:39  knoaman
  159.  * update <any> validation.
  160.  *
  161.  * Revision 1.30  2001/08/02 16:54:39  tng
  162.  * Reset some Scanner flags in scanReset().
  163.  *
  164.  * Revision 1.29  2001/08/01 19:11:01  tng
  165.  * Add full schema constraint checking flag to the samples and the parser.
  166.  *
  167.  * Revision 1.28  2001/07/24 21:23:39  tng
  168.  * Schema: Use DatatypeValidator for ID/IDREF/ENTITY/ENTITIES/NOTATION.
  169.  *
  170.  * Revision 1.27  2001/07/13 16:56:48  tng
  171.  * ScanId fix.
  172.  *
  173.  * Revision 1.26  2001/07/12 18:50:17  tng
  174.  * Some performance modification regarding standalone check and xml decl check.
  175.  *
  176.  * Revision 1.25  2001/07/10 21:09:31  tng
  177.  * Give proper error messsage when scanning external id.
  178.  *
  179.  * Revision 1.24  2001/07/09 13:42:08  tng
  180.  * Partial Markup in Parameter Entity is validity constraint and thus should be just error, not fatal error.
  181.  *
  182.  * Revision 1.23  2001/07/05 13:12:11  tng
  183.  * Standalone checking is validity constraint and thus should be just error, not fatal error:
  184.  *
  185.  * Revision 1.22  2001/06/22 12:42:33  tng
  186.  * [Bug 2257] 1.5 thinks a <?xml-stylesheet ...> tag is a <?xml ...> tag
  187.  *
  188.  * Revision 1.21  2001/06/04 20:59:29  jberry
  189.  * Add method incrementErrorCount for use by validator. Make sure to reset error count in _both_ the scanReset methods.
  190.  *
  191.  * Revision 1.20  2001/06/03 19:21:40  jberry
  192.  * Add support for tracking error count during parse; enables simple parse without requiring error handler.
  193.  *
  194.  * Revision 1.19  2001/05/28 20:55:02  tng
  195.  * Schema: allocate a fDTDValidator, fSchemaValidator explicitly to avoid wrong cast
  196.  *
  197.  * Revision 1.18  2001/05/11 15:17:28  tng
  198.  * Schema: Nillable fixes.
  199.  *
  200.  * Revision 1.17  2001/05/11 13:26:17  tng
  201.  * Copyright update.
  202.  *
  203.  * Revision 1.16  2001/05/03 20:34:29  tng
  204.  * Schema: SchemaValidator update
  205.  *
  206.  * Revision 1.15  2001/05/03 19:09:09  knoaman
  207.  * Support Warning/Error/FatalError messaging.
  208.  * Validity constraints errors are treated as errors, with the ability by user to set
  209.  * validity constraints as fatal errors.
  210.  *
  211.  * Revision 1.14  2001/04/19 18:16:59  tng
  212.  * Schema: SchemaValidator update, and use QName in Content Model
  213.  *
  214.  * Revision 1.13  2001/03/30 16:46:56  tng
  215.  * Schema: Use setDoSchema instead of setSchemaValidation which makes more sense.
  216.  *
  217.  * Revision 1.12  2001/03/30 16:35:06  tng
  218.  * Schema: Whitespace normalization.
  219.  *
  220.  * Revision 1.11  2001/03/21 21:56:05  tng
  221.  * Schema: Add Schema Grammar, Schema Validator, and split the DTDValidator into DTDValidator, DTDScanner, and DTDGrammar.
  222.  *
  223.  * Revision 1.10  2001/02/15 15:56:27  tng
  224.  * Schema: Add setSchemaValidation and getSchemaValidation for DOMParser and SAXParser.
  225.  * Add feature "http://apache.org/xml/features/validation/schema" for SAX2XMLReader.
  226.  * New data field  fSchemaValidation in XMLScanner as the flag.
  227.  *
  228.  * Revision 1.9  2000/04/12 22:58:28  roddey
  229.  * Added support for 'auto validate' mode.
  230.  *
  231.  * Revision 1.8  2000/03/03 01:29:32  roddey
  232.  * Added a scanReset()/parseReset() method to the scanner and
  233.  * parsers, to allow for reset after early exit from a progressive parse.
  234.  * Added calls to new Terminate() call to all of the samples. Improved
  235.  * documentation in SAX and DOM parsers.
  236.  *
  237.  * Revision 1.7  2000/03/02 19:54:30  roddey
  238.  * This checkin includes many changes done while waiting for the
  239.  * 1.1.0 code to be finished. I can't list them all here, but a list is
  240.  * available elsewhere.
  241.  *
  242.  * Revision 1.6  2000/02/24 20:18:07  abagchi
  243.  * Swat for removing Log from API docs
  244.  *
  245.  * Revision 1.5  2000/02/06 07:47:54  rahulj
  246.  * Year 2K copyright swat.
  247.  *
  248.  * Revision 1.4  2000/01/24 20:40:43  roddey
  249.  * Exposed the APIs to get to the byte offset in the source XML buffer. This stuff
  250.  * is not tested yet, but I wanted to get the API changes in now so that the API
  251.  * can be stablized.
  252.  *
  253.  * Revision 1.3  2000/01/12 23:52:46  roddey
  254.  * These are trivial changes required to get the C++ and Java versions
  255.  * of error messages more into sync. Mostly it was where the Java version
  256.  * was passing out one or more parameter than the C++ version was. In
  257.  * some cases the change just required an extra parameter to get the
  258.  * needed info to the place where the error was issued.
  259.  *
  260.  * Revision 1.2  2000/01/12 00:15:04  roddey
  261.  * Changes to deal with multiply nested, relative pathed, entities and to deal
  262.  * with the new URL class changes.
  263.  *
  264.  * Revision 1.1.1.1  1999/11/09 01:08:23  twl
  265.  * Initial checkin
  266.  *
  267.  * Revision 1.4  1999/11/08 20:44:52  rahul
  268.  * Swat for adding in Product name and CVS comment log variable.
  269.  *
  270.  */
  273. #if !defined(XMLSCANNER_HPP)
  274. #define XMLSCANNER_HPP
  276. #include <xercesc/framework/XMLBufferMgr.hpp>
  277. #include <xercesc/framework/XMLErrorCodes.hpp>
  278. #include <xercesc/framework/XMLRefInfo.hpp>
  279. #include <xercesc/util/PlatformUtils.hpp>
  280. #include <xercesc/util/NameIdPool.hpp>
  281. #include <xercesc/util/RefHashTableOf.hpp>
  282. #include <xercesc/util/SecurityManager.hpp>
  283. #include <xercesc/internal/ReaderMgr.hpp>
  284. #include <xercesc/validators/DTD/DTDEntityDecl.hpp>
  285. #include <xercesc/framework/XMLAttr.hpp>
  288. XERCES_CPP_NAMESPACE_BEGIN
  290. class InputSource;
  291. class XMLDocumentHandler;
  292. class XMLEntityHandler;
  293. class ErrorHandler;
  294. class DocTypeHandler;
  295. class XMLPScanToken;
  296. class XMLStringPool;
  297. class Grammar;
  298. class GrammarResolver;
  299. class XMLValidator;
  300. class MemoryManager;
  303. //  This is the mondo scanner class, which does the vast majority of the
  304. //  work of parsing. It handles reading in input and spitting out events
  305. //  to installed handlers.
  306. class XMLPARSER_EXPORT XMLScanner : public XMemory
  307. {
  308. public :
  309.     // -----------------------------------------------------------------------
  310.     //  Public class types
  311.     //
  312.     //  NOTE: These should really be private, but some of the compilers we
  313.     //  have to deal with are too stupid to understand this.
  314.     //
  315.     //  DeclTypes
  316.     //      Used by scanXMLDecl() to know what type of decl it should scan.
  317.     //      Text decls have slightly different rules from XMLDecls.
  318.     //
  319.     //  EntityExpRes
  320.     //      These are the values returned from the entity expansion method,
  321.     //      to indicate how it went.
  322.     //
  323.     //  XMLTokens
  324.     //      These represent the possible types of input we can get while
  325.     //      scanning content.
  326.     //
  327.     //  ValScheme
  328.     //      This indicates what the scanner should do in terms of validation.
  329.     //      'Auto' means if there is any int/ext subset, then validate. Else,
  330.     //      don't.
  331.     // -----------------------------------------------------------------------
  332.     enum DeclTypes
  333.     {
  334.         Decl_Text
  335.         , Decl_XML
  336.     };
  338.     enum EntityExpRes
  339.     {
  340.         EntityExp_Pushed
  341.         , EntityExp_Returned
  342.         , EntityExp_Failed
  343.     };
  345.     enum XMLTokens
  346.     {
  347.         Token_CData
  348.         , Token_CharData
  349.         , Token_Comment
  350.         , Token_EndTag
  351.         , Token_EOF
  352.         , Token_PI
  353.         , Token_StartTag
  354.         , Token_Unknown
  355.     };
  357.     enum ValSchemes
  358.     {
  359.         Val_Never
  360.         , Val_Always
  361.         , Val_Auto
  362.     };
  365.     // -----------------------------------------------------------------------
  366.     //  Constructors and Destructor
  367.     // -----------------------------------------------------------------------
  368.     XMLScanner
  369.     (
  370.         XMLValidator* const valToAdopt
  371.         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  372.     );
  373.     XMLScanner
  374.     (
  375.         XMLDocumentHandler* const  docHandler
  376.         , DocTypeHandler* const    docTypeHandler
  377.         , XMLEntityHandler* const  entityHandler
  378.         , XMLErrorReporter* const  errReporter
  379.         , XMLValidator* const      valToAdopt
  380.         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
  381.     );
  382.     virtual ~XMLScanner();
  385.     // -----------------------------------------------------------------------
  386.     //  Error emitter methods
  387.     // -----------------------------------------------------------------------
  388.     void emitError(const XMLErrs::Codes toEmit);
  389.     void emitError
  390.     (
  391.         const   XMLErrs::Codes    toEmit
  392.         , const XMLCh* const        text1
  393.         , const XMLCh* const        text2 = 0
  394.         , const XMLCh* const        text3 = 0
  395.         , const XMLCh* const        text4 = 0
  396.     );
  397.     void emitError
  398.     (
  399.         const   XMLErrs::Codes    toEmit
  400.         , const char* const         text1
  401.         , const char* const         text2 = 0
  402.         , const char* const         text3 = 0
  403.         , const char* const         text4 = 0
  404.     );
  406.     // -----------------------------------------------------------------------
  407.     //  Public pure virtual methods
  408.     // -----------------------------------------------------------------------
  409.     virtual const XMLCh* getName() const = 0;
  410.     virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool() = 0;
  411.     virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const = 0;
  412.     virtual unsigned int resolveQName
  413.     (
  414.         const   XMLCh* const        qName
  415.         ,       XMLBuffer&          prefixBufToFill
  416.         , const short               mode
  417.         ,       int&                prefixColonPos
  418.     ) = 0;
  419.     virtual void scanDocument
  420.     (
  421.         const   InputSource&    src
  422.     ) = 0;
  423.     virtual bool scanNext(XMLPScanToken& toFill) = 0;
  424.     virtual Grammar* loadGrammar
  425.     (
  426.         const   InputSource&    src
  427.         , const short           grammarType
  428.         , const bool            toCache = false
  429.     ) = 0;
  432.     // -----------------------------------------------------------------------
  433.     //  Getter methods
  434.     // -----------------------------------------------------------------------
  435.     const XMLDocumentHandler* getDocHandler() const;
  436.     XMLDocumentHandler* getDocHandler();
  437.     const DocTypeHandler* getDocTypeHandler() const;
  438.     DocTypeHandler* getDocTypeHandler();
  439.     bool getDoNamespaces() const;
  440.     ValSchemes getValidationScheme() const;
  441.     bool getDoSchema() const;
  442.     bool getValidationSchemaFullChecking() const;
  443.     const XMLEntityHandler* getEntityHandler() const;
  444.     XMLEntityHandler* getEntityHandler();
  445.     const XMLErrorReporter* getErrorReporter() const;
  446.     XMLErrorReporter* getErrorReporter();
  447.     const ErrorHandler* getErrorHandler() const;
  448.     ErrorHandler* getErrorHandler();
  449.     bool getExitOnFirstFatal() const;
  450.     bool getValidationConstraintFatal() const;
  451.     RefHashTableOf<XMLRefInfo>* getIDRefList();
  452.     const RefHashTableOf<XMLRefInfo>* getIDRefList() const;
  453.     bool getInException() const;
  454.     /*bool getLastExtLocation
  455.     (
  456.                 XMLCh* const    sysIdToFill
  457.         , const unsigned int    maxSysIdChars
  458.         ,       XMLCh* const    pubIdToFill
  459.         , const unsigned int    maxPubIdChars
  460.         ,       XMLSSize_t&     lineToFill
  461.         ,       XMLSSize_t&     colToFill
  462.     ) const;*/
  463.     const Locator* getLocator() const;
  464.     const ReaderMgr* getReaderMgr() const;
  465.     unsigned int getSrcOffset() const;
  466.     bool getStandalone() const;
  467.     const XMLValidator* getValidator() const;
  468.     XMLValidator* getValidator();
  469.     int getErrorCount();
  470.     const XMLStringPool* getURIStringPool() const;
  471.     XMLStringPool* getURIStringPool();
  472.     bool getHasNoDTD() const;
  473.     XMLCh* getExternalSchemaLocation() const;
  474.     XMLCh* getExternalNoNamespaceSchemaLocation() const;
  475.     SecurityManager* getSecurityManager() const;
  476.     bool getLoadExternalDTD() const;
  477.     bool getNormalizeData() const;
  478.     bool isCachingGrammarFromParse() const;
  479.     bool isUsingCachedGrammarInParse() const;
  480.     bool getCalculateSrcOfs() const;
  481.     Grammar* getRootGrammar() const;
  482.     XMLReader::XMLVersion getXMLVersion() const;
  483.     MemoryManager* getMemoryManager() const;
  485.     // -----------------------------------------------------------------------
  486.     //  Getter methods
  487.     // -----------------------------------------------------------------------
  488.     /**
  489.       * When an attribute name has no prefix, unlike elements, it is not mapped
  490.       * to the global namespace. So, in order to have something to map it to
  491.       * for practical purposes, a id for an empty URL is created and used for
  492.       * such names.
  493.       *
  494.       * @return The URL pool id of the URL for an empty URL "".
  495.       */
  496.     unsigned int getEmptyNamespaceId() const;
  498.     /**
  499.       * When a prefix is found that has not been mapped, an error is issued.
  500.       * However, if the parser has been instructed not to stop on the first
  501.       * fatal error, it needs to be able to continue. To do so, it will map
  502.       * that prefix tot his magic unknown namespace id.
  503.       *
  504.       * @return The URL pool id of the URL for the unknown prefix
  505.       *         namespace.
  506.       */
  507.     unsigned int getUnknownNamespaceId() const;
  509.     /**
  510.       * The prefix 'xml' is a magic prefix, defined by the XML spec and
  511.       * requiring no prior definition. This method returns the id for the
  512.       * intrinsically defined URL for this prefix.
  513.       *
  514.       * @return The URL pool id of the URL for the 'xml' prefix.
  515.       */
  516.     unsigned int getXMLNamespaceId() const;
  518.     /**
  519.       * The prefix 'xmlns' is a magic prefix, defined by the namespace spec
  520.       * and requiring no prior definition. This method returns the id for the
  521.       * intrinsically defined URL for this prefix.
  522.       *
  523.       * @return The URL pool id of the URL for the 'xmlns' prefix.
  524.       */
  525.     unsigned int getXMLNSNamespaceId() const;
  527.     /**
  528.       * This method find the passed URI id in its URI pool and
  529.       * copy the text of that URI into the passed buffer.
  530.       */
  531.     bool getURIText
  532.     (
  533.         const   unsigned int    uriId
  534.         ,       XMLBuffer&      uriBufToFill
  535.     )   const;
  537.     const XMLCh* getURIText(const   unsigned int    uriId) const;
  539.     /* tell if the validator comes from user */
  540.     bool isValidatorFromUser();
  542.     /* tell if standard URI are forced */
  543.     bool getStandardUriConformant() const;
  545.     // -----------------------------------------------------------------------
  546.     //  Setter methods
  547.     // -----------------------------------------------------------------------
  548.     void setDocHandler(XMLDocumentHandler* const docHandler);
  549.     void setDocTypeHandler(DocTypeHandler* const docTypeHandler);
  550.     void setDoNamespaces(const bool doNamespaces);
  551.     void setEntityHandler(XMLEntityHandler* const docTypeHandler);
  552.     void setErrorReporter(XMLErrorReporter* const errHandler);
  553.     void setErrorHandler(ErrorHandler* const handler);
  554.     void setGrammarResolver(GrammarResolver* const grammarResolver);
  555.     void setURIStringPool(XMLStringPool* const stringPool);
  556.     void setExitOnFirstFatal(const bool newValue);
  557.     void setValidationConstraintFatal(const bool newValue);
  558.     void setValidationScheme(const ValSchemes newScheme);
  559.     void setValidator(XMLValidator* const valToAdopt);
  560.     void setDoSchema(const bool doSchema);
  561.     void setValidationSchemaFullChecking(const bool schemaFullChecking);
  562.     void setHasNoDTD(const bool hasNoDTD);
  563.     void cacheGrammarFromParse(const bool newValue);
  564.     void useCachedGrammarInParse(const bool newValue);
  565.     void setRootElemName(XMLCh* rootElemName);
  566.     void setExternalSchemaLocation(const XMLCh* const schemaLocation);
  567.     void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
  568.     void setExternalSchemaLocation(const char* const schemaLocation);
  569.     void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
  570.     void setSecurityManager(SecurityManager* const securityManager);
  571.     void setLoadExternalDTD(const bool loadDTD);
  572.     void setNormalizeData(const bool normalizeData);
  573.     void setCalculateSrcOfs(const bool newValue);
  574.     void setParseSettings(XMLScanner* const refScanner);
  575.     void setStandardUriConformant(const bool newValue);
  577.     // -----------------------------------------------------------------------
  578.     //  Mutator methods
  579.     // -----------------------------------------------------------------------
  580.     void incrementErrorCount(void); // For use by XMLValidator
  582.     // -----------------------------------------------------------------------
  583.     //  Deprecated methods as of 3.2.0. Use getValidationScheme() and
  584.     //  setValidationScheme() instead.
  585.     // -----------------------------------------------------------------------
  586.     bool getDoValidation() const;
  587.     void setDoValidation(const bool validate);
  589.     // -----------------------------------------------------------------------
  590.     //  Document scanning methods
  591.     //
  592.     //  scanDocument() does the entire source document. scanFirst(),
  593.     //  scanNext(), and scanReset() support a progressive parse.
  594.     // -----------------------------------------------------------------------
  595.     void scanDocument
  596.     (
  597.         const   XMLCh* const    systemId
  598.     );
  599.     void scanDocument
  600.     (
  601.         const   char* const     systemId
  602.     );
  604.     bool scanFirst
  605.     (
  606.         const   InputSource&    src
  607.         ,       XMLPScanToken&  toFill
  608.     );
  609.     bool scanFirst
  610.     (
  611.         const   XMLCh* const    systemId
  612.         ,       XMLPScanToken&  toFill
  613.     );
  614.     bool scanFirst
  615.     (
  616.         const   char* const     systemId
  617.         ,       XMLPScanToken&  toFill
  618.     );
  620.     void scanReset(XMLPScanToken& toFill);
  622.     bool checkXMLDecl(bool startWithAngle);
  624.     // -----------------------------------------------------------------------
  625.     //  Grammar preparsing methods
  626.     // -----------------------------------------------------------------------
  627.     Grammar* loadGrammar
  628.     (
  629.         const   XMLCh* const    systemId
  630.         , const short           grammarType
  631.         , const bool            toCache = false
  632.     );
  633.     Grammar* loadGrammar
  634.     (
  635.         const   char* const     systemId
  636.         , const short           grammarType
  637.         , const bool            toCache = false
  638.     );
  640.     // -----------------------------------------------------------------------
  641.     //  Notification that lazy data has been deleted
  642.     // -----------------------------------------------------------------------
  643. static void reinitScannerMutex();
  644. static void reinitMsgLoader();
  646. protected:
  647.     // -----------------------------------------------------------------------
  648.     //  Protected pure virtual methods
  649.     // -----------------------------------------------------------------------
  650.     virtual void scanCDSection() = 0;
  651.     virtual void scanCharData(XMLBuffer& toToUse) = 0;
  652.     virtual EntityExpRes scanEntityRef
  653.     (
  654.         const   bool    inAttVal
  655.         ,       XMLCh&  firstCh
  656.         ,       XMLCh&  secondCh
  657.         ,       bool&   escaped
  658.     ) = 0;
  659.     virtual void scanDocTypeDecl() = 0;
  660.     virtual void scanReset(const InputSource& src) = 0;
  661.     virtual void sendCharData(XMLBuffer& toSend) = 0;
  663.     // -----------------------------------------------------------------------
  664.     //  Protected scanning methods
  665.     // -----------------------------------------------------------------------
  666.     bool scanCharRef(XMLCh& toFill, XMLCh& second);
  667.     void scanComment();
  668.     bool scanEq();
  669.     void scanMiscellaneous();
  670.     void scanPI();
  671.     void scanProlog();
  672.     void scanXMLDecl(const DeclTypes type);
  674.     // -----------------------------------------------------------------------
  675.     //  Private helper methods
  676.     // -----------------------------------------------------------------------
  677.     void checkIDRefs();
  678.     bool isLegalToken(const XMLPScanToken& toCheck);
  679.     XMLTokens senseNextToken(unsigned int& orgReader);
  680.     void initValidator(XMLValidator* theValidator);
  682.     // -----------------------------------------------------------------------
  683.     //  Data members
  684.     //
  685.     //  fAttrList
  686.     //      Every time we get a new element start tag, we have to pass to
  687.     //      the document handler the attributes found. To make it more
  688.     //      efficient we keep this ref vector of XMLAttr objects around. We
  689.     //      just reuse it over and over, allowing it to grow to meet the
  690.     //      peek need.
  691.     //
  692.     //  fBufMgr
  693.     //      This is a manager for temporary buffers used during scanning.
  694.     //      For efficiency we must use a set of static buffers, but we have
  695.     //      to insure that they are not incorrectly reused. So this manager
  696.     //      provides the smarts to hand out buffers as required.
  697.     //
  698.     //  fDocHandler
  699.     //      The client code's document handler. If zero, then no document
  700.     //      handler callouts are done. We don't adopt it.
  701.     //
  702.     //  fDocTypeHandler
  703.     //      The client code's document type handler (used by DTD Validator).
  704.     //
  705.     //  fDoNamespaces
  706.     //      This flag indicates whether the client code wants us to do
  707.     //      namespaces or not. If the installed validator indicates that it
  708.     //      has to do namespaces, then this is ignored.
  709.     //
  710.     //  fEntityHandler
  711.     //      The client code's entity handler. If zero, then no entity handler
  712.     //      callouts are done. We don't adopt it.
  713.     //
  714.     //  fErrorReporter
  715.     //      The client code's error reporter. If zero, then no error reporter
  716.     //      callouts are done. We don't adopt it.
  717.     //
  718.     //  fErrorHandler
  719.     //      The client code's error handler.  Need to store this info for
  720.     //      Schema parse error handling.
  721.     //
  722.     //  fExitOnFirstFatal
  723.     //      This indicates whether we bail out on the first fatal XML error
  724.     //      or not. It defaults to true, which is the strict XML way, but it
  725.     //      can be changed.
  726.     //
  727.     //  fValidationConstraintFatal
  728.     //      This indicates whether we treat validation constraint errors as
  729.     //      fatal errors or not. It defaults to false, but it can be changed.
  730.     //
  731.     //  fIDRefList
  732.     //      This is a list of XMLRefInfo objects. This member lets us do all
  733.     //      needed ID-IDREF balancing checks.
  734.     //
  735.     //  fInException
  736.     //      To avoid a circular freakout when we catch an exception and emit
  737.     //      it, which would normally throw again if the 'fail on first error'
  738.     //      flag is one.
  739.     //
  740.     //  fReaderMgr
  741.     //      This is the reader manager, from which we get characters. It
  742.     //      manages the reader stack for us, and provides a lot of convenience
  743.     //      methods to do specialized checking for chars, sequences of chars,
  744.     //      skipping chars, etc...
  745.     //
  746.     //  fScannerId
  747.     //  fSequenceId
  748.     //      These are used for progressive parsing, to make sure that the
  749.     //      client code does the right thing at the right time.
  750.     //
  751.     //  fStandalone
  752.     //      Indicates whether the document is standalone or not. Defaults to
  753.     //      no, but can be overridden in the XMLDecl.
  754.     //
  755.     //  fHasNoDTD
  756.     //      Indicates the document has no DTD or has only an internal DTD subset
  757.     //      which contains no parameter entity references.
  758.     //
  759.     //  fValidate
  760.     //      Indicates whether any validation should be done. This is defined
  761.     //      by the existence of a Grammar together with fValScheme.
  762.     //
  763.     //  fValidator
  764.     //      The installed validator. We look at them via the abstract
  765.     //      validator interface, and don't know what it actual is.
  766.     //      Either point to user's installed validator, or fDTDValidator
  767.     //      or fSchemaValidator.
  768.     //
  769.     //  fValidatorFromUser
  770.     //      This flag indicates whether the validator was installed from
  771.     //      user.  If false, then the validator was created by the Scanner.
  772.     //
  773.     //  fValScheme
  774.     //      This is the currently set validation scheme. It defaults to
  775.     //      'never', but can be set by the client.
  776.     //
  777.     //  fErrorCount
  778.     // The number of errors we've encountered.
  779.     //
  780.     //  fDoSchema
  781.     //      This flag indicates whether the client code wants Schema to
  782.     //      be processed or not.
  783.     //
  784.     //  fSchemaFullChecking
  785.     //      This flag indicates whether the client code wants full Schema
  786.     //      constraint checking.
  787.     //
  788.     //  fAttName
  789.     //  fAttValue
  790.     //  fCDataBuf
  791.     //  fNameBuf
  792.     //  fQNameBuf
  793.     //  fPrefixBuf
  794.     //      For the most part, buffers are obtained from the fBufMgr object
  795.     //      on the fly. However, for the start tag scan, we have a set of
  796.     //      fixed buffers for performance reasons. These are used a lot and
  797.     //      there are a number of them, so asking the buffer manager each
  798.     //      time for new buffers is a bit too much overhead.
  799.     //
  800.     //  fEmptyNamespaceId
  801.     //      This is the id of the empty namespace URI. This is a special one
  802.     //      because of the xmlns="" type of deal. We have to quickly sense
  803.     //      that its the empty namespace.
  804.     //
  805.     //  fUnknownNamespaceId
  806.     //      This is the id of the namespace URI which is assigned to the
  807.     //      global namespace. Its for debug purposes only, since there is no
  808.     //      real global namespace URI. Its set by the derived class.
  809.     //
  810.     //  fXMLNamespaceId
  811.     //  fXMLNSNamespaceId
  812.     //      These are the ids of the namespace URIs which are assigned to the
  813.     //      'xml' and 'xmlns' special prefixes. The former is officially
  814.     //      defined but the latter is not, so we just provide one for debug
  815.     //      purposes.
  816.     //
  817.     //  fSchemaNamespaceId
  818.     //      This is the id of the schema namespace URI.
  819.     //
  820.     //  fGrammarResolver
  821.     //      Grammar Pool that stores all the grammars. Key is namespace for
  822.     //      schema and system id for external DTD. When caching a grammar, if
  823.     //      a grammar is already in the pool, it will be replaced with the
  824.     //      new parsed one.
  825.     //
  826.     //  fGrammar
  827.     //      Current Grammar used by the Scanner and Validator
  828.     //
  829.     //  fRootGrammar
  830.     //      The grammar where the root element is declared.
  831.     //
  832.     //  fGrammarType
  833.     //      Current Grammar Type.  Store this value instead of calling getGrammarType
  834.     //      all the time for faster performance.
  835.     //
  836.     //  fURIStringPool
  837.     //      This is a pool for URIs with unique ids assigned. We use a standard
  838.     //      string pool class.  This pool is going to be shared by all Grammar.
  839.     //      Use only if namespace is turned on.
  840.     //
  841.     //  fRootElemName
  842.     //      No matter we are using DTD or Schema Grammar, if a DOCTYPE exists,
  843.     //      we need to verify the root element name.  So store the rootElement
  844.     //      that is used in the DOCTYPE in the Scanner instead of in the DTDGrammar
  845.     //      where it used to
  846.     //
  847.     //  fExternalSchemaLocation
  848.     //      The list of Namespace/SchemaLocation that was specified externally
  849.     //      using setExternalSchemaLocation.
  850.     //
  851.     //  fExternalNoNamespaceSchemaLocation
  852.     //      The no target namespace XML Schema Location that was specified
  853.     //      externally using setExternalNoNamespaceSchemaLocation.
  854.     //
  855.     //  fSecurityManager
  856.     //      The SecurityManager instance; as and when set by the application.
  857.     //
  858.     //  fEntityExpansionLimit
  859.     //      The number of entity expansions to be permitted while processing this document
  860.     //      Only meaningful when fSecurityManager != 0
  861.     //
  862.     //  fEntityExpansionCount
  863.     //      The number of general entities expanded so far in this document.
  864.     //      Only meaningful when fSecurityManager != null
  865.     //
  866.     //  fLoadExternalDTD
  867.     //      This flag indicates whether the external DTD be loaded or not
  868.     //
  869.     //  fNormalizeData
  870.     //      This flag indicates whether the parser should perform datatype
  871.     //      normalization that is defined in the schema.
  872.     //
  873.     //  fCalculateSrcOfs
  874.     //      This flag indicates the parser should calculate the source offset.
  875.     //      Turning this on may impact performance.
  876.     //
  877.     //  fStandardUriConformant
  878.     //      This flag controls whether we force conformant URI
  879.     //
  880.     //  fXMLVersion
  881.     //      Enum to indicate if the main doc is XML 1.1 or XML 1.0 conformant    
  882.     //
  883.     //  fMemoryManager
  884.     //      Pluggable memory manager for dynamic allocation/deallocation.
  885.     // -----------------------------------------------------------------------
  886.     bool                        fStandardUriConformant;
  887.     bool                        fCalculateSrcOfs;
  888.     bool                        fDoNamespaces;
  889.     bool                        fExitOnFirstFatal;
  890.     bool                        fValidationConstraintFatal;
  891.     bool                        fInException;
  892.     bool                        fStandalone;
  893.     bool                        fHasNoDTD;
  894.     bool                        fValidate;
  895.     bool                        fValidatorFromUser;
  896.     bool                        fDoSchema;
  897.     bool                        fSchemaFullChecking;
  898.     bool                        fToCacheGrammar;
  899.     bool                        fUseCachedGrammar;
  900.     bool                        fLoadExternalDTD;
  901.     bool                        fNormalizeData;
  902.     int                         fErrorCount;
  903.     unsigned int                fEntityExpansionLimit;
  904.     unsigned int                fEntityExpansionCount;
  905.     unsigned int                fEmptyNamespaceId;
  906.     unsigned int                fUnknownNamespaceId;
  907.     unsigned int                fXMLNamespaceId;
  908.     unsigned int                fXMLNSNamespaceId;
  909.     unsigned int                fSchemaNamespaceId;
  910.     XMLUInt32                   fScannerId;
  911.     XMLUInt32                   fSequenceId;
  912.     RefVectorOf<XMLAttr>*       fAttrList;
  913.     XMLDocumentHandler*         fDocHandler;
  914.     DocTypeHandler*             fDocTypeHandler;
  915.     XMLEntityHandler*           fEntityHandler;
  916.     XMLErrorReporter*           fErrorReporter;
  917.     ErrorHandler*               fErrorHandler;
  918.     RefHashTableOf<XMLRefInfo>* fIDRefList;
  919.     ReaderMgr                   fReaderMgr;
  920.     XMLValidator*               fValidator;
  921.     ValSchemes                  fValScheme;
  922.     GrammarResolver*            fGrammarResolver;
  923.     Grammar*                    fGrammar;
  924.     Grammar*                    fRootGrammar;
  925.     XMLStringPool*              fURIStringPool;
  926.     XMLCh*                      fRootElemName;
  927.     XMLCh*                      fExternalSchemaLocation;
  928.     XMLCh*                      fExternalNoNamespaceSchemaLocation;
  929.     SecurityManager*            fSecurityManager;
  930.     XMLReader::XMLVersion       fXMLVersion;
  931.     MemoryManager*              fMemoryManager;
  932.     XMLBufferMgr                fBufMgr;
  933.     XMLBuffer                   fAttNameBuf;
  934.     XMLBuffer                   fAttValueBuf;
  935.     XMLBuffer                   fCDataBuf;
  936.     XMLBuffer                   fQNameBuf;
  937.     XMLBuffer                   fPrefixBuf;
  938.     XMLBuffer                   fURIBuf;
  940. private :
  941.     // -----------------------------------------------------------------------
  942.     //  Unimplemented constructors and operators
  943.     // -----------------------------------------------------------------------
  944.     XMLScanner();
  945.     XMLScanner(const XMLScanner&);
  946.     XMLScanner& operator=(const XMLScanner&);
  948.     // -----------------------------------------------------------------------
  949.     //  Private helper methods
  950.     // -----------------------------------------------------------------------
  951.     void commonInit();
  953.     // -----------------------------------------------------------------------
  954.     //  Private scanning methods
  955.     // -----------------------------------------------------------------------
  956.     bool getQuotedString(XMLBuffer& toFill);
  957.     unsigned int scanUpToWSOr
  958.     (
  959.                 XMLBuffer&  toFill
  960.         , const XMLCh       chEndChar
  961.     );
  962. };
  964. // ---------------------------------------------------------------------------
  965. //  XMLScanner: Getter methods
  966. // ---------------------------------------------------------------------------
  967. inline const XMLDocumentHandler* XMLScanner::getDocHandler() const
  968. {
  969.     return fDocHandler;
  970. }
  972. inline XMLDocumentHandler* XMLScanner::getDocHandler()
  973. {
  974.     return fDocHandler;
  975. }
  977. inline const DocTypeHandler* XMLScanner::getDocTypeHandler() const
  978. {
  979.     return fDocTypeHandler;
  980. }
  982. inline DocTypeHandler* XMLScanner::getDocTypeHandler()
  983. {
  984.     return fDocTypeHandler;
  985. }
  987. inline bool XMLScanner::getDoNamespaces() const
  988. {
  989.     return fDoNamespaces;
  990. }
  992. inline const XMLEntityHandler* XMLScanner::getEntityHandler() const
  993. {
  994.     return fEntityHandler;
  995. }
  997. inline XMLEntityHandler* XMLScanner::getEntityHandler()
  998. {
  999.     return fEntityHandler;
  1000. }
  1002. inline const XMLErrorReporter* XMLScanner::getErrorReporter() const
  1003. {
  1004.     return fErrorReporter;
  1005. }
  1007. inline XMLErrorReporter* XMLScanner::getErrorReporter()
  1008. {
  1009.     return fErrorReporter;
  1010. }
  1012. inline const ErrorHandler* XMLScanner::getErrorHandler() const
  1013. {
  1014.     return fErrorHandler;
  1015. }
  1017. inline ErrorHandler* XMLScanner::getErrorHandler()
  1018. {
  1019.     return fErrorHandler;
  1020. }
  1022. inline bool XMLScanner::getExitOnFirstFatal() const
  1023. {
  1024.     return fExitOnFirstFatal;
  1025. }
  1027. inline bool XMLScanner::getValidationConstraintFatal() const
  1028. {
  1029.     return fValidationConstraintFatal;
  1030. }
  1032. inline bool XMLScanner::getInException() const
  1033. {
  1034.     return fInException;
  1035. }
  1037. inline RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList()
  1038. {
  1039.     return fIDRefList;
  1040. }
  1042. inline const RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList() const
  1043. {
  1044.     return fIDRefList;
  1045. }
  1047. inline const Locator* XMLScanner::getLocator() const
  1048. {
  1049.     return &fReaderMgr;
  1050. }
  1052. inline const ReaderMgr* XMLScanner::getReaderMgr() const
  1053. {
  1054.     return &fReaderMgr;
  1055. }
  1057. inline unsigned int XMLScanner::getSrcOffset() const
  1058. {
  1059.     return fReaderMgr.getSrcOffset();
  1060. }
  1062. inline bool XMLScanner::getStandalone() const
  1063. {
  1064.     return fStandalone;
  1065. }
  1067. inline XMLScanner::ValSchemes XMLScanner::getValidationScheme() const
  1068. {
  1069.     return fValScheme;
  1070. }
  1072. inline const XMLValidator* XMLScanner::getValidator() const
  1073. {
  1074.     return fValidator;
  1075. }
  1077. inline XMLValidator* XMLScanner::getValidator()
  1078. {
  1079.     return fValidator;
  1080. }
  1082. inline bool XMLScanner::getDoSchema() const
  1083. {
  1084.     return fDoSchema;
  1085. }
  1087. inline bool XMLScanner::getValidationSchemaFullChecking() const
  1088. {
  1089.     return fSchemaFullChecking;
  1090. }
  1092. inline int XMLScanner::getErrorCount()
  1093. {
  1094.     return fErrorCount;
  1095. }
  1097. inline bool XMLScanner::isValidatorFromUser()
  1098. {
  1099.     return fValidatorFromUser;
  1100. }
  1102. inline unsigned int XMLScanner::getEmptyNamespaceId() const
  1103. {
  1104.     return fEmptyNamespaceId;
  1105. }
  1107. inline unsigned int XMLScanner::getUnknownNamespaceId() const
  1108. {
  1109.     return fUnknownNamespaceId;
  1110. }
  1112. inline unsigned int XMLScanner::getXMLNamespaceId() const
  1113. {
  1114.     return fXMLNamespaceId;
  1115. }
  1117. inline unsigned int XMLScanner::getXMLNSNamespaceId() const
  1118. {
  1119.     return fXMLNSNamespaceId;
  1120. }
  1122. inline const XMLStringPool* XMLScanner::getURIStringPool() const
  1123. {
  1124.     return fURIStringPool;
  1125. }
  1127. inline XMLStringPool* XMLScanner::getURIStringPool()
  1128. {
  1129.     return fURIStringPool;
  1130. }
  1132. inline bool XMLScanner::getHasNoDTD() const
  1133. {
  1134.     return fHasNoDTD;
  1135. }
  1137. inline XMLCh* XMLScanner::getExternalSchemaLocation() const
  1138. {
  1139.     return fExternalSchemaLocation;
  1140. }
  1142. inline XMLCh* XMLScanner::getExternalNoNamespaceSchemaLocation() const
  1143. {
  1144.     return fExternalNoNamespaceSchemaLocation;
  1145. }
  1147. inline SecurityManager* XMLScanner::getSecurityManager() const
  1148. {
  1149.     return fSecurityManager;
  1150. }
  1152. inline bool XMLScanner::getLoadExternalDTD() const
  1153. {
  1154.     return fLoadExternalDTD;
  1155. }
  1157. inline bool XMLScanner::getNormalizeData() const
  1158. {
  1159.     return fNormalizeData;
  1160. }
  1162. inline bool XMLScanner::isCachingGrammarFromParse() const
  1163. {
  1164.     return fToCacheGrammar;
  1165. }
  1167. inline bool XMLScanner::isUsingCachedGrammarInParse() const
  1168. {
  1169.     return fUseCachedGrammar;
  1170. }
  1172. inline bool XMLScanner::getCalculateSrcOfs() const
  1173. {
  1174.     return fCalculateSrcOfs;
  1175. }
  1177. inline Grammar* XMLScanner::getRootGrammar() const
  1178. {
  1179.     return fRootGrammar;
  1180. }
  1182. inline bool XMLScanner::getStandardUriConformant() const
  1183. {
  1184.     return fStandardUriConformant;
  1185. }
  1187. inline XMLReader::XMLVersion XMLScanner::getXMLVersion() const
  1188. {
  1189. return fXMLVersion;
  1190. }
  1192. inline MemoryManager* XMLScanner::getMemoryManager() const
  1193. {
  1194.     return fMemoryManager;
  1195. }
  1197. // ---------------------------------------------------------------------------
  1198. //  XMLScanner: Setter methods
  1199. // ---------------------------------------------------------------------------
  1200. inline void XMLScanner::setDocHandler(XMLDocumentHandler* const docHandler)
  1201. {
  1202.     fDocHandler = docHandler;
  1203. }
  1205. inline void XMLScanner::setDocTypeHandler(DocTypeHandler* const docTypeHandler)
  1206. {
  1207.     fDocTypeHandler = docTypeHandler;
  1208. }
  1210. inline void XMLScanner::setErrorHandler(ErrorHandler* const handler)
  1211. {
  1212.     fErrorHandler = handler;
  1213. }
  1215. inline void XMLScanner::setEntityHandler(XMLEntityHandler* const entityHandler)
  1216. {
  1217.     fEntityHandler = entityHandler;
  1218.     fReaderMgr.setEntityHandler(entityHandler);
  1219. }
  1221. inline void XMLScanner::setErrorReporter(XMLErrorReporter* const errHandler)
  1222. {
  1223.     fErrorReporter = errHandler;
  1224. }
  1226. inline void XMLScanner::setGrammarResolver(GrammarResolver* const grammarResolver)
  1227. {
  1228.     fGrammarResolver = grammarResolver;
  1229. }
  1231. inline void XMLScanner::setExitOnFirstFatal(const bool newValue)
  1232. {
  1233.     fExitOnFirstFatal = newValue;
  1234. }
  1237. inline void XMLScanner::setValidationConstraintFatal(const bool newValue)
  1238. {
  1239.     fValidationConstraintFatal = newValue;
  1240. }
  1242. inline void XMLScanner::setValidationScheme(const ValSchemes newScheme)
  1243. {
  1244.     fValScheme = newScheme;
  1246.     // validation flag for Val_Auto is set to false by default,
  1247.     //   and will be turned to true if a grammar is seen
  1248.     if (fValScheme == Val_Always)
  1249.         fValidate = true;
  1250.     else
  1251.         fValidate = false;
  1252. }
  1254. inline void XMLScanner::setDoSchema(const bool doSchema)
  1255. {
  1256.     fDoSchema = doSchema;
  1257. }
  1259. inline void XMLScanner::setDoNamespaces(const bool doNamespaces)
  1260. {
  1261.     fDoNamespaces = doNamespaces;
  1262. }
  1264. inline void XMLScanner::setValidationSchemaFullChecking(const bool schemaFullChecking)
  1265. {
  1266.     fSchemaFullChecking = schemaFullChecking;
  1267. }
  1269. inline void XMLScanner::setHasNoDTD(const bool hasNoDTD)
  1270. {
  1271.     fHasNoDTD = hasNoDTD;
  1272. }
  1274. inline void XMLScanner::setRootElemName(XMLCh* rootElemName)
  1275. {
  1276.     fMemoryManager->deallocate(fRootElemName);//delete [] fRootElemName;
  1277.     fRootElemName = XMLString::replicate(rootElemName, fMemoryManager);
  1278. }
  1280. inline void XMLScanner::setExternalSchemaLocation(const XMLCh* const schemaLocation)
  1281. {
  1282.     fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
  1283.     fExternalSchemaLocation = XMLString::replicate(schemaLocation, fMemoryManager);
  1284. }
  1286. inline void XMLScanner::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
  1287. {
  1288.     fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
  1289.     fExternalNoNamespaceSchemaLocation = XMLString::replicate(noNamespaceSchemaLocation, fMemoryManager);
  1290. }
  1292. inline void XMLScanner::setExternalSchemaLocation(const char* const schemaLocation)
  1293. {
  1294.     fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
  1295.     fExternalSchemaLocation = XMLString::transcode(schemaLocation, fMemoryManager);
  1296. }
  1298. inline void XMLScanner::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
  1299. {
  1300.     fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
  1301.     fExternalNoNamespaceSchemaLocation = XMLString::transcode(noNamespaceSchemaLocation, fMemoryManager);
  1302. }
  1304. inline void XMLScanner::setSecurityManager(SecurityManager* const securityManager)
  1305. {
  1306.     fSecurityManager = securityManager;
  1307.     if(securityManager != 0) 
  1308.     {
  1309.         fEntityExpansionLimit = securityManager->getEntityExpansionLimit();
  1310.         fEntityExpansionCount = 0;
  1311.     }
  1312. }
  1314. inline void XMLScanner::setLoadExternalDTD(const bool loadDTD)
  1315. {
  1316.     fLoadExternalDTD = loadDTD;
  1317. }
  1319. inline void XMLScanner::setNormalizeData(const bool normalizeData)
  1320. {
  1321.     fNormalizeData = normalizeData;
  1322. }
  1324. inline void XMLScanner::cacheGrammarFromParse(const bool newValue)
  1325. {
  1326.     fToCacheGrammar = newValue;
  1327. }
  1329. inline void XMLScanner::useCachedGrammarInParse(const bool newValue)
  1330. {
  1331.     fUseCachedGrammar = newValue;
  1332. }
  1334. inline void XMLScanner::setCalculateSrcOfs(const bool newValue)
  1335. {
  1336.     fCalculateSrcOfs = newValue;
  1337. }
  1339. inline void XMLScanner::setStandardUriConformant(const bool newValue)
  1340. {
  1341.     fStandardUriConformant = newValue;
  1342.     fReaderMgr.setStandardUriConformant(newValue);
  1343. }
  1345. // ---------------------------------------------------------------------------
  1346. //  XMLScanner: Mutator methods
  1347. // ---------------------------------------------------------------------------
  1348. inline void XMLScanner::incrementErrorCount()
  1349. {
  1350.     ++fErrorCount;
  1351. }
  1353. // ---------------------------------------------------------------------------
  1354. //  XMLScanner: Deprecated methods
  1355. // ---------------------------------------------------------------------------
  1356. inline bool XMLScanner::getDoValidation() const
  1357. {
  1358.     return fValidate;
  1359. }
  1361. inline void XMLScanner::setDoValidation(const bool validate)
  1362. {
  1363.     fValidate = validate;
  1364.     if (fValidate)
  1365.         fValScheme = Val_Always;
  1366.     else
  1367.         fValScheme = Val_Never;
  1368. }
  1370. XERCES_CPP_NAMESPACE_END
  1372. #endif