secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLScanner.hpp
/*
* 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