diff -r 127731b7107d -r 3eebb1e54d3a secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLScanner.hpp --- a/secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLScanner.hpp Fri Jan 22 09:56:12 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1388 +0,0 @@ -/* - * 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -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* getEntityDeclPool() = 0; - virtual const NameIdPool* 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* getIDRefList(); - const RefHashTableOf* 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* 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* fAttrList; - RefHash2KeysTableOf* 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* XMLScanner::getIDRefList() -{ - return fValidationContext->getIdRefList(); -} - -inline const RefHashTableOf* 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* 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 - ( - 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 -