| /* |
| * 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 |
| |
