1 /*

     2  * Licensed to the Apache Software Foundation (ASF) under one or more

     3  * contributor license agreements.  See the NOTICE file distributed with

     4  * this work for additional information regarding copyright ownership.

     5  * The ASF licenses this file to You under the Apache License, Version 2.0

     6  * (the "License"); you may not use this file except in compliance with

     7  * the License.  You may obtain a copy of the License at

     8  * 

     9  *      http://www.apache.org/licenses/LICENSE-2.0

    10  * 

    11  * Unless required by applicable law or agreed to in writing, software

    12  * distributed under the License is distributed on an "AS IS" BASIS,

    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    14  * See the License for the specific language governing permissions and

    15  * limitations under the License.

    16  */

    17 

    18 /*

    19  * $Id: XMLScanner.hpp 568078 2007-08-21 11:43:25Z amassari $

    20  */

    21 

    22 #if !defined(XMLSCANNER_HPP)

    23 #define XMLSCANNER_HPP

    24 

    25 #include <xercesc/framework/XMLBufferMgr.hpp>

    26 #include <xercesc/framework/XMLErrorCodes.hpp>

    27 #include <xercesc/framework/XMLRefInfo.hpp>

    28 #include <xercesc/util/PlatformUtils.hpp>

    29 #include <xercesc/util/NameIdPool.hpp>

    30 #include <xercesc/util/RefHashTableOf.hpp>

    31 #include <xercesc/util/SecurityManager.hpp>

    32 #include <xercesc/internal/ReaderMgr.hpp>

    33 #include <xercesc/internal/ElemStack.hpp>

    34 #include <xercesc/validators/DTD/DTDEntityDecl.hpp>

    35 #include <xercesc/framework/XMLAttr.hpp>

    36 #include <xercesc/framework/ValidationContext.hpp>

    37 #include <xercesc/validators/common/GrammarResolver.hpp>

    38 

    39 XERCES_CPP_NAMESPACE_BEGIN

    40 

    41 class InputSource;

    42 class XMLDocumentHandler;

    43 class XMLEntityHandler;

    44 class ErrorHandler;

    45 class DocTypeHandler;

    46 class XMLPScanToken;

    47 class XMLStringPool;

    48 class Grammar;

    49 class XMLValidator;

    50 class MemoryManager;

    51 class PSVIHandler;

    52 

    53 

    54 struct PSVIElemContext

    55 {

    56     bool               fIsSpecified;

    57     bool               fErrorOccurred;

    58     int                fElemDepth;

    59     int                fFullValidationDepth;

    60     int                fNoneValidationDepth;

    61     DatatypeValidator* fCurrentDV;

    62     ComplexTypeInfo*   fCurrentTypeInfo;

    63     const XMLCh*       fNormalizedValue;

    64 };

    65 

    66 //  This is the mondo scanner class, which does the vast majority of the

    67 //  work of parsing. It handles reading in input and spitting out events

    68 //  to installed handlers.

    69 class XMLPARSER_EXPORT XMLScanner : public XMemory, public XMLBufferFullHandler

    70 {

    71 public :

    72     // -----------------------------------------------------------------------

    73     //  Public class types

    74     //

    75     //  NOTE: These should really be private, but some of the compilers we

    76     //  have to deal with are too stupid to understand this.

    77     //

    78     //  DeclTypes

    79     //      Used by scanXMLDecl() to know what type of decl it should scan.

    80     //      Text decls have slightly different rules from XMLDecls.

    81     //

    82     //  EntityExpRes

    83     //      These are the values returned from the entity expansion method,

    84     //      to indicate how it went.

    85     //

    86     //  XMLTokens

    87     //      These represent the possible types of input we can get while

    88     //      scanning content.

    89     //

    90     //  ValScheme

    91     //      This indicates what the scanner should do in terms of validation.

    92     //      'Auto' means if there is any int/ext subset, then validate. Else,

    93     //      don't.

    94     // -----------------------------------------------------------------------

    95     enum DeclTypes

    96     {

    97         Decl_Text

    98         , Decl_XML

    99     };

   100 

   101     enum EntityExpRes

   102     {

   103         EntityExp_Pushed

   104         , EntityExp_Returned

   105         , EntityExp_Failed

   106     };

   107 

   108     enum XMLTokens

   109     {

   110         Token_CData

   111         , Token_CharData

   112         , Token_Comment

   113         , Token_EndTag

   114         , Token_EOF

   115         , Token_PI

   116         , Token_StartTag

   117         , Token_Unknown

   118     };

   119 

   120     enum ValSchemes

   121     {

   122         Val_Never

   123         , Val_Always

   124         , Val_Auto

   125     };

   126 

   127 

   128     // -----------------------------------------------------------------------

   129     //  Constructors and Destructor

   130     // -----------------------------------------------------------------------

   131     XMLScanner

   132     (

   133         XMLValidator* const valToAdopt

   134         , GrammarResolver* const grammarResolver

   135         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager

   136     );

   137     XMLScanner

   138     (

   139         XMLDocumentHandler* const  docHandler

   140         , DocTypeHandler* const    docTypeHandler

   141         , XMLEntityHandler* const  entityHandler

   142         , XMLErrorReporter* const  errReporter

   143         , XMLValidator* const      valToAdopt

   144         , GrammarResolver* const grammarResolver

   145         , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager

   146     );

   147     virtual ~XMLScanner();

   148 

   149 

   150     // -----------------------------------------------------------------------

   151     //  Error emitter methods

   152     // -----------------------------------------------------------------------

   153     bool emitErrorWillThrowException(const XMLErrs::Codes toEmit);

   154     void emitError(const XMLErrs::Codes toEmit);

   155     void emitError

   156     (

   157         const   XMLErrs::Codes    toEmit

   158         , const XMLCh* const        text1

   159         , const XMLCh* const        text2 = 0

   160         , const XMLCh* const        text3 = 0

   161         , const XMLCh* const        text4 = 0

   162     );

   163     void emitError

   164     (

   165         const   XMLErrs::Codes    toEmit

   166         , const char* const         text1

   167         , const char* const         text2 = 0

   168         , const char* const         text3 = 0

   169         , const char* const         text4 = 0

   170     );

   171     void emitError

   172     (

   173         const   XMLErrs::Codes    toEmit

   174         , const XMLExcepts::Codes   originalErrorCode

   175         , const XMLCh* const        text1 = 0

   176         , const XMLCh* const        text2 = 0

   177         , const XMLCh* const        text3 = 0

   178         , const XMLCh* const        text4 = 0

   179     );

   180 

   181     // -----------------------------------------------------------------------

   182     //  Implementation of XMLBufferFullHandler interface

   183     // -----------------------------------------------------------------------

   184 

   185     virtual bool bufferFull(XMLBuffer& toSend)

   186     {

   187         sendCharData(toSend);

   188         return true;

   189     }

   190 

   191     virtual Grammar::GrammarType getCurrentGrammarType() const;

   192 

   193     // -----------------------------------------------------------------------

   194     //  Public pure virtual methods

   195     // -----------------------------------------------------------------------

   196     virtual const XMLCh* getName() const = 0;

   197     virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool() = 0;

   198     virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const = 0;

   199     virtual unsigned int resolveQName

   200     (

   201         const   XMLCh* const        qName

   202         ,       XMLBuffer&          prefixBufToFill

   203         , const short               mode

   204         ,       int&                prefixColonPos

   205     ) = 0;

   206     virtual void scanDocument

   207     (

   208         const   InputSource&    src

   209     ) = 0;

   210     virtual bool scanNext(XMLPScanToken& toFill) = 0;

   211     virtual Grammar* loadGrammar

   212     (

   213         const   InputSource&    src

   214         , const short           grammarType

   215         , const bool            toCache = false

   216     ) = 0;

   217 

   218     // -----------------------------------------------------------------------

   219     //  Getter methods

   220     // -----------------------------------------------------------------------

   221     const XMLDocumentHandler* getDocHandler() const;

   222     XMLDocumentHandler* getDocHandler();

   223     const DocTypeHandler* getDocTypeHandler() const;

   224     DocTypeHandler* getDocTypeHandler();

   225     bool getDoNamespaces() const;

   226     ValSchemes getValidationScheme() const;

   227     bool getDoSchema() const;

   228     bool getValidationSchemaFullChecking() const;

   229     bool getIdentityConstraintChecking() const;

   230     const XMLEntityHandler* getEntityHandler() const;

   231     XMLEntityHandler* getEntityHandler();

   232     const XMLErrorReporter* getErrorReporter() const;

   233     XMLErrorReporter* getErrorReporter();

   234     const ErrorHandler* getErrorHandler() const;

   235     ErrorHandler* getErrorHandler();

   236     const PSVIHandler* getPSVIHandler() const;

   237     PSVIHandler* getPSVIHandler();

   238     bool getExitOnFirstFatal() const;

   239     bool getValidationConstraintFatal() const;

   240     RefHashTableOf<XMLRefInfo>* getIDRefList();

   241     const RefHashTableOf<XMLRefInfo>* getIDRefList() const;

   242 

   243     ValidationContext*   getValidationContext();

   244 

   245     bool getInException() const;

   246     /*bool getLastExtLocation

   247     (

   248                 XMLCh* const    sysIdToFill

   249         , const unsigned int    maxSysIdChars

   250         ,       XMLCh* const    pubIdToFill

   251         , const unsigned int    maxPubIdChars

   252         ,       XMLSSize_t&     lineToFill

   253         ,       XMLSSize_t&     colToFill

   254     ) const;*/

   255     const Locator* getLocator() const;

   256     const ReaderMgr* getReaderMgr() const;

   257     unsigned int getSrcOffset() const;

   258     bool getStandalone() const;

   259     const XMLValidator* getValidator() const;

   260     XMLValidator* getValidator();

   261     int getErrorCount();

   262     const XMLStringPool* getURIStringPool() const;

   263     XMLStringPool* getURIStringPool();

   264     bool getHasNoDTD() const;

   265     XMLCh* getExternalSchemaLocation() const;

   266     XMLCh* getExternalNoNamespaceSchemaLocation() const;

   267     SecurityManager* getSecurityManager() const;

   268     bool getLoadExternalDTD() const;

   269     bool getNormalizeData() const;

   270     bool isCachingGrammarFromParse() const;

   271     bool isUsingCachedGrammarInParse() const;

   272     bool getCalculateSrcOfs() const;

   273     Grammar* getRootGrammar() const;

   274     XMLReader::XMLVersion getXMLVersion() const;

   275     MemoryManager* getMemoryManager() const;

   276     ValueVectorOf<PrefMapElem*>* getNamespaceContext() const;

   277     unsigned int getPrefixId(const XMLCh* const prefix) const;

   278     const XMLCh* getPrefixForId(unsigned int prefId) const;

   279 

   280     bool getGenerateSyntheticAnnotations() const;

   281     bool getValidateAnnotations() const;

   282     bool getIgnoreCachedDTD() const;

   283     bool getIgnoreAnnotations() const;

   284     bool getDisableDefaultEntityResolution() const;

   285     bool getSkipDTDValidation() const;

   286 

   287     // -----------------------------------------------------------------------

   288     //  Getter methods

   289     // -----------------------------------------------------------------------

   290     /**

   291       * When an attribute name has no prefix, unlike elements, it is not mapped

   292       * to the global namespace. So, in order to have something to map it to

   293       * for practical purposes, a id for an empty URL is created and used for

   294       * such names.

   295       *

   296       * @return The URL pool id of the URL for an empty URL "".

   297       */

   298     unsigned int getEmptyNamespaceId() const;

   299 

   300     /**

   301       * When a prefix is found that has not been mapped, an error is issued.

   302       * However, if the parser has been instructed not to stop on the first

   303       * fatal error, it needs to be able to continue. To do so, it will map

   304       * that prefix tot his magic unknown namespace id.

   305       *

   306       * @return The URL pool id of the URL for the unknown prefix

   307       *         namespace.

   308       */

   309     unsigned int getUnknownNamespaceId() const;

   310 

   311     /**

   312       * The prefix 'xml' is a magic prefix, defined by the XML spec and

   313       * requiring no prior definition. This method returns the id for the

   314       * intrinsically defined URL for this prefix.

   315       *

   316       * @return The URL pool id of the URL for the 'xml' prefix.

   317       */

   318     unsigned int getXMLNamespaceId() const;

   319 

   320     /**

   321       * The prefix 'xmlns' is a magic prefix, defined by the namespace spec

   322       * and requiring no prior definition. This method returns the id for the

   323       * intrinsically defined URL for this prefix.

   324       *

   325       * @return The URL pool id of the URL for the 'xmlns' prefix.

   326       */

   327     unsigned int getXMLNSNamespaceId() const;

   328 

   329     /**

   330       * This method find the passed URI id in its URI pool and

   331       * copy the text of that URI into the passed buffer.

   332       */

   333     bool getURIText

   334     (

   335         const   unsigned int    uriId

   336         ,       XMLBuffer&      uriBufToFill

   337     )   const;

   338 

   339     const XMLCh* getURIText(const   unsigned int    uriId) const;

   340 

   341     /* tell if the validator comes from user */

   342     bool isValidatorFromUser();

   343 

   344     /* tell if standard URI are forced */

   345     bool getStandardUriConformant() const;

   346 

   347     // -----------------------------------------------------------------------

   348     //  Setter methods

   349     // -----------------------------------------------------------------------

   350     void setDocHandler(XMLDocumentHandler* const docHandler);

   351     void setDocTypeHandler(DocTypeHandler* const docTypeHandler);

   352     void setDoNamespaces(const bool doNamespaces);

   353     void setEntityHandler(XMLEntityHandler* const docTypeHandler);

   354     void setErrorReporter(XMLErrorReporter* const errHandler);

   355     void setErrorHandler(ErrorHandler* const handler);

   356     void setPSVIHandler(PSVIHandler* const handler);

   357     void setURIStringPool(XMLStringPool* const stringPool);

   358     void setExitOnFirstFatal(const bool newValue);

   359     void setValidationConstraintFatal(const bool newValue);

   360     void setValidationScheme(const ValSchemes newScheme);

   361     void setValidator(XMLValidator* const valToAdopt);

   362     void setDoSchema(const bool doSchema);

   363     void setValidationSchemaFullChecking(const bool schemaFullChecking);

   364     void setIdentityConstraintChecking(const bool identityConstraintChecking);

   365     void setHasNoDTD(const bool hasNoDTD);

   366     void cacheGrammarFromParse(const bool newValue);

   367     void useCachedGrammarInParse(const bool newValue);

   368     void setRootElemName(XMLCh* rootElemName);

   369     void setExternalSchemaLocation(const XMLCh* const schemaLocation);

   370     void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);

   371     void setExternalSchemaLocation(const char* const schemaLocation);

   372     void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);

   373     void setSecurityManager(SecurityManager* const securityManager);

   374     void setLoadExternalDTD(const bool loadDTD);

   375     void setNormalizeData(const bool normalizeData);

   376     void setCalculateSrcOfs(const bool newValue);

   377     void setParseSettings(XMLScanner* const refScanner);

   378     void setStandardUriConformant(const bool newValue);

   379     void setInputBufferSize(const size_t bufferSize);

   380 

   381     void setGenerateSyntheticAnnotations(const bool newValue);

   382     void setValidateAnnotations(const bool newValue);

   383     void setIgnoredCachedDTD(const bool newValue);

   384     void setIgnoreAnnotations(const bool newValue);

   385     void setDisableDefaultEntityResolution(const bool newValue);

   386     void setSkipDTDValidation(const bool newValue);

   387 

   388     // -----------------------------------------------------------------------

   389     //  Mutator methods

   390     // -----------------------------------------------------------------------

   391     void incrementErrorCount(void);			// For use by XMLValidator

   392 

   393     // -----------------------------------------------------------------------

   394     //  Deprecated methods as of 3.2.0. Use getValidationScheme() and

   395     //  setValidationScheme() instead.

   396     // -----------------------------------------------------------------------

   397     bool getDoValidation() const;

   398     void setDoValidation(const bool validate);

   399 

   400     // -----------------------------------------------------------------------

   401     //  Document scanning methods

   402     //

   403     //  scanDocument() does the entire source document. scanFirst(),

   404     //  scanNext(), and scanReset() support a progressive parse.

   405     // -----------------------------------------------------------------------

   406     void scanDocument

   407     (

   408         const   XMLCh* const    systemId

   409     );

   410     void scanDocument

   411     (

   412         const   char* const     systemId

   413     );

   414 

   415     bool scanFirst

   416     (

   417         const   InputSource&    src

   418         ,       XMLPScanToken&  toFill

   419     );

   420     bool scanFirst

   421     (

   422         const   XMLCh* const    systemId

   423         ,       XMLPScanToken&  toFill

   424     );

   425     bool scanFirst

   426     (

   427         const   char* const     systemId

   428         ,       XMLPScanToken&  toFill

   429     );

   430 

   431     void scanReset(XMLPScanToken& toFill);

   432 

   433     bool checkXMLDecl(bool startWithAngle);

   434 

   435     // -----------------------------------------------------------------------

   436     //  Grammar preparsing methods

   437     // -----------------------------------------------------------------------

   438     Grammar* loadGrammar

   439     (

   440         const   XMLCh* const    systemId

   441         , const short           grammarType

   442         , const bool            toCache = false

   443     );

   444     Grammar* loadGrammar

   445     (

   446         const   char* const     systemId

   447         , const short           grammarType

   448         , const bool            toCache = false

   449     );

   450 

   451     // -----------------------------------------------------------------------

   452     //  Notification that lazy data has been deleted

   453     // -----------------------------------------------------------------------

   454 	static void reinitScannerMutex();

   455 	static void reinitMsgLoader();

   456 

   457 protected:

   458     // -----------------------------------------------------------------------

   459     //  Protected pure virtual methods

   460     // -----------------------------------------------------------------------

   461     virtual void scanCDSection() = 0;

   462     virtual void scanCharData(XMLBuffer& toToUse) = 0;

   463     virtual EntityExpRes scanEntityRef

   464     (

   465         const   bool    inAttVal

   466         ,       XMLCh&  firstCh

   467         ,       XMLCh&  secondCh

   468         ,       bool&   escaped

   469     ) = 0;

   470     virtual void scanDocTypeDecl() = 0;

   471     virtual void scanReset(const InputSource& src) = 0;

   472     virtual void sendCharData(XMLBuffer& toSend) = 0;

   473 

   474     //return owned by the caller

   475     virtual InputSource* resolveSystemId(const XMLCh* const /*sysId*/

   476                                         ,const XMLCh* const /*pubId*/) {return 0;};

   477 

   478     // -----------------------------------------------------------------------

   479     //  Protected scanning methods

   480     // -----------------------------------------------------------------------

   481     bool scanCharRef(XMLCh& toFill, XMLCh& second);

   482     void scanComment();

   483     bool scanEq(bool inDecl = false);

   484     void scanMiscellaneous();

   485     void scanPI();

   486     void scanProlog();

   487     void scanXMLDecl(const DeclTypes type);

   488 

   489     // -----------------------------------------------------------------------

   490     //  Private helper methods

   491     // -----------------------------------------------------------------------

   492     void checkInternalDTD(bool hasExtSubset, const XMLCh* const sysId, const XMLCh* const pubId);

   493     void checkIDRefs();

   494     bool isLegalToken(const XMLPScanToken& toCheck);

   495     XMLTokens senseNextToken(unsigned int& orgReader);

   496     void initValidator(XMLValidator* theValidator);

   497     inline void resetValidationContext();

   498     unsigned int *getNewUIntPtr();

   499     void resetUIntPool();

   500     void recreateUIntPool();

   501 

   502     inline

   503     void setAttrDupChkRegistry

   504          (

   505             const unsigned int &attrNumber

   506           ,       bool         &toUseHashTable

   507          );

   508 

   509     // -----------------------------------------------------------------------

   510     //  Data members

   511     //

   512     //  fBufferSize

   513     //      Maximum input buffer size

   514     //

   515     //  fAttrList

   516     //      Every time we get a new element start tag, we have to pass to

   517     //      the document handler the attributes found. To make it more

   518     //      efficient we keep this ref vector of XMLAttr objects around. We

   519     //      just reuse it over and over, allowing it to grow to meet the

   520     //      peak need.

   521     //

   522     //  fBufMgr

   523     //      This is a manager for temporary buffers used during scanning.

   524     //      For efficiency we must use a set of static buffers, but we have

   525     //      to insure that they are not incorrectly reused. So this manager

   526     //      provides the smarts to hand out buffers as required.

   527     //

   528     //  fDocHandler

   529     //      The client code's document handler. If zero, then no document

   530     //      handler callouts are done. We don't adopt it.

   531     //

   532     //  fDocTypeHandler

   533     //      The client code's document type handler (used by DTD Validator).

   534     //

   535     //  fDoNamespaces

   536     //      This flag indicates whether the client code wants us to do

   537     //      namespaces or not. If the installed validator indicates that it

   538     //      has to do namespaces, then this is ignored.

   539     //

   540     //  fEntityHandler

   541     //      The client code's entity handler. If zero, then no entity handler

   542     //      callouts are done. We don't adopt it.

   543     //

   544     //  fErrorReporter

   545     //      The client code's error reporter. If zero, then no error reporter

   546     //      callouts are done. We don't adopt it.

   547     //

   548     //  fErrorHandler

   549     //      The client code's error handler.  Need to store this info for

   550     //      Schema parse error handling.

   551     //

   552     //  fPSVIHandler

   553     //      The client code's PSVI handler.

   554     //

   555     //  fExitOnFirstFatal

   556     //      This indicates whether we bail out on the first fatal XML error

   557     //      or not. It defaults to true, which is the strict XML way, but it

   558     //      can be changed.

   559     //

   560     //  fValidationConstraintFatal

   561     //      This indicates whether we treat validation constraint errors as

   562     //      fatal errors or not. It defaults to false, but it can be changed.

   563     //

   564     //  fIDRefList

   565     //      This is a list of XMLRefInfo objects. This member lets us do all

   566     //      needed ID-IDREF balancing checks.

   567     //

   568     //  fInException

   569     //      To avoid a circular freakout when we catch an exception and emit

   570     //      it, which would normally throw again if the 'fail on first error'

   571     //      flag is one.

   572     //

   573     //  fReaderMgr

   574     //      This is the reader manager, from which we get characters. It

   575     //      manages the reader stack for us, and provides a lot of convenience

   576     //      methods to do specialized checking for chars, sequences of chars,

   577     //      skipping chars, etc...

   578     //

   579     //  fScannerId

   580     //  fSequenceId

   581     //      These are used for progressive parsing, to make sure that the

   582     //      client code does the right thing at the right time.

   583     //

   584     //  fStandalone

   585     //      Indicates whether the document is standalone or not. Defaults to

   586     //      no, but can be overridden in the XMLDecl.

   587     //

   588     //  fHasNoDTD

   589     //      Indicates the document has no DTD or has only an internal DTD subset

   590     //      which contains no parameter entity references.

   591     //

   592     //  fValidate

   593     //      Indicates whether any validation should be done. This is defined

   594     //      by the existence of a Grammar together with fValScheme.

   595     //

   596     //  fValidator

   597     //      The installed validator. We look at them via the abstract

   598     //      validator interface, and don't know what it actual is.

   599     //      Either point to user's installed validator, or fDTDValidator

   600     //      or fSchemaValidator.

   601     //

   602     //  fValidatorFromUser

   603     //      This flag indicates whether the validator was installed from

   604     //      user.  If false, then the validator was created by the Scanner.

   605     //

   606     //  fValScheme

   607     //      This is the currently set validation scheme. It defaults to

   608     //      'never', but can be set by the client.

   609     //

   610     //  fErrorCount

   611     //		The number of errors we've encountered.

   612     //

   613     //  fDoSchema

   614     //      This flag indicates whether the client code wants Schema to

   615     //      be processed or not.

   616     //

   617     //  fSchemaFullChecking

   618     //      This flag indicates whether the client code wants full Schema

   619     //      constraint checking.

   620     //

   621     //  fIdentityConstraintChecking

   622     //      This flag indicates whether the client code wants Identity

   623     //      Constraint checking, defaulted to true to maintain backward

   624     //      compatibility (to minimize supprise)

   625     //

   626     //  fAttName

   627     //  fAttValue

   628     //  fCDataBuf

   629     //  fNameBuf

   630     //  fQNameBuf

   631     //  fPrefixBuf

   632     //      For the most part, buffers are obtained from the fBufMgr object

   633     //      on the fly. However, for the start tag scan, we have a set of

   634     //      fixed buffers for performance reasons. These are used a lot and

   635     //      there are a number of them, so asking the buffer manager each

   636     //      time for new buffers is a bit too much overhead.

   637     //

   638     //  fEmptyNamespaceId

   639     //      This is the id of the empty namespace URI. This is a special one

   640     //      because of the xmlns="" type of deal. We have to quickly sense

   641     //      that its the empty namespace.

   642     //

   643     //  fUnknownNamespaceId

   644     //      This is the id of the namespace URI which is assigned to the

   645     //      global namespace. Its for debug purposes only, since there is no

   646     //      real global namespace URI. Its set by the derived class.

   647     //

   648     //  fXMLNamespaceId

   649     //  fXMLNSNamespaceId

   650     //      These are the ids of the namespace URIs which are assigned to the

   651     //      'xml' and 'xmlns' special prefixes. The former is officially

   652     //      defined but the latter is not, so we just provide one for debug

   653     //      purposes.

   654     //

   655     //  fSchemaNamespaceId

   656     //      This is the id of the schema namespace URI.

   657     //

   658     //  fGrammarResolver

   659     //      Grammar Pool that stores all the grammars. Key is namespace for

   660     //      schema and system id for external DTD. When caching a grammar, if

   661     //      a grammar is already in the pool, it will be replaced with the

   662     //      new parsed one.

   663     //

   664     //  fGrammar

   665     //      Current Grammar used by the Scanner and Validator

   666     //

   667     //  fRootGrammar

   668     //      The grammar where the root element is declared.

   669     //

   670     //  fGrammarType

   671     //      Current Grammar Type.  Store this value instead of calling getGrammarType

   672     //      all the time for faster performance.

   673     //

   674     //  fURIStringPool

   675     //      This is a pool for URIs with unique ids assigned. We use a standard

   676     //      string pool class.  This pool is going to be shared by all Grammar.

   677     //      Use only if namespace is turned on.

   678     //

   679     //  fRootElemName

   680     //      No matter we are using DTD or Schema Grammar, if a DOCTYPE exists,

   681     //      we need to verify the root element name.  So store the rootElement

   682     //      that is used in the DOCTYPE in the Scanner instead of in the DTDGrammar

   683     //      where it used to

   684     //

   685     //  fExternalSchemaLocation

   686     //      The list of Namespace/SchemaLocation that was specified externally

   687     //      using setExternalSchemaLocation.

   688     //

   689     //  fExternalNoNamespaceSchemaLocation

   690     //      The no target namespace XML Schema Location that was specified

   691     //      externally using setExternalNoNamespaceSchemaLocation.

   692     //

   693     //  fSecurityManager

   694     //      The SecurityManager instance; as and when set by the application.

   695     //

   696     //  fEntityExpansionLimit

   697     //      The number of entity expansions to be permitted while processing this document

   698     //      Only meaningful when fSecurityManager != 0

   699     //

   700     //  fEntityExpansionCount

   701     //      The number of general entities expanded so far in this document.

   702     //      Only meaningful when fSecurityManager != null

   703     //

   704     //  fLoadExternalDTD

   705     //      This flag indicates whether the external DTD be loaded or not

   706     //

   707     //  fNormalizeData

   708     //      This flag indicates whether the parser should perform datatype

   709     //      normalization that is defined in the schema.

   710     //

   711     //  fCalculateSrcOfs

   712     //      This flag indicates the parser should calculate the source offset.

   713     //      Turning this on may impact performance.

   714     //

   715     //  fStandardUriConformant

   716     //      This flag controls whether we force conformant URI

   717     //

   718     //  fXMLVersion

   719     //      Enum to indicate if the main doc is XML 1.1 or XML 1.0 conformant    

   720     //  fUIntPool

   721     //      pool of unsigned integers to help with duplicate attribute

   722     //      detection and filling in default/fixed attributes

   723     //  fUIntPoolRow

   724     //      current row in fUIntPool

   725     //  fUIntPoolCol

   726     //      current column i row

   727     //  fUIntPoolRowTotal

   728     //      total number of rows in table

   729     //

   730     //  fMemoryManager

   731     //      Pluggable memory manager for dynamic allocation/deallocation.

   732     //

   733     // -----------------------------------------------------------------------

   734     size_t                      fBufferSize;

   735     bool                        fStandardUriConformant;

   736     bool                        fCalculateSrcOfs;

   737     bool                        fDoNamespaces;

   738     bool                        fExitOnFirstFatal;

   739     bool                        fValidationConstraintFatal;

   740     bool                        fInException;

   741     bool                        fStandalone;

   742     bool                        fHasNoDTD;

   743     bool                        fValidate;

   744     bool                        fValidatorFromUser;

   745     bool                        fDoSchema;

   746     bool                        fSchemaFullChecking;

   747     bool                        fIdentityConstraintChecking;

   748     bool                        fToCacheGrammar;

   749     bool                        fUseCachedGrammar;

   750     bool                        fLoadExternalDTD;

   751     bool                        fNormalizeData;

   752     bool                        fGenerateSyntheticAnnotations;

   753     bool                        fValidateAnnotations;

   754     bool                        fIgnoreCachedDTD;

   755     bool                        fIgnoreAnnotations;

   756     bool                        fDisableDefaultEntityResolution;

   757     bool                        fSkipDTDValidation;

   758     int                         fErrorCount;

   759     unsigned int                fEntityExpansionLimit;

   760     unsigned int                fEntityExpansionCount;

   761     unsigned int                fEmptyNamespaceId;

   762     unsigned int                fUnknownNamespaceId;

   763     unsigned int                fXMLNamespaceId;

   764     unsigned int                fXMLNSNamespaceId;

   765     unsigned int                fSchemaNamespaceId;

   766     unsigned int **             fUIntPool;

   767     unsigned int                fUIntPoolRow;

   768     unsigned int                fUIntPoolCol;

   769     unsigned int                fUIntPoolRowTotal;

   770     XMLUInt32                   fScannerId;

   771     XMLUInt32                   fSequenceId;

   772     RefVectorOf<XMLAttr>*       fAttrList;

   773     RefHash2KeysTableOf<XMLAttr>*  fAttrDupChkRegistry;    

   774     XMLDocumentHandler*         fDocHandler;

   775     DocTypeHandler*             fDocTypeHandler;

   776     XMLEntityHandler*           fEntityHandler;

   777     XMLErrorReporter*           fErrorReporter;

   778     ErrorHandler*               fErrorHandler;

   779     PSVIHandler*                fPSVIHandler;

   780     ValidationContext           *fValidationContext;

   781     bool                        fEntityDeclPoolRetrieved;

   782     ReaderMgr                   fReaderMgr;

   783     XMLValidator*               fValidator;

   784     ValSchemes                  fValScheme;

   785     GrammarResolver* const      fGrammarResolver;

   786     MemoryManager* const        fGrammarPoolMemoryManager;

   787     Grammar*                    fGrammar;

   788     Grammar*                    fRootGrammar;

   789     XMLStringPool*              fURIStringPool;

   790     XMLCh*                      fRootElemName;

   791     XMLCh*                      fExternalSchemaLocation;

   792     XMLCh*                      fExternalNoNamespaceSchemaLocation;

   793     SecurityManager*            fSecurityManager;

   794     XMLReader::XMLVersion       fXMLVersion;

   795     MemoryManager*              fMemoryManager;

   796     XMLBufferMgr                fBufMgr;

   797     XMLBuffer                   fAttNameBuf;

   798     XMLBuffer                   fAttValueBuf;

   799     XMLBuffer                   fCDataBuf;

   800     XMLBuffer                   fQNameBuf;

   801     XMLBuffer                   fPrefixBuf;

   802     XMLBuffer                   fURIBuf;

   803     XMLBuffer                   fWSNormalizeBuf;

   804     ElemStack                   fElemStack;

   805 

   806 

   807 private :

   808     // -----------------------------------------------------------------------

   809     //  Unimplemented constructors and operators

   810     // -----------------------------------------------------------------------

   811     XMLScanner();

   812     XMLScanner(const XMLScanner&);

   813     XMLScanner& operator=(const XMLScanner&);

   814 

   815     // -----------------------------------------------------------------------

   816     //  Private helper methods

   817     // -----------------------------------------------------------------------

   818     void commonInit();

   819     void cleanUp();

   820 

   821     // -----------------------------------------------------------------------

   822     //  Private scanning methods

   823     // -----------------------------------------------------------------------

   824     bool getQuotedString(XMLBuffer& toFill);

   825     unsigned int scanUpToWSOr

   826     (

   827                 XMLBuffer&  toFill

   828         , const XMLCh       chEndChar

   829     );

   830 };

   831 

   832 // ---------------------------------------------------------------------------

   833 //  XMLScanner: Getter methods

   834 // ---------------------------------------------------------------------------

   835 inline const XMLDocumentHandler* XMLScanner::getDocHandler() const

   836 {

   837     return fDocHandler;

   838 }

   839 

   840 inline XMLDocumentHandler* XMLScanner::getDocHandler()

   841 {

   842     return fDocHandler;

   843 }

   844 

   845 inline const DocTypeHandler* XMLScanner::getDocTypeHandler() const

   846 {

   847     return fDocTypeHandler;

   848 }

   849 

   850 inline DocTypeHandler* XMLScanner::getDocTypeHandler()

   851 {

   852     return fDocTypeHandler;

   853 }

   854 

   855 inline bool XMLScanner::getDoNamespaces() const

   856 {

   857     return fDoNamespaces;

   858 }

   859 

   860 inline const XMLEntityHandler* XMLScanner::getEntityHandler() const

   861 {

   862     return fEntityHandler;

   863 }

   864 

   865 inline XMLEntityHandler* XMLScanner::getEntityHandler()

   866 {

   867     return fEntityHandler;

   868 }

   869 

   870 inline const XMLErrorReporter* XMLScanner::getErrorReporter() const

   871 {

   872     return fErrorReporter;

   873 }

   874 

   875 inline XMLErrorReporter* XMLScanner::getErrorReporter()

   876 {

   877     return fErrorReporter;

   878 }

   879 

   880 inline const ErrorHandler* XMLScanner::getErrorHandler() const

   881 {

   882     return fErrorHandler;

   883 }

   884 

   885 inline ErrorHandler* XMLScanner::getErrorHandler()

   886 {

   887     return fErrorHandler;

   888 }

   889 

   890 inline const PSVIHandler* XMLScanner::getPSVIHandler() const

   891 {

   892     return fPSVIHandler;

   893 }

   894 

   895 inline PSVIHandler* XMLScanner::getPSVIHandler()

   896 {

   897     return fPSVIHandler;

   898 }

   899 

   900 inline bool XMLScanner::getExitOnFirstFatal() const

   901 {

   902     return fExitOnFirstFatal;

   903 }

   904 

   905 inline bool XMLScanner::getValidationConstraintFatal() const

   906 {

   907     return fValidationConstraintFatal;

   908 }

   909 

   910 inline bool XMLScanner::getInException() const

   911 {

   912     return fInException;

   913 }

   914 

   915 inline RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList()

   916 {

   917     return fValidationContext->getIdRefList();

   918 }

   919 

   920 inline const RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList() const

   921 {

   922     return fValidationContext->getIdRefList();

   923 }

   924 

   925 inline ValidationContext*  XMLScanner::getValidationContext()

   926 {

   927     if (!fEntityDeclPoolRetrieved)

   928     {

   929         fValidationContext->setEntityDeclPool(getEntityDeclPool());

   930         fEntityDeclPoolRetrieved = true;

   931     }

   932 

   933     return fValidationContext;

   934 }

   935 

   936 inline const Locator* XMLScanner::getLocator() const

   937 {

   938     return &fReaderMgr;

   939 }

   940 

   941 inline const ReaderMgr* XMLScanner::getReaderMgr() const

   942 {

   943     return &fReaderMgr;

   944 }

   945 

   946 inline unsigned int XMLScanner::getSrcOffset() const

   947 {

   948     return fReaderMgr.getSrcOffset();

   949 }

   950 

   951 inline bool XMLScanner::getStandalone() const

   952 {

   953     return fStandalone;

   954 }

   955 

   956 inline XMLScanner::ValSchemes XMLScanner::getValidationScheme() const

   957 {

   958     return fValScheme;

   959 }

   960 

   961 inline const XMLValidator* XMLScanner::getValidator() const

   962 {

   963     return fValidator;

   964 }

   965 

   966 inline XMLValidator* XMLScanner::getValidator()

   967 {

   968     return fValidator;

   969 }

   970 

   971 inline bool XMLScanner::getDoSchema() const

   972 {

   973     return fDoSchema;

   974 }

   975 

   976 inline bool XMLScanner::getValidationSchemaFullChecking() const

   977 {

   978     return fSchemaFullChecking;

   979 }

   980 

   981 inline bool XMLScanner::getIdentityConstraintChecking() const

   982 {

   983     return fIdentityConstraintChecking;

   984 }

   985 

   986 inline int XMLScanner::getErrorCount()

   987 {

   988     return fErrorCount;

   989 }

   990 

   991 inline bool XMLScanner::isValidatorFromUser()

   992 {

   993     return fValidatorFromUser;

   994 }

   995 

   996 inline unsigned int XMLScanner::getEmptyNamespaceId() const

   997 {

   998     return fEmptyNamespaceId;

   999 }

  1000 

  1001 inline unsigned int XMLScanner::getUnknownNamespaceId() const

  1002 {

  1003     return fUnknownNamespaceId;

  1004 }

  1005 

  1006 inline unsigned int XMLScanner::getXMLNamespaceId() const

  1007 {

  1008     return fXMLNamespaceId;

  1009 }

  1010 

  1011 inline unsigned int XMLScanner::getXMLNSNamespaceId() const

  1012 {

  1013     return fXMLNSNamespaceId;

  1014 }

  1015 

  1016 inline const XMLStringPool* XMLScanner::getURIStringPool() const

  1017 {

  1018     return fURIStringPool;

  1019 }

  1020 

  1021 inline XMLStringPool* XMLScanner::getURIStringPool()

  1022 {

  1023     return fURIStringPool;

  1024 }

  1025 

  1026 inline bool XMLScanner::getHasNoDTD() const

  1027 {

  1028     return fHasNoDTD;

  1029 }

  1030 

  1031 inline XMLCh* XMLScanner::getExternalSchemaLocation() const

  1032 {

  1033     return fExternalSchemaLocation;

  1034 }

  1035 

  1036 inline XMLCh* XMLScanner::getExternalNoNamespaceSchemaLocation() const

  1037 {

  1038     return fExternalNoNamespaceSchemaLocation;

  1039 }

  1040 

  1041 inline SecurityManager* XMLScanner::getSecurityManager() const

  1042 {

  1043     return fSecurityManager;

  1044 }

  1045 

  1046 inline bool XMLScanner::getLoadExternalDTD() const

  1047 {

  1048     return fLoadExternalDTD;

  1049 }

  1050 

  1051 inline bool XMLScanner::getNormalizeData() const

  1052 {

  1053     return fNormalizeData;

  1054 }

  1055 

  1056 inline bool XMLScanner::isCachingGrammarFromParse() const

  1057 {

  1058     return fToCacheGrammar;

  1059 }

  1060 

  1061 inline bool XMLScanner::isUsingCachedGrammarInParse() const

  1062 {

  1063     return fUseCachedGrammar;

  1064 }

  1065 

  1066 inline bool XMLScanner::getCalculateSrcOfs() const

  1067 {

  1068     return fCalculateSrcOfs;

  1069 }

  1070 

  1071 inline Grammar* XMLScanner::getRootGrammar() const

  1072 {

  1073     return fRootGrammar;

  1074 }

  1075 

  1076 inline bool XMLScanner::getStandardUriConformant() const

  1077 {

  1078     return fStandardUriConformant;

  1079 }

  1080 

  1081 inline XMLReader::XMLVersion XMLScanner::getXMLVersion() const

  1082 {

  1083 	return fXMLVersion;

  1084 }

  1085 

  1086 inline MemoryManager* XMLScanner::getMemoryManager() const

  1087 {

  1088     return fMemoryManager;

  1089 }

  1090 

  1091 inline ValueVectorOf<PrefMapElem*>* XMLScanner::getNamespaceContext() const

  1092 {

  1093     return fElemStack.getNamespaceMap();

  1094 }

  1095 

  1096 inline unsigned int XMLScanner::getPrefixId(const XMLCh* const prefix) const

  1097 {

  1098     return fElemStack.getPrefixId(prefix);

  1099 }

  1100 

  1101 inline const XMLCh* XMLScanner::getPrefixForId(unsigned int prefId) const

  1102 {

  1103     return fElemStack.getPrefixForId(prefId);

  1104 }

  1105 

  1106 inline bool XMLScanner::getGenerateSyntheticAnnotations() const

  1107 {

  1108     return fGenerateSyntheticAnnotations;

  1109 }

  1110 

  1111 inline bool XMLScanner::getValidateAnnotations() const

  1112 {

  1113     return fValidateAnnotations;

  1114 }

  1115 

  1116 inline bool XMLScanner::getIgnoreCachedDTD() const

  1117 {

  1118     return fIgnoreCachedDTD;

  1119 }

  1120 

  1121 inline bool XMLScanner::getIgnoreAnnotations() const

  1122 {

  1123     return fIgnoreAnnotations;

  1124 }

  1125 

  1126 inline bool XMLScanner::getDisableDefaultEntityResolution() const

  1127 {

  1128     return fDisableDefaultEntityResolution;

  1129 }

  1130 

  1131 inline bool XMLScanner::getSkipDTDValidation() const

  1132 {

  1133     return fSkipDTDValidation;

  1134 }