--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLScanner.hpp Fri Jan 22 09:56:12 2010 +0200
@@ -0,0 +1,1388 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * $Id: XMLScanner.hpp 568078 2007-08-21 11:43:25Z amassari $
+ */
+
+#if !defined(XMLSCANNER_HPP)
+#define XMLSCANNER_HPP
+
+#include <xercesc/framework/XMLBufferMgr.hpp>
+#include <xercesc/framework/XMLErrorCodes.hpp>
+#include <xercesc/framework/XMLRefInfo.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/util/NameIdPool.hpp>
+#include <xercesc/util/RefHashTableOf.hpp>
+#include <xercesc/util/SecurityManager.hpp>
+#include <xercesc/internal/ReaderMgr.hpp>
+#include <xercesc/internal/ElemStack.hpp>
+#include <xercesc/validators/DTD/DTDEntityDecl.hpp>
+#include <xercesc/framework/XMLAttr.hpp>
+#include <xercesc/framework/ValidationContext.hpp>
+#include <xercesc/validators/common/GrammarResolver.hpp>
+
+XERCES_CPP_NAMESPACE_BEGIN
+
+class InputSource;
+class XMLDocumentHandler;
+class XMLEntityHandler;
+class ErrorHandler;
+class DocTypeHandler;
+class XMLPScanToken;
+class XMLStringPool;
+class Grammar;
+class XMLValidator;
+class MemoryManager;
+class PSVIHandler;
+
+
+struct PSVIElemContext
+{
+ bool fIsSpecified;
+ bool fErrorOccurred;
+ int fElemDepth;
+ int fFullValidationDepth;
+ int fNoneValidationDepth;
+ DatatypeValidator* fCurrentDV;
+ ComplexTypeInfo* fCurrentTypeInfo;
+ const XMLCh* fNormalizedValue;
+};
+
+// This is the mondo scanner class, which does the vast majority of the
+// work of parsing. It handles reading in input and spitting out events
+// to installed handlers.
+class XMLPARSER_EXPORT XMLScanner : public XMemory, public XMLBufferFullHandler
+{
+public :
+ // -----------------------------------------------------------------------
+ // Public class types
+ //
+ // NOTE: These should really be private, but some of the compilers we
+ // have to deal with are too stupid to understand this.
+ //
+ // DeclTypes
+ // Used by scanXMLDecl() to know what type of decl it should scan.
+ // Text decls have slightly different rules from XMLDecls.
+ //
+ // EntityExpRes
+ // These are the values returned from the entity expansion method,
+ // to indicate how it went.
+ //
+ // XMLTokens
+ // These represent the possible types of input we can get while
+ // scanning content.
+ //
+ // ValScheme
+ // This indicates what the scanner should do in terms of validation.
+ // 'Auto' means if there is any int/ext subset, then validate. Else,
+ // don't.
+ // -----------------------------------------------------------------------
+ enum DeclTypes
+ {
+ Decl_Text
+ , Decl_XML
+ };
+
+ enum EntityExpRes
+ {
+ EntityExp_Pushed
+ , EntityExp_Returned
+ , EntityExp_Failed
+ };
+
+ enum XMLTokens
+ {
+ Token_CData
+ , Token_CharData
+ , Token_Comment
+ , Token_EndTag
+ , Token_EOF
+ , Token_PI
+ , Token_StartTag
+ , Token_Unknown
+ };
+
+ enum ValSchemes
+ {
+ Val_Never
+ , Val_Always
+ , Val_Auto
+ };
+
+
+ // -----------------------------------------------------------------------
+ // Constructors and Destructor
+ // -----------------------------------------------------------------------
+ XMLScanner
+ (
+ XMLValidator* const valToAdopt
+ , GrammarResolver* const grammarResolver
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ XMLScanner
+ (
+ XMLDocumentHandler* const docHandler
+ , DocTypeHandler* const docTypeHandler
+ , XMLEntityHandler* const entityHandler
+ , XMLErrorReporter* const errReporter
+ , XMLValidator* const valToAdopt
+ , GrammarResolver* const grammarResolver
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+ virtual ~XMLScanner();
+
+
+ // -----------------------------------------------------------------------
+ // Error emitter methods
+ // -----------------------------------------------------------------------
+ bool emitErrorWillThrowException(const XMLErrs::Codes toEmit);
+ void emitError(const XMLErrs::Codes toEmit);
+ void emitError
+ (
+ const XMLErrs::Codes toEmit
+ , const XMLCh* const text1
+ , const XMLCh* const text2 = 0
+ , const XMLCh* const text3 = 0
+ , const XMLCh* const text4 = 0
+ );
+ void emitError
+ (
+ const XMLErrs::Codes toEmit
+ , const char* const text1
+ , const char* const text2 = 0
+ , const char* const text3 = 0
+ , const char* const text4 = 0
+ );
+ void emitError
+ (
+ const XMLErrs::Codes toEmit
+ , const XMLExcepts::Codes originalErrorCode
+ , const XMLCh* const text1 = 0
+ , const XMLCh* const text2 = 0
+ , const XMLCh* const text3 = 0
+ , const XMLCh* const text4 = 0
+ );
+
+ // -----------------------------------------------------------------------
+ // Implementation of XMLBufferFullHandler interface
+ // -----------------------------------------------------------------------
+
+ virtual bool bufferFull(XMLBuffer& toSend)
+ {
+ sendCharData(toSend);
+ return true;
+ }
+
+ virtual Grammar::GrammarType getCurrentGrammarType() const;
+
+ // -----------------------------------------------------------------------
+ // Public pure virtual methods
+ // -----------------------------------------------------------------------
+ virtual const XMLCh* getName() const = 0;
+ virtual NameIdPool<DTDEntityDecl>* getEntityDeclPool() = 0;
+ virtual const NameIdPool<DTDEntityDecl>* getEntityDeclPool() const = 0;
+ virtual unsigned int resolveQName
+ (
+ const XMLCh* const qName
+ , XMLBuffer& prefixBufToFill
+ , const short mode
+ , int& prefixColonPos
+ ) = 0;
+ virtual void scanDocument
+ (
+ const InputSource& src
+ ) = 0;
+ virtual bool scanNext(XMLPScanToken& toFill) = 0;
+ virtual Grammar* loadGrammar
+ (
+ const InputSource& src
+ , const short grammarType
+ , const bool toCache = false
+ ) = 0;
+
+ // -----------------------------------------------------------------------
+ // Getter methods
+ // -----------------------------------------------------------------------
+ const XMLDocumentHandler* getDocHandler() const;
+ XMLDocumentHandler* getDocHandler();
+ const DocTypeHandler* getDocTypeHandler() const;
+ DocTypeHandler* getDocTypeHandler();
+ bool getDoNamespaces() const;
+ ValSchemes getValidationScheme() const;
+ bool getDoSchema() const;
+ bool getValidationSchemaFullChecking() const;
+ bool getIdentityConstraintChecking() const;
+ const XMLEntityHandler* getEntityHandler() const;
+ XMLEntityHandler* getEntityHandler();
+ const XMLErrorReporter* getErrorReporter() const;
+ XMLErrorReporter* getErrorReporter();
+ const ErrorHandler* getErrorHandler() const;
+ ErrorHandler* getErrorHandler();
+ const PSVIHandler* getPSVIHandler() const;
+ PSVIHandler* getPSVIHandler();
+ bool getExitOnFirstFatal() const;
+ bool getValidationConstraintFatal() const;
+ RefHashTableOf<XMLRefInfo>* getIDRefList();
+ const RefHashTableOf<XMLRefInfo>* getIDRefList() const;
+
+ ValidationContext* getValidationContext();
+
+ bool getInException() const;
+ /*bool getLastExtLocation
+ (
+ XMLCh* const sysIdToFill
+ , const unsigned int maxSysIdChars
+ , XMLCh* const pubIdToFill
+ , const unsigned int maxPubIdChars
+ , XMLSSize_t& lineToFill
+ , XMLSSize_t& colToFill
+ ) const;*/
+ const Locator* getLocator() const;
+ const ReaderMgr* getReaderMgr() const;
+ unsigned int getSrcOffset() const;
+ bool getStandalone() const;
+ const XMLValidator* getValidator() const;
+ XMLValidator* getValidator();
+ int getErrorCount();
+ const XMLStringPool* getURIStringPool() const;
+ XMLStringPool* getURIStringPool();
+ bool getHasNoDTD() const;
+ XMLCh* getExternalSchemaLocation() const;
+ XMLCh* getExternalNoNamespaceSchemaLocation() const;
+ SecurityManager* getSecurityManager() const;
+ bool getLoadExternalDTD() const;
+ bool getNormalizeData() const;
+ bool isCachingGrammarFromParse() const;
+ bool isUsingCachedGrammarInParse() const;
+ bool getCalculateSrcOfs() const;
+ Grammar* getRootGrammar() const;
+ XMLReader::XMLVersion getXMLVersion() const;
+ MemoryManager* getMemoryManager() const;
+ ValueVectorOf<PrefMapElem*>* getNamespaceContext() const;
+ unsigned int getPrefixId(const XMLCh* const prefix) const;
+ const XMLCh* getPrefixForId(unsigned int prefId) const;
+
+ bool getGenerateSyntheticAnnotations() const;
+ bool getValidateAnnotations() const;
+ bool getIgnoreCachedDTD() const;
+ bool getIgnoreAnnotations() const;
+ bool getDisableDefaultEntityResolution() const;
+ bool getSkipDTDValidation() const;
+
+ // -----------------------------------------------------------------------
+ // Getter methods
+ // -----------------------------------------------------------------------
+ /**
+ * When an attribute name has no prefix, unlike elements, it is not mapped
+ * to the global namespace. So, in order to have something to map it to
+ * for practical purposes, a id for an empty URL is created and used for
+ * such names.
+ *
+ * @return The URL pool id of the URL for an empty URL "".
+ */
+ unsigned int getEmptyNamespaceId() const;
+
+ /**
+ * When a prefix is found that has not been mapped, an error is issued.
+ * However, if the parser has been instructed not to stop on the first
+ * fatal error, it needs to be able to continue. To do so, it will map
+ * that prefix tot his magic unknown namespace id.
+ *
+ * @return The URL pool id of the URL for the unknown prefix
+ * namespace.
+ */
+ unsigned int getUnknownNamespaceId() const;
+
+ /**
+ * The prefix 'xml' is a magic prefix, defined by the XML spec and
+ * requiring no prior definition. This method returns the id for the
+ * intrinsically defined URL for this prefix.
+ *
+ * @return The URL pool id of the URL for the 'xml' prefix.
+ */
+ unsigned int getXMLNamespaceId() const;
+
+ /**
+ * The prefix 'xmlns' is a magic prefix, defined by the namespace spec
+ * and requiring no prior definition. This method returns the id for the
+ * intrinsically defined URL for this prefix.
+ *
+ * @return The URL pool id of the URL for the 'xmlns' prefix.
+ */
+ unsigned int getXMLNSNamespaceId() const;
+
+ /**
+ * This method find the passed URI id in its URI pool and
+ * copy the text of that URI into the passed buffer.
+ */
+ bool getURIText
+ (
+ const unsigned int uriId
+ , XMLBuffer& uriBufToFill
+ ) const;
+
+ const XMLCh* getURIText(const unsigned int uriId) const;
+
+ /* tell if the validator comes from user */
+ bool isValidatorFromUser();
+
+ /* tell if standard URI are forced */
+ bool getStandardUriConformant() const;
+
+ // -----------------------------------------------------------------------
+ // Setter methods
+ // -----------------------------------------------------------------------
+ void setDocHandler(XMLDocumentHandler* const docHandler);
+ void setDocTypeHandler(DocTypeHandler* const docTypeHandler);
+ void setDoNamespaces(const bool doNamespaces);
+ void setEntityHandler(XMLEntityHandler* const docTypeHandler);
+ void setErrorReporter(XMLErrorReporter* const errHandler);
+ void setErrorHandler(ErrorHandler* const handler);
+ void setPSVIHandler(PSVIHandler* const handler);
+ void setURIStringPool(XMLStringPool* const stringPool);
+ void setExitOnFirstFatal(const bool newValue);
+ void setValidationConstraintFatal(const bool newValue);
+ void setValidationScheme(const ValSchemes newScheme);
+ void setValidator(XMLValidator* const valToAdopt);
+ void setDoSchema(const bool doSchema);
+ void setValidationSchemaFullChecking(const bool schemaFullChecking);
+ void setIdentityConstraintChecking(const bool identityConstraintChecking);
+ void setHasNoDTD(const bool hasNoDTD);
+ void cacheGrammarFromParse(const bool newValue);
+ void useCachedGrammarInParse(const bool newValue);
+ void setRootElemName(XMLCh* rootElemName);
+ void setExternalSchemaLocation(const XMLCh* const schemaLocation);
+ void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
+ void setExternalSchemaLocation(const char* const schemaLocation);
+ void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
+ void setSecurityManager(SecurityManager* const securityManager);
+ void setLoadExternalDTD(const bool loadDTD);
+ void setNormalizeData(const bool normalizeData);
+ void setCalculateSrcOfs(const bool newValue);
+ void setParseSettings(XMLScanner* const refScanner);
+ void setStandardUriConformant(const bool newValue);
+ void setInputBufferSize(const size_t bufferSize);
+
+ void setGenerateSyntheticAnnotations(const bool newValue);
+ void setValidateAnnotations(const bool newValue);
+ void setIgnoredCachedDTD(const bool newValue);
+ void setIgnoreAnnotations(const bool newValue);
+ void setDisableDefaultEntityResolution(const bool newValue);
+ void setSkipDTDValidation(const bool newValue);
+
+ // -----------------------------------------------------------------------
+ // Mutator methods
+ // -----------------------------------------------------------------------
+ void incrementErrorCount(void); // For use by XMLValidator
+
+ // -----------------------------------------------------------------------
+ // Deprecated methods as of 3.2.0. Use getValidationScheme() and
+ // setValidationScheme() instead.
+ // -----------------------------------------------------------------------
+ bool getDoValidation() const;
+ void setDoValidation(const bool validate);
+
+ // -----------------------------------------------------------------------
+ // Document scanning methods
+ //
+ // scanDocument() does the entire source document. scanFirst(),
+ // scanNext(), and scanReset() support a progressive parse.
+ // -----------------------------------------------------------------------
+ void scanDocument
+ (
+ const XMLCh* const systemId
+ );
+ void scanDocument
+ (
+ const char* const systemId
+ );
+
+ bool scanFirst
+ (
+ const InputSource& src
+ , XMLPScanToken& toFill
+ );
+ bool scanFirst
+ (
+ const XMLCh* const systemId
+ , XMLPScanToken& toFill
+ );
+ bool scanFirst
+ (
+ const char* const systemId
+ , XMLPScanToken& toFill
+ );
+
+ void scanReset(XMLPScanToken& toFill);
+
+ bool checkXMLDecl(bool startWithAngle);
+
+ // -----------------------------------------------------------------------
+ // Grammar preparsing methods
+ // -----------------------------------------------------------------------
+ Grammar* loadGrammar
+ (
+ const XMLCh* const systemId
+ , const short grammarType
+ , const bool toCache = false
+ );
+ Grammar* loadGrammar
+ (
+ const char* const systemId
+ , const short grammarType
+ , const bool toCache = false
+ );
+
+ // -----------------------------------------------------------------------
+ // Notification that lazy data has been deleted
+ // -----------------------------------------------------------------------
+ static void reinitScannerMutex();
+ static void reinitMsgLoader();
+
+protected:
+ // -----------------------------------------------------------------------
+ // Protected pure virtual methods
+ // -----------------------------------------------------------------------
+ virtual void scanCDSection() = 0;
+ virtual void scanCharData(XMLBuffer& toToUse) = 0;
+ virtual EntityExpRes scanEntityRef
+ (
+ const bool inAttVal
+ , XMLCh& firstCh
+ , XMLCh& secondCh
+ , bool& escaped
+ ) = 0;
+ virtual void scanDocTypeDecl() = 0;
+ virtual void scanReset(const InputSource& src) = 0;
+ virtual void sendCharData(XMLBuffer& toSend) = 0;
+
+ //return owned by the caller
+ virtual InputSource* resolveSystemId(const XMLCh* const /*sysId*/
+ ,const XMLCh* const /*pubId*/) {return 0;};
+
+ // -----------------------------------------------------------------------
+ // Protected scanning methods
+ // -----------------------------------------------------------------------
+ bool scanCharRef(XMLCh& toFill, XMLCh& second);
+ void scanComment();
+ bool scanEq(bool inDecl = false);
+ void scanMiscellaneous();
+ void scanPI();
+ void scanProlog();
+ void scanXMLDecl(const DeclTypes type);
+
+ // -----------------------------------------------------------------------
+ // Private helper methods
+ // -----------------------------------------------------------------------
+ void checkInternalDTD(bool hasExtSubset, const XMLCh* const sysId, const XMLCh* const pubId);
+ void checkIDRefs();
+ bool isLegalToken(const XMLPScanToken& toCheck);
+ XMLTokens senseNextToken(unsigned int& orgReader);
+ void initValidator(XMLValidator* theValidator);
+ inline void resetValidationContext();
+ unsigned int *getNewUIntPtr();
+ void resetUIntPool();
+ void recreateUIntPool();
+
+ inline
+ void setAttrDupChkRegistry
+ (
+ const unsigned int &attrNumber
+ , bool &toUseHashTable
+ );
+
+ // -----------------------------------------------------------------------
+ // Data members
+ //
+ // fBufferSize
+ // Maximum input buffer size
+ //
+ // fAttrList
+ // Every time we get a new element start tag, we have to pass to
+ // the document handler the attributes found. To make it more
+ // efficient we keep this ref vector of XMLAttr objects around. We
+ // just reuse it over and over, allowing it to grow to meet the
+ // peak need.
+ //
+ // fBufMgr
+ // This is a manager for temporary buffers used during scanning.
+ // For efficiency we must use a set of static buffers, but we have
+ // to insure that they are not incorrectly reused. So this manager
+ // provides the smarts to hand out buffers as required.
+ //
+ // fDocHandler
+ // The client code's document handler. If zero, then no document
+ // handler callouts are done. We don't adopt it.
+ //
+ // fDocTypeHandler
+ // The client code's document type handler (used by DTD Validator).
+ //
+ // fDoNamespaces
+ // This flag indicates whether the client code wants us to do
+ // namespaces or not. If the installed validator indicates that it
+ // has to do namespaces, then this is ignored.
+ //
+ // fEntityHandler
+ // The client code's entity handler. If zero, then no entity handler
+ // callouts are done. We don't adopt it.
+ //
+ // fErrorReporter
+ // The client code's error reporter. If zero, then no error reporter
+ // callouts are done. We don't adopt it.
+ //
+ // fErrorHandler
+ // The client code's error handler. Need to store this info for
+ // Schema parse error handling.
+ //
+ // fPSVIHandler
+ // The client code's PSVI handler.
+ //
+ // fExitOnFirstFatal
+ // This indicates whether we bail out on the first fatal XML error
+ // or not. It defaults to true, which is the strict XML way, but it
+ // can be changed.
+ //
+ // fValidationConstraintFatal
+ // This indicates whether we treat validation constraint errors as
+ // fatal errors or not. It defaults to false, but it can be changed.
+ //
+ // fIDRefList
+ // This is a list of XMLRefInfo objects. This member lets us do all
+ // needed ID-IDREF balancing checks.
+ //
+ // fInException
+ // To avoid a circular freakout when we catch an exception and emit
+ // it, which would normally throw again if the 'fail on first error'
+ // flag is one.
+ //
+ // fReaderMgr
+ // This is the reader manager, from which we get characters. It
+ // manages the reader stack for us, and provides a lot of convenience
+ // methods to do specialized checking for chars, sequences of chars,
+ // skipping chars, etc...
+ //
+ // fScannerId
+ // fSequenceId
+ // These are used for progressive parsing, to make sure that the
+ // client code does the right thing at the right time.
+ //
+ // fStandalone
+ // Indicates whether the document is standalone or not. Defaults to
+ // no, but can be overridden in the XMLDecl.
+ //
+ // fHasNoDTD
+ // Indicates the document has no DTD or has only an internal DTD subset
+ // which contains no parameter entity references.
+ //
+ // fValidate
+ // Indicates whether any validation should be done. This is defined
+ // by the existence of a Grammar together with fValScheme.
+ //
+ // fValidator
+ // The installed validator. We look at them via the abstract
+ // validator interface, and don't know what it actual is.
+ // Either point to user's installed validator, or fDTDValidator
+ // or fSchemaValidator.
+ //
+ // fValidatorFromUser
+ // This flag indicates whether the validator was installed from
+ // user. If false, then the validator was created by the Scanner.
+ //
+ // fValScheme
+ // This is the currently set validation scheme. It defaults to
+ // 'never', but can be set by the client.
+ //
+ // fErrorCount
+ // The number of errors we've encountered.
+ //
+ // fDoSchema
+ // This flag indicates whether the client code wants Schema to
+ // be processed or not.
+ //
+ // fSchemaFullChecking
+ // This flag indicates whether the client code wants full Schema
+ // constraint checking.
+ //
+ // fIdentityConstraintChecking
+ // This flag indicates whether the client code wants Identity
+ // Constraint checking, defaulted to true to maintain backward
+ // compatibility (to minimize supprise)
+ //
+ // fAttName
+ // fAttValue
+ // fCDataBuf
+ // fNameBuf
+ // fQNameBuf
+ // fPrefixBuf
+ // For the most part, buffers are obtained from the fBufMgr object
+ // on the fly. However, for the start tag scan, we have a set of
+ // fixed buffers for performance reasons. These are used a lot and
+ // there are a number of them, so asking the buffer manager each
+ // time for new buffers is a bit too much overhead.
+ //
+ // fEmptyNamespaceId
+ // This is the id of the empty namespace URI. This is a special one
+ // because of the xmlns="" type of deal. We have to quickly sense
+ // that its the empty namespace.
+ //
+ // fUnknownNamespaceId
+ // This is the id of the namespace URI which is assigned to the
+ // global namespace. Its for debug purposes only, since there is no
+ // real global namespace URI. Its set by the derived class.
+ //
+ // fXMLNamespaceId
+ // fXMLNSNamespaceId
+ // These are the ids of the namespace URIs which are assigned to the
+ // 'xml' and 'xmlns' special prefixes. The former is officially
+ // defined but the latter is not, so we just provide one for debug
+ // purposes.
+ //
+ // fSchemaNamespaceId
+ // This is the id of the schema namespace URI.
+ //
+ // fGrammarResolver
+ // Grammar Pool that stores all the grammars. Key is namespace for
+ // schema and system id for external DTD. When caching a grammar, if
+ // a grammar is already in the pool, it will be replaced with the
+ // new parsed one.
+ //
+ // fGrammar
+ // Current Grammar used by the Scanner and Validator
+ //
+ // fRootGrammar
+ // The grammar where the root element is declared.
+ //
+ // fGrammarType
+ // Current Grammar Type. Store this value instead of calling getGrammarType
+ // all the time for faster performance.
+ //
+ // fURIStringPool
+ // This is a pool for URIs with unique ids assigned. We use a standard
+ // string pool class. This pool is going to be shared by all Grammar.
+ // Use only if namespace is turned on.
+ //
+ // fRootElemName
+ // No matter we are using DTD or Schema Grammar, if a DOCTYPE exists,
+ // we need to verify the root element name. So store the rootElement
+ // that is used in the DOCTYPE in the Scanner instead of in the DTDGrammar
+ // where it used to
+ //
+ // fExternalSchemaLocation
+ // The list of Namespace/SchemaLocation that was specified externally
+ // using setExternalSchemaLocation.
+ //
+ // fExternalNoNamespaceSchemaLocation
+ // The no target namespace XML Schema Location that was specified
+ // externally using setExternalNoNamespaceSchemaLocation.
+ //
+ // fSecurityManager
+ // The SecurityManager instance; as and when set by the application.
+ //
+ // fEntityExpansionLimit
+ // The number of entity expansions to be permitted while processing this document
+ // Only meaningful when fSecurityManager != 0
+ //
+ // fEntityExpansionCount
+ // The number of general entities expanded so far in this document.
+ // Only meaningful when fSecurityManager != null
+ //
+ // fLoadExternalDTD
+ // This flag indicates whether the external DTD be loaded or not
+ //
+ // fNormalizeData
+ // This flag indicates whether the parser should perform datatype
+ // normalization that is defined in the schema.
+ //
+ // fCalculateSrcOfs
+ // This flag indicates the parser should calculate the source offset.
+ // Turning this on may impact performance.
+ //
+ // fStandardUriConformant
+ // This flag controls whether we force conformant URI
+ //
+ // fXMLVersion
+ // Enum to indicate if the main doc is XML 1.1 or XML 1.0 conformant
+ // fUIntPool
+ // pool of unsigned integers to help with duplicate attribute
+ // detection and filling in default/fixed attributes
+ // fUIntPoolRow
+ // current row in fUIntPool
+ // fUIntPoolCol
+ // current column i row
+ // fUIntPoolRowTotal
+ // total number of rows in table
+ //
+ // fMemoryManager
+ // Pluggable memory manager for dynamic allocation/deallocation.
+ //
+ // -----------------------------------------------------------------------
+ size_t fBufferSize;
+ bool fStandardUriConformant;
+ bool fCalculateSrcOfs;
+ bool fDoNamespaces;
+ bool fExitOnFirstFatal;
+ bool fValidationConstraintFatal;
+ bool fInException;
+ bool fStandalone;
+ bool fHasNoDTD;
+ bool fValidate;
+ bool fValidatorFromUser;
+ bool fDoSchema;
+ bool fSchemaFullChecking;
+ bool fIdentityConstraintChecking;
+ bool fToCacheGrammar;
+ bool fUseCachedGrammar;
+ bool fLoadExternalDTD;
+ bool fNormalizeData;
+ bool fGenerateSyntheticAnnotations;
+ bool fValidateAnnotations;
+ bool fIgnoreCachedDTD;
+ bool fIgnoreAnnotations;
+ bool fDisableDefaultEntityResolution;
+ bool fSkipDTDValidation;
+ int fErrorCount;
+ unsigned int fEntityExpansionLimit;
+ unsigned int fEntityExpansionCount;
+ unsigned int fEmptyNamespaceId;
+ unsigned int fUnknownNamespaceId;
+ unsigned int fXMLNamespaceId;
+ unsigned int fXMLNSNamespaceId;
+ unsigned int fSchemaNamespaceId;
+ unsigned int ** fUIntPool;
+ unsigned int fUIntPoolRow;
+ unsigned int fUIntPoolCol;
+ unsigned int fUIntPoolRowTotal;
+ XMLUInt32 fScannerId;
+ XMLUInt32 fSequenceId;
+ RefVectorOf<XMLAttr>* fAttrList;
+ RefHash2KeysTableOf<XMLAttr>* fAttrDupChkRegistry;
+ XMLDocumentHandler* fDocHandler;
+ DocTypeHandler* fDocTypeHandler;
+ XMLEntityHandler* fEntityHandler;
+ XMLErrorReporter* fErrorReporter;
+ ErrorHandler* fErrorHandler;
+ PSVIHandler* fPSVIHandler;
+ ValidationContext *fValidationContext;
+ bool fEntityDeclPoolRetrieved;
+ ReaderMgr fReaderMgr;
+ XMLValidator* fValidator;
+ ValSchemes fValScheme;
+ GrammarResolver* const fGrammarResolver;
+ MemoryManager* const fGrammarPoolMemoryManager;
+ Grammar* fGrammar;
+ Grammar* fRootGrammar;
+ XMLStringPool* fURIStringPool;
+ XMLCh* fRootElemName;
+ XMLCh* fExternalSchemaLocation;
+ XMLCh* fExternalNoNamespaceSchemaLocation;
+ SecurityManager* fSecurityManager;
+ XMLReader::XMLVersion fXMLVersion;
+ MemoryManager* fMemoryManager;
+ XMLBufferMgr fBufMgr;
+ XMLBuffer fAttNameBuf;
+ XMLBuffer fAttValueBuf;
+ XMLBuffer fCDataBuf;
+ XMLBuffer fQNameBuf;
+ XMLBuffer fPrefixBuf;
+ XMLBuffer fURIBuf;
+ XMLBuffer fWSNormalizeBuf;
+ ElemStack fElemStack;
+
+
+private :
+ // -----------------------------------------------------------------------
+ // Unimplemented constructors and operators
+ // -----------------------------------------------------------------------
+ XMLScanner();
+ XMLScanner(const XMLScanner&);
+ XMLScanner& operator=(const XMLScanner&);
+
+ // -----------------------------------------------------------------------
+ // Private helper methods
+ // -----------------------------------------------------------------------
+ void commonInit();
+ void cleanUp();
+
+ // -----------------------------------------------------------------------
+ // Private scanning methods
+ // -----------------------------------------------------------------------
+ bool getQuotedString(XMLBuffer& toFill);
+ unsigned int scanUpToWSOr
+ (
+ XMLBuffer& toFill
+ , const XMLCh chEndChar
+ );
+};
+
+// ---------------------------------------------------------------------------
+// XMLScanner: Getter methods
+// ---------------------------------------------------------------------------
+inline const XMLDocumentHandler* XMLScanner::getDocHandler() const
+{
+ return fDocHandler;
+}
+
+inline XMLDocumentHandler* XMLScanner::getDocHandler()
+{
+ return fDocHandler;
+}
+
+inline const DocTypeHandler* XMLScanner::getDocTypeHandler() const
+{
+ return fDocTypeHandler;
+}
+
+inline DocTypeHandler* XMLScanner::getDocTypeHandler()
+{
+ return fDocTypeHandler;
+}
+
+inline bool XMLScanner::getDoNamespaces() const
+{
+ return fDoNamespaces;
+}
+
+inline const XMLEntityHandler* XMLScanner::getEntityHandler() const
+{
+ return fEntityHandler;
+}
+
+inline XMLEntityHandler* XMLScanner::getEntityHandler()
+{
+ return fEntityHandler;
+}
+
+inline const XMLErrorReporter* XMLScanner::getErrorReporter() const
+{
+ return fErrorReporter;
+}
+
+inline XMLErrorReporter* XMLScanner::getErrorReporter()
+{
+ return fErrorReporter;
+}
+
+inline const ErrorHandler* XMLScanner::getErrorHandler() const
+{
+ return fErrorHandler;
+}
+
+inline ErrorHandler* XMLScanner::getErrorHandler()
+{
+ return fErrorHandler;
+}
+
+inline const PSVIHandler* XMLScanner::getPSVIHandler() const
+{
+ return fPSVIHandler;
+}
+
+inline PSVIHandler* XMLScanner::getPSVIHandler()
+{
+ return fPSVIHandler;
+}
+
+inline bool XMLScanner::getExitOnFirstFatal() const
+{
+ return fExitOnFirstFatal;
+}
+
+inline bool XMLScanner::getValidationConstraintFatal() const
+{
+ return fValidationConstraintFatal;
+}
+
+inline bool XMLScanner::getInException() const
+{
+ return fInException;
+}
+
+inline RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList()
+{
+ return fValidationContext->getIdRefList();
+}
+
+inline const RefHashTableOf<XMLRefInfo>* XMLScanner::getIDRefList() const
+{
+ return fValidationContext->getIdRefList();
+}
+
+inline ValidationContext* XMLScanner::getValidationContext()
+{
+ if (!fEntityDeclPoolRetrieved)
+ {
+ fValidationContext->setEntityDeclPool(getEntityDeclPool());
+ fEntityDeclPoolRetrieved = true;
+ }
+
+ return fValidationContext;
+}
+
+inline const Locator* XMLScanner::getLocator() const
+{
+ return &fReaderMgr;
+}
+
+inline const ReaderMgr* XMLScanner::getReaderMgr() const
+{
+ return &fReaderMgr;
+}
+
+inline unsigned int XMLScanner::getSrcOffset() const
+{
+ return fReaderMgr.getSrcOffset();
+}
+
+inline bool XMLScanner::getStandalone() const
+{
+ return fStandalone;
+}
+
+inline XMLScanner::ValSchemes XMLScanner::getValidationScheme() const
+{
+ return fValScheme;
+}
+
+inline const XMLValidator* XMLScanner::getValidator() const
+{
+ return fValidator;
+}
+
+inline XMLValidator* XMLScanner::getValidator()
+{
+ return fValidator;
+}
+
+inline bool XMLScanner::getDoSchema() const
+{
+ return fDoSchema;
+}
+
+inline bool XMLScanner::getValidationSchemaFullChecking() const
+{
+ return fSchemaFullChecking;
+}
+
+inline bool XMLScanner::getIdentityConstraintChecking() const
+{
+ return fIdentityConstraintChecking;
+}
+
+inline int XMLScanner::getErrorCount()
+{
+ return fErrorCount;
+}
+
+inline bool XMLScanner::isValidatorFromUser()
+{
+ return fValidatorFromUser;
+}
+
+inline unsigned int XMLScanner::getEmptyNamespaceId() const
+{
+ return fEmptyNamespaceId;
+}
+
+inline unsigned int XMLScanner::getUnknownNamespaceId() const
+{
+ return fUnknownNamespaceId;
+}
+
+inline unsigned int XMLScanner::getXMLNamespaceId() const
+{
+ return fXMLNamespaceId;
+}
+
+inline unsigned int XMLScanner::getXMLNSNamespaceId() const
+{
+ return fXMLNSNamespaceId;
+}
+
+inline const XMLStringPool* XMLScanner::getURIStringPool() const
+{
+ return fURIStringPool;
+}
+
+inline XMLStringPool* XMLScanner::getURIStringPool()
+{
+ return fURIStringPool;
+}
+
+inline bool XMLScanner::getHasNoDTD() const
+{
+ return fHasNoDTD;
+}
+
+inline XMLCh* XMLScanner::getExternalSchemaLocation() const
+{
+ return fExternalSchemaLocation;
+}
+
+inline XMLCh* XMLScanner::getExternalNoNamespaceSchemaLocation() const
+{
+ return fExternalNoNamespaceSchemaLocation;
+}
+
+inline SecurityManager* XMLScanner::getSecurityManager() const
+{
+ return fSecurityManager;
+}
+
+inline bool XMLScanner::getLoadExternalDTD() const
+{
+ return fLoadExternalDTD;
+}
+
+inline bool XMLScanner::getNormalizeData() const
+{
+ return fNormalizeData;
+}
+
+inline bool XMLScanner::isCachingGrammarFromParse() const
+{
+ return fToCacheGrammar;
+}
+
+inline bool XMLScanner::isUsingCachedGrammarInParse() const
+{
+ return fUseCachedGrammar;
+}
+
+inline bool XMLScanner::getCalculateSrcOfs() const
+{
+ return fCalculateSrcOfs;
+}
+
+inline Grammar* XMLScanner::getRootGrammar() const
+{
+ return fRootGrammar;
+}
+
+inline bool XMLScanner::getStandardUriConformant() const
+{
+ return fStandardUriConformant;
+}
+
+inline XMLReader::XMLVersion XMLScanner::getXMLVersion() const
+{
+ return fXMLVersion;
+}
+
+inline MemoryManager* XMLScanner::getMemoryManager() const
+{
+ return fMemoryManager;
+}
+
+inline ValueVectorOf<PrefMapElem*>* XMLScanner::getNamespaceContext() const
+{
+ return fElemStack.getNamespaceMap();
+}
+
+inline unsigned int XMLScanner::getPrefixId(const XMLCh* const prefix) const
+{
+ return fElemStack.getPrefixId(prefix);
+}
+
+inline const XMLCh* XMLScanner::getPrefixForId(unsigned int prefId) const
+{
+ return fElemStack.getPrefixForId(prefId);
+}
+
+inline bool XMLScanner::getGenerateSyntheticAnnotations() const
+{
+ return fGenerateSyntheticAnnotations;
+}
+
+inline bool XMLScanner::getValidateAnnotations() const
+{
+ return fValidateAnnotations;
+}
+
+inline bool XMLScanner::getIgnoreCachedDTD() const
+{
+ return fIgnoreCachedDTD;
+}
+
+inline bool XMLScanner::getIgnoreAnnotations() const
+{
+ return fIgnoreAnnotations;
+}
+
+inline bool XMLScanner::getDisableDefaultEntityResolution() const
+{
+ return fDisableDefaultEntityResolution;
+}
+
+inline bool XMLScanner::getSkipDTDValidation() const
+{
+ return fSkipDTDValidation;
+}
+
+// ---------------------------------------------------------------------------
+// XMLScanner: Setter methods
+// ---------------------------------------------------------------------------
+inline void XMLScanner::setDocHandler(XMLDocumentHandler* const docHandler)
+{
+ fDocHandler = docHandler;
+}
+
+inline void XMLScanner::setDocTypeHandler(DocTypeHandler* const docTypeHandler)
+{
+ fDocTypeHandler = docTypeHandler;
+}
+
+inline void XMLScanner::setErrorHandler(ErrorHandler* const handler)
+{
+ fErrorHandler = handler;
+}
+
+inline void XMLScanner::setPSVIHandler(PSVIHandler* const handler)
+{
+ fPSVIHandler = handler;
+}
+
+inline void XMLScanner::setEntityHandler(XMLEntityHandler* const entityHandler)
+{
+ fEntityHandler = entityHandler;
+ fReaderMgr.setEntityHandler(entityHandler);
+}
+
+inline void XMLScanner::setErrorReporter(XMLErrorReporter* const errHandler)
+{
+ fErrorReporter = errHandler;
+}
+
+inline void XMLScanner::setExitOnFirstFatal(const bool newValue)
+{
+ fExitOnFirstFatal = newValue;
+}
+
+
+inline void XMLScanner::setValidationConstraintFatal(const bool newValue)
+{
+ fValidationConstraintFatal = newValue;
+}
+
+inline void XMLScanner::setValidationScheme(const ValSchemes newScheme)
+{
+ fValScheme = newScheme;
+
+ // validation flag for Val_Auto is set to false by default,
+ // and will be turned to true if a grammar is seen
+ if (fValScheme == Val_Always)
+ fValidate = true;
+ else
+ fValidate = false;
+}
+
+inline void XMLScanner::setDoSchema(const bool doSchema)
+{
+ fDoSchema = doSchema;
+}
+
+inline void XMLScanner::setDoNamespaces(const bool doNamespaces)
+{
+ fDoNamespaces = doNamespaces;
+}
+
+inline void XMLScanner::setValidationSchemaFullChecking(const bool schemaFullChecking)
+{
+ fSchemaFullChecking = schemaFullChecking;
+}
+
+inline void XMLScanner::setIdentityConstraintChecking(const bool identityConstraintChecking)
+{
+ fIdentityConstraintChecking = identityConstraintChecking;
+}
+
+inline void XMLScanner::setHasNoDTD(const bool hasNoDTD)
+{
+ fHasNoDTD = hasNoDTD;
+}
+
+inline void XMLScanner::setRootElemName(XMLCh* rootElemName)
+{
+ fMemoryManager->deallocate(fRootElemName);//delete [] fRootElemName;
+ fRootElemName = XMLString::replicate(rootElemName, fMemoryManager);
+}
+
+inline void XMLScanner::setExternalSchemaLocation(const XMLCh* const schemaLocation)
+{
+ fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
+ fExternalSchemaLocation = XMLString::replicate(schemaLocation, fMemoryManager);
+}
+
+inline void XMLScanner::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
+{
+ fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
+ fExternalNoNamespaceSchemaLocation = XMLString::replicate(noNamespaceSchemaLocation, fMemoryManager);
+}
+
+inline void XMLScanner::setExternalSchemaLocation(const char* const schemaLocation)
+{
+ fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
+ fExternalSchemaLocation = XMLString::transcode(schemaLocation, fMemoryManager);
+}
+
+inline void XMLScanner::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
+{
+ fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
+ fExternalNoNamespaceSchemaLocation = XMLString::transcode(noNamespaceSchemaLocation, fMemoryManager);
+}
+
+inline void XMLScanner::setSecurityManager(SecurityManager* const securityManager)
+{
+ fSecurityManager = securityManager;
+ if(securityManager != 0)
+ {
+ fEntityExpansionLimit = securityManager->getEntityExpansionLimit();
+ fEntityExpansionCount = 0;
+ }
+}
+
+inline void XMLScanner::setLoadExternalDTD(const bool loadDTD)
+{
+ fLoadExternalDTD = loadDTD;
+}
+
+inline void XMLScanner::setNormalizeData(const bool normalizeData)
+{
+ fNormalizeData = normalizeData;
+}
+
+inline void XMLScanner::cacheGrammarFromParse(const bool newValue)
+{
+ fToCacheGrammar = newValue;
+}
+
+inline void XMLScanner::useCachedGrammarInParse(const bool newValue)
+{
+ fUseCachedGrammar = newValue;
+}
+
+inline void XMLScanner::setCalculateSrcOfs(const bool newValue)
+{
+ fCalculateSrcOfs = newValue;
+}
+
+inline void XMLScanner::setStandardUriConformant(const bool newValue)
+{
+ fStandardUriConformant = newValue;
+ fReaderMgr.setStandardUriConformant(newValue);
+}
+
+inline void XMLScanner::setGenerateSyntheticAnnotations(const bool newValue)
+{
+ fGenerateSyntheticAnnotations = newValue;
+}
+
+inline void XMLScanner::setValidateAnnotations(const bool newValue)
+{
+ fValidateAnnotations = newValue;
+}
+
+inline void XMLScanner::setInputBufferSize(const size_t bufferSize)
+{
+ fBufferSize = bufferSize;
+ fCDataBuf.setFullHandler(this, (unsigned int)fBufferSize);
+}
+
+inline void XMLScanner::setIgnoredCachedDTD(const bool newValue)
+{
+ fIgnoreCachedDTD = newValue;
+}
+
+inline void XMLScanner::setIgnoreAnnotations(const bool newValue)
+{
+ fIgnoreAnnotations = newValue;
+}
+
+inline void XMLScanner::setDisableDefaultEntityResolution(const bool newValue)
+{
+ fDisableDefaultEntityResolution = newValue;
+}
+
+inline void XMLScanner::setSkipDTDValidation(const bool newValue)
+{
+ fSkipDTDValidation = newValue;
+}
+
+// ---------------------------------------------------------------------------
+// XMLScanner: Mutator methods
+// ---------------------------------------------------------------------------
+inline void XMLScanner::incrementErrorCount()
+{
+ ++fErrorCount;
+}
+
+// ---------------------------------------------------------------------------
+// XMLScanner: Deprecated methods
+// ---------------------------------------------------------------------------
+inline bool XMLScanner::getDoValidation() const
+{
+ return fValidate;
+}
+
+inline void XMLScanner::setDoValidation(const bool validate)
+{
+ fValidate = validate;
+ if (fValidate)
+ fValScheme = Val_Always;
+ else
+ fValScheme = Val_Never;
+}
+
+inline void XMLScanner::resetValidationContext()
+{
+ fValidationContext->clearIdRefList();
+ fValidationContext->setEntityDeclPool(0);
+ fEntityDeclPoolRetrieved = false;
+}
+
+inline void XMLScanner::setAttrDupChkRegistry(const unsigned int &attrNumber
+ , bool &toUseHashTable)
+{
+ // once the attribute exceed 100, we use hash table to check duplication
+ if (attrNumber > 100)
+ {
+ toUseHashTable = true;
+
+ if (!fAttrDupChkRegistry)
+ {
+ fAttrDupChkRegistry = new (fMemoryManager) RefHash2KeysTableOf<XMLAttr>
+ (
+ 2*attrNumber+1, false, new (fMemoryManager)HashXMLCh(), fMemoryManager
+ );
+ }
+ else
+ {
+ fAttrDupChkRegistry->removeAll();
+ }
+ }
+
+}
+
+inline Grammar::GrammarType XMLScanner::getCurrentGrammarType() const
+{
+ return Grammar::UnKnown;
+}
+
+XERCES_CPP_NAMESPACE_END
+
+#endif
+