--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/ReaderMgr.hpp Fri Jan 22 09:56:12 2010 +0200
@@ -0,0 +1,436 @@
+/*
+ * 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: ReaderMgr.hpp 568078 2007-08-21 11:43:25Z amassari $
+ */
+
+#if !defined(READERMGR_HPP)
+#define READERMGR_HPP
+
+#include <xercesc/internal/XMLReader.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/util/RefStackOf.hpp>
+#include <xercesc/sax/Locator.hpp>
+#include <xercesc/framework/XMLBuffer.hpp>
+
+XERCES_CPP_NAMESPACE_BEGIN
+
+class XMLEntityDecl;
+class XMLEntityHandler;
+class XMLDocumentHandler;
+class XMLScanner;
+
+
+// ---------------------------------------------------------------------------
+// This class is used by the scanner. The scanner must deal with expansion
+// of entities, some of which are totally different files (external parsed
+// entities.) It does so by pushing readers onto a stack. The top reader is
+// the one it wants to read out of, but that one must be popped when it is
+// empty. To keep that logic from being all over the place, the scanner
+// talks to the reader manager, which handles the stack and popping off
+// used up readers.
+// ---------------------------------------------------------------------------
+class XMLPARSER_EXPORT ReaderMgr : public XMemory
+ , public Locator
+{
+public :
+ // -----------------------------------------------------------------------
+ // Class specific types
+ // -----------------------------------------------------------------------
+ struct LastExtEntityInfo : public XMemory
+ {
+ const XMLCh* systemId;
+ const XMLCh* publicId;
+ XMLSSize_t lineNumber;
+ XMLSSize_t colNumber;
+ };
+
+
+ // -----------------------------------------------------------------------
+ // Constructors and Destructor
+ // -----------------------------------------------------------------------
+ ReaderMgr(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
+ ~ReaderMgr();
+
+
+ // -----------------------------------------------------------------------
+ // Convenience scanning methods
+ //
+ // This are all convenience methods that work in terms of the core
+ // character spooling methods.
+ // -----------------------------------------------------------------------
+ bool atEOF() const;
+ bool getName(XMLBuffer& toFill);
+ bool getQName(XMLBuffer& toFill, int* colonPosition);
+ bool getNameToken(XMLBuffer& toFill);
+ XMLCh getNextChar();
+ bool getNextCharIfNot(const XMLCh chNotToGet, XMLCh& chGotten);
+ void movePlainContentChars(XMLBuffer &dest);
+ void getSpaces(XMLBuffer& toFill);
+ void getUpToCharOrWS(XMLBuffer& toFill, const XMLCh toCheck);
+ bool isEmpty() const;
+ bool lookingAtChar(const XMLCh toCheck);
+ bool lookingAtSpace();
+ XMLCh peekNextChar();
+ bool skipIfQuote(XMLCh& chGotten);
+ void skipPastChar(const XMLCh toSkip);
+ bool skipPastSpaces(bool inDecl = false);
+ void skipToChar(const XMLCh toSkipTo);
+ bool skippedChar(const XMLCh toSkip);
+ bool skippedSpace();
+ bool skippedString(const XMLCh* const toSkip);
+ void skipQuotedString(const XMLCh quoteCh);
+ XMLCh skipUntilIn(const XMLCh* const listToSkip);
+ XMLCh skipUntilInOrWS(const XMLCh* const listToSkip);
+ bool peekString(const XMLCh* const toPeek);
+
+
+ // -----------------------------------------------------------------------
+ // Control methods
+ // -----------------------------------------------------------------------
+ void cleanStackBackTo(const unsigned int readerNum);
+ XMLReader* createReader
+ (
+ const InputSource& src
+ , const bool xmlDecl
+ , const XMLReader::RefFrom refFrom
+ , const XMLReader::Types type
+ , const XMLReader::Sources source
+ , const bool calcSrsOfs = true
+ );
+ XMLReader* createReader
+ (
+ const XMLCh* const sysId
+ , const XMLCh* const pubId
+ , const bool xmlDecl
+ , const XMLReader::RefFrom refFrom
+ , const XMLReader::Types type
+ , const XMLReader::Sources source
+ , InputSource*& srcToFill
+ , const bool calcSrcOfs = true
+ , const bool disableDefaultEntityResolution = false
+ );
+ XMLReader* createReader
+ (
+ const XMLCh* const baseURI
+ , const XMLCh* const sysId
+ , const XMLCh* const pubId
+ , const bool xmlDecl
+ , const XMLReader::RefFrom refFrom
+ , const XMLReader::Types type
+ , const XMLReader::Sources source
+ , InputSource*& srcToFill
+ , const bool calcSrcOfs = true
+ , const bool disableDefaultEntityResolution = false
+ );
+ XMLReader* createIntEntReader
+ (
+ const XMLCh* const sysId
+ , const XMLReader::RefFrom refFrom
+ , const XMLReader::Types type
+ , const XMLCh* const dataBuf
+ , const unsigned int dataLen
+ , const bool copyBuf
+ , const bool calcSrcOfs = true
+ );
+ bool isScanningPERefOutOfLiteral() const;
+ bool pushReader
+ (
+ XMLReader* const reader
+ , XMLEntityDecl* const entity
+ );
+ void reset();
+
+
+ // -----------------------------------------------------------------------
+ // Getter methods
+ // -----------------------------------------------------------------------
+ const XMLCh* getCurrentEncodingStr() const;
+ const XMLEntityDecl* getCurrentEntity() const;
+ XMLEntityDecl* getCurrentEntity();
+ const XMLReader* getCurrentReader() const;
+ XMLReader* getCurrentReader();
+ unsigned int getCurrentReaderNum() const;
+ unsigned int getReaderDepth() const;
+ void getLastExtEntityInfo(LastExtEntityInfo& lastInfo) const;
+ unsigned int getSrcOffset() const;
+ bool getThrowEOE() const;
+
+
+ // -----------------------------------------------------------------------
+ // Setter methods
+ // -----------------------------------------------------------------------
+ void setEntityHandler(XMLEntityHandler* const newHandler);
+ void setThrowEOE(const bool newValue);
+ void setXMLVersion(const XMLReader::XMLVersion version);
+ void setStandardUriConformant(const bool newValue);
+
+ // -----------------------------------------------------------------------
+ // Implement the SAX Locator interface
+ // -----------------------------------------------------------------------
+ virtual const XMLCh* getPublicId() const;
+ virtual const XMLCh* getSystemId() const;
+ virtual XMLSSize_t getLineNumber() const;
+ virtual XMLSSize_t getColumnNumber() const;
+
+
+private :
+ // -----------------------------------------------------------------------
+ // Private helper methods
+ // -----------------------------------------------------------------------
+ const XMLReader* getLastExtEntity(const XMLEntityDecl*& itsEntity) const;
+ bool popReader();
+
+ // -----------------------------------------------------------------------
+ // Unimplemented constructors and operators
+ // -----------------------------------------------------------------------
+ ReaderMgr(const ReaderMgr&);
+ ReaderMgr& operator=(const ReaderMgr&);
+
+ // -----------------------------------------------------------------------
+ // Private data members
+ //
+ // fCurEntity
+ // This is the current top of stack entity. We pull it off the stack
+ // and store it here for efficiency.
+ //
+ // fCurReader
+ // This is the current top of stack reader. We pull it off the
+ // stack and store it here for efficiency.
+ //
+ // fEntityHandler
+ // This is the installed entity handler. Its installed via the
+ // scanner but he passes it on to us since we need it the most, in
+ // process of creating external entity readers.
+ //
+ // fEntityStack
+ // We need to keep up with which of the pushed readers are pushed
+ // entity values that are being spooled. This is done to avoid the
+ // problem of recursive definitions. This stack consists of refs to
+ // EntityDecl objects for the pushed entities.
+ //
+ // fNextReaderNum
+ // This is the reader serial number value. Each new reader that is
+ // created from this reader is given a successive number. This lets
+ // us catch things like partial markup errors and such.
+ //
+ // fReaderStack
+ // This is the stack of reader references. We own all the readers
+ // and destroy them when they are used up.
+ //
+ // fThrowEOE
+ // This flag controls whether we throw an exception when we hit an
+ // end of entity. The scanner doesn't really need to know about ends
+ // of entities in the int/ext subsets, so it will turn this flag off
+ // until it gets into the content usually.
+ //
+ // fXMLVersion
+ // Enum to indicate if each Reader should be created as XML 1.1 or
+ // XML 1.0 conformant
+ //
+ // fStandardUriConformant
+ // This flag controls whether we force conformant URI
+ // -----------------------------------------------------------------------
+ XMLEntityDecl* fCurEntity;
+ XMLReader* fCurReader;
+ XMLEntityHandler* fEntityHandler;
+ RefStackOf<XMLEntityDecl>* fEntityStack;
+ unsigned int fNextReaderNum;
+ RefStackOf<XMLReader>* fReaderStack;
+ bool fThrowEOE;
+ XMLReader::XMLVersion fXMLVersion;
+ bool fStandardUriConformant;
+ MemoryManager* fMemoryManager;
+};
+
+
+
+// ---------------------------------------------------------------------------
+// ReaderMgr: Inlined methods
+//
+// NOTE: We cannot put these in alphabetical and type order as we usually
+// do because some of the compilers we have to support are too stupid to
+// understand out of order inlines!
+// ---------------------------------------------------------------------------
+inline unsigned int ReaderMgr::getCurrentReaderNum() const
+{
+ return fCurReader->getReaderNum();
+}
+
+inline const XMLReader* ReaderMgr::getCurrentReader() const
+{
+ return fCurReader;
+}
+
+inline XMLReader* ReaderMgr::getCurrentReader()
+{
+ return fCurReader;
+}
+
+inline bool ReaderMgr::getName(XMLBuffer& toFill)
+{
+ toFill.reset();
+ return fCurReader->getName(toFill, false);
+}
+
+inline bool ReaderMgr::getQName(XMLBuffer& toFill, int *colonPosition)
+{
+ toFill.reset();
+ return fCurReader->getQName(toFill, colonPosition);
+}
+
+inline bool ReaderMgr::getNameToken(XMLBuffer& toFill)
+{
+ toFill.reset();
+ return fCurReader->getName(toFill, true);
+}
+
+inline bool ReaderMgr::getNextCharIfNot(const XMLCh chNotToGet, XMLCh& chGotten)
+{
+ return fCurReader->getNextCharIfNot(chNotToGet, chGotten);
+}
+
+inline void ReaderMgr::movePlainContentChars(XMLBuffer &dest)
+{
+ fCurReader->movePlainContentChars(dest);
+}
+
+inline bool ReaderMgr::getThrowEOE() const
+{
+ return fThrowEOE;
+}
+
+inline unsigned int ReaderMgr::getSrcOffset() const
+{
+ return fCurReader? fCurReader->getSrcOffset() : 0;
+}
+
+inline bool ReaderMgr::lookingAtChar(const XMLCh chToCheck)
+{
+ return (chToCheck == peekNextChar());
+}
+
+inline bool ReaderMgr::lookingAtSpace()
+{
+ XMLCh c = peekNextChar();
+ return fCurReader->isWhitespace(c);
+}
+
+inline void ReaderMgr::setThrowEOE(const bool newValue)
+{
+ fThrowEOE = newValue;
+}
+
+inline void ReaderMgr::setStandardUriConformant(const bool newValue)
+{
+ fStandardUriConformant = newValue;
+}
+
+inline bool ReaderMgr::skippedString(const XMLCh* const toSkip)
+{
+ return fCurReader->skippedString(toSkip);
+}
+
+inline void ReaderMgr::skipToChar(const XMLCh toSkipTo)
+{
+ XMLCh nextCh = 0;
+ do
+ {
+ // Get chars until we find the one to skip
+ nextCh = getNextChar();
+ }
+ // Break out at end of input or the char to skip
+ while((nextCh != toSkipTo) && nextCh!=0);
+}
+
+inline void ReaderMgr::skipPastChar(const XMLCh toSkipPast)
+{
+ XMLCh nextCh = 0;
+ do
+ {
+ // Get chars until we find the one to skip
+ nextCh = getNextChar();
+ }
+ while((nextCh != toSkipPast) && nextCh!=0);
+}
+
+inline bool ReaderMgr::peekString(const XMLCh* const toPeek)
+{
+ return fCurReader->peekString(toPeek);
+}
+
+inline void ReaderMgr::setEntityHandler(XMLEntityHandler* const newHandler)
+{
+ fEntityHandler = newHandler;
+}
+
+inline void ReaderMgr::setXMLVersion(const XMLReader::XMLVersion version)
+{
+ fXMLVersion = version;
+ fCurReader->setXMLVersion(version);
+}
+
+//
+// This is a simple class to temporarily change the 'throw at end of entity'
+// flag of the reader manager. There are some places where we need to
+// turn this on and off on a scoped basis.
+//
+class XMLPARSER_EXPORT ThrowEOEJanitor
+{
+public :
+ // -----------------------------------------------------------------------
+ // Constructors and destructor
+ // -----------------------------------------------------------------------
+ ThrowEOEJanitor(ReaderMgr* mgrTarget, const bool newValue) :
+
+ fOld(mgrTarget->getThrowEOE())
+ , fMgr(mgrTarget)
+ {
+ mgrTarget->setThrowEOE(newValue);
+ }
+
+ ~ThrowEOEJanitor()
+ {
+ fMgr->setThrowEOE(fOld);
+ };
+
+private :
+ // -----------------------------------------------------------------------
+ // Unimplemented constructors and operators
+ // -----------------------------------------------------------------------
+ ThrowEOEJanitor(const ThrowEOEJanitor&);
+ ThrowEOEJanitor& operator=(const ThrowEOEJanitor&);
+
+ // -----------------------------------------------------------------------
+ // Private data members
+ //
+ // fOld
+ // The previous value of the flag, which we replaced during ctor,
+ // and will replace during dtor.
+ //
+ // fMgr
+ // A pointer to the reader manager we are going to set/reset the
+ // flag on.
+ // -----------------------------------------------------------------------
+ bool fOld;
+ ReaderMgr* fMgr;
+};
+
+XERCES_CPP_NAMESPACE_END
+
+#endif