--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/secureswitools/swisistools/source/xmlparser/xerces/include/xercesc/internal/XMLReader.hpp Fri Jan 22 09:56:12 2010 +0200
@@ -0,0 +1,783 @@
+/*
+ * 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: XMLReader.hpp 568078 2007-08-21 11:43:25Z amassari $
+ */
+
+#if !defined(XMLREADER_HPP)
+#define XMLREADER_HPP
+
+#include <xercesc/util/XMLChar.hpp>
+#include <xercesc/framework/XMLRecognizer.hpp>
+#include <xercesc/framework/XMLBuffer.hpp>
+#include <xercesc/util/TranscodingException.hpp>
+
+XERCES_CPP_NAMESPACE_BEGIN
+
+class InputSource;
+class BinInputStream;
+class ReaderMgr;
+class XMLScanner;
+class XMLTranscoder;
+
+
+// ---------------------------------------------------------------------------
+// Instances of this class are used to manage the content of entities. The
+// scanner maintains a stack of these, one for each entity (this means entity
+// in the sense of any parsed file or internal entity) currently being
+// scanned. This class, given a binary input stream will handle reading in
+// the data and decoding it from its external decoding into the internal
+// Unicode format. Once internallized, this class provides the access
+// methods to read in the data in various ways, maintains line and column
+// information, and provides high performance character attribute checking
+// methods.
+//
+// This is NOT to be derived from.
+//
+// ---------------------------------------------------------------------------
+class XMLPARSER_EXPORT XMLReader : public XMemory
+{
+public:
+ // -----------------------------------------------------------------------
+ // Public types
+ // -----------------------------------------------------------------------
+ enum Types
+ {
+ Type_PE
+ , Type_General
+ };
+
+ enum Sources
+ {
+ Source_Internal
+ , Source_External
+ };
+
+ enum RefFrom
+ {
+ RefFrom_Literal
+ , RefFrom_NonLiteral
+ };
+
+ enum XMLVersion
+ {
+ XMLV1_0
+ , XMLV1_1
+ , XMLV_Unknown
+ };
+
+
+ // -----------------------------------------------------------------------
+ // Public, query methods
+ // -----------------------------------------------------------------------
+ bool isAllSpaces
+ (
+ const XMLCh* const toCheck
+ , const unsigned int count
+ ) const;
+
+ bool containsWhiteSpace
+ (
+ const XMLCh* const toCheck
+ , const unsigned int count
+ ) const;
+
+
+ bool isXMLLetter(const XMLCh toCheck) const;
+ bool isFirstNameChar(const XMLCh toCheck) const;
+ bool isNameChar(const XMLCh toCheck) const;
+ bool isPlainContentChar(const XMLCh toCheck) const;
+ bool isSpecialStartTagChar(const XMLCh toCheck) const;
+ bool isXMLChar(const XMLCh toCheck) const;
+ bool isWhitespace(const XMLCh toCheck) const;
+ bool isControlChar(const XMLCh toCheck) const;
+ bool isPublicIdChar(const XMLCh toCheck) const;
+ bool isFirstNCNameChar(const XMLCh toCheck) const;
+ bool isNCNameChar(const XMLCh toCheck) const;
+
+ // -----------------------------------------------------------------------
+ // Constructors and Destructor
+ // -----------------------------------------------------------------------
+ XMLReader
+ (
+ const XMLCh* const pubId
+ , const XMLCh* const sysId
+ , BinInputStream* const streamToAdopt
+ , const RefFrom from
+ , const Types type
+ , const Sources source
+ , const bool throwAtEnd = false
+ , const bool calculateSrcOfs = true
+ , const XMLVersion xmlVersion = XMLV1_0
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+
+ XMLReader
+ (
+ const XMLCh* const pubId
+ , const XMLCh* const sysId
+ , BinInputStream* const streamToAdopt
+ , const XMLCh* const encodingStr
+ , const RefFrom from
+ , const Types type
+ , const Sources source
+ , const bool throwAtEnd = false
+ , const bool calculateSrcOfs = true
+ , const XMLVersion xmlVersion = XMLV1_0
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+
+ XMLReader
+ (
+ const XMLCh* const pubId
+ , const XMLCh* const sysId
+ , BinInputStream* const streamToAdopt
+ , XMLRecognizer::Encodings encodingEnum
+ , const RefFrom from
+ , const Types type
+ , const Sources source
+ , const bool throwAtEnd = false
+ , const bool calculateSrcOfs = true
+ , const XMLVersion xmlVersion = XMLV1_0
+ , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager
+ );
+
+ ~XMLReader();
+
+
+ // -----------------------------------------------------------------------
+ // Character buffer management methods
+ // -----------------------------------------------------------------------
+ unsigned long charsLeftInBuffer() const;
+ bool refreshCharBuffer();
+
+
+ // -----------------------------------------------------------------------
+ // Scanning methods
+ // -----------------------------------------------------------------------
+ bool getName(XMLBuffer& toFill, const bool token);
+ bool getQName(XMLBuffer& toFill, int* colonPosition);
+ bool getNextChar(XMLCh& chGotten);
+ bool getNextCharIfNot(const XMLCh chNotToGet, XMLCh& chGotten);
+ void movePlainContentChars(XMLBuffer &dest);
+ bool getSpaces(XMLBuffer& toFill);
+ bool getUpToCharOrWS(XMLBuffer& toFill, const XMLCh toCheck);
+ bool peekNextChar(XMLCh& chGotten);
+ bool skipIfQuote(XMLCh& chGotten);
+ bool skipSpaces(bool& skippedSomething, bool inDecl = false);
+ bool skippedChar(const XMLCh toSkip);
+ bool skippedSpace();
+ bool skippedString(const XMLCh* const toSkip);
+ bool peekString(const XMLCh* const toPeek);
+
+
+ // -----------------------------------------------------------------------
+ // Getter methods
+ // -----------------------------------------------------------------------
+ XMLSSize_t getColumnNumber() const;
+ const XMLCh* getEncodingStr() const;
+ XMLSSize_t getLineNumber() const;
+ bool getNoMoreFlag() const;
+ const XMLCh* getPublicId() const;
+ unsigned int getReaderNum() const;
+ RefFrom getRefFrom() const;
+ Sources getSource() const;
+ unsigned int getSrcOffset() const;
+ const XMLCh* getSystemId() const;
+ bool getThrowAtEnd() const;
+ Types getType() const;
+
+
+ // -----------------------------------------------------------------------
+ // Setter methods
+ // -----------------------------------------------------------------------
+ bool setEncoding
+ (
+ const XMLCh* const newEncoding
+ );
+ void setReaderNum(const unsigned int newNum);
+ void setThrowAtEnd(const bool newValue);
+ void setXMLVersion(const XMLVersion version);
+
+
+private:
+ // -----------------------------------------------------------------------
+ // Unimplemented constructors and operators
+ // -----------------------------------------------------------------------
+ XMLReader(const XMLReader&);
+ XMLReader& operator=(const XMLReader&);
+
+ // ---------------------------------------------------------------------------
+ // Class Constants
+ //
+ // kCharBufSize
+ // The size of the character spool buffer that we use. Its not terribly
+ // large because its just getting filled with data from a raw byte
+ // buffer as we go along. We don't want to decode all the text at
+ // once before we find out that there is an error.
+ //
+ // NOTE: This is a size in characters, not bytes.
+ //
+ // kRawBufSize
+ // The size of the raw buffer from which raw bytes are spooled out
+ // as we transcode chunks of data. As it is emptied, it is filled back
+ // in again from the source stream.
+ // ---------------------------------------------------------------------------
+ enum Constants
+ {
+ kCharBufSize = 16 * 1024
+ , kRawBufSize = 48 * 1024
+ };
+
+
+ // -----------------------------------------------------------------------
+ // Private helper methods
+ // -----------------------------------------------------------------------
+ void checkForSwapped();
+
+ void doInitCharSizeChecks();
+
+ void doInitDecode();
+
+ XMLByte getNextRawByte
+ (
+ const bool eoiOk
+ );
+
+ void refreshRawBuffer();
+
+ void setTranscoder
+ (
+ const XMLCh* const newEncoding
+ );
+
+ unsigned int xcodeMoreChars
+ (
+ XMLCh* const bufToFill
+ , unsigned char* const charSizes
+ , const unsigned int maxChars
+ );
+
+ void handleEOL
+ (
+ XMLCh& curCh
+ , bool inDecl = false
+ );
+
+ // -----------------------------------------------------------------------
+ // Data members
+ //
+ // fCharIndex
+ // The index into the character buffer. When this hits fCharsAvail
+ // then its time to refill.
+ //
+ // fCharBuf
+ // A buffer that the reader manager fills up with transcoded
+ // characters a small amount at a time.
+ //
+ // fCharsAvail
+ // The characters currently available in the character buffer.
+ //
+ // fCharSizeBuf
+ // This buffer is an array that contains the number of source chars
+ // eaten to create each char in the fCharBuf buffer. So the entry
+ // fCharSizeBuf[x] is the number of source chars that were eaten
+ // to make the internalized char fCharBuf[x]. This only contains
+ // useful data if fSrcOfsSupported is true.
+ //
+ // fCharOfsBuf
+ // This buffer is an array that contains the offset in the
+ // fRawByteBuf buffer of each char in the fCharBuf buffer. It
+ // only contains useful data if fSrcOfsSupported is true.
+ //
+ // fCurCol
+ // fCurLine
+ // The current line and column that we are in within this reader's
+ // text.
+ //
+ // fEncoding
+ // This is the rough encoding setting. This enum is set during
+ // construction and just tells us the rough family of encoding that
+ // we are doing.
+ //
+ // fEncodingStr
+ // This is the name of the encoding we are using. It will be
+ // provisionally set during construction, from the auto-sensed
+ // encoding. But it might be overridden when the XMLDecl is finally
+ // seen by the scanner. It can also be forced to a particular
+ // encoding, in which case fForcedEncoding is set.
+ //
+ // fForcedEncoding
+ // If the encoding if forced then this is set and all other
+ // information will be ignored. This encoding will be taken as
+ // gospel. This is done by calling an alternate constructor.
+ //
+ // fNoMore
+ // This is set when the source text is exhausted. It lets us know
+ // quickly that no more text is available.
+ //
+ // fRawBufIndex
+ // The current index into the raw byte buffer. When its equal to
+ // fRawBytesAvail then we need to read another buffer.
+ //
+ // fRawByteBuf
+ // This is the raw byte buffer that is used to spool out bytes
+ // from into the fCharBuf buffer, as we transcode in blocks.
+ //
+ // fRawBytesAvail
+ // The number of bytes currently available in the raw buffer. This
+ // helps deal with the last buffer's worth, which will usually not
+ // be a full one.
+ //
+ // fReaderNum
+ // Each reader from a particular reader manager (which means from a
+ // particular document) is given a unique number. The reader manager
+ // sets these numbers. They are used to catch things like partial
+ // markup errors.
+ //
+ // fRefFrom
+ // This flag is provided in the ctor, and tells us if we represent
+ // some entity being expanded inside a literal. Sometimes things
+ // happen differently inside and outside literals.
+ //
+ // fPublicId
+ // fSystemId
+ // These are the system and public ids of the source that this
+ // reader is reading.
+ //
+ // fSentTrailingSpace
+ // If we are a PE entity being read and we not referenced from a
+ // literal, then a leading and trailing space must be faked into the
+ // data. This lets us know we've done the trailing space already (so
+ // we don't just keep doing it again and again.)
+ //
+ // fSource
+ // Indicates whether the content this reader is spooling as already
+ // been internalized. This will prevent multiple processing of
+ // whitespace when an already internalized entity is being spooled
+ // out.
+ //
+ // fSpareChar
+ // Some encodings can create two chars in an atomic way, e.g.
+ // surrogate pairs. We might not be able to store both, so we store
+ // it here until the next buffer transcoding operation.
+ //
+ // fSrcOfsBase
+ // This is the base offset within the source of this entity. Values
+ // in the curent fCharSizeBuf array are relative to this value.
+ //
+ // fSrcOfsSupported
+ // This flag is set to indicate whether source byte offset info
+ // is supported. For intrinsic encodings, its always set since we
+ // can always support it. For transcoder based encodings, we ask
+ // the transcoder if it supports it or not.
+ //
+ // fStream
+ // This is the input stream that provides the data for the reader.
+ // Its always treated as a raw byte stream. The derived class will
+ // ask for buffers of text from it and will handle making some
+ // sense of it.
+ //
+ // fSwapped
+ // If the encoding is one of the ones we do intrinsically, and its
+ // in a different byte order from our native order, then this is
+ // set to remind us to byte swap it during transcoding.
+ //
+ // fThrowAtEnd
+ // Indicates whether the reader manager should throw an end of entity
+ // exception at the end of this reader instance. This is usually
+ // set for top level external entity references. It overrides the
+ // reader manager's global flag that controls throwing at the end
+ // of entities. Defaults to false.
+ //
+ // fTranscoder
+ // If the encoding is not one that we handle intrinsically, then
+ // we use an an external transcoder to do it. This class is an
+ // abstraction that allows us to use pluggable external transcoding
+ // services (via XMLTransService in util.)
+ //
+ // fType
+ // Indicates whether this reader represents a PE or not. If this
+ // flag is true and the fInLiteral flag is false, then we will put
+ // out an extra space at the end.
+ //
+ // fgCharCharsTable;
+ // Pointer to XMLChar table, depends on XML version
+ //
+ // fNEL
+ // Boolean indicates if NEL and LSEP should be recognized as NEL
+ //
+ // fXMLVersion
+ // Enum to indicate if this Reader is conforming to XML 1.0 or XML 1.1
+ // -----------------------------------------------------------------------
+ unsigned int fCharIndex;
+ XMLCh fCharBuf[kCharBufSize];
+ unsigned int fCharsAvail;
+ unsigned char fCharSizeBuf[kCharBufSize];
+ unsigned int fCharOfsBuf[kCharBufSize];
+ XMLSSize_t fCurCol;
+ XMLSSize_t fCurLine;
+ XMLRecognizer::Encodings fEncoding;
+ XMLCh* fEncodingStr;
+ bool fForcedEncoding;
+ bool fNoMore;
+ XMLCh* fPublicId;
+ unsigned int fRawBufIndex;
+ XMLByte fRawByteBuf[kRawBufSize];
+ unsigned int fRawBytesAvail;
+ unsigned int fReaderNum;
+ RefFrom fRefFrom;
+ bool fSentTrailingSpace;
+ Sources fSource;
+ unsigned int fSrcOfsBase;
+ bool fSrcOfsSupported;
+ bool fCalculateSrcOfs;
+ XMLCh* fSystemId;
+ BinInputStream* fStream;
+ bool fSwapped;
+ bool fThrowAtEnd;
+ XMLTranscoder* fTranscoder;
+ Types fType;
+ XMLByte* fgCharCharsTable;
+ bool fNEL;
+ XMLVersion fXMLVersion;
+ MemoryManager* fMemoryManager;
+};
+
+
+// ---------------------------------------------------------------------------
+// XMLReader: Public, query methods
+// ---------------------------------------------------------------------------
+inline bool XMLReader::isNameChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gNameCharMask) != 0);
+}
+
+inline bool XMLReader::isNCNameChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gNCNameCharMask) != 0);
+}
+
+inline bool XMLReader::isPlainContentChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gPlainContentCharMask) != 0);
+}
+
+
+inline bool XMLReader::isFirstNameChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gFirstNameCharMask) != 0);
+}
+
+inline bool XMLReader::isFirstNCNameChar(const XMLCh toCheck) const
+{
+ return (((fgCharCharsTable[toCheck] & gFirstNameCharMask) != 0)
+ && (toCheck != chColon));
+}
+
+inline bool XMLReader::isSpecialStartTagChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gSpecialStartTagCharMask) != 0);
+}
+
+inline bool XMLReader::isXMLChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gXMLCharMask) != 0);
+}
+
+inline bool XMLReader::isXMLLetter(const XMLCh toCheck) const
+{
+ return (((fgCharCharsTable[toCheck] & gFirstNameCharMask) != 0)
+ && (toCheck != chColon) && (toCheck != chUnderscore));
+}
+
+inline bool XMLReader::isWhitespace(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gWhitespaceCharMask) != 0);
+}
+
+inline bool XMLReader::isControlChar(const XMLCh toCheck) const
+{
+ return ((fgCharCharsTable[toCheck] & gControlCharMask) != 0);
+}
+
+// ---------------------------------------------------------------------------
+// XMLReader: Buffer management methods
+// ---------------------------------------------------------------------------
+inline unsigned long XMLReader::charsLeftInBuffer() const
+{
+ return fCharsAvail - fCharIndex;
+}
+
+
+// ---------------------------------------------------------------------------
+// XMLReader: Getter methods
+// ---------------------------------------------------------------------------
+inline XMLSSize_t XMLReader::getColumnNumber() const
+{
+ return fCurCol;
+}
+
+inline const XMLCh* XMLReader::getEncodingStr() const
+{
+ return fEncodingStr;
+}
+
+inline XMLSSize_t XMLReader::getLineNumber() const
+{
+ return fCurLine;
+}
+
+inline bool XMLReader::getNoMoreFlag() const
+{
+ return fNoMore;
+}
+
+inline const XMLCh* XMLReader::getPublicId() const
+{
+ return fPublicId;
+}
+
+inline unsigned int XMLReader::getReaderNum() const
+{
+ return fReaderNum;
+}
+
+inline XMLReader::RefFrom XMLReader::getRefFrom() const
+{
+ return fRefFrom;
+}
+
+inline XMLReader::Sources XMLReader::getSource() const
+{
+ return fSource;
+}
+
+inline const XMLCh* XMLReader::getSystemId() const
+{
+ return fSystemId;
+}
+
+inline bool XMLReader::getThrowAtEnd() const
+{
+ return fThrowAtEnd;
+}
+
+inline XMLReader::Types XMLReader::getType() const
+{
+ return fType;
+}
+
+// ---------------------------------------------------------------------------
+// XMLReader: Setter methods
+// ---------------------------------------------------------------------------
+inline void XMLReader::setReaderNum(const unsigned int newNum)
+{
+ fReaderNum = newNum;
+}
+
+inline void XMLReader::setThrowAtEnd(const bool newValue)
+{
+ fThrowAtEnd = newValue;
+}
+
+inline void XMLReader::setXMLVersion(const XMLVersion version)
+{
+ fXMLVersion = version;
+ if (version == XMLV1_1) {
+ fNEL = true;
+ fgCharCharsTable = XMLChar1_1::fgCharCharsTable1_1;
+ }
+ else {
+ fNEL = XMLChar1_0::enableNEL;
+ fgCharCharsTable = XMLChar1_0::fgCharCharsTable1_0;
+ }
+
+}
+
+
+
+// ---------------------------------------------------------------------------
+//
+// XMLReader: movePlainContentChars()
+//
+// Move as many plain (no special handling of any sort required) content
+// characters as possible from this reader to the supplied destination buffer.
+//
+// This is THE hottest performance spot in the parser.
+//
+// ---------------------------------------------------------------------------
+inline void XMLReader::movePlainContentChars(XMLBuffer &dest)
+{
+ unsigned int count = fCharIndex;
+
+ while (fCharIndex < fCharsAvail)
+ {
+ if (!isPlainContentChar(fCharBuf[fCharIndex]))
+ break;
+ fCharIndex++;
+ }
+
+ if (count != fCharIndex)
+ {
+ fCurCol += (fCharIndex - count);
+ dest.append(&fCharBuf[count], fCharIndex - count);
+ }
+}
+
+
+// ---------------------------------------------------------------------------
+// XMLReader: getNextCharIfNot() method inlined for speed
+// ---------------------------------------------------------------------------
+inline bool XMLReader::getNextCharIfNot(const XMLCh chNotToGet, XMLCh& chGotten)
+{
+ //
+ // See if there is at least a char in the buffer. Else, do the buffer
+ // reload logic.
+ //
+ if (fCharIndex >= fCharsAvail)
+ {
+ // If fNoMore is set, then we have nothing else to give
+ if (fNoMore)
+ return false;
+
+ // Try to refresh
+ if (!refreshCharBuffer())
+ return false;
+ }
+
+ // Check the next char
+ if (fCharBuf[fCharIndex] == chNotToGet)
+ return false;
+
+ // Its not the one we want to skip so bump the index
+ chGotten = fCharBuf[fCharIndex++];
+
+ // Handle end of line normalization and line/col member maintenance.
+ //
+ // we can have end-of-line combinations with a leading
+ // chCR(xD), chLF(xA), chNEL(x85), or chLineSeparator(x2028)
+ //
+ // 0000000000001101 chCR
+ // 0000000000001010 chLF
+ // 0000000010000101 chNEL
+ // 0010000000101000 chLineSeparator
+ // -----------------------
+ // 1101111101010000 == ~(chCR|chLF|chNEL|chLineSeparator)
+ //
+ // if the result of the logical-& operation is
+ // true : 'curCh' can not be chCR, chLF, chNEL or chLineSeparator
+ // false : 'curCh' can be chCR, chLF, chNEL or chLineSeparator
+ //
+ if ( chGotten & (XMLCh) ~(chCR|chLF|chNEL|chLineSeparator) )
+ {
+ fCurCol++;
+ } else
+ {
+ handleEOL(chGotten, false);
+ }
+
+ return true;
+}
+
+// ---------------------------------------------------------------------------
+// XMLReader: getNextChar() method inlined for speed
+// ---------------------------------------------------------------------------
+inline bool XMLReader::getNextChar(XMLCh& chGotten)
+{
+ //
+ // See if there is at least a char in the buffer. Else, do the buffer
+ // reload logic.
+ //
+ if (fCharIndex >= fCharsAvail)
+ {
+ // If fNoMore is set, then we have nothing else to give
+ if (fNoMore)
+ return false;
+
+ // Try to refresh
+ if (!refreshCharBuffer())
+ return false;
+ }
+
+ chGotten = fCharBuf[fCharIndex++];
+
+ // Handle end of line normalization and line/col member maintenance.
+ //
+ // we can have end-of-line combinations with a leading
+ // chCR(xD), chLF(xA), chNEL(x85), or chLineSeparator(x2028)
+ //
+ // 0000000000001101 chCR
+ // 0000000000001010 chLF
+ // 0000000010000101 chNEL
+ // 0010000000101000 chLineSeparator
+ // -----------------------
+ // 1101111101010000 == ~(chCR|chLF|chNEL|chLineSeparator)
+ //
+ // if the result of the logical-& operation is
+ // true : 'curCh' can not be chCR, chLF, chNEL or chLineSeparator
+ // false : 'curCh' can be chCR, chLF, chNEL or chLineSeparator
+ //
+ if ( chGotten & (XMLCh) ~(chCR|chLF|chNEL|chLineSeparator) )
+ {
+ fCurCol++;
+ } else
+ {
+ handleEOL(chGotten, false);
+ }
+
+ return true;
+}
+
+
+// ---------------------------------------------------------------------------
+// XMLReader: peekNextChar() method inlined for speed
+// ---------------------------------------------------------------------------
+inline bool XMLReader::peekNextChar(XMLCh& chGotten)
+{
+ //
+ // If there is something still in the buffer, get it. Else do the reload
+ // scenario.
+ //
+ if (fCharIndex >= fCharsAvail)
+ {
+ // Try to refresh the buffer
+ if (!refreshCharBuffer())
+ {
+ chGotten = chNull;
+ return false;
+ }
+ }
+
+ chGotten = fCharBuf[fCharIndex];
+
+ //
+ // Even though we are only peeking, we have to act the same as the
+ // normal char get method in regards to newline normalization, though
+ // its not as complicated as the actual character getting method's.
+ //
+ if ((chGotten == chCR || (fNEL && (chGotten == chNEL || chGotten == chLineSeparator)))
+ && (fSource == Source_External))
+ chGotten = chLF;
+
+ return true;
+}
+
+XERCES_CPP_NAMESPACE_END
+
+#endif